+
+
+### Mergo in the wild
+
+Mergo is used by [thousands](https://deps.dev/go/dario.cat%2Fmergo/v1.0.0/dependents) [of](https://deps.dev/go/github.com%2Fimdario%2Fmergo/v0.3.16/dependents) [projects](https://deps.dev/go/github.com%2Fimdario%2Fmergo/v0.3.12), including:
+
+* [containerd/containerd](https://github.com/containerd/containerd)
+* [datadog/datadog-agent](https://github.com/datadog/datadog-agent)
+* [docker/cli/](https://github.com/docker/cli/)
+* [goreleaser/goreleaser](https://github.com/goreleaser/goreleaser)
+* [go-micro/go-micro](https://github.com/go-micro/go-micro)
+* [grafana/loki](https://github.com/grafana/loki)
+* [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes)
+* [masterminds/sprig](github.com/Masterminds/sprig)
+* [moby/moby](https://github.com/moby/moby)
+* [slackhq/nebula](https://github.com/slackhq/nebula)
+* [volcano-sh/volcano](https://github.com/volcano-sh/volcano)
+
+## Install
+
+ go get dario.cat/mergo
+
+ // use in your .go code
+ import (
+ "dario.cat/mergo"
+ )
+
+## Usage
+
+You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as [they are zero values](https://golang.org/ref/spec#The_zero_value) too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection).
+
+```go
+if err := mergo.Merge(&dst, src); err != nil {
+ // ...
+}
+```
+
+Also, you can merge overwriting values using the transformer `WithOverride`.
+
+```go
+if err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil {
+ // ...
+}
+```
+
+If you need to override pointers, so the source pointer's value is assigned to the destination's pointer, you must use `WithoutDereference`:
+
+```go
+package main
+
+import (
+ "fmt"
+
+ "dario.cat/mergo"
+)
+
+type Foo struct {
+ A *string
+ B int64
+}
+
+func main() {
+ first := "first"
+ second := "second"
+ src := Foo{
+ A: &first,
+ B: 2,
+ }
+
+ dest := Foo{
+ A: &second,
+ B: 1,
+ }
+
+ mergo.Merge(&dest, src, mergo.WithOverride, mergo.WithoutDereference)
+}
+```
+
+Additionally, you can map a `map[string]interface{}` to a struct (and otherwise, from struct to map), following the same restrictions as in `Merge()`. Keys are capitalized to find each corresponding exported field.
+
+```go
+if err := mergo.Map(&dst, srcMap); err != nil {
+ // ...
+}
+```
+
+Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as `map[string]interface{}`. They will be just assigned as values.
+
+Here is a nice example:
+
+```go
+package main
+
+import (
+ "fmt"
+ "dario.cat/mergo"
+)
+
+type Foo struct {
+ A string
+ B int64
+}
+
+func main() {
+ src := Foo{
+ A: "one",
+ B: 2,
+ }
+ dest := Foo{
+ A: "two",
+ }
+ mergo.Merge(&dest, src)
+ fmt.Println(dest)
+ // Will print
+ // {two 2}
+}
+```
+
+Note: if test are failing due missing package, please execute:
+
+ go get gopkg.in/yaml.v3
+
+### Transformers
+
+Transformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, `time.Time` is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero `time.Time`?
+
+```go
+package main
+
+import (
+ "fmt"
+ "dario.cat/mergo"
+ "reflect"
+ "time"
+)
+
+type timeTransformer struct {
+}
+
+func (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {
+ if typ == reflect.TypeOf(time.Time{}) {
+ return func(dst, src reflect.Value) error {
+ if dst.CanSet() {
+ isZero := dst.MethodByName("IsZero")
+ result := isZero.Call([]reflect.Value{})
+ if result[0].Bool() {
+ dst.Set(src)
+ }
+ }
+ return nil
+ }
+ }
+ return nil
+}
+
+type Snapshot struct {
+ Time time.Time
+ // ...
+}
+
+func main() {
+ src := Snapshot{time.Now()}
+ dest := Snapshot{}
+ mergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{}))
+ fmt.Println(dest)
+ // Will print
+ // { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 }
+}
+```
+
+## Contact me
+
+If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): [@im_dario](https://twitter.com/im_dario)
+
+## About
+
+Written by [Dario Castañé](http://dario.im).
+
+## License
+
+[BSD 3-Clause](http://opensource.org/licenses/BSD-3-Clause) license, as [Go language](http://golang.org/LICENSE).
+
+[](https://app.fossa.io/projects/git%2Bgithub.com%2Fimdario%2Fmergo?ref=badge_large)
diff --git a/vendor/dario.cat/mergo/SECURITY.md b/vendor/dario.cat/mergo/SECURITY.md
new file mode 100644
index 0000000000..a5de61f77b
--- /dev/null
+++ b/vendor/dario.cat/mergo/SECURITY.md
@@ -0,0 +1,14 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported |
+| ------- | ------------------ |
+| 0.3.x | :white_check_mark: |
+| < 0.3 | :x: |
+
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
diff --git a/vendor/dario.cat/mergo/doc.go b/vendor/dario.cat/mergo/doc.go
new file mode 100644
index 0000000000..7d96ec0546
--- /dev/null
+++ b/vendor/dario.cat/mergo/doc.go
@@ -0,0 +1,148 @@
+// Copyright 2013 Dario Castañé. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+A helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements.
+
+Mergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).
+
+# Status
+
+It is ready for production use. It is used in several projects by Docker, Google, The Linux Foundation, VMWare, Shopify, etc.
+
+# Important notes
+
+1.0.0
+
+In 1.0.0 Mergo moves to a vanity URL `dario.cat/mergo`.
+
+0.3.9
+
+Please keep in mind that a problematic PR broke 0.3.9. We reverted it in 0.3.10. We consider 0.3.10 as stable but not bug-free. . Also, this version adds suppot for go modules.
+
+Keep in mind that in 0.3.2, Mergo changed Merge() and Map() signatures to support transformers. We added an optional/variadic argument so that it won't break the existing code.
+
+If you were using Mergo before April 6th, 2015, please check your project works as intended after updating your local copy with go get -u dario.cat/mergo. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause in existing projects after the change (release 0.2.0).
+
+# Install
+
+Do your usual installation procedure:
+
+ go get dario.cat/mergo
+
+ // use in your .go code
+ import (
+ "dario.cat/mergo"
+ )
+
+# Usage
+
+You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as they are zero values too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection).
+
+ if err := mergo.Merge(&dst, src); err != nil {
+ // ...
+ }
+
+Also, you can merge overwriting values using the transformer WithOverride.
+
+ if err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil {
+ // ...
+ }
+
+Additionally, you can map a map[string]interface{} to a struct (and otherwise, from struct to map), following the same restrictions as in Merge(). Keys are capitalized to find each corresponding exported field.
+
+ if err := mergo.Map(&dst, srcMap); err != nil {
+ // ...
+ }
+
+Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as map[string]interface{}. They will be just assigned as values.
+
+Here is a nice example:
+
+ package main
+
+ import (
+ "fmt"
+ "dario.cat/mergo"
+ )
+
+ type Foo struct {
+ A string
+ B int64
+ }
+
+ func main() {
+ src := Foo{
+ A: "one",
+ B: 2,
+ }
+ dest := Foo{
+ A: "two",
+ }
+ mergo.Merge(&dest, src)
+ fmt.Println(dest)
+ // Will print
+ // {two 2}
+ }
+
+# Transformers
+
+Transformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, time.Time is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero time.Time?
+
+ package main
+
+ import (
+ "fmt"
+ "dario.cat/mergo"
+ "reflect"
+ "time"
+ )
+
+ type timeTransformer struct {
+ }
+
+ func (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {
+ if typ == reflect.TypeOf(time.Time{}) {
+ return func(dst, src reflect.Value) error {
+ if dst.CanSet() {
+ isZero := dst.MethodByName("IsZero")
+ result := isZero.Call([]reflect.Value{})
+ if result[0].Bool() {
+ dst.Set(src)
+ }
+ }
+ return nil
+ }
+ }
+ return nil
+ }
+
+ type Snapshot struct {
+ Time time.Time
+ // ...
+ }
+
+ func main() {
+ src := Snapshot{time.Now()}
+ dest := Snapshot{}
+ mergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{}))
+ fmt.Println(dest)
+ // Will print
+ // { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 }
+ }
+
+# Contact me
+
+If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): https://twitter.com/im_dario
+
+# About
+
+Written by Dario Castañé: https://da.rio.hn
+
+# License
+
+BSD 3-Clause license, as Go language.
+*/
+package mergo
diff --git a/vendor/dario.cat/mergo/map.go b/vendor/dario.cat/mergo/map.go
new file mode 100644
index 0000000000..759b4f74fd
--- /dev/null
+++ b/vendor/dario.cat/mergo/map.go
@@ -0,0 +1,178 @@
+// Copyright 2014 Dario Castañé. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Based on src/pkg/reflect/deepequal.go from official
+// golang's stdlib.
+
+package mergo
+
+import (
+ "fmt"
+ "reflect"
+ "unicode"
+ "unicode/utf8"
+)
+
+func changeInitialCase(s string, mapper func(rune) rune) string {
+ if s == "" {
+ return s
+ }
+ r, n := utf8.DecodeRuneInString(s)
+ return string(mapper(r)) + s[n:]
+}
+
+func isExported(field reflect.StructField) bool {
+ r, _ := utf8.DecodeRuneInString(field.Name)
+ return r >= 'A' && r <= 'Z'
+}
+
+// Traverses recursively both values, assigning src's fields values to dst.
+// The map argument tracks comparisons that have already been seen, which allows
+// short circuiting on recursive types.
+func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) {
+ overwrite := config.Overwrite
+ if dst.CanAddr() {
+ addr := dst.UnsafeAddr()
+ h := 17 * addr
+ seen := visited[h]
+ typ := dst.Type()
+ for p := seen; p != nil; p = p.next {
+ if p.ptr == addr && p.typ == typ {
+ return nil
+ }
+ }
+ // Remember, remember...
+ visited[h] = &visit{typ, seen, addr}
+ }
+ zeroValue := reflect.Value{}
+ switch dst.Kind() {
+ case reflect.Map:
+ dstMap := dst.Interface().(map[string]interface{})
+ for i, n := 0, src.NumField(); i < n; i++ {
+ srcType := src.Type()
+ field := srcType.Field(i)
+ if !isExported(field) {
+ continue
+ }
+ fieldName := field.Name
+ fieldName = changeInitialCase(fieldName, unicode.ToLower)
+ if _, ok := dstMap[fieldName]; !ok || (!isEmptyValue(reflect.ValueOf(src.Field(i).Interface()), !config.ShouldNotDereference) && overwrite) || config.overwriteWithEmptyValue {
+ dstMap[fieldName] = src.Field(i).Interface()
+ }
+ }
+ case reflect.Ptr:
+ if dst.IsNil() {
+ v := reflect.New(dst.Type().Elem())
+ dst.Set(v)
+ }
+ dst = dst.Elem()
+ fallthrough
+ case reflect.Struct:
+ srcMap := src.Interface().(map[string]interface{})
+ for key := range srcMap {
+ config.overwriteWithEmptyValue = true
+ srcValue := srcMap[key]
+ fieldName := changeInitialCase(key, unicode.ToUpper)
+ dstElement := dst.FieldByName(fieldName)
+ if dstElement == zeroValue {
+ // We discard it because the field doesn't exist.
+ continue
+ }
+ srcElement := reflect.ValueOf(srcValue)
+ dstKind := dstElement.Kind()
+ srcKind := srcElement.Kind()
+ if srcKind == reflect.Ptr && dstKind != reflect.Ptr {
+ srcElement = srcElement.Elem()
+ srcKind = reflect.TypeOf(srcElement.Interface()).Kind()
+ } else if dstKind == reflect.Ptr {
+ // Can this work? I guess it can't.
+ if srcKind != reflect.Ptr && srcElement.CanAddr() {
+ srcPtr := srcElement.Addr()
+ srcElement = reflect.ValueOf(srcPtr)
+ srcKind = reflect.Ptr
+ }
+ }
+
+ if !srcElement.IsValid() {
+ continue
+ }
+ if srcKind == dstKind {
+ if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ } else if dstKind == reflect.Interface && dstElement.Kind() == reflect.Interface {
+ if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ } else if srcKind == reflect.Map {
+ if err = deepMap(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ } else {
+ return fmt.Errorf("type mismatch on %s field: found %v, expected %v", fieldName, srcKind, dstKind)
+ }
+ }
+ }
+ return
+}
+
+// Map sets fields' values in dst from src.
+// src can be a map with string keys or a struct. dst must be the opposite:
+// if src is a map, dst must be a valid pointer to struct. If src is a struct,
+// dst must be map[string]interface{}.
+// It won't merge unexported (private) fields and will do recursively
+// any exported field.
+// If dst is a map, keys will be src fields' names in lower camel case.
+// Missing key in src that doesn't match a field in dst will be skipped. This
+// doesn't apply if dst is a map.
+// This is separated method from Merge because it is cleaner and it keeps sane
+// semantics: merging equal types, mapping different (restricted) types.
+func Map(dst, src interface{}, opts ...func(*Config)) error {
+ return _map(dst, src, opts...)
+}
+
+// MapWithOverwrite will do the same as Map except that non-empty dst attributes will be overridden by
+// non-empty src attribute values.
+// Deprecated: Use Map(…) with WithOverride
+func MapWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {
+ return _map(dst, src, append(opts, WithOverride)...)
+}
+
+func _map(dst, src interface{}, opts ...func(*Config)) error {
+ if dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr {
+ return ErrNonPointerArgument
+ }
+ var (
+ vDst, vSrc reflect.Value
+ err error
+ )
+ config := &Config{}
+
+ for _, opt := range opts {
+ opt(config)
+ }
+
+ if vDst, vSrc, err = resolveValues(dst, src); err != nil {
+ return err
+ }
+ // To be friction-less, we redirect equal-type arguments
+ // to deepMerge. Only because arguments can be anything.
+ if vSrc.Kind() == vDst.Kind() {
+ return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)
+ }
+ switch vSrc.Kind() {
+ case reflect.Struct:
+ if vDst.Kind() != reflect.Map {
+ return ErrExpectedMapAsDestination
+ }
+ case reflect.Map:
+ if vDst.Kind() != reflect.Struct {
+ return ErrExpectedStructAsDestination
+ }
+ default:
+ return ErrNotSupported
+ }
+ return deepMap(vDst, vSrc, make(map[uintptr]*visit), 0, config)
+}
diff --git a/vendor/dario.cat/mergo/merge.go b/vendor/dario.cat/mergo/merge.go
new file mode 100644
index 0000000000..fd47c95b2b
--- /dev/null
+++ b/vendor/dario.cat/mergo/merge.go
@@ -0,0 +1,409 @@
+// Copyright 2013 Dario Castañé. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Based on src/pkg/reflect/deepequal.go from official
+// golang's stdlib.
+
+package mergo
+
+import (
+ "fmt"
+ "reflect"
+)
+
+func hasMergeableFields(dst reflect.Value) (exported bool) {
+ for i, n := 0, dst.NumField(); i < n; i++ {
+ field := dst.Type().Field(i)
+ if field.Anonymous && dst.Field(i).Kind() == reflect.Struct {
+ exported = exported || hasMergeableFields(dst.Field(i))
+ } else if isExportedComponent(&field) {
+ exported = exported || len(field.PkgPath) == 0
+ }
+ }
+ return
+}
+
+func isExportedComponent(field *reflect.StructField) bool {
+ pkgPath := field.PkgPath
+ if len(pkgPath) > 0 {
+ return false
+ }
+ c := field.Name[0]
+ if 'a' <= c && c <= 'z' || c == '_' {
+ return false
+ }
+ return true
+}
+
+type Config struct {
+ Transformers Transformers
+ Overwrite bool
+ ShouldNotDereference bool
+ AppendSlice bool
+ TypeCheck bool
+ overwriteWithEmptyValue bool
+ overwriteSliceWithEmptyValue bool
+ sliceDeepCopy bool
+ debug bool
+}
+
+type Transformers interface {
+ Transformer(reflect.Type) func(dst, src reflect.Value) error
+}
+
+// Traverses recursively both values, assigning src's fields values to dst.
+// The map argument tracks comparisons that have already been seen, which allows
+// short circuiting on recursive types.
+func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) {
+ overwrite := config.Overwrite
+ typeCheck := config.TypeCheck
+ overwriteWithEmptySrc := config.overwriteWithEmptyValue
+ overwriteSliceWithEmptySrc := config.overwriteSliceWithEmptyValue
+ sliceDeepCopy := config.sliceDeepCopy
+
+ if !src.IsValid() {
+ return
+ }
+ if dst.CanAddr() {
+ addr := dst.UnsafeAddr()
+ h := 17 * addr
+ seen := visited[h]
+ typ := dst.Type()
+ for p := seen; p != nil; p = p.next {
+ if p.ptr == addr && p.typ == typ {
+ return nil
+ }
+ }
+ // Remember, remember...
+ visited[h] = &visit{typ, seen, addr}
+ }
+
+ if config.Transformers != nil && !isReflectNil(dst) && dst.IsValid() {
+ if fn := config.Transformers.Transformer(dst.Type()); fn != nil {
+ err = fn(dst, src)
+ return
+ }
+ }
+
+ switch dst.Kind() {
+ case reflect.Struct:
+ if hasMergeableFields(dst) {
+ for i, n := 0, dst.NumField(); i < n; i++ {
+ if err = deepMerge(dst.Field(i), src.Field(i), visited, depth+1, config); err != nil {
+ return
+ }
+ }
+ } else {
+ if dst.CanSet() && (isReflectNil(dst) || overwrite) && (!isEmptyValue(src, !config.ShouldNotDereference) || overwriteWithEmptySrc) {
+ dst.Set(src)
+ }
+ }
+ case reflect.Map:
+ if dst.IsNil() && !src.IsNil() {
+ if dst.CanSet() {
+ dst.Set(reflect.MakeMap(dst.Type()))
+ } else {
+ dst = src
+ return
+ }
+ }
+
+ if src.Kind() != reflect.Map {
+ if overwrite && dst.CanSet() {
+ dst.Set(src)
+ }
+ return
+ }
+
+ for _, key := range src.MapKeys() {
+ srcElement := src.MapIndex(key)
+ if !srcElement.IsValid() {
+ continue
+ }
+ dstElement := dst.MapIndex(key)
+ switch srcElement.Kind() {
+ case reflect.Chan, reflect.Func, reflect.Map, reflect.Interface, reflect.Slice:
+ if srcElement.IsNil() {
+ if overwrite {
+ dst.SetMapIndex(key, srcElement)
+ }
+ continue
+ }
+ fallthrough
+ default:
+ if !srcElement.CanInterface() {
+ continue
+ }
+ switch reflect.TypeOf(srcElement.Interface()).Kind() {
+ case reflect.Struct:
+ fallthrough
+ case reflect.Ptr:
+ fallthrough
+ case reflect.Map:
+ srcMapElm := srcElement
+ dstMapElm := dstElement
+ if srcMapElm.CanInterface() {
+ srcMapElm = reflect.ValueOf(srcMapElm.Interface())
+ if dstMapElm.IsValid() {
+ dstMapElm = reflect.ValueOf(dstMapElm.Interface())
+ }
+ }
+ if err = deepMerge(dstMapElm, srcMapElm, visited, depth+1, config); err != nil {
+ return
+ }
+ case reflect.Slice:
+ srcSlice := reflect.ValueOf(srcElement.Interface())
+
+ var dstSlice reflect.Value
+ if !dstElement.IsValid() || dstElement.IsNil() {
+ dstSlice = reflect.MakeSlice(srcSlice.Type(), 0, srcSlice.Len())
+ } else {
+ dstSlice = reflect.ValueOf(dstElement.Interface())
+ }
+
+ if (!isEmptyValue(src, !config.ShouldNotDereference) || overwriteWithEmptySrc || overwriteSliceWithEmptySrc) && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) && !config.AppendSlice && !sliceDeepCopy {
+ if typeCheck && srcSlice.Type() != dstSlice.Type() {
+ return fmt.Errorf("cannot override two slices with different type (%s, %s)", srcSlice.Type(), dstSlice.Type())
+ }
+ dstSlice = srcSlice
+ } else if config.AppendSlice {
+ if srcSlice.Type() != dstSlice.Type() {
+ return fmt.Errorf("cannot append two slices with different type (%s, %s)", srcSlice.Type(), dstSlice.Type())
+ }
+ dstSlice = reflect.AppendSlice(dstSlice, srcSlice)
+ } else if sliceDeepCopy {
+ i := 0
+ for ; i < srcSlice.Len() && i < dstSlice.Len(); i++ {
+ srcElement := srcSlice.Index(i)
+ dstElement := dstSlice.Index(i)
+
+ if srcElement.CanInterface() {
+ srcElement = reflect.ValueOf(srcElement.Interface())
+ }
+ if dstElement.CanInterface() {
+ dstElement = reflect.ValueOf(dstElement.Interface())
+ }
+
+ if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ }
+
+ }
+ dst.SetMapIndex(key, dstSlice)
+ }
+ }
+
+ if dstElement.IsValid() && !isEmptyValue(dstElement, !config.ShouldNotDereference) {
+ if reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Slice {
+ continue
+ }
+ if reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Map && reflect.TypeOf(dstElement.Interface()).Kind() == reflect.Map {
+ continue
+ }
+ }
+
+ if srcElement.IsValid() && ((srcElement.Kind() != reflect.Ptr && overwrite) || !dstElement.IsValid() || isEmptyValue(dstElement, !config.ShouldNotDereference)) {
+ if dst.IsNil() {
+ dst.Set(reflect.MakeMap(dst.Type()))
+ }
+ dst.SetMapIndex(key, srcElement)
+ }
+ }
+
+ // Ensure that all keys in dst are deleted if they are not in src.
+ if overwriteWithEmptySrc {
+ for _, key := range dst.MapKeys() {
+ srcElement := src.MapIndex(key)
+ if !srcElement.IsValid() {
+ dst.SetMapIndex(key, reflect.Value{})
+ }
+ }
+ }
+ case reflect.Slice:
+ if !dst.CanSet() {
+ break
+ }
+ if (!isEmptyValue(src, !config.ShouldNotDereference) || overwriteWithEmptySrc || overwriteSliceWithEmptySrc) && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) && !config.AppendSlice && !sliceDeepCopy {
+ dst.Set(src)
+ } else if config.AppendSlice {
+ if src.Type() != dst.Type() {
+ return fmt.Errorf("cannot append two slice with different type (%s, %s)", src.Type(), dst.Type())
+ }
+ dst.Set(reflect.AppendSlice(dst, src))
+ } else if sliceDeepCopy {
+ for i := 0; i < src.Len() && i < dst.Len(); i++ {
+ srcElement := src.Index(i)
+ dstElement := dst.Index(i)
+ if srcElement.CanInterface() {
+ srcElement = reflect.ValueOf(srcElement.Interface())
+ }
+ if dstElement.CanInterface() {
+ dstElement = reflect.ValueOf(dstElement.Interface())
+ }
+
+ if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
+ return
+ }
+ }
+ }
+ case reflect.Ptr:
+ fallthrough
+ case reflect.Interface:
+ if isReflectNil(src) {
+ if overwriteWithEmptySrc && dst.CanSet() && src.Type().AssignableTo(dst.Type()) {
+ dst.Set(src)
+ }
+ break
+ }
+
+ if src.Kind() != reflect.Interface {
+ if dst.IsNil() || (src.Kind() != reflect.Ptr && overwrite) {
+ if dst.CanSet() && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) {
+ dst.Set(src)
+ }
+ } else if src.Kind() == reflect.Ptr {
+ if !config.ShouldNotDereference {
+ if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
+ return
+ }
+ } else if src.Elem().Kind() != reflect.Struct {
+ if overwriteWithEmptySrc || (overwrite && !src.IsNil()) || dst.IsNil() {
+ dst.Set(src)
+ }
+ }
+ } else if dst.Elem().Type() == src.Type() {
+ if err = deepMerge(dst.Elem(), src, visited, depth+1, config); err != nil {
+ return
+ }
+ } else {
+ return ErrDifferentArgumentsTypes
+ }
+ break
+ }
+
+ if dst.IsNil() || overwrite {
+ if dst.CanSet() && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) {
+ dst.Set(src)
+ }
+ break
+ }
+
+ if dst.Elem().Kind() == src.Elem().Kind() {
+ if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
+ return
+ }
+ break
+ }
+ default:
+ mustSet := (isEmptyValue(dst, !config.ShouldNotDereference) || overwrite) && (!isEmptyValue(src, !config.ShouldNotDereference) || overwriteWithEmptySrc)
+ if mustSet {
+ if dst.CanSet() {
+ dst.Set(src)
+ } else {
+ dst = src
+ }
+ }
+ }
+
+ return
+}
+
+// Merge will fill any empty for value type attributes on the dst struct using corresponding
+// src attributes if they themselves are not empty. dst and src must be valid same-type structs
+// and dst must be a pointer to struct.
+// It won't merge unexported (private) fields and will do recursively any exported field.
+func Merge(dst, src interface{}, opts ...func(*Config)) error {
+ return merge(dst, src, opts...)
+}
+
+// MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overridden by
+// non-empty src attribute values.
+// Deprecated: use Merge(…) with WithOverride
+func MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {
+ return merge(dst, src, append(opts, WithOverride)...)
+}
+
+// WithTransformers adds transformers to merge, allowing to customize the merging of some types.
+func WithTransformers(transformers Transformers) func(*Config) {
+ return func(config *Config) {
+ config.Transformers = transformers
+ }
+}
+
+// WithOverride will make merge override non-empty dst attributes with non-empty src attributes values.
+func WithOverride(config *Config) {
+ config.Overwrite = true
+}
+
+// WithOverwriteWithEmptyValue will make merge override non empty dst attributes with empty src attributes values.
+func WithOverwriteWithEmptyValue(config *Config) {
+ config.Overwrite = true
+ config.overwriteWithEmptyValue = true
+}
+
+// WithOverrideEmptySlice will make merge override empty dst slice with empty src slice.
+func WithOverrideEmptySlice(config *Config) {
+ config.overwriteSliceWithEmptyValue = true
+}
+
+// WithoutDereference prevents dereferencing pointers when evaluating whether they are empty
+// (i.e. a non-nil pointer is never considered empty).
+func WithoutDereference(config *Config) {
+ config.ShouldNotDereference = true
+}
+
+// WithAppendSlice will make merge append slices instead of overwriting it.
+func WithAppendSlice(config *Config) {
+ config.AppendSlice = true
+}
+
+// WithTypeCheck will make merge check types while overwriting it (must be used with WithOverride).
+func WithTypeCheck(config *Config) {
+ config.TypeCheck = true
+}
+
+// WithSliceDeepCopy will merge slice element one by one with Overwrite flag.
+func WithSliceDeepCopy(config *Config) {
+ config.sliceDeepCopy = true
+ config.Overwrite = true
+}
+
+func merge(dst, src interface{}, opts ...func(*Config)) error {
+ if dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr {
+ return ErrNonPointerArgument
+ }
+ var (
+ vDst, vSrc reflect.Value
+ err error
+ )
+
+ config := &Config{}
+
+ for _, opt := range opts {
+ opt(config)
+ }
+
+ if vDst, vSrc, err = resolveValues(dst, src); err != nil {
+ return err
+ }
+ if vDst.Type() != vSrc.Type() {
+ return ErrDifferentArgumentsTypes
+ }
+ return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)
+}
+
+// IsReflectNil is the reflect value provided nil
+func isReflectNil(v reflect.Value) bool {
+ k := v.Kind()
+ switch k {
+ case reflect.Interface, reflect.Slice, reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr:
+ // Both interface and slice are nil if first word is 0.
+ // Both are always bigger than a word; assume flagIndir.
+ return v.IsNil()
+ default:
+ return false
+ }
+}
diff --git a/vendor/dario.cat/mergo/mergo.go b/vendor/dario.cat/mergo/mergo.go
new file mode 100644
index 0000000000..0a721e2d85
--- /dev/null
+++ b/vendor/dario.cat/mergo/mergo.go
@@ -0,0 +1,81 @@
+// Copyright 2013 Dario Castañé. All rights reserved.
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Based on src/pkg/reflect/deepequal.go from official
+// golang's stdlib.
+
+package mergo
+
+import (
+ "errors"
+ "reflect"
+)
+
+// Errors reported by Mergo when it finds invalid arguments.
+var (
+ ErrNilArguments = errors.New("src and dst must not be nil")
+ ErrDifferentArgumentsTypes = errors.New("src and dst must be of same type")
+ ErrNotSupported = errors.New("only structs, maps, and slices are supported")
+ ErrExpectedMapAsDestination = errors.New("dst was expected to be a map")
+ ErrExpectedStructAsDestination = errors.New("dst was expected to be a struct")
+ ErrNonPointerArgument = errors.New("dst must be a pointer")
+)
+
+// During deepMerge, must keep track of checks that are
+// in progress. The comparison algorithm assumes that all
+// checks in progress are true when it reencounters them.
+// Visited are stored in a map indexed by 17 * a1 + a2;
+type visit struct {
+ typ reflect.Type
+ next *visit
+ ptr uintptr
+}
+
+// From src/pkg/encoding/json/encode.go.
+func isEmptyValue(v reflect.Value, shouldDereference bool) bool {
+ switch v.Kind() {
+ case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+ return v.Len() == 0
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v.Uint() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.Interface, reflect.Ptr:
+ if v.IsNil() {
+ return true
+ }
+ if shouldDereference {
+ return isEmptyValue(v.Elem(), shouldDereference)
+ }
+ return false
+ case reflect.Func:
+ return v.IsNil()
+ case reflect.Invalid:
+ return true
+ }
+ return false
+}
+
+func resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) {
+ if dst == nil || src == nil {
+ err = ErrNilArguments
+ return
+ }
+ vDst = reflect.ValueOf(dst).Elem()
+ if vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map && vDst.Kind() != reflect.Slice {
+ err = ErrNotSupported
+ return
+ }
+ vSrc = reflect.ValueOf(src)
+ // We check if vSrc is a pointer to dereference it.
+ if vSrc.Kind() == reflect.Ptr {
+ vSrc = vSrc.Elem()
+ }
+ return
+}
diff --git a/vendor/github.com/Masterminds/semver/v3/CHANGELOG.md b/vendor/github.com/Masterminds/semver/v3/CHANGELOG.md
index f12626423a..f95a504fe7 100644
--- a/vendor/github.com/Masterminds/semver/v3/CHANGELOG.md
+++ b/vendor/github.com/Masterminds/semver/v3/CHANGELOG.md
@@ -1,5 +1,33 @@
# Changelog
+## 3.3.0 (2024-08-27)
+
+### Added
+
+- #238: Add LessThanEqual and GreaterThanEqual functions (thanks @grosser)
+- #213: nil version equality checking (thanks @KnutZuidema)
+
+### Changed
+
+- #241: Simplify StrictNewVersion parsing (thanks @grosser)
+- Testing support up through Go 1.23
+- Minimum version set to 1.21 as this is what's tested now
+- Fuzz testing now supports caching
+
+## 3.2.1 (2023-04-10)
+
+### Changed
+
+- #198: Improved testing around pre-release names
+- #200: Improved code scanning with addition of CodeQL
+- #201: Testing now includes Go 1.20. Go 1.17 has been dropped
+- #202: Migrated Fuzz testing to Go built-in Fuzzing. CI runs daily
+- #203: Docs updated for security details
+
+### Fixed
+
+- #199: Fixed issue with range transformations
+
## 3.2.0 (2022-11-28)
### Added
diff --git a/vendor/github.com/Masterminds/semver/v3/Makefile b/vendor/github.com/Masterminds/semver/v3/Makefile
index 0e7b5c7138..9ca87a2c79 100644
--- a/vendor/github.com/Masterminds/semver/v3/Makefile
+++ b/vendor/github.com/Masterminds/semver/v3/Makefile
@@ -19,6 +19,7 @@ test-cover:
.PHONY: fuzz
fuzz:
@echo "==> Running Fuzz Tests"
+ go env GOCACHE
go test -fuzz=FuzzNewVersion -fuzztime=15s .
go test -fuzz=FuzzStrictNewVersion -fuzztime=15s .
go test -fuzz=FuzzNewConstraint -fuzztime=15s .
@@ -27,4 +28,4 @@ $(GOLANGCI_LINT):
# Install golangci-lint. The configuration for it is in the .golangci.yml
# file in the root of the repository
echo ${GOPATH}
- curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(GOPATH)/bin v1.17.1
+ curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(GOPATH)/bin v1.56.2
diff --git a/vendor/github.com/Masterminds/semver/v3/README.md b/vendor/github.com/Masterminds/semver/v3/README.md
index eab8cac3b7..ed56936084 100644
--- a/vendor/github.com/Masterminds/semver/v3/README.md
+++ b/vendor/github.com/Masterminds/semver/v3/README.md
@@ -13,12 +13,9 @@ Active](https://masterminds.github.io/stability/active.svg)](https://masterminds
[](https://pkg.go.dev/github.com/Masterminds/semver/v3)
[](https://goreportcard.com/report/github.com/Masterminds/semver)
-If you are looking for a command line tool for version comparisons please see
-[vert](https://github.com/Masterminds/vert) which uses this library.
-
## Package Versions
-Note, import `github.com/github.com/Masterminds/semver/v3` to use the latest version.
+Note, import `github.com/Masterminds/semver/v3` to use the latest version.
There are three major versions fo the `semver` package.
@@ -80,12 +77,12 @@ There are two methods for comparing versions. One uses comparison methods on
differences to notes between these two methods of comparison.
1. When two versions are compared using functions such as `Compare`, `LessThan`,
- and others it will follow the specification and always include prereleases
+ and others it will follow the specification and always include pre-releases
within the comparison. It will provide an answer that is valid with the
comparison section of the spec at https://semver.org/#spec-item-11
2. When constraint checking is used for checks or validation it will follow a
different set of rules that are common for ranges with tools like npm/js
- and Rust/Cargo. This includes considering prereleases to be invalid if the
+ and Rust/Cargo. This includes considering pre-releases to be invalid if the
ranges does not include one. If you want to have it include pre-releases a
simple solution is to include `-0` in your range.
3. Constraint ranges can have some complex rules including the shorthand use of
@@ -113,7 +110,7 @@ v, err := semver.NewVersion("1.3")
if err != nil {
// Handle version not being parsable.
}
-// Check if the version meets the constraints. The a variable will be true.
+// Check if the version meets the constraints. The variable a will be true.
a := c.Check(v)
```
@@ -137,20 +134,20 @@ The basic comparisons are:
### Working With Prerelease Versions
Pre-releases, for those not familiar with them, are used for software releases
-prior to stable or generally available releases. Examples of prereleases include
-development, alpha, beta, and release candidate releases. A prerelease may be
+prior to stable or generally available releases. Examples of pre-releases include
+development, alpha, beta, and release candidate releases. A pre-release may be
a version such as `1.2.3-beta.1` while the stable release would be `1.2.3`. In the
-order of precedence, prereleases come before their associated releases. In this
+order of precedence, pre-releases come before their associated releases. In this
example `1.2.3-beta.1 < 1.2.3`.
-According to the Semantic Version specification prereleases may not be
+According to the Semantic Version specification, pre-releases may not be
API compliant with their release counterpart. It says,
> A pre-release version indicates that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version.
-SemVer comparisons using constraints without a prerelease comparator will skip
-prerelease versions. For example, `>=1.2.3` will skip prereleases when looking
-at a list of releases while `>=1.2.3-0` will evaluate and find prereleases.
+SemVer's comparisons using constraints without a pre-release comparator will skip
+pre-release versions. For example, `>=1.2.3` will skip pre-releases when looking
+at a list of releases while `>=1.2.3-0` will evaluate and find pre-releases.
The reason for the `0` as a pre-release version in the example comparison is
because pre-releases can only contain ASCII alphanumerics and hyphens (along with
@@ -171,6 +168,9 @@ These look like:
* `1.2 - 1.4.5` which is equivalent to `>= 1.2 <= 1.4.5`
* `2.3.4 - 4.5` which is equivalent to `>= 2.3.4 <= 4.5`
+Note that `1.2-1.4.5` without whitespace is parsed completely differently; it's
+parsed as a single constraint `1.2.0` with _prerelease_ `1.4.5`.
+
### Wildcards In Comparisons
The `x`, `X`, and `*` characters can be used as a wildcard character. This works
diff --git a/vendor/github.com/Masterminds/semver/v3/version.go b/vendor/github.com/Masterminds/semver/v3/version.go
index 7c4bed3347..ff499fb664 100644
--- a/vendor/github.com/Masterminds/semver/v3/version.go
+++ b/vendor/github.com/Masterminds/semver/v3/version.go
@@ -83,22 +83,23 @@ func StrictNewVersion(v string) (*Version, error) {
original: v,
}
- // check for prerelease or build metadata
- var extra []string
- if strings.ContainsAny(parts[2], "-+") {
- // Start with the build metadata first as it needs to be on the right
- extra = strings.SplitN(parts[2], "+", 2)
- if len(extra) > 1 {
- // build metadata found
- sv.metadata = extra[1]
- parts[2] = extra[0]
+ // Extract build metadata
+ if strings.Contains(parts[2], "+") {
+ extra := strings.SplitN(parts[2], "+", 2)
+ sv.metadata = extra[1]
+ parts[2] = extra[0]
+ if err := validateMetadata(sv.metadata); err != nil {
+ return nil, err
}
+ }
- extra = strings.SplitN(parts[2], "-", 2)
- if len(extra) > 1 {
- // prerelease found
- sv.pre = extra[1]
- parts[2] = extra[0]
+ // Extract build prerelease
+ if strings.Contains(parts[2], "-") {
+ extra := strings.SplitN(parts[2], "-", 2)
+ sv.pre = extra[1]
+ parts[2] = extra[0]
+ if err := validatePrerelease(sv.pre); err != nil {
+ return nil, err
}
}
@@ -114,7 +115,7 @@ func StrictNewVersion(v string) (*Version, error) {
}
}
- // Extract the major, minor, and patch elements onto the returned Version
+ // Extract major, minor, and patch
var err error
sv.major, err = strconv.ParseUint(parts[0], 10, 64)
if err != nil {
@@ -131,23 +132,6 @@ func StrictNewVersion(v string) (*Version, error) {
return nil, err
}
- // No prerelease or build metadata found so returning now as a fastpath.
- if sv.pre == "" && sv.metadata == "" {
- return sv, nil
- }
-
- if sv.pre != "" {
- if err = validatePrerelease(sv.pre); err != nil {
- return nil, err
- }
- }
-
- if sv.metadata != "" {
- if err = validateMetadata(sv.metadata); err != nil {
- return nil, err
- }
- }
-
return sv, nil
}
@@ -381,15 +365,31 @@ func (v *Version) LessThan(o *Version) bool {
return v.Compare(o) < 0
}
+// LessThanEqual tests if one version is less or equal than another one.
+func (v *Version) LessThanEqual(o *Version) bool {
+ return v.Compare(o) <= 0
+}
+
// GreaterThan tests if one version is greater than another one.
func (v *Version) GreaterThan(o *Version) bool {
return v.Compare(o) > 0
}
+// GreaterThanEqual tests if one version is greater or equal than another one.
+func (v *Version) GreaterThanEqual(o *Version) bool {
+ return v.Compare(o) >= 0
+}
+
// Equal tests if two versions are equal to each other.
// Note, versions can be equal with different metadata since metadata
// is not considered part of the comparable version.
func (v *Version) Equal(o *Version) bool {
+ if v == o {
+ return true
+ }
+ if v == nil || o == nil {
+ return false
+ }
return v.Compare(o) == 0
}
diff --git a/vendor/github.com/Masterminds/sprig/v3/CHANGELOG.md b/vendor/github.com/Masterminds/sprig/v3/CHANGELOG.md
index 2ce45dd4ec..b5ef766a7a 100644
--- a/vendor/github.com/Masterminds/sprig/v3/CHANGELOG.md
+++ b/vendor/github.com/Masterminds/sprig/v3/CHANGELOG.md
@@ -1,5 +1,23 @@
# Changelog
+## Release 3.3.0 (2024-08-29)
+
+### Added
+
+- #400: added sha512sum function (thanks @itzik-elayev)
+
+### Changed
+
+- #407: Removed duplicate documentation (functions were documentated in 2 places)
+- #290: Corrected copy/paster oops in math documentation (thanks @zzhu41)
+- #369: Corrected template reference in docs (thanks @chey)
+- #375: Added link to URL documenation (thanks @carlpett)
+- #406: Updated the mergo dependency which had a breaking change (which was accounted for)
+- #376: Fixed documentation error (thanks @jheyduk)
+- #404: Updated dependency tree
+- #391: Fixed misspelling (thanks @chrishalbert)
+- #405: Updated Go versions used in testing
+
## Release 3.2.3 (2022-11-29)
### Changed
@@ -307,7 +325,7 @@ This release adds new functions, including:
- Added `semver` and `semverCompare` for Semantic Versions
- `list` replaces `tuple`
- Fixed issue with `join`
-- Added `first`, `last`, `intial`, `rest`, `prepend`, `append`, `toString`, `toStrings`, `sortAlpha`, `reverse`, `coalesce`, `pluck`, `pick`, `compact`, `keys`, `omit`, `uniq`, `has`, `without`
+- Added `first`, `last`, `initial`, `rest`, `prepend`, `append`, `toString`, `toStrings`, `sortAlpha`, `reverse`, `coalesce`, `pluck`, `pick`, `compact`, `keys`, `omit`, `uniq`, `has`, `without`
## Release 2.9.0 (2017-02-23)
@@ -361,7 +379,7 @@ Because we switched from `int` to `int64` as the return value for all integer ma
- `min` complements `max` (formerly `biggest`)
- `empty` indicates that a value is the empty value for its type
- `tuple` creates a tuple inside of a template: `{{$t := tuple "a", "b" "c"}}`
-- `dict` creates a dictionary inside of a template `{{$d := dict "key1" "val1" "key2" "val2"}}`
+- `dict` creates a dictionary inside of a template `{{$d := dict "key1" "val1" "key2" "val2"}}`
- Date formatters have been added for HTML dates (as used in `date` input fields)
- Integer math functions can convert from a number of types, including `string` (via `strconv.ParseInt`).
diff --git a/vendor/github.com/Masterminds/sprig/v3/crypto.go b/vendor/github.com/Masterminds/sprig/v3/crypto.go
index 13a5cd5593..75fe027e4d 100644
--- a/vendor/github.com/Masterminds/sprig/v3/crypto.go
+++ b/vendor/github.com/Masterminds/sprig/v3/crypto.go
@@ -14,6 +14,7 @@ import (
"crypto/rsa"
"crypto/sha1"
"crypto/sha256"
+ "crypto/sha512"
"crypto/x509"
"crypto/x509/pkix"
"encoding/asn1"
@@ -36,6 +37,11 @@ import (
"golang.org/x/crypto/scrypt"
)
+func sha512sum(input string) string {
+ hash := sha512.Sum512([]byte(input))
+ return hex.EncodeToString(hash[:])
+}
+
func sha256sum(input string) string {
hash := sha256.Sum256([]byte(input))
return hex.EncodeToString(hash[:])
diff --git a/vendor/github.com/Masterminds/sprig/v3/dict.go b/vendor/github.com/Masterminds/sprig/v3/dict.go
index ade8896984..4315b3542a 100644
--- a/vendor/github.com/Masterminds/sprig/v3/dict.go
+++ b/vendor/github.com/Masterminds/sprig/v3/dict.go
@@ -1,7 +1,7 @@
package sprig
import (
- "github.com/imdario/mergo"
+ "dario.cat/mergo"
"github.com/mitchellh/copystructure"
)
diff --git a/vendor/github.com/Masterminds/sprig/v3/doc.go b/vendor/github.com/Masterminds/sprig/v3/doc.go
index aabb9d4489..91031d6d19 100644
--- a/vendor/github.com/Masterminds/sprig/v3/doc.go
+++ b/vendor/github.com/Masterminds/sprig/v3/doc.go
@@ -6,7 +6,7 @@ inside of Go `html/template` and `text/template` files.
To add these functions, use the `template.Funcs()` method:
- t := templates.New("foo").Funcs(sprig.FuncMap())
+ t := template.New("foo").Funcs(sprig.FuncMap())
Note that you should add the function map before you parse any template files.
diff --git a/vendor/github.com/Masterminds/sprig/v3/functions.go b/vendor/github.com/Masterminds/sprig/v3/functions.go
index 57fcec1d9e..cda47d26f2 100644
--- a/vendor/github.com/Masterminds/sprig/v3/functions.go
+++ b/vendor/github.com/Masterminds/sprig/v3/functions.go
@@ -22,8 +22,7 @@ import (
//
// Use this to pass the functions into the template engine:
//
-// tpl := template.New("foo").Funcs(sprig.FuncMap()))
-//
+// tpl := template.New("foo").Funcs(sprig.FuncMap()))
func FuncMap() template.FuncMap {
return HtmlFuncMap()
}
@@ -142,10 +141,13 @@ var genericMap = map[string]interface{}{
"swapcase": util.SwapCase,
"shuffle": xstrings.Shuffle,
"snakecase": xstrings.ToSnakeCase,
- "camelcase": xstrings.ToCamelCase,
- "kebabcase": xstrings.ToKebabCase,
- "wrap": func(l int, s string) string { return util.Wrap(s, l) },
- "wrapWith": func(l int, sep, str string) string { return util.WrapCustom(str, l, sep, true) },
+ // camelcase used to call xstrings.ToCamelCase, but that function had a breaking change in version
+ // 1.5 that moved it from upper camel case to lower camel case. This is a breaking change for sprig.
+ // A new xstrings.ToPascalCase function was added that provided upper camel case.
+ "camelcase": xstrings.ToPascalCase,
+ "kebabcase": xstrings.ToKebabCase,
+ "wrap": func(l int, s string) string { return util.Wrap(s, l) },
+ "wrapWith": func(l int, sep, str string) string { return util.WrapCustom(str, l, sep, true) },
// Switch order so that "foobar" | contains "foo"
"contains": func(substr string, str string) bool { return strings.Contains(str, substr) },
"hasPrefix": func(substr string, str string) bool { return strings.HasPrefix(str, substr) },
@@ -159,6 +161,7 @@ var genericMap = map[string]interface{}{
"plural": plural,
"sha1sum": sha1sum,
"sha256sum": sha256sum,
+ "sha512sum": sha512sum,
"adler32sum": adler32sum,
"toString": strval,
@@ -336,20 +339,20 @@ var genericMap = map[string]interface{}{
"mustChunk": mustChunk,
// Crypto:
- "bcrypt": bcrypt,
- "htpasswd": htpasswd,
- "genPrivateKey": generatePrivateKey,
- "derivePassword": derivePassword,
- "buildCustomCert": buildCustomCertificate,
- "genCA": generateCertificateAuthority,
- "genCAWithKey": generateCertificateAuthorityWithPEMKey,
- "genSelfSignedCert": generateSelfSignedCertificate,
+ "bcrypt": bcrypt,
+ "htpasswd": htpasswd,
+ "genPrivateKey": generatePrivateKey,
+ "derivePassword": derivePassword,
+ "buildCustomCert": buildCustomCertificate,
+ "genCA": generateCertificateAuthority,
+ "genCAWithKey": generateCertificateAuthorityWithPEMKey,
+ "genSelfSignedCert": generateSelfSignedCertificate,
"genSelfSignedCertWithKey": generateSelfSignedCertificateWithPEMKey,
- "genSignedCert": generateSignedCertificate,
- "genSignedCertWithKey": generateSignedCertificateWithPEMKey,
- "encryptAES": encryptAES,
- "decryptAES": decryptAES,
- "randBytes": randBytes,
+ "genSignedCert": generateSignedCertificate,
+ "genSignedCertWithKey": generateSignedCertificateWithPEMKey,
+ "encryptAES": encryptAES,
+ "decryptAES": decryptAES,
+ "randBytes": randBytes,
// UUIDs:
"uuidv4": uuidv4,
diff --git a/vendor/github.com/cilium/charts/README.md b/vendor/github.com/cilium/charts/README.md
index 7ba0702cc6..9368c5e55e 100644
--- a/vendor/github.com/cilium/charts/README.md
+++ b/vendor/github.com/cilium/charts/README.md
@@ -1,5 +1,6 @@
This repository holds helm templates for the following Cilium releases:
+* [v1.17.0-pre.0](https://github.com/cilium/cilium/releases/tag/v1.17.0-pre.0) (_[source](https://github.com/cilium/cilium/tree/v1.17.0-pre.0/install/kubernetes/cilium)_)
* [v1.16.1](https://github.com/cilium/cilium/releases/tag/v1.16.1) (_[source](https://github.com/cilium/cilium/tree/v1.16.1/install/kubernetes/cilium)_)
* [v1.16.0](https://github.com/cilium/cilium/releases/tag/v1.16.0) (_[source](https://github.com/cilium/cilium/tree/v1.16.0/install/kubernetes/cilium)_)
* [v1.16.0-rc.2](https://github.com/cilium/cilium/releases/tag/v1.16.0-rc.2) (_[source](https://github.com/cilium/cilium/tree/v1.16.0-rc.2/install/kubernetes/cilium)_)
@@ -215,6 +216,7 @@ This repository holds helm templates for the following Cilium releases:
This repository holds helm templates for the following Tetragon releases:
+* [v1.2.0](https://github.com/cilium/tetragon/releases/tag/v1.2.0) (_[source](https://github.com/cilium/tetragon/tree/v1.2.0/install/kubernetes/tetragon)_)
* [v1.1.2](https://github.com/cilium/tetragon/releases/tag/v1.1.2) (_[source](https://github.com/cilium/tetragon/tree/v1.1.2/install/kubernetes/tetragon)_)
* [v1.1.0](https://github.com/cilium/tetragon/releases/tag/v1.1.0) (_[source](https://github.com/cilium/tetragon/tree/v1.1.0/install/kubernetes/tetragon)_)
* [v1.0.3](https://github.com/cilium/tetragon/releases/tag/v1.0.3) (_[source](https://github.com/cilium/tetragon/tree/v1.0.3/install/kubernetes)_)
diff --git a/vendor/github.com/cilium/charts/cilium-1.17.0-pre.0.tgz b/vendor/github.com/cilium/charts/cilium-1.17.0-pre.0.tgz
new file mode 100644
index 0000000000..1d36f41b12
Binary files /dev/null and b/vendor/github.com/cilium/charts/cilium-1.17.0-pre.0.tgz differ
diff --git a/vendor/github.com/cilium/charts/index.yaml b/vendor/github.com/cilium/charts/index.yaml
index 076c7524e0..c9de75db71 100644
--- a/vendor/github.com/cilium/charts/index.yaml
+++ b/vendor/github.com/cilium/charts/index.yaml
@@ -1,6 +1,112 @@
apiVersion: v1
entries:
cilium:
+ - annotations:
+ artifacthub.io/crds: "- kind: CiliumNetworkPolicy\n version: v2\n name: ciliumnetworkpolicies.cilium.io\n
+ \ displayName: Cilium Network Policy\n description: |\n Cilium Network
+ Policies provide additional functionality beyond what\n is provided by
+ standard Kubernetes NetworkPolicy such as the ability\n to allow traffic
+ based on FQDNs, or to filter at Layer 7.\n- kind: CiliumClusterwideNetworkPolicy\n
+ \ version: v2\n name: ciliumclusterwidenetworkpolicies.cilium.io\n displayName:
+ Cilium Clusterwide Network Policy\n description: |\n Cilium Clusterwide
+ Network Policies support configuring network traffic\n policiies across
+ the entire cluster, including applying node firewalls.\n- kind: CiliumExternalWorkload\n
+ \ version: v2\n name: ciliumexternalworkloads.cilium.io\n displayName: Cilium
+ External Workload\n description: |\n Cilium External Workload supports
+ configuring the ability for external\n non-Kubernetes workloads to join
+ the cluster.\n- kind: CiliumLocalRedirectPolicy\n version: v2\n name: ciliumlocalredirectpolicies.cilium.io\n
+ \ displayName: Cilium Local Redirect Policy\n description: |\n Cilium
+ Local Redirect Policy allows local redirects to be configured\n within
+ a node to support use cases like Node-Local DNS or KIAM.\n- kind: CiliumNode\n
+ \ version: v2\n name: ciliumnodes.cilium.io\n displayName: Cilium Node\n
+ \ description: |\n Cilium Node represents a node managed by Cilium. It
+ contains a\n specification to control various node specific configuration
+ aspects\n and a status section to represent the status of the node.\n-
+ kind: CiliumIdentity\n version: v2\n name: ciliumidentities.cilium.io\n
+ \ displayName: Cilium Identity\n description: |\n Cilium Identity allows
+ introspection into security identities that\n Cilium allocates which identify
+ sets of labels that are assigned to\n individual endpoints in the cluster.\n-
+ kind: CiliumEndpoint\n version: v2\n name: ciliumendpoints.cilium.io\n displayName:
+ Cilium Endpoint\n description: |\n Cilium Endpoint represents the status
+ of individual pods or nodes in\n the cluster which are managed by Cilium,
+ including enforcement status,\n IP addressing and whether the networking
+ is successfully operational.\n- kind: CiliumEndpointSlice\n version: v2alpha1\n
+ \ name: ciliumendpointslices.cilium.io\n displayName: Cilium Endpoint Slice\n
+ \ description: |\n Cilium Endpoint Slice represents the status of groups
+ of pods or nodes\n in the cluster which are managed by Cilium, including
+ enforcement status,\n IP addressing and whether the networking is successfully
+ operational.\n- kind: CiliumEgressGatewayPolicy\n version: v2\n name: ciliumegressgatewaypolicies.cilium.io\n
+ \ displayName: Cilium Egress Gateway Policy\n description: |\n Cilium
+ Egress Gateway Policy provides control over the way that traffic\n leaves
+ the cluster and which source addresses to use for that traffic.\n- kind: CiliumClusterwideEnvoyConfig\n
+ \ version: v2\n name: ciliumclusterwideenvoyconfigs.cilium.io\n displayName:
+ Cilium Clusterwide Envoy Config\n description: |\n Cilium Clusterwide
+ Envoy Config specifies Envoy resources and K8s service mappings\n to be
+ provisioned into Cilium host proxy instances in cluster context.\n- kind:
+ CiliumEnvoyConfig\n version: v2\n name: ciliumenvoyconfigs.cilium.io\n displayName:
+ Cilium Envoy Config\n description: |\n Cilium Envoy Config specifies Envoy
+ resources and K8s service mappings\n to be provisioned into Cilium host
+ proxy instances in namespace context.\n- kind: CiliumBGPPeeringPolicy\n version:
+ v2alpha1\n name: ciliumbgppeeringpolicies.cilium.io\n displayName: Cilium
+ BGP Peering Policy\n description: |\n Cilium BGP Peering Policy instructs
+ Cilium to create specific BGP peering\n configurations.\n- kind: CiliumBGPClusterConfig\n
+ \ version: v2alpha1\n name: ciliumbgpclusterconfigs.cilium.io\n displayName:
+ Cilium BGP Cluster Config\n description: |\n Cilium BGP Cluster Config
+ instructs Cilium operator to create specific BGP cluster\n configurations.\n-
+ kind: CiliumBGPPeerConfig\n version: v2alpha1\n name: ciliumbgppeerconfigs.cilium.io\n
+ \ displayName: Cilium BGP Peer Config\n description: |\n CiliumBGPPeerConfig
+ is a common set of BGP peer configurations. It can be referenced \n by
+ multiple peers from CiliumBGPClusterConfig.\n- kind: CiliumBGPAdvertisement\n
+ \ version: v2alpha1\n name: ciliumbgpadvertisements.cilium.io\n displayName:
+ Cilium BGP Advertisement\n description: |\n CiliumBGPAdvertisement is
+ used to define source of BGP advertisement as well as BGP attributes \n to
+ be advertised with those prefixes.\n- kind: CiliumBGPNodeConfig\n version:
+ v2alpha1\n name: ciliumbgpnodeconfigs.cilium.io\n displayName: Cilium BGP
+ Node Config\n description: |\n CiliumBGPNodeConfig is read only node specific
+ BGP configuration. It is constructed by Cilium operator.\n It will also
+ contain node local BGP state information.\n- kind: CiliumBGPNodeConfigOverride\n
+ \ version: v2alpha1\n name: ciliumbgpnodeconfigoverrides.cilium.io\n displayName:
+ Cilium BGP Node Config Override\n description: |\n CiliumBGPNodeConfigOverride
+ can be used to override node specific BGP configuration.\n- kind: CiliumLoadBalancerIPPool\n
+ \ version: v2alpha1\n name: ciliumloadbalancerippools.cilium.io\n displayName:
+ Cilium Load Balancer IP Pool\n description: |\n Defining a Cilium Load
+ Balancer IP Pool instructs Cilium to assign IPs to LoadBalancer Services.\n-
+ kind: CiliumNodeConfig\n version: v2alpha1\n name: ciliumnodeconfigs.cilium.io\n
+ \ displayName: Cilium Node Configuration\n description: |\n CiliumNodeConfig
+ is a list of configuration key-value pairs. It is applied to\n nodes indicated
+ by a label selector.\n- kind: CiliumCIDRGroup\n version: v2alpha1\n name:
+ ciliumcidrgroups.cilium.io\n displayName: Cilium CIDR Group\n description:
+ |\n CiliumCIDRGroup is a list of CIDRs that can be referenced as a single
+ entity from CiliumNetworkPolicies.\n- kind: CiliumL2AnnouncementPolicy\n version:
+ v2alpha1\n name: ciliuml2announcementpolicies.cilium.io\n displayName: Cilium
+ L2 Announcement Policy\n description: |\n CiliumL2AnnouncementPolicy is
+ a policy which determines which service IPs will be announced to\n the
+ local area network, by which nodes, and via which interfaces.\n- kind: CiliumPodIPPool\n
+ \ version: v2alpha1\n name: ciliumpodippools.cilium.io\n displayName: Cilium
+ Pod IP Pool\n description: |\n CiliumPodIPPool defines an IP pool that
+ can be used for pooled IPAM (i.e. the multi-pool IPAM mode).\n"
+ apiVersion: v2
+ appVersion: 1.17.0-pre.0
+ created: "2024-09-05T09:21:38.425895279Z"
+ description: eBPF-based Networking, Security, and Observability
+ digest: b09c94dfee569ff7426af691ff7e5c5620df6187993f9f29155106160fa8be85
+ home: https://cilium.io/
+ icon: https://cdn.jsdelivr.net/gh/cilium/cilium@main/Documentation/images/logo-solo.svg
+ keywords:
+ - BPF
+ - eBPF
+ - Kubernetes
+ - Networking
+ - Security
+ - Observability
+ - Troubleshooting
+ kubeVersion: '>= 1.21.0-0'
+ name: cilium
+ sources:
+ - https://github.com/cilium/cilium
+ urls:
+ - cilium-1.17.0-pre.0.tgz
+ version: 1.17.0-pre.0
- annotations:
artifacthub.io/crds: "- kind: CiliumNetworkPolicy\n version: v2\n name: ciliumnetworkpolicies.cilium.io\n
\ displayName: Cilium Network Policy\n description: |\n Cilium Network
@@ -19438,6 +19544,16 @@ entries:
- cilium-1.6.5.tgz
version: 1.6.5
tetragon:
+ - apiVersion: v2
+ appVersion: 1.2.0
+ created: "2024-09-05T13:21:20.070471945Z"
+ description: Helm chart for Tetragon
+ digest: 711faa2847966e52323f92e50ca5da69a462046470a2427176d273b1e1899d8e
+ name: tetragon
+ type: application
+ urls:
+ - tetragon-1.2.0.tgz
+ version: 1.2.0
- apiVersion: v2
appVersion: 1.1.2
created: "2024-06-12T13:47:35.499542532Z"
@@ -19618,4 +19734,4 @@ entries:
urls:
- tetragon-0.8.0.tgz
version: 0.8.0
-generated: "2024-08-14T12:57:36.96901942Z"
+generated: "2024-09-05T13:21:20.06903384Z"
diff --git a/vendor/github.com/cilium/charts/tetragon-1.2.0.tgz b/vendor/github.com/cilium/charts/tetragon-1.2.0.tgz
new file mode 100644
index 0000000000..e42dca3ebf
Binary files /dev/null and b/vendor/github.com/cilium/charts/tetragon-1.2.0.tgz differ
diff --git a/vendor/github.com/cilium/cilium/AUTHORS b/vendor/github.com/cilium/cilium/AUTHORS
index aa08cc59ed..36e1322ea3 100644
--- a/vendor/github.com/cilium/cilium/AUTHORS
+++ b/vendor/github.com/cilium/cilium/AUTHORS
@@ -163,6 +163,7 @@ Christoph Puhl cpu@isovalent.com
Chris Werner Rau cwrau@cwrau.info
ChrsMark chrismarkou92@gmail.com
Cilium Imagebot noreply@cilium.io
+Cilium Release Bot noreply@cilium.io
Cintia Sanchez Garcia cynthiasg@icloud.com
CJ Virtucio cjv287@gmail.com
Claudia J. Kang claudiajkang@gmail.com
@@ -207,7 +208,6 @@ David Bouchare david.bouchare@datadoghq.com
David Calvert david@0xdc.me
David Cheng david.cheng@shopline.com
David Chosrova dchosrova@gmail.com
-David CHOSROVA dchosrova@gmail.com
David Donchez donch@dailymotion.com
David Korczynski david@adalogics.com
David Leadbeater dgl@dgl.cx
@@ -506,8 +506,7 @@ Manuel Rüger manuel@rueg.eu
Manuel Stößel manuel.stoessel@t-systems.com
Marc Barry 4965634+marc-barry@users.noreply.github.com
Marcelo Moreira de Mello tchello.mello@gmail.com
-Marcel Zieba marcel.zieba@isovalent.com
-Marcel Zięba marseel@gmail.com
+Marcel Zięba marcel.zieba@isovalent.com
Marcin Skarbek git@skarbek.name
Marcin Swiderski forgems@gmail.com
Marco Aurelio Caldas Miranda 17923899+macmiranda@users.noreply.github.com
@@ -672,7 +671,7 @@ Priya Sharma Priya.Sharma6693@gmail.com
Qasim Sarfraz qasim.sarfraz@esailors.de
Qifeng Guo qifeng.guo@daocloud.io
Qingchuan Hao qinhao@microsoft.com
-Quentin Monnet quentin@isovalent.com
+Quentin Monnet qmo@qmon.net
Raam ram29@bskyb.com
Rachid Zarouali rachid.zarouali@sevensphere.io
Rafael da Fonseca rafael.fonseca@wildlifestudios.com
@@ -842,7 +841,6 @@ vakr vakr@microsoft.com
Valas Valancius valas@google.com
Vance Li vanceli@tencent.com
Vigneshwaren Sunder vickymailed@gmail.com
-viktor-kurchenko viktor.kurchenko@isovalent.com
Viktor Kurchenko viktor.kurchenko@isovalent.com
Viktor Kuzmin kvaster@gmail.com
Viktor Oreshkin imselfish@stek29.rocks
diff --git a/vendor/github.com/cilium/cilium/api/v1/flow/flow.pb.go b/vendor/github.com/cilium/cilium/api/v1/flow/flow.pb.go
index f3a4afb0b4..50b838fb72 100644
--- a/vendor/github.com/cilium/cilium/api/v1/flow/flow.pb.go
+++ b/vendor/github.com/cilium/cilium/api/v1/flow/flow.pb.go
@@ -4,7 +4,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.34.2
-// protoc v5.28.0
+// protoc v5.28.1
// source: flow/flow.proto
package flow
diff --git a/vendor/github.com/cilium/cilium/api/v1/models/bgp_route_policy_statement.go b/vendor/github.com/cilium/cilium/api/v1/models/bgp_route_policy_statement.go
index 00f0c0678e..46d29fd8d6 100644
--- a/vendor/github.com/cilium/cilium/api/v1/models/bgp_route_policy_statement.go
+++ b/vendor/github.com/cilium/cilium/api/v1/models/bgp_route_policy_statement.go
@@ -30,6 +30,9 @@ type BgpRoutePolicyStatement struct {
// List of BGP large community values to be added to the matched route
AddLargeCommunities []string `json:"add-large-communities"`
+ // Matches any of the provided address families. If empty matches all address families.
+ MatchFamilies []*BgpFamily `json:"match-families"`
+
// Matches any of the provided BGP neighbor IP addresses. If empty matches all neighbors.
MatchNeighbors []string `json:"match-neighbors"`
@@ -48,6 +51,10 @@ type BgpRoutePolicyStatement struct {
func (m *BgpRoutePolicyStatement) Validate(formats strfmt.Registry) error {
var res []error
+ if err := m.validateMatchFamilies(formats); err != nil {
+ res = append(res, err)
+ }
+
if err := m.validateMatchPrefixes(formats); err != nil {
res = append(res, err)
}
@@ -62,6 +69,32 @@ func (m *BgpRoutePolicyStatement) Validate(formats strfmt.Registry) error {
return nil
}
+func (m *BgpRoutePolicyStatement) validateMatchFamilies(formats strfmt.Registry) error {
+ if swag.IsZero(m.MatchFamilies) { // not required
+ return nil
+ }
+
+ for i := 0; i < len(m.MatchFamilies); i++ {
+ if swag.IsZero(m.MatchFamilies[i]) { // not required
+ continue
+ }
+
+ if m.MatchFamilies[i] != nil {
+ if err := m.MatchFamilies[i].Validate(formats); err != nil {
+ if ve, ok := err.(*errors.Validation); ok {
+ return ve.ValidateName("match-families" + "." + strconv.Itoa(i))
+ } else if ce, ok := err.(*errors.CompositeError); ok {
+ return ce.ValidateName("match-families" + "." + strconv.Itoa(i))
+ }
+ return err
+ }
+ }
+
+ }
+
+ return nil
+}
+
func (m *BgpRoutePolicyStatement) validateMatchPrefixes(formats strfmt.Registry) error {
if swag.IsZero(m.MatchPrefixes) { // not required
return nil
@@ -137,6 +170,10 @@ func (m *BgpRoutePolicyStatement) validateRouteAction(formats strfmt.Registry) e
func (m *BgpRoutePolicyStatement) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
var res []error
+ if err := m.contextValidateMatchFamilies(ctx, formats); err != nil {
+ res = append(res, err)
+ }
+
if err := m.contextValidateMatchPrefixes(ctx, formats); err != nil {
res = append(res, err)
}
@@ -147,6 +184,31 @@ func (m *BgpRoutePolicyStatement) ContextValidate(ctx context.Context, formats s
return nil
}
+func (m *BgpRoutePolicyStatement) contextValidateMatchFamilies(ctx context.Context, formats strfmt.Registry) error {
+
+ for i := 0; i < len(m.MatchFamilies); i++ {
+
+ if m.MatchFamilies[i] != nil {
+
+ if swag.IsZero(m.MatchFamilies[i]) { // not required
+ return nil
+ }
+
+ if err := m.MatchFamilies[i].ContextValidate(ctx, formats); err != nil {
+ if ve, ok := err.(*errors.Validation); ok {
+ return ve.ValidateName("match-families" + "." + strconv.Itoa(i))
+ } else if ce, ok := err.(*errors.CompositeError); ok {
+ return ce.ValidateName("match-families" + "." + strconv.Itoa(i))
+ }
+ return err
+ }
+ }
+
+ }
+
+ return nil
+}
+
func (m *BgpRoutePolicyStatement) contextValidateMatchPrefixes(ctx context.Context, formats strfmt.Registry) error {
for i := 0; i < len(m.MatchPrefixes); i++ {
diff --git a/vendor/github.com/cilium/cilium/api/v1/observer/observer.pb.go b/vendor/github.com/cilium/cilium/api/v1/observer/observer.pb.go
index 5d7fca2947..23a160ff91 100644
--- a/vendor/github.com/cilium/cilium/api/v1/observer/observer.pb.go
+++ b/vendor/github.com/cilium/cilium/api/v1/observer/observer.pb.go
@@ -4,7 +4,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.34.2
-// protoc v5.28.0
+// protoc v5.28.1
// source: observer/observer.proto
package observer
diff --git a/vendor/github.com/cilium/cilium/api/v1/observer/observer_grpc.pb.go b/vendor/github.com/cilium/cilium/api/v1/observer/observer_grpc.pb.go
index 3c5c99324f..72ee582527 100644
--- a/vendor/github.com/cilium/cilium/api/v1/observer/observer_grpc.pb.go
+++ b/vendor/github.com/cilium/cilium/api/v1/observer/observer_grpc.pb.go
@@ -4,7 +4,7 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
-// - protoc v5.28.0
+// - protoc v5.28.1
// source: observer/observer.proto
package observer
diff --git a/vendor/github.com/cilium/cilium/api/v1/relay/relay.pb.go b/vendor/github.com/cilium/cilium/api/v1/relay/relay.pb.go
index ed204a3096..8e33fb161c 100644
--- a/vendor/github.com/cilium/cilium/api/v1/relay/relay.pb.go
+++ b/vendor/github.com/cilium/cilium/api/v1/relay/relay.pb.go
@@ -4,7 +4,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.34.2
-// protoc v5.28.0
+// protoc v5.28.1
// source: relay/relay.proto
package relay
diff --git a/vendor/github.com/cilium/cilium/cilium-cli/bgp/peers.go b/vendor/github.com/cilium/cilium/cilium-cli/bgp/peers.go
index 7f4882211f..61819c9c97 100644
--- a/vendor/github.com/cilium/cilium/cilium-cli/bgp/peers.go
+++ b/vendor/github.com/cilium/cilium/cilium-cli/bgp/peers.go
@@ -10,6 +10,7 @@ import (
"fmt"
"io"
"os"
+ "slices"
"sort"
"strings"
"sync"
@@ -134,7 +135,7 @@ func printSummary(out io.Writer, peersPerNode map[string][]*models.BgpPeer) {
for node := range peersPerNode {
nodes = append(nodes, node)
}
- sort.Strings(nodes)
+ slices.Sort(nodes)
// sort peers per node
for _, peers := range peersPerNode {
diff --git a/vendor/github.com/cilium/cilium/cilium-cli/bgp/routes.go b/vendor/github.com/cilium/cilium/cilium-cli/bgp/routes.go
index 3d46eb09bf..228660381d 100644
--- a/vendor/github.com/cilium/cilium/cilium-cli/bgp/routes.go
+++ b/vendor/github.com/cilium/cilium/cilium-cli/bgp/routes.go
@@ -11,6 +11,7 @@ import (
"io"
"net/netip"
"os"
+ "slices"
"sort"
"strconv"
"strings"
@@ -243,7 +244,7 @@ func printRouteSummary(out io.Writer, routesPerNode map[string][]*models.BgpRout
for node := range routesPerNode {
nodes = append(nodes, node)
}
- sort.Strings(nodes)
+ slices.Sort(nodes)
// sort routes per node
for _, routes := range routesPerNode {
diff --git a/vendor/github.com/cilium/cilium/cilium-cli/cli/clustermesh.go b/vendor/github.com/cilium/cilium/cilium-cli/cli/clustermesh.go
index 0f466b5976..4677c1e938 100644
--- a/vendor/github.com/cilium/cilium/cilium-cli/cli/clustermesh.go
+++ b/vendor/github.com/cilium/cilium/cilium-cli/cli/clustermesh.go
@@ -5,6 +5,7 @@ package cli
import (
"context"
+ "fmt"
"io"
"os"
"strings"
@@ -13,6 +14,7 @@ import (
"github.com/spf13/cobra"
"github.com/cilium/cilium/cilium-cli/clustermesh"
+ "github.com/cilium/cilium/cilium-cli/defaults"
"github.com/cilium/cilium/cilium-cli/status"
k8sConst "github.com/cilium/cilium/pkg/k8s/apis/cilium.io"
)
@@ -322,13 +324,17 @@ func newCmdClusterMeshDisconnectWithHelm() *cobra.Command {
}
},
}
- cmd.Flags().StringVar(¶ms.DestinationContext, "destination-context", "", "Kubernetes configuration context of destination cluster")
+ cmd.Flags().StringVar(¶ms.ConnectionMode, "connection-mode", defaults.ClusterMeshConnectionModeBidirectional,
+ fmt.Sprintf("Connection mode: %s, %s or %s", defaults.ClusterMeshConnectionModeUnicast, defaults.ClusterMeshConnectionModeBidirectional, defaults.ClusterMeshConnectionModeMesh))
+ cmd.Flags().StringSliceVar(¶ms.DestinationContext, "destination-context", []string{}, "Comma separated list of Kubernetes configuration contexts of destination cluster")
return cmd
}
func addCommonConnectFlags(cmd *cobra.Command, params *clustermesh.Parameters) {
- cmd.Flags().StringVar(¶ms.DestinationContext, "destination-context", "", "Kubernetes configuration context of destination cluster")
+ cmd.Flags().StringVar(¶ms.ConnectionMode, "connection-mode", defaults.ClusterMeshConnectionModeBidirectional,
+ fmt.Sprintf("Connection mode: %s, %s or %s", defaults.ClusterMeshConnectionModeUnicast, defaults.ClusterMeshConnectionModeBidirectional, defaults.ClusterMeshConnectionModeMesh))
+ cmd.Flags().StringSliceVar(¶ms.DestinationContext, "destination-context", []string{}, "Comma separated list of Kubernetes configuration contexts of destination cluster")
cmd.Flags().StringSliceVar(¶ms.DestinationEndpoints, "destination-endpoint", []string{}, "IP of ClusterMesh service of destination cluster")
cmd.Flags().StringSliceVar(¶ms.SourceEndpoints, "source-endpoint", []string{}, "IP of ClusterMesh service of source cluster")
}
diff --git a/vendor/github.com/cilium/cilium/cilium-cli/cli/cmd.go b/vendor/github.com/cilium/cilium/cilium-cli/cli/cmd.go
index 54f5818b27..4159f3cd28 100644
--- a/vendor/github.com/cilium/cilium/cilium-cli/cli/cmd.go
+++ b/vendor/github.com/cilium/cilium/cilium-cli/cli/cmd.go
@@ -38,6 +38,10 @@ func NewCiliumCommand(hooks api.Hooks) *cobra.Command {
switch cmd.Name() {
case "completion", "help":
return nil
+ case "version":
+ if clientFlag, err := cmd.Flags().GetBool("client"); err == nil && clientFlag {
+ return nil
+ }
}
c, err := k8s.NewClient(contextName, "", namespace)
diff --git a/vendor/github.com/cilium/cilium/cilium-cli/cli/install.go b/vendor/github.com/cilium/cilium/cilium-cli/cli/install.go
index 3412c2b8a8..0c0f73c27e 100644
--- a/vendor/github.com/cilium/cilium/cilium-cli/cli/install.go
+++ b/vendor/github.com/cilium/cilium/cilium-cli/cli/install.go
@@ -27,6 +27,7 @@ func addCommonInstallFlags(cmd *cobra.Command, params *install.Parameters) {
cmd.Flags().BoolVar(¶ms.ListVersions, "list-versions", false, "List all the available versions without actually installing")
cmd.Flags().BoolVar(¶ms.NodesWithoutCilium, "nodes-without-cilium", false, "Configure the affinities to avoid scheduling Cilium components on nodes labeled with cilium.io/no-schedule. It is assumed that the infrastructure has set up routing on these nodes to provide connectivity within the Cilium cluster.")
cmd.Flags().StringSliceVar(¶ms.DisableChecks, "disable-check", []string{}, "Disable a particular validation check")
+ cmd.Flags().MarkDeprecated("disable-check", "cilium-cli no longer performs any validation checks.")
}
// addCommonUninstallFlags adds uninstall command flags that are shared between classic and helm mode.
diff --git a/vendor/github.com/cilium/cilium/cilium-cli/cli/status.go b/vendor/github.com/cilium/cilium/cilium-cli/cli/status.go
index e9b1b931cf..834996d666 100644
--- a/vendor/github.com/cilium/cilium/cilium-cli/cli/status.go
+++ b/vendor/github.com/cilium/cilium/cilium-cli/cli/status.go
@@ -25,6 +25,7 @@ func newCmdStatus() *cobra.Command {
Long: ``,
RunE: func(_ *cobra.Command, _ []string) error {
params.Namespace = namespace
+ params.HelmReleaseName = helmReleaseName
collector, err := status.NewK8sStatusCollector(k8sClient, params)
if err != nil {
diff --git a/vendor/github.com/cilium/cilium/cilium-cli/clustermesh/clustermesh.go b/vendor/github.com/cilium/cilium/cilium-cli/clustermesh/clustermesh.go
index 2714c84887..8dbe67a43e 100644
--- a/vendor/github.com/cilium/cilium/cilium-cli/clustermesh/clustermesh.go
+++ b/vendor/github.com/cilium/cilium/cilium-cli/clustermesh/clustermesh.go
@@ -14,15 +14,15 @@ import (
"errors"
"fmt"
"io"
+ "maps"
"net"
"os"
- "sort"
+ "slices"
"strconv"
"strings"
"text/tabwriter"
"time"
- "golang.org/x/exp/maps"
"helm.sh/helm/v3/pkg/release"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
@@ -94,7 +94,8 @@ type K8sClusterMesh struct {
type Parameters struct {
Namespace string
ServiceType string
- DestinationContext string
+ DestinationContext []string
+ ConnectionMode string
Wait bool
WaitDuration time.Duration
DestinationEndpoints []string
@@ -488,15 +489,18 @@ func (k *K8sClusterMesh) extractAccessInformation(ctx context.Context, client k8
return ai, nil
}
-// getClientsForConnect returns a k8s.Client for the local and remote cluster, respectively
-func (k *K8sClusterMesh) getClientsForConnect() (*k8s.Client, *k8s.Client, error) {
- remoteClient, err := k8s.NewClient(k.params.DestinationContext, "", k.params.Namespace)
- if err != nil {
- return nil, nil, fmt.Errorf(
- "unable to create Kubernetes client to access remote cluster %q: %w",
- k.params.DestinationContext, err)
+func (k *K8sClusterMesh) getRemoteClients() ([]*k8s.Client, error) {
+ var remoteClients []*k8s.Client
+ for _, d := range k.params.DestinationContext {
+ remoteClient, err := k8s.NewClient(d, "", k.params.Namespace)
+ if err != nil {
+ return nil, fmt.Errorf(
+ "unable to create Kubernetes client to access remote cluster %q: %w",
+ d, err)
+ }
+ remoteClients = append(remoteClients, remoteClient)
}
- return k.client.(*k8s.Client), remoteClient, nil
+ return remoteClients, nil
}
func (k *K8sClusterMesh) shallowExtractAccessInfo(ctx context.Context, c *k8s.Client) (*accessInformation, error) {
@@ -519,24 +523,16 @@ func (k *K8sClusterMesh) shallowExtractAccessInfo(ctx context.Context, c *k8s.Cl
}, nil
}
-// connectAccessInit initializes a Kubernetes client for the local and remote cluster
-// and performs some validation that the two clusters can be connected via clustermesh
func (k *K8sClusterMesh) getAccessInfoForConnect(
- ctx context.Context, localClient, remoteClient *k8s.Client,
-) (*accessInformation, *accessInformation, error) {
- aiRemote, err := k.extractAccessInformation(ctx, remoteClient, k.params.DestinationEndpoints, true, false)
- if err != nil {
- k.Log("❌ Unable to retrieve access information of remote cluster %q: %s", remoteClient.ClusterName(), err)
- return nil, nil, err
- }
-
- aiLocal, err := k.extractAccessInformation(ctx, localClient, k.params.SourceEndpoints, true, false)
+ ctx context.Context, client *k8s.Client, endpoints []string,
+) (*accessInformation, error) {
+ ai, err := k.extractAccessInformation(ctx, client, endpoints, true, false)
if err != nil {
- k.Log("❌ Unable to retrieve access information of local cluster %q: %s", k.client.ClusterName(), err)
- return nil, nil, err
+ k.Log("❌ Unable to retrieve access information of cluster %q: %s", client.ClusterName(), err)
+ return nil, err
}
- return aiLocal, aiRemote, nil
+ return ai, nil
}
// connectAccessInit initializes a Kubernetes client for the local and remote cluster
@@ -976,9 +972,7 @@ func (k *K8sClusterMesh) outputConnectivityStatus(agents, kvstoremesh *Connectiv
k.Log("")
if len(agents.Clusters) > 0 {
k.Log("🔌 Cluster Connections:")
- clusters := maps.Keys(agents.Clusters)
- sort.Strings(clusters)
- for _, cluster := range clusters {
+ for _, cluster := range slices.Sorted(maps.Keys(agents.Clusters)) {
stats := agents.Clusters[cluster]
line := fmt.Sprintf(" - %s: %d/%d configured, %d/%d connected",
@@ -1018,9 +1012,7 @@ func (k *K8sClusterMesh) outputConnectivityStatus(agents, kvstoremesh *Connectiv
k.Log("❌ %d Errors:", errCount)
outputErrors := func(errs status.ErrorCountMapMap, container, cmd string, likelyKVStoreMesh bool) {
- podNames := maps.Keys(errs)
- sort.Strings(podNames)
- for _, podName := range podNames {
+ for _, podName := range slices.Sorted(maps.Keys(errs)) {
clusters := errs[podName]
for clusterName, a := range clusters {
for _, err := range a.Errors {
@@ -1589,23 +1581,35 @@ func (k *K8sClusterMesh) validateCAMatch(aiLocal, aiRemote *accessInformation) (
return true, nil
}
-// ConnectWithHelm enables clustermesh using a Helm Upgrade
-// action. Certificates are generated via the Helm chart's cronJob
-// (certgen) mode. As with classic mode, only autodetected IP-based
-// clustermesh-apiserver Service endpoints are currently supported.
-func (k *K8sClusterMesh) ConnectWithHelm(ctx context.Context) error {
- localRelease, err := getRelease(k.client.(*k8s.Client), k.params)
- if err != nil {
- k.Log("❌ Unable to find Helm release for the target cluster")
- return err
- }
+// ClusterState holds the state during the processing of remote clusters.
+type ClusterState struct {
+ localOldClusters []map[string]interface{} // current clustermesh section of helm values
+ localNewClusters []map[string]interface{} // new clustermesh section of helm values
+ localHelmValues map[string]interface{} // localOldClusters + localNewClusters => local helm values generated
+ remoteHelmValuesMesh []map[string]interface{} // helm values for all remote cluster in mesh mode
+ remoteHelmValuesBD []map[string]interface{} // helm values for all remote cluster bidirectional mode
+ remoteOldClustersAll map[string][]map[string]interface{} // current clustermesh sections of helm values for remote clusters
+ remoteHelmValuesDelete map[*k8s.Client]map[string]interface{} // helm values for all remote clusters to disconnect
+ remoteNewCluster map[string]interface{} // local cluster to add to remote clusters
+ remoteClusterNames []string // names of remote clusters for displaying logs
+ remoteClusterNamesAi []string // names of remote clusters for remove sections
+}
+
+func processLocalClient(ctx context.Context, localRelease *release.Release) (*ClusterState, error) {
+ state := &ClusterState{}
+ var err error
- localClient, remoteClient, err := k.getClientsForConnect()
+ state.localOldClusters, err = getOldClusters(localRelease.Config)
if err != nil {
- return err
+ return state, err
}
- aiLocal, aiRemote, err := k.getAccessInfoForConnect(ctx, localClient, remoteClient)
+ return state, nil
+}
+
+func (k *K8sClusterMesh) processSingleRemoteClient(ctx context.Context, remoteClient *k8s.Client, aiLocal *accessInformation, state *ClusterState) error {
+ state.remoteClusterNames = append(state.remoteClusterNames, remoteClient.ClusterName())
+ aiRemote, err := k.getAccessInfoForConnect(ctx, remoteClient, k.params.DestinationEndpoints)
if err != nil {
return err
}
@@ -1623,13 +1627,9 @@ func (k *K8sClusterMesh) ConnectWithHelm(ctx context.Context) error {
k.Log("⚠️ Cilium CA certificates do not match between clusters. Multicluster features will be limited!")
}
- // Get existing helm values for the local cluster
- localHelmValues := localRelease.Config
// Expand those values to include the clustermesh configuration
- localHelmValues, err = updateClustermeshConfig(localHelmValues, aiRemote, !match)
- if err != nil {
- return err
- }
+ newCluster := getCluster(aiRemote, !match)
+ state.localNewClusters = append(state.localNewClusters, newCluster)
// Get existing helm values for the remote cluster
remoteRelease, err := getRelease(remoteClient, k.params)
@@ -1637,110 +1637,342 @@ func (k *K8sClusterMesh) ConnectWithHelm(ctx context.Context) error {
k.Log("❌ Unable to find Helm release for the remote cluster")
return err
}
- remoteHelmValues := remoteRelease.Config
- // Expand those values to include the clustermesh configuration
- remoteHelmValues, err = updateClustermeshConfig(remoteHelmValues, aiLocal, !match)
+
+ remoteOldClusters, err := getOldClusters(remoteRelease.Config)
+ if err != nil {
+ return err
+ }
+ if state.remoteOldClustersAll == nil {
+ state.remoteOldClustersAll = make(map[string][]map[string]interface{})
+ }
+ state.remoteOldClustersAll[aiRemote.ClusterName] = remoteOldClusters
+
+ state.remoteNewCluster = getCluster(aiLocal, !match)
+ remoteHelmValues, err := mergeClusters(remoteOldClusters, []map[string]interface{}{state.remoteNewCluster}, "")
if err != nil {
return err
}
+ state.remoteHelmValuesBD = append(state.remoteHelmValuesBD, remoteHelmValues)
+ return nil
+}
+func (k *K8sClusterMesh) processRemoteClients(ctx context.Context, remoteClients []*k8s.Client, localClient *k8s.Client, state *ClusterState) error {
+ aiLocal, err := k.getAccessInfoForConnect(ctx, localClient, k.params.SourceEndpoints)
+ if err != nil {
+ return err
+ }
+
+ for _, remoteClient := range remoteClients {
+ err := k.processSingleRemoteClient(ctx, remoteClient, aiLocal, state)
+ if err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func processRemoteHelmValuesMesh(state *ClusterState) error {
+ remoteNewClusters := append(state.localNewClusters, state.remoteNewCluster)
+ for clusterName, remoteOldClusters := range state.remoteOldClustersAll {
+ remoteHelmValues, err := mergeClusters(remoteOldClusters, remoteNewClusters, clusterName)
+ if err != nil {
+ return err
+ }
+ state.remoteHelmValuesMesh = append(state.remoteHelmValuesMesh, remoteHelmValues)
+ }
+ return nil
+}
+
+func (k *K8sClusterMesh) connectLocalWithHelm(ctx context.Context, localClient *k8s.Client, state *ClusterState) error {
+ var err error
+ state.localHelmValues, err = mergeClusters(state.localOldClusters, state.localNewClusters, "")
+ if err != nil {
+ return err
+ }
+
+ k.Log("ℹ️ Configuring Cilium in cluster %s to connect to cluster %s",
+ localClient.ClusterName(), strings.Join(state.remoteClusterNames, ","))
+ return k.helmUpgrade(ctx, localClient, state.localHelmValues)
+}
+
+func (k *K8sClusterMesh) helmUpgrade(ctx context.Context, client *k8s.Client, values map[string]interface{}) error {
upgradeParams := helm.UpgradeParameters{
Namespace: k.params.Namespace,
Name: k.params.HelmReleaseName,
- Values: localHelmValues,
+ Values: values,
ResetValues: false,
ReuseValues: true,
}
- // Enable clustermesh using a Helm Upgrade command against our target cluster
- k.Log("ℹ️ Configuring Cilium in cluster '%s' to connect to cluster '%s'",
- localClient.ClusterName(), remoteClient.ClusterName())
- _, err = helm.Upgrade(ctx, localClient.HelmActionConfig, upgradeParams)
+ _, err := helm.Upgrade(ctx, client.HelmActionConfig, upgradeParams)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+func (k *K8sClusterMesh) checkConnectionMode() error {
+ validModes := []string{
+ defaults.ClusterMeshConnectionModeBidirectional,
+ defaults.ClusterMeshConnectionModeMesh,
+ defaults.ClusterMeshConnectionModeUnicast,
+ }
+
+ for _, mode := range validModes {
+ if k.params.ConnectionMode == mode {
+ return nil
+ }
+ }
+
+ k.Log("❌ %s is not a correct connection mode.", k.params.ConnectionMode)
+ k.Log("Available connection modes: %s", strings.Join(validModes, ", "))
+ return errors.New("Bad connection mode")
+}
+
+// ConnectWithHelm enables clustermesh using a Helm Upgrade
+// action. Certificates are generated via the Helm chart's cronJob
+// (certgen) mode. As with classic mode, only autodetected IP-based
+// clustermesh-apiserver Service endpoints are currently supported.
+func (k *K8sClusterMesh) ConnectWithHelm(ctx context.Context) error {
+ localClient := k.client.(*k8s.Client)
+ err := k.checkConnectionMode()
+ if err != nil {
+ return err
+ }
+
+ localRelease, err := getRelease(localClient, k.params)
+ if err != nil {
+ k.Log("❌ Unable to find Helm release for the target cluster")
+ return err
+ }
+
+ remoteClients, err := k.getRemoteClients()
+ if err != nil {
+ return err
+ }
+
+ clusterState, err := processLocalClient(ctx, localRelease)
if err != nil {
return err
}
- // Enable clustermesh using a Helm Upgrade command against the remote cluster
- k.Log("ℹ️ Configuring Cilium in cluster '%s' to connect to cluster '%s'",
- remoteClient.ClusterName(), localClient.ClusterName())
- upgradeParams.Values = remoteHelmValues
- _, err = helm.Upgrade(ctx, remoteClient.HelmActionConfig, upgradeParams)
+ err = k.processRemoteClients(ctx, remoteClients, localClient, clusterState)
if err != nil {
return err
}
- k.Log("✅ Connected cluster %s and %s!", localClient.ClusterName(), remoteClient.ClusterName())
+ err = processRemoteHelmValuesMesh(clusterState)
+ if err != nil {
+ return err
+ }
+
+ err = k.connectLocalWithHelm(ctx, localClient, clusterState)
+ if err != nil {
+ return err
+ }
+
+ err = k.connectRemoteWithHelm(ctx, localClient.ClusterName(), remoteClients, clusterState)
+ if err != nil {
+ return err
+ }
+ k.displayCompleteMessage(localClient, remoteClients, clusterState)
return nil
}
-func (k *K8sClusterMesh) DisconnectWithHelm(ctx context.Context) error {
- localRelease, err := getRelease(k.client.(*k8s.Client), k.params)
+func (k *K8sClusterMesh) displayCompleteMessage(localClient *k8s.Client, remoteClients []*k8s.Client, state *ClusterState) {
+ switch k.params.ConnectionMode {
+ case defaults.ClusterMeshConnectionModeBidirectional:
+ for _, remoteClient := range remoteClients {
+ k.Log("✅ Connected cluster %s <=> %s!", localClient.ClusterName(), remoteClient.ClusterName())
+ }
+ case defaults.ClusterMeshConnectionModeMesh:
+ k.Log("✅ Connected clusters %s, and %s!", strings.Join(state.remoteClusterNames, ", "), localClient.ClusterName())
+ case defaults.ClusterMeshConnectionModeUnicast:
+ for _, remoteClient := range remoteClients {
+ k.Log("✅ Connected cluster %s => %s!", localClient.ClusterName(), remoteClient.ClusterName())
+ }
+ }
+}
+
+func (k *K8sClusterMesh) connectRemoteWithHelm(ctx context.Context, clusterName string, remoteClients []*k8s.Client, state *ClusterState) error {
+ var rc []*k8s.Client
+ var cn []string
+ var helmValues []map[string]interface{}
+
+ switch k.params.ConnectionMode {
+ case defaults.ClusterMeshConnectionModeBidirectional:
+ rc = remoteClients
+ helmValues = state.remoteHelmValuesBD
+ cn = []string{clusterName}
+ case defaults.ClusterMeshConnectionModeMesh:
+ rc = remoteClients
+ helmValues = state.remoteHelmValuesMesh
+ cn = append(state.remoteClusterNames, clusterName)
+ }
+
+ for i, remoteClient := range rc {
+ err := k.connectSingleRemoteWithHelm(ctx, remoteClient, cn, helmValues[i])
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (k *K8sClusterMesh) connectSingleRemoteWithHelm(ctx context.Context, remoteClient *k8s.Client, clusterNames []string, helmValues map[string]interface{}) error {
+ clusterNamesExceptRemote := removeStringFromSlice(remoteClient.ClusterName(), clusterNames)
+ k.Log("ℹ️ Configuring Cilium in cluster %s to connect to cluster %s",
+ remoteClient.ClusterName(), strings.Join(clusterNamesExceptRemote, ","))
+ err := k.helmUpgrade(ctx, remoteClient, helmValues)
if err != nil {
- k.Log("❌ Unable to find Helm release for the target cluster")
return err
}
+ return nil
+}
+
+func (k *K8sClusterMesh) getRemoteClusterNamesAi(ctx context.Context, remoteClients []*k8s.Client) (*ClusterState, error) {
+ state := &ClusterState{}
+
+ for _, remoteClient := range remoteClients {
+ aiRemote, err := k.shallowExtractAccessInfo(ctx, remoteClient)
+ if err != nil {
+ return state, err
+ }
+ state.remoteClusterNamesAi = append(state.remoteClusterNamesAi, aiRemote.ClusterName)
+ }
- localClient, remoteClient, err := k.getClientsForConnect()
+ return state, nil
+}
+
+func (k *K8sClusterMesh) retrieveRemoteHelmValues(ctx context.Context, remoteClients []*k8s.Client, state *ClusterState) error {
+ aiLocal, err := k.shallowExtractAccessInfo(ctx, k.client.(*k8s.Client))
if err != nil {
return err
}
- aiLocal, err := k.shallowExtractAccessInfo(ctx, localClient)
+ remoteClusterNames := []string{aiLocal.ClusterName}
+ if k.params.ConnectionMode == defaults.ClusterMeshConnectionModeMesh {
+ remoteClusterNames = append(remoteClusterNames, state.remoteClusterNamesAi...)
+ }
+ for _, remoteClient := range remoteClients {
+ remoteRelease, err := getRelease(remoteClient, k.params)
+ if err != nil {
+ k.Log("❌ Unable to find Helm release for the remote cluster")
+ return err
+ }
+ // Modify the clustermesh config to remove the intended cluster if any
+ remoteHelmValues, err := removeFromClustermeshConfig(remoteRelease.Config, remoteClusterNames)
+ if err != nil {
+ return err
+ }
+ if state.remoteHelmValuesDelete == nil {
+ state.remoteHelmValuesDelete = make(map[*k8s.Client]map[string]interface{})
+ }
+ state.remoteHelmValuesDelete[remoteClient] = remoteHelmValues
+ state.remoteClusterNames = append(state.remoteClusterNames, remoteClient.ClusterName())
+ }
+ return nil
+}
+
+func removeStringFromSlice(name string, names []string) []string {
+ namesCopy := append([]string{}, names...)
+ namesCopy = slices.DeleteFunc(namesCopy, func(n string) bool {
+ return n == name
+ })
+ return namesCopy
+}
+
+func (k *K8sClusterMesh) valueOfFromClusterName(clusterName string, remoteClusterName string, remoteClusterNames []string) string {
+ cn := clusterName
+ if k.params.ConnectionMode == defaults.ClusterMeshConnectionModeMesh {
+ clusterNamesExceptRemote := removeStringFromSlice(remoteClusterName, remoteClusterNames)
+ clusterNamesExceptRemote = append(clusterNamesExceptRemote, clusterName)
+ cn = strings.Join(clusterNamesExceptRemote, ",")
+ }
+ return cn
+}
+
+func (k *K8sClusterMesh) disconnectRemoteWithHelm(ctx context.Context, clusterName string, state *ClusterState) error {
+ if k.params.ConnectionMode == defaults.ClusterMeshConnectionModeUnicast {
+ return nil
+ }
+ for remoteClient, helmValues := range state.remoteHelmValuesDelete {
+ cn := k.valueOfFromClusterName(clusterName, remoteClient.ClusterName(), state.remoteClusterNames)
+ k.Log("ℹ️ Configuring Cilium in cluster %s to disconnect from cluster %s",
+ remoteClient.ClusterName(), cn)
+ err := k.helmUpgrade(ctx, remoteClient, helmValues)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (k *K8sClusterMesh) DisconnectWithHelm(ctx context.Context) error {
+ localClient := k.client.(*k8s.Client)
+ err := k.checkConnectionMode()
if err != nil {
return err
}
- aiRemote, err := k.shallowExtractAccessInfo(ctx, remoteClient)
+
+ localRelease, err := getRelease(localClient, k.params)
if err != nil {
+ k.Log("❌ Unable to find Helm release for the target cluster")
return err
}
- // Modify the clustermesh config to remove the intended cluster if any
- localHelmValues, err := removeFromClustermeshConfig(localRelease.Config, aiRemote.ClusterName)
+ remoteClients, err := k.getRemoteClients()
if err != nil {
return err
}
-
- // Get existing helm values for the remote cluster
- remoteRelease, err := getRelease(remoteClient, k.params)
+ clusterState, err := k.getRemoteClusterNamesAi(ctx, remoteClients)
if err != nil {
- k.Log("❌ Unable to find Helm release for the remote cluster")
return err
}
+
// Modify the clustermesh config to remove the intended cluster if any
- remoteHelmValues, err := removeFromClustermeshConfig(remoteRelease.Config, aiLocal.ClusterName)
+ localHelmValues, err := removeFromClustermeshConfig(localRelease.Config, clusterState.remoteClusterNamesAi)
if err != nil {
return err
}
- upgradeParams := helm.UpgradeParameters{
- Namespace: k.params.Namespace,
- Name: k.params.HelmReleaseName,
- Values: localHelmValues,
- ResetValues: false,
- ReuseValues: true,
+ err = k.retrieveRemoteHelmValues(ctx, remoteClients, clusterState)
+ if err != nil {
+ return err
}
- // Disconnect clustermesh using a Helm Upgrade command against our target cluster
- k.Log("ℹ️ Configuring Cilium in cluster '%s' to disconnect from cluster '%s'",
- localClient.ClusterName(), remoteClient.ClusterName())
- if _, err = helm.Upgrade(ctx, localClient.HelmActionConfig, upgradeParams); err != nil {
+ k.Log("ℹ️ Configuring Cilium in cluster %s to disconnect from cluster %s",
+ localClient.ClusterName(), strings.Join(clusterState.remoteClusterNames, ","))
+ err = k.helmUpgrade(ctx, localClient, localHelmValues)
+ if err != nil {
return err
}
-
- // Disconnect clustermesh using a Helm Upgrade command against the remote cluster
- k.Log("ℹ️ Configuring Cilium in cluster '%s' to disconnect from cluster '%s'",
- remoteClient.ClusterName(), localClient.ClusterName())
- upgradeParams.Values = remoteHelmValues
- if _, err = helm.Upgrade(ctx, remoteClient.HelmActionConfig, upgradeParams); err != nil {
+ err = k.disconnectRemoteWithHelm(ctx, localClient.ClusterName(), clusterState)
+ if err != nil {
return err
}
- k.Log("✅ Disconnected clusters %s and %s!", localClient.ClusterName(), remoteClient.ClusterName())
+
+ k.displayDisconnectedCompleteMessage(localClient, remoteClients, clusterState)
return nil
}
-func updateClustermeshConfig(
- values map[string]interface{}, aiRemote *accessInformation, configTLS bool,
-) (map[string]interface{}, error) {
+func (k *K8sClusterMesh) displayDisconnectedCompleteMessage(localClient *k8s.Client, remoteClients []*k8s.Client, state *ClusterState) {
+ switch k.params.ConnectionMode {
+ case defaults.ClusterMeshConnectionModeBidirectional:
+ for _, remoteClient := range remoteClients {
+ k.Log("✅ Disconnected clusters %s + +This library provides options for fast detection and rejection of duplicate map keys based on applying a Go-specific data model to CBOR's extended generic data model in order to determine duplicate vs distinct map keys. Detection relies on whether the CBOR map key would be a duplicate "key" when decoded and applied to the user-provided Go map or struct. + +`DupMapKeyQuiet` turns off detection of duplicate map keys. It tries to use a "keep fastest" method by choosing either "keep first" or "keep last" depending on the Go data type. + +`DupMapKeyEnforcedAPF` enforces detection and rejection of duplidate map keys. Decoding stops immediately and returns `DupMapKeyError` when the first duplicate key is detected. The error includes the duplicate map key and the index number. + +APF suffix means "Allow Partial Fill" so the destination map or struct can contain some decoded values at the time of error. It is the caller's responsibility to respond to the `DupMapKeyError` by discarding the partially filled result if that's required by their protocol. + +
+ +This library checks tag validity for built-in tags (currently tag numbers 0, 1, 2, 3, and 55799): + +* Inadmissible type for tag content +* Inadmissible value for tag content + +Unknown tag data items (not tag number 0, 1, 2, 3, or 55799) are handled in two ways: + +* When decoding into an empty interface, unknown tag data item will be decoded into `cbor.Tag` data type, which contains tag number and tag content. The tag content will be decoded into the default Go data type for the CBOR data type. +* When decoding into other Go types, unknown tag data item is decoded into the specified Go type. If Go type is registered with a tag number, the tag number can optionally be verified. + +Decoder also has an option to forbid tag data items (treat any tag data item as error) which is specified by protocols such as CTAP2 Canonical CBOR. + +For more information, see [decoding options](#decoding-options-1) and [tag options](#tag-options). + +