Upgrade the operator to use Operator SDK v1.33.0 (#182)

* Move controller package inside internal directory

Based on the go/v4 project structure, the following changed:
- Pakcage `controllers` is now named `controller`
- Package `controller` now lives inside new `internal` directory

* Move main.go in cmd directory

Based on the new go/v4 project structure, `main.go` now lives in the `cmd` directory.

* Change package import in main.go

* Update go mod dependencies

Update the dependencies based on the versions obtained by creating a new operator project using `kubebuilder init --domain onepassword.com --plugins=go/v4`.

This is based on the migration steps provided to go from go/v3 to go/v4 (https://book.kubebuilder.io/migration/migration_guide_gov3_to_gov4)

* Update vendor

* Adjust code for breaking changes from pkg update

sigs.k8s.io/controller-runtime package had breaking changes from v0.14.5 to v0.16.3. This commit brings the changes needed to achieve the same things using the new functionality avaialble.

* Adjust paths to connect yaml files

Since `main.go` is now in `cmd` directory, the paths to the files for deploying Connect have to be adjusted based on the new location `main.go` is executed from.

* Update files based on new structure and scaffolding

These changes are made based on the new project structure and scaffolding obtained when using the new go/v4 project structure.

These were done based on the migration steps mentioned when migrating to go/v4 (https://book.kubebuilder.io/migration/migration_guide_gov3_to_gov4).

* Update config files

These updates are made based on the Kustomize v4 syntax.

This is part of the upgrate to go/v4 (https://book.kubebuilder.io/migration/migration_guide_gov3_to_gov4)

* Update dependencies and GO version

* Update vendor

* Update Kubernetes tools versions

* Update operator version in Makefile

Now the version in the Makefile matches the version of the operator

* Update Operator SDK version in version.go

* Adjust generated deepcopy

It seems that the +build tag is no longer needed based on the latest generated scaffolding, therefore it's removed.

* Update copyright year

* Bring back missing changes from migration

Some customization in Makefile was lost during the migration process. Specifically, the namespace customization for `make deploy` command.

Also, we push changes to kustomization.yaml for making the deploy process smoother.

* Add RBAC perms for coordination.k8s.io

It seems that with the latest changes to Kubernetes and Kustomize, we need to add additional RBAC to the service account used so that it can properly access the `leases` resource.

* Optimize Dockerfile

Dockerfile had a step for caching dependencies (go mod download). However, this is already done by the vendor directory, which we include. Therefore, this step can be removed to make the image build time faster.

vendor/github.com/imdario/mergo/merge.go

@@ -13,40 +13,22 @@ import (
 	"reflect"
 )
 
-func hasMergeableFields(dst reflect.Value) (exported bool) {
+func hasExportedField(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 || hasExportedField(dst.Field(i))
+		} else {
 			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
+	Overwrite    bool
+	AppendSlice  bool
+	Transformers Transformers
 }
 
 type Transformers interface {
@@ -58,10 +40,6 @@ type Transformers interface {
 // 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
@@ -77,10 +55,10 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 			}
 		}
 		// Remember, remember...
-		visited[h] = &visit{typ, seen, addr}
+		visited[h] = &visit{addr, typ, seen}
 	}
 
-	if config.Transformers != nil && !isReflectNil(dst) && dst.IsValid() {
+	if config.Transformers != nil && !isEmptyValue(dst) {
 		if fn := config.Transformers.Transformer(dst.Type()); fn != nil {
 			err = fn(dst, src)
 			return
@@ -89,34 +67,21 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 
 	switch dst.Kind() {
 	case reflect.Struct:
-		if hasMergeableFields(dst) {
+		if hasExportedField(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) {
+			if dst.CanSet() && !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) {
 				dst.Set(src)
 			}
 		}
 	case reflect.Map:
 		if dst.IsNil() && !src.IsNil() {
-			if dst.CanSet() {
-				dst.Set(reflect.MakeMap(dst.Type()))
-			} else {
-				dst = src
-				return
-			}
+			dst.Set(reflect.MakeMap(dst.Type()))
 		}
-
-		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() {
@@ -126,9 +91,6 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 			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
@@ -163,116 +125,54 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 						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())
-						}
+					if !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice {
 						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())
+							return fmt.Errorf("cannot append two slice 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 dstElement.IsValid() && reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Map {
+				continue
 			}
 
-			if srcElement.IsValid() && ((srcElement.Kind() != reflect.Ptr && overwrite) || !dstElement.IsValid() || isEmptyValue(dstElement, !config.ShouldNotDereference)) {
+			if srcElement.IsValid() && (overwrite || (!dstElement.IsValid() || isEmptyValue(dstElement))) {
 				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 {
+		if !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice {
 			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)
-			}
+		if src.IsNil() {
 			break
 		}
-
 		if src.Kind() != reflect.Interface {
-			if dst.IsNil() || (src.Kind() != reflect.Ptr && overwrite) {
-				if dst.CanSet() && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) {
+			if dst.IsNil() || overwrite {
+				if dst.CanSet() && (overwrite || isEmptyValue(dst)) {
 					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 overwriteWithEmptySrc || (overwrite && !src.IsNil()) || dst.IsNil() {
-						dst.Set(src)
-					}
+				if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
+					return
 				}
 			} else if dst.Elem().Type() == src.Type() {
 				if err = deepMerge(dst.Elem(), src, visited, depth+1, config); err != nil {
@@ -283,31 +183,18 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 			}
 			break
 		}
-
 		if dst.IsNil() || overwrite {
-			if dst.CanSet() && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) {
+			if dst.CanSet() && (overwrite || isEmptyValue(dst)) {
 				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
+		} else if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
+			return
 		}
 	default:
-		mustSet := (isEmptyValue(dst, !config.ShouldNotDereference) || overwrite) && (!isEmptyValue(src, !config.ShouldNotDereference) || overwriteWithEmptySrc)
-		if mustSet {
-			if dst.CanSet() {
-				dst.Set(src)
-			} else {
-				dst = src
-			}
+		if dst.CanSet() && !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) {
+			dst.Set(src)
 		}
 	}
-
 	return
 }
 
@@ -319,7 +206,7 @@ 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
+// MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overriden by
 // non-empty src attribute values.
 // Deprecated: use Merge(…) with WithOverride
 func MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {
@@ -338,43 +225,12 @@ 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.
+// 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
@@ -394,16 +250,3 @@ func merge(dst, src interface{}, opts ...func(*Config)) error {
 	}
 	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
-	}
-}