update golangci-lint to 2.x

xrstf · xrstf · commit 809d7e98b6d7 · 2025-06-04T13:37:33.000+02:00
On-behalf-of: @SAP christoph.mewes@sap.com
diff --git a/.golangci.yml b/.golangci.yml
@@ -1,25 +1,14 @@
+version: "2"
 run:
-  timeout: 10m
   allow-parallel-runners: true
-
-issues:
-  max-same-issues: 0
-
-  # don't skip warning about doc comments
-  # don't exclude the default set of lint
-  exclude-use-default: false
-
 linters:
-  disable-all: true
+  default: none
   enable:
     - copyloopvar
     - errcheck
     - ginkgolinter
     - goconst
     - gocyclo
-    - gofmt
-    - goimports
-    - gosimple
     - govet
     - importas
     - ineffassign
@@ -28,34 +17,47 @@ linters:
     - prealloc
     - revive
     - staticcheck
-    - typecheck
     - unconvert
     - unparam
     - unused
-
-linters-settings:
-  revive:
-    rules:
-      - name: comment-spacings
-      - name: duplicated-imports
-        severity: warning
-  importas:
-    no-unaliased: true
-    alias:
-      # kcp operator
-      - pkg: github.com/kcp-dev/kcp-operator/sdk/apis/(\w+)/(v[\w\d]+)
-        alias: $1$2
-      # Kubernetes
-      - pkg: k8s.io/api/(\w+)/(v[\w\d]+)
-        alias: $1$2
-      - pkg: k8s.io/apimachinery/pkg/apis/meta/v1
-        alias: metav1
-      - pkg: k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1
-        alias: apiextensionsv1
-      - pkg: k8s.io/apimachinery/pkg/api/errors
-        alias: apierrors
-      - pkg: k8s.io/apimachinery/pkg/util/errors
-        alias: kerrors
-      # Controller Runtime (otherwise this will usually lead to shadowing a local "client" variable)
-      - pkg: sigs.k8s.io/controller-runtime/pkg/client
-        alias: ctrlruntimeclient
+  settings:
+    importas:
+      alias:
+        - pkg: github.com/kcp-dev/kcp-operator/sdk/apis/(\w+)/(v[\w\d]+)
+          alias: $1$2
+        - pkg: k8s.io/api/(\w+)/(v[\w\d]+)
+          alias: $1$2
+        - pkg: k8s.io/apimachinery/pkg/apis/meta/v1
+          alias: metav1
+        - pkg: k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1
+          alias: apiextensionsv1
+        - pkg: k8s.io/apimachinery/pkg/api/errors
+          alias: apierrors
+        - pkg: k8s.io/apimachinery/pkg/util/errors
+          alias: kerrors
+        - pkg: sigs.k8s.io/controller-runtime/pkg/client
+          alias: ctrlruntimeclient
+      no-unaliased: true
+    revive:
+      rules:
+        - name: comment-spacings
+        - name: duplicated-imports
+          severity: warning
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
+issues:
+  max-same-issues: 0
+formatters:
+  enable:
+    - gofmt
+    - goimports
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
diff --git a/Makefile b/Makefile
@@ -9,7 +9,7 @@ KUBECTL_VERSION ?= v1.32.0
 KUSTOMIZE_VERSION ?= v5.4.3
 CONTROLLER_TOOLS_VERSION ?= v0.16.1
 ENVTEST_VERSION ?= release-0.19
-GOLANGCI_LINT_VERSION ?= 1.63.4
+GOLANGCI_LINT_VERSION ?= 2.1.6
 
 # Image URL to use all building/pushing image targets
 IMG ?= ghcr.io/kcp-dev/kcp-operator
@@ -72,11 +72,11 @@ test-e2e:
 
 .PHONY: lint
 lint: golangci-lint ## Run golangci-lint linter.
-	$(GOLANGCI_LINT) run
+	$(GOLANGCI_LINT) run --timeout 10m
 
 .PHONY: lint-fix
 lint-fix: golangci-lint ## Run golangci-lint linter and perform fixes.
-	$(GOLANGCI_LINT) run --fix
+	$(GOLANGCI_LINT) run --timeout 10m --fix
 
 .PHONY: modules
 modules: ## Run go mod tidy to ensure modules are up to date.
diff --git a/internal/controller/frontproxy_controller.go b/internal/controller/frontproxy_controller.go
@@ -94,7 +94,7 @@ func (r *FrontProxyReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	logger.V(4).Info("Reconciling")
 
 	var frontProxy operatorv1alpha1.FrontProxy
-	if err := r.Client.Get(ctx, req.NamespacedName, &frontProxy); err != nil {
+	if err := r.Get(ctx, req.NamespacedName, &frontProxy); err != nil {
 		if ctrlruntimeclient.IgnoreNotFound(err) != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to get FrontProxy object: %w", err)
 		}
@@ -204,7 +204,7 @@ func (r *FrontProxyReconciler) reconcileStatus(ctx context.Context, oldFrontProx
 
 	// only patch the status if there are actual changes.
 	if !equality.Semantic.DeepEqual(oldFrontProxy.Status, frontProxy.Status) {
-		if err := r.Client.Status().Patch(ctx, frontProxy, ctrlruntimeclient.MergeFrom(oldFrontProxy)); err != nil {
+		if err := r.Status().Patch(ctx, frontProxy, ctrlruntimeclient.MergeFrom(oldFrontProxy)); err != nil {
 			errs = append(errs, err)
 		}
 	}
diff --git a/internal/controller/kubeconfig_controller.go b/internal/controller/kubeconfig_controller.go
@@ -69,7 +69,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	logger.V(4).Info("Reconciling")
 
 	var kc operatorv1alpha1.Kubeconfig
-	if err := r.Client.Get(ctx, req.NamespacedName, &kc); err != nil {
+	if err := r.Get(ctx, req.NamespacedName, &kc); err != nil {
 		return ctrl.Result{}, err
 	}
 
@@ -80,7 +80,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	switch {
 	case kc.Spec.Target.RootShardRef != nil:
 		var rootShard operatorv1alpha1.RootShard
-		if err := r.Client.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.RootShardRef.Name, Namespace: req.Namespace}, &rootShard); err != nil {
+		if err := r.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.RootShardRef.Name, Namespace: req.Namespace}, &rootShard); err != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to get RootShard: %w", err)
 		}
 
@@ -91,7 +91,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 
 	case kc.Spec.Target.ShardRef != nil:
 		var shard operatorv1alpha1.Shard
-		if err := r.Client.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.ShardRef.Name, Namespace: req.Namespace}, &shard); err != nil {
+		if err := r.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.ShardRef.Name, Namespace: req.Namespace}, &shard); err != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to get Shard: %w", err)
 		}
 
@@ -100,7 +100,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 			return ctrl.Result{}, errors.New("the Shard does not reference a (valid) RootShard")
 		}
 		var rootShard operatorv1alpha1.RootShard
-		if err := r.Client.Get(ctx, types.NamespacedName{Name: ref.Name, Namespace: req.Namespace}, &rootShard); err != nil {
+		if err := r.Get(ctx, types.NamespacedName{Name: ref.Name, Namespace: req.Namespace}, &rootShard); err != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to get RootShard: %w", err)
 		}
 
@@ -112,7 +112,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 
 	case kc.Spec.Target.FrontProxyRef != nil:
 		var frontProxy operatorv1alpha1.FrontProxy
-		if err := r.Client.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.FrontProxyRef.Name, Namespace: req.Namespace}, &frontProxy); err != nil {
+		if err := r.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.FrontProxyRef.Name, Namespace: req.Namespace}, &frontProxy); err != nil {
 			return ctrl.Result{}, fmt.Errorf("referenced FrontProxy '%s' does not exist", kc.Spec.Target.FrontProxyRef.Name)
 		}
 
@@ -121,7 +121,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 			return ctrl.Result{}, errors.New("the FrontProxy does not reference a (valid) RootShard")
 		}
 		var rootShard operatorv1alpha1.RootShard
-		if err := r.Client.Get(ctx, types.NamespacedName{Name: frontProxy.Spec.RootShard.Reference.Name, Namespace: req.Namespace}, &rootShard); err != nil {
+		if err := r.Get(ctx, types.NamespacedName{Name: frontProxy.Spec.RootShard.Reference.Name, Namespace: req.Namespace}, &rootShard); err != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to get RootShard: %w", err)
 		}
 
@@ -174,7 +174,7 @@ func (r *KubeconfigReconciler) getCertificateSecret(ctx context.Context, name, n
 	logger := log.FromContext(ctx).WithValues("certificate", name)
 
 	certificate := &certmanagerv1.Certificate{}
-	if err := r.Client.Get(ctx, types.NamespacedName{Name: name, Namespace: namespace}, certificate); err != nil {
+	if err := r.Get(ctx, types.NamespacedName{Name: name, Namespace: namespace}, certificate); err != nil {
 		// Because of how the reconciling framework works, this should never happen.
 		logger.V(6).Info("Certificate does not exist yet, trying later ...")
 		return nil, nil
@@ -194,7 +194,7 @@ func (r *KubeconfigReconciler) getCertificateSecret(ctx context.Context, name, n
 	}
 
 	secret := &corev1.Secret{}
-	if err := r.Client.Get(ctx, types.NamespacedName{Name: certificate.Spec.SecretName, Namespace: certificate.Namespace}, secret); err != nil {
+	if err := r.Get(ctx, types.NamespacedName{Name: certificate.Spec.SecretName, Namespace: certificate.Namespace}, secret); err != nil {
 		return nil, err
 	}
 
diff --git a/internal/controller/rootshard_controller.go b/internal/controller/rootshard_controller.go
@@ -81,7 +81,7 @@ func (r *RootShardReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	logger.V(4).Info("Reconciling")
 
 	var rootShard operatorv1alpha1.RootShard
-	if err := r.Client.Get(ctx, req.NamespacedName, &rootShard); err != nil {
+	if err := r.Get(ctx, req.NamespacedName, &rootShard); err != nil {
 		if ctrlruntimeclient.IgnoreNotFound(err) != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to find %s/%s: %w", req.Namespace, req.Name, err)
 		}
@@ -199,7 +199,7 @@ func (r *RootShardReconciler) reconcileStatus(ctx context.Context, oldRootShard
 
 	// only patch the status if there are actual changes.
 	if !equality.Semantic.DeepEqual(oldRootShard.Status, rootShard.Status) {
-		if err := r.Client.Status().Patch(ctx, rootShard, ctrlruntimeclient.MergeFrom(oldRootShard)); err != nil {
+		if err := r.Status().Patch(ctx, rootShard, ctrlruntimeclient.MergeFrom(oldRootShard)); err != nil {
 			errs = append(errs, err)
 		}
 	}
diff --git a/internal/controller/shard_controller.go b/internal/controller/shard_controller.go
@@ -93,7 +93,7 @@ func (r *ShardReconciler) Reconcile(ctx context.Context, req ctrl.Request) (res
 	logger.V(4).Info("Reconciling Shard object")
 
 	var s operatorv1alpha1.Shard
-	if err := r.Client.Get(ctx, req.NamespacedName, &s); err != nil {
+	if err := r.Get(ctx, req.NamespacedName, &s); err != nil {
 		if ctrlruntimeclient.IgnoreNotFound(err) != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to get shard: %w", err)
 		}
diff --git a/internal/resources/frontproxy/deployment.go b/internal/resources/frontproxy/deployment.go
@@ -39,7 +39,7 @@ func DeploymentReconciler(frontProxy *operatorv1alpha1.FrontProxy, rootShard *op
 			dep.Spec.Selector = &metav1.LabelSelector{
 				MatchLabels: resources.GetFrontProxyResourceLabels(frontProxy),
 			}
-			dep.Spec.Template.ObjectMeta.SetLabels(resources.GetFrontProxyResourceLabels(frontProxy))
+			dep.Spec.Template.SetLabels(resources.GetFrontProxyResourceLabels(frontProxy))
 
 			image, _ := resources.GetImageSettings(frontProxy.Spec.Image)
 			args := getArgs(&frontProxy.Spec)
diff --git a/internal/resources/rootshard/deployment.go b/internal/resources/rootshard/deployment.go
@@ -70,7 +70,7 @@ func DeploymentReconciler(rootShard *operatorv1alpha1.RootShard) reconciling.Nam
 			dep.Spec.Selector = &metav1.LabelSelector{
 				MatchLabels: labels,
 			}
-			dep.Spec.Template.ObjectMeta.SetLabels(labels)
+			dep.Spec.Template.SetLabels(labels)
 
 			secretMounts := []utils.SecretMount{{
 				VolumeName: "kcp-ca",
diff --git a/internal/resources/shard/deployment.go b/internal/resources/shard/deployment.go
@@ -69,7 +69,7 @@ func DeploymentReconciler(shard *operatorv1alpha1.Shard, rootShard *operatorv1al
 			dep.Spec.Selector = &metav1.LabelSelector{
 				MatchLabels: labels,
 			}
-			dep.Spec.Template.ObjectMeta.SetLabels(labels)
+			dep.Spec.Template.SetLabels(labels)
 
 			secretMounts := []utils.SecretMount{{
 				VolumeName: "kcp-ca",
diff --git a/internal/resources/utils/shard.go b/internal/resources/utils/shard.go
@@ -31,6 +31,7 @@ import (
 
 func ApplyCommonShardConfig(deployment *appsv1.Deployment, spec *operatorv1alpha1.CommonShardSpec) (*appsv1.Deployment, error) {
 	if len(deployment.Spec.Template.Spec.Containers) == 0 {
+		//nolint:staticcheck // allow capital letter in error message
 		return deployment, errors.New("Deployment does not contain any containers")
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ func (r *FrontProxyReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`94`	`94`	`logger.V(4).Info("Reconciling")`
`95`	`95`
`96`	`96`	`var frontProxy operatorv1alpha1.FrontProxy`
`97`		`- if err := r.Client.Get(ctx, req.NamespacedName, &frontProxy); err != nil {`
	`97`	`+ if err := r.Get(ctx, req.NamespacedName, &frontProxy); err != nil {`
`98`	`98`	`if ctrlruntimeclient.IgnoreNotFound(err) != nil {`
`99`	`99`	`return ctrl.Result{}, fmt.Errorf("failed to get FrontProxy object: %w", err)`
`100`	`100`	`}`
`@@ -204,7 +204,7 @@ func (r *FrontProxyReconciler) reconcileStatus(ctx context.Context, oldFrontProx`
`204`	`204`
`205`	`205`	`// only patch the status if there are actual changes.`
`206`	`206`	`if !equality.Semantic.DeepEqual(oldFrontProxy.Status, frontProxy.Status) {`
`207`		`- if err := r.Client.Status().Patch(ctx, frontProxy, ctrlruntimeclient.MergeFrom(oldFrontProxy)); err != nil {`
	`207`	`+ if err := r.Status().Patch(ctx, frontProxy, ctrlruntimeclient.MergeFrom(oldFrontProxy)); err != nil {`
`208`	`208`	`errs = append(errs, err)`
`209`	`209`	`}`
`210`	`210`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`69`	`69`	`logger.V(4).Info("Reconciling")`
`70`	`70`
`71`	`71`	`var kc operatorv1alpha1.Kubeconfig`
`72`		`- if err := r.Client.Get(ctx, req.NamespacedName, &kc); err != nil {`
	`72`	`+ if err := r.Get(ctx, req.NamespacedName, &kc); err != nil {`
`73`	`73`	`return ctrl.Result{}, err`
`74`	`74`	`}`
`75`	`75`
`@@ -80,7 +80,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`80`	`80`	`switch {`
`81`	`81`	`case kc.Spec.Target.RootShardRef != nil:`
`82`	`82`	`var rootShard operatorv1alpha1.RootShard`
`83`		`- if err := r.Client.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.RootShardRef.Name, Namespace: req.Namespace}, &rootShard); err != nil {`
	`83`	`+ if err := r.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.RootShardRef.Name, Namespace: req.Namespace}, &rootShard); err != nil {`
`84`	`84`	`return ctrl.Result{}, fmt.Errorf("failed to get RootShard: %w", err)`
`85`	`85`	`}`
`86`	`86`
`@@ -91,7 +91,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`91`	`91`
`92`	`92`	`case kc.Spec.Target.ShardRef != nil:`
`93`	`93`	`var shard operatorv1alpha1.Shard`
`94`		`- if err := r.Client.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.ShardRef.Name, Namespace: req.Namespace}, &shard); err != nil {`
	`94`	`+ if err := r.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.ShardRef.Name, Namespace: req.Namespace}, &shard); err != nil {`
`95`	`95`	`return ctrl.Result{}, fmt.Errorf("failed to get Shard: %w", err)`
`96`	`96`	`}`
`97`	`97`
`@@ -100,7 +100,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`100`	`100`	`return ctrl.Result{}, errors.New("the Shard does not reference a (valid) RootShard")`
`101`	`101`	`}`
`102`	`102`	`var rootShard operatorv1alpha1.RootShard`
`103`		`- if err := r.Client.Get(ctx, types.NamespacedName{Name: ref.Name, Namespace: req.Namespace}, &rootShard); err != nil {`
	`103`	`+ if err := r.Get(ctx, types.NamespacedName{Name: ref.Name, Namespace: req.Namespace}, &rootShard); err != nil {`
`104`	`104`	`return ctrl.Result{}, fmt.Errorf("failed to get RootShard: %w", err)`
`105`	`105`	`}`
`106`	`106`
`@@ -112,7 +112,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`112`	`112`
`113`	`113`	`case kc.Spec.Target.FrontProxyRef != nil:`
`114`	`114`	`var frontProxy operatorv1alpha1.FrontProxy`
`115`		`- if err := r.Client.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.FrontProxyRef.Name, Namespace: req.Namespace}, &frontProxy); err != nil {`
	`115`	`+ if err := r.Get(ctx, types.NamespacedName{Name: kc.Spec.Target.FrontProxyRef.Name, Namespace: req.Namespace}, &frontProxy); err != nil {`
`116`	`116`	`return ctrl.Result{}, fmt.Errorf("referenced FrontProxy '%s' does not exist", kc.Spec.Target.FrontProxyRef.Name)`
`117`	`117`	`}`
`118`	`118`
`@@ -121,7 +121,7 @@ func (r *KubeconfigReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`121`	`121`	`return ctrl.Result{}, errors.New("the FrontProxy does not reference a (valid) RootShard")`
`122`	`122`	`}`
`123`	`123`	`var rootShard operatorv1alpha1.RootShard`
`124`		`- if err := r.Client.Get(ctx, types.NamespacedName{Name: frontProxy.Spec.RootShard.Reference.Name, Namespace: req.Namespace}, &rootShard); err != nil {`
	`124`	`+ if err := r.Get(ctx, types.NamespacedName{Name: frontProxy.Spec.RootShard.Reference.Name, Namespace: req.Namespace}, &rootShard); err != nil {`
`125`	`125`	`return ctrl.Result{}, fmt.Errorf("failed to get RootShard: %w", err)`
`126`	`126`	`}`
`127`	`127`
`@@ -174,7 +174,7 @@ func (r *KubeconfigReconciler) getCertificateSecret(ctx context.Context, name, n`
`174`	`174`	`logger := log.FromContext(ctx).WithValues("certificate", name)`
`175`	`175`
`176`	`176`	`certificate := &certmanagerv1.Certificate{}`
`177`		`- if err := r.Client.Get(ctx, types.NamespacedName{Name: name, Namespace: namespace}, certificate); err != nil {`
	`177`	`+ if err := r.Get(ctx, types.NamespacedName{Name: name, Namespace: namespace}, certificate); err != nil {`
`178`	`178`	`// Because of how the reconciling framework works, this should never happen.`
`179`	`179`	`logger.V(6).Info("Certificate does not exist yet, trying later ...")`
`180`	`180`	`return nil, nil`
`@@ -194,7 +194,7 @@ func (r *KubeconfigReconciler) getCertificateSecret(ctx context.Context, name, n`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`secret := &corev1.Secret{}`
`197`		`- if err := r.Client.Get(ctx, types.NamespacedName{Name: certificate.Spec.SecretName, Namespace: certificate.Namespace}, secret); err != nil {`
	`197`	`+ if err := r.Get(ctx, types.NamespacedName{Name: certificate.Spec.SecretName, Namespace: certificate.Namespace}, secret); err != nil {`
`198`	`198`	`return nil, err`
`199`	`199`	`}`
`200`	`200`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ func (r *RootShardReconciler) Reconcile(ctx context.Context, req ctrl.Request) (`
`81`	`81`	`logger.V(4).Info("Reconciling")`
`82`	`82`
`83`	`83`	`var rootShard operatorv1alpha1.RootShard`
`84`		`- if err := r.Client.Get(ctx, req.NamespacedName, &rootShard); err != nil {`
	`84`	`+ if err := r.Get(ctx, req.NamespacedName, &rootShard); err != nil {`
`85`	`85`	`if ctrlruntimeclient.IgnoreNotFound(err) != nil {`
`86`	`86`	`return ctrl.Result{}, fmt.Errorf("failed to find %s/%s: %w", req.Namespace, req.Name, err)`
`87`	`87`	`}`
`@@ -199,7 +199,7 @@ func (r *RootShardReconciler) reconcileStatus(ctx context.Context, oldRootShard`
`199`	`199`
`200`	`200`	`// only patch the status if there are actual changes.`
`201`	`201`	`if !equality.Semantic.DeepEqual(oldRootShard.Status, rootShard.Status) {`
`202`		`- if err := r.Client.Status().Patch(ctx, rootShard, ctrlruntimeclient.MergeFrom(oldRootShard)); err != nil {`
	`202`	`+ if err := r.Status().Patch(ctx, rootShard, ctrlruntimeclient.MergeFrom(oldRootShard)); err != nil {`
`203`	`203`	`errs = append(errs, err)`
`204`	`204`	`}`
`205`	`205`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ func (r *ShardReconciler) Reconcile(ctx context.Context, req ctrl.Request) (res`
`93`	`93`	`logger.V(4).Info("Reconciling Shard object")`
`94`	`94`
`95`	`95`	`var s operatorv1alpha1.Shard`
`96`		`- if err := r.Client.Get(ctx, req.NamespacedName, &s); err != nil {`
	`96`	`+ if err := r.Get(ctx, req.NamespacedName, &s); err != nil {`
`97`	`97`	`if ctrlruntimeclient.IgnoreNotFound(err) != nil {`
`98`	`98`	`return ctrl.Result{}, fmt.Errorf("failed to get shard: %w", err)`
`99`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ func DeploymentReconciler(frontProxy operatorv1alpha1.FrontProxy, rootShard op`
`39`	`39`	`dep.Spec.Selector = &metav1.LabelSelector{`
`40`	`40`	`MatchLabels: resources.GetFrontProxyResourceLabels(frontProxy),`
`41`	`41`	`}`
`42`		`- dep.Spec.Template.ObjectMeta.SetLabels(resources.GetFrontProxyResourceLabels(frontProxy))`
	`42`	`+ dep.Spec.Template.SetLabels(resources.GetFrontProxyResourceLabels(frontProxy))`
`43`	`43`
`44`	`44`	`image, _ := resources.GetImageSettings(frontProxy.Spec.Image)`
`45`	`45`	`args := getArgs(&frontProxy.Spec)`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ func DeploymentReconciler(rootShard *operatorv1alpha1.RootShard) reconciling.Nam`
`70`	`70`	`dep.Spec.Selector = &metav1.LabelSelector{`
`71`	`71`	`MatchLabels: labels,`
`72`	`72`	`}`
`73`		`- dep.Spec.Template.ObjectMeta.SetLabels(labels)`
	`73`	`+ dep.Spec.Template.SetLabels(labels)`
`74`	`74`
`75`	`75`	`secretMounts := []utils.SecretMount{{`
`76`	`76`	`VolumeName: "kcp-ca",`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ func DeploymentReconciler(shard operatorv1alpha1.Shard, rootShard operatorv1al`
`69`	`69`	`dep.Spec.Selector = &metav1.LabelSelector{`
`70`	`70`	`MatchLabels: labels,`
`71`	`71`	`}`
`72`		`- dep.Spec.Template.ObjectMeta.SetLabels(labels)`
	`72`	`+ dep.Spec.Template.SetLabels(labels)`
`73`	`73`
`74`	`74`	`secretMounts := []utils.SecretMount{{`
`75`	`75`	`VolumeName: "kcp-ca",`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,7 @@ import (`
`31`	`31`
`32`	`32`	`func ApplyCommonShardConfig(deployment appsv1.Deployment, spec operatorv1alpha1.CommonShardSpec) (*appsv1.Deployment, error) {`
`33`	`33`	`if len(deployment.Spec.Template.Spec.Containers) == 0 {`
	`34`	`+ //nolint:staticcheck // allow capital letter in error message`
`34`	`35`	`return deployment, errors.New("Deployment does not contain any containers")`
`35`	`36`	`}`
`36`	`37`