fix lints

cpanato · cpanato · commit 1b12c051c8ac · 2025-06-02T14:44:54.000+02:00
Signed-off-by: Carlos Panato &lt;ctadeu@gmail.com&gt;
diff --git a/cloud/scope/cluster.go b/cloud/scope/cluster.go
@@ -50,13 +50,13 @@ func NewClusterScope(ctx context.Context, params ClusterScopeParams) (*ClusterSc
 		return nil, errors.New("failed to generate new scope from nil GCPCluster")
 	}
 
-	if params.GCPServices.Compute == nil {
+	if params.Compute == nil {
 		computeSvc, err := newComputeService(ctx, params.GCPCluster.Spec.CredentialsRef, params.Client, params.GCPCluster.Spec.ServiceEndpoints)
 		if err != nil {
 			return nil, errors.Errorf("failed to create gcp compute client: %v", err)
 		}
 
-		params.GCPServices.Compute = computeSvc
+		params.Compute = computeSvc
 	}
 
 	helper, err := patch.NewHelper(params.GCPCluster, params.Client)
diff --git a/cloud/scope/managedcluster.go b/cloud/scope/managedcluster.go
@@ -51,13 +51,13 @@ func NewManagedClusterScope(ctx context.Context, params ManagedClusterScopeParam
 		return nil, errors.New("failed to generate new scope from nil GCPManagedCluster")
 	}
 
-	if params.GCPServices.Compute == nil {
+	if params.Compute == nil {
 		computeSvc, err := newComputeService(ctx, params.GCPManagedCluster.Spec.CredentialsRef, params.Client, params.GCPManagedCluster.Spec.ServiceEndpoints)
 		if err != nil {
 			return nil, errors.Errorf("failed to create gcp compute client: %v", err)
 		}
 
-		params.GCPServices.Compute = computeSvc
+		params.Compute = computeSvc
 	}
 
 	helper, err := patch.NewHelper(params.GCPManagedCluster, params.Client)
diff --git a/cloud/services/compute/firewalls/reconcile_test.go b/cloud/services/compute/firewalls/reconcile_test.go
@@ -155,7 +155,7 @@ func TestService_Reconcile(t *testing.T) {
 				Objects:       map[meta.Key]*cloud.MockFirewallsObj{},
 			},
 			assert: func(ctx context.Context, t testCase) error {
-				key := meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.ObjectMeta.Name))
+				key := meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.Name))
 				fwRule, err := t.mockFirewalls.Get(ctx, key)
 				if err != nil {
 					return err
@@ -173,7 +173,7 @@ func TestService_Reconcile(t *testing.T) {
 			mockFirewalls: &cloud.MockFirewalls{
 				ProjectRouter: &cloud.SingleProjectRouter{ID: "my-proj"},
 				Objects: map[meta.Key]*cloud.MockFirewallsObj{
-					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.ObjectMeta.Name)): {},
+					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.Name)): {},
 				},
 			},
 		},
@@ -196,7 +196,7 @@ func TestService_Reconcile(t *testing.T) {
 				ProjectRouter: &cloud.SingleProjectRouter{ID: "my-proj"},
 				Objects:       map[meta.Key]*cloud.MockFirewallsObj{},
 				InsertError: map[meta.Key]error{
-					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.ObjectMeta.Name)): &googleapi.Error{Code: http.StatusBadRequest},
+					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.Name)): &googleapi.Error{Code: http.StatusBadRequest},
 				},
 			},
 			wantErr: true,
@@ -207,7 +207,7 @@ func TestService_Reconcile(t *testing.T) {
 			mockFirewalls: &cloud.MockFirewalls{
 				ProjectRouter: &cloud.SingleProjectRouter{ID: "my-proj"},
 				Objects: map[meta.Key]*cloud.MockFirewallsObj{
-					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.ObjectMeta.Name)): {},
+					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.Name)): {},
 				},
 			},
 		},
@@ -269,7 +269,7 @@ func TestService_Delete(t *testing.T) {
 			mockFirewalls: &cloud.MockFirewalls{
 				ProjectRouter: &cloud.SingleProjectRouter{ID: "my-proj"},
 				DeleteError: map[meta.Key]error{
-					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.ObjectMeta.Name)): &googleapi.Error{Code: http.StatusNotFound},
+					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.Name)): &googleapi.Error{Code: http.StatusNotFound},
 				},
 			},
 		},
@@ -279,7 +279,7 @@ func TestService_Delete(t *testing.T) {
 			mockFirewalls: &cloud.MockFirewalls{
 				ProjectRouter: &cloud.SingleProjectRouter{ID: "my-proj"},
 				DeleteError: map[meta.Key]error{
-					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.ObjectMeta.Name)): &googleapi.Error{Code: http.StatusBadRequest},
+					*meta.GlobalKey(fmt.Sprintf("allow-%s-healthchecks", fakeGCPCluster.Name)): &googleapi.Error{Code: http.StatusBadRequest},
 				},
 			},
 			wantErr: true,
diff --git a/controllers/gcpmachine_controller.go b/controllers/gcpmachine_controller.go
@@ -173,7 +173,7 @@ func (r *GCPMachineReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 		Namespace: gcpMachine.Namespace,
 		Name:      cluster.Spec.InfrastructureRef.Name,
 	}
-	if err := r.Client.Get(ctx, gcpClusterKey, gcpCluster); err != nil {
+	if err := r.Get(ctx, gcpClusterKey, gcpCluster); err != nil {
 		log.Info("GCPCluster is not available yet")
 		return ctrl.Result{}, nil
 	}
@@ -207,7 +207,7 @@ func (r *GCPMachineReconciler) Reconcile(ctx context.Context, req ctrl.Request)
 	}()
 
 	// Handle deleted machines
-	if !gcpMachine.ObjectMeta.DeletionTimestamp.IsZero() {
+	if !gcpMachine.DeletionTimestamp.IsZero() {
 		return ctrl.Result{}, r.reconcileDelete(ctx, machineScope)
 	}
 
diff --git a/exp/controllers/gcpmanagedcluster_controller.go b/exp/controllers/gcpmanagedcluster_controller.go
@@ -275,7 +275,7 @@ func (r *GCPManagedClusterReconciler) managedControlPlaneMapper() handler.MapFun
 
 		log = log.WithValues("objectMapper", "cpTomc", "gcpmanagedcontrolplane", klog.KRef(gcpManagedControlPlane.Namespace, gcpManagedControlPlane.Name))
 
-		if !gcpManagedControlPlane.ObjectMeta.DeletionTimestamp.IsZero() {
+		if !gcpManagedControlPlane.DeletionTimestamp.IsZero() {
 			log.Info("GCPManagedControlPlane has a deletion timestamp, skipping mapping")
 			return nil
 		}
@@ -319,7 +319,7 @@ func (r *GCPManagedClusterReconciler) dependencyCount(ctx context.Context, clust
 	}
 
 	managedMachinePools := &infrav1exp.GCPManagedMachinePoolList{}
-	if err := r.Client.List(ctx, managedMachinePools, listOptions...); err != nil {
+	if err := r.List(ctx, managedMachinePools, listOptions...); err != nil {
 		return 0, fmt.Errorf("failed to list managed machine pools for cluster %s/%s: %w", clusterNamespace, clusterName, err)
 	}
 
diff --git a/exp/controllers/gcpmanagedcontrolplane_controller.go b/exp/controllers/gcpmanagedcontrolplane_controller.go
@@ -92,7 +92,7 @@ func (r *GCPManagedControlPlaneReconciler) Reconcile(ctx context.Context, req ct
 
 	// Get the control plane instance
 	gcpManagedControlPlane := &infrav1exp.GCPManagedControlPlane{}
-	if err := r.Client.Get(ctx, req.NamespacedName, gcpManagedControlPlane); err != nil {
+	if err := r.Get(ctx, req.NamespacedName, gcpManagedControlPlane); err != nil {
 		if apierrors.IsNotFound(err) {
 			return ctrl.Result{}, nil
 		}
@@ -121,7 +121,7 @@ func (r *GCPManagedControlPlaneReconciler) Reconcile(ctx context.Context, req ct
 		Namespace: gcpManagedControlPlane.Namespace,
 		Name:      cluster.Spec.InfrastructureRef.Name,
 	}
-	if err := r.Client.Get(ctx, key, managedCluster); err != nil {
+	if err := r.Get(ctx, key, managedCluster); err != nil {
 		log.Error(err, "Failed to retrieve GCPManagedCluster from the API Server")
 		return ctrl.Result{}, err
 	}
diff --git a/exp/controllers/gcpmanagedmachinepool_controller.go b/exp/controllers/gcpmanagedmachinepool_controller.go
@@ -112,7 +112,7 @@ func managedControlPlaneToManagedMachinePoolMapFunc(c client.Client, gvk schema.
 			panic(fmt.Sprintf("Expected a GCPManagedControlPlane but got a %T", o))
 		}
 
-		if !gcpManagedControlPlane.ObjectMeta.DeletionTimestamp.IsZero() {
+		if !gcpManagedControlPlane.DeletionTimestamp.IsZero() {
 			return nil
 		}
 
@@ -231,7 +231,7 @@ func (r *GCPManagedMachinePoolReconciler) Reconcile(ctx context.Context, req ctr
 
 	// Get the managed machine pool
 	gcpManagedMachinePool := &infrav1exp.GCPManagedMachinePool{}
-	if err := r.Client.Get(ctx, req.NamespacedName, gcpManagedMachinePool); err != nil {
+	if err := r.Get(ctx, req.NamespacedName, gcpManagedMachinePool); err != nil {
 		if apierrors.IsNotFound(err) {
 			return ctrl.Result{}, nil
 		}
@@ -266,7 +266,7 @@ func (r *GCPManagedMachinePoolReconciler) Reconcile(ctx context.Context, req ctr
 		Name:      cluster.Spec.InfrastructureRef.Name,
 	}
 	gcpManagedCluster := &infrav1exp.GCPManagedCluster{}
-	if err := r.Client.Get(ctx, gcpManagedClusterKey, gcpManagedCluster); err != nil {
+	if err := r.Get(ctx, gcpManagedClusterKey, gcpManagedCluster); err != nil {
 		log.Error(err, "Failed to retrieve GCPManagedCluster from the API Server")
 		return ctrl.Result{}, err
 	}
@@ -276,7 +276,7 @@ func (r *GCPManagedMachinePoolReconciler) Reconcile(ctx context.Context, req ctr
 		Name:      cluster.Spec.ControlPlaneRef.Name,
 	}
 	gcpManagedControlPlane := &infrav1exp.GCPManagedControlPlane{}
-	if err := r.Client.Get(ctx, gcpManagedControlPlaneKey, gcpManagedControlPlane); err != nil {
+	if err := r.Get(ctx, gcpManagedControlPlaneKey, gcpManagedControlPlane); err != nil {
 		log.Info("Failed to retrieve ManagedControlPlane from ManagedMachinePool")
 		return reconcile.Result{}, nil
 	}

Original file line number	Diff line number	Diff line change
`@@ -50,13 +50,13 @@ func NewClusterScope(ctx context.Context, params ClusterScopeParams) (*ClusterSc`
`50`	`50`	`return nil, errors.New("failed to generate new scope from nil GCPCluster")`
`51`	`51`	`}`
`52`	`52`
`53`		`- if params.GCPServices.Compute == nil {`
	`53`	`+ if params.Compute == nil {`
`54`	`54`	`computeSvc, err := newComputeService(ctx, params.GCPCluster.Spec.CredentialsRef, params.Client, params.GCPCluster.Spec.ServiceEndpoints)`
`55`	`55`	`if err != nil {`
`56`	`56`	`return nil, errors.Errorf("failed to create gcp compute client: %v", err)`
`57`	`57`	`}`
`58`	`58`
`59`		`- params.GCPServices.Compute = computeSvc`
	`59`	`+ params.Compute = computeSvc`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`helper, err := patch.NewHelper(params.GCPCluster, params.Client)`
Original file line number	Diff line number	Diff line change
`@@ -51,13 +51,13 @@ func NewManagedClusterScope(ctx context.Context, params ManagedClusterScopeParam`
`51`	`51`	`return nil, errors.New("failed to generate new scope from nil GCPManagedCluster")`
`52`	`52`	`}`
`53`	`53`
`54`		`- if params.GCPServices.Compute == nil {`
	`54`	`+ if params.Compute == nil {`
`55`	`55`	`computeSvc, err := newComputeService(ctx, params.GCPManagedCluster.Spec.CredentialsRef, params.Client, params.GCPManagedCluster.Spec.ServiceEndpoints)`
`56`	`56`	`if err != nil {`
`57`	`57`	`return nil, errors.Errorf("failed to create gcp compute client: %v", err)`
`58`	`58`	`}`
`59`	`59`
`60`		`- params.GCPServices.Compute = computeSvc`
	`60`	`+ params.Compute = computeSvc`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`helper, err := patch.NewHelper(params.GCPManagedCluster, params.Client)`
Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ func (r *GCPMachineReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`173`	`173`	`Namespace: gcpMachine.Namespace,`
`174`	`174`	`Name: cluster.Spec.InfrastructureRef.Name,`
`175`	`175`	`}`
`176`		`- if err := r.Client.Get(ctx, gcpClusterKey, gcpCluster); err != nil {`
	`176`	`+ if err := r.Get(ctx, gcpClusterKey, gcpCluster); err != nil {`
`177`	`177`	`log.Info("GCPCluster is not available yet")`
`178`	`178`	`return ctrl.Result{}, nil`
`179`	`179`	`}`
`@@ -207,7 +207,7 @@ func (r *GCPMachineReconciler) Reconcile(ctx context.Context, req ctrl.Request)`
`207`	`207`	`}()`
`208`	`208`
`209`	`209`	`// Handle deleted machines`
`210`		`- if !gcpMachine.ObjectMeta.DeletionTimestamp.IsZero() {`
	`210`	`+ if !gcpMachine.DeletionTimestamp.IsZero() {`
`211`	`211`	`return ctrl.Result{}, r.reconcileDelete(ctx, machineScope)`
`212`	`212`	`}`
`213`	`213`
Original file line number	Diff line number	Diff line change
`@@ -275,7 +275,7 @@ func (r *GCPManagedClusterReconciler) managedControlPlaneMapper() handler.MapFun`
`275`	`275`
`276`	`276`	`log = log.WithValues("objectMapper", "cpTomc", "gcpmanagedcontrolplane", klog.KRef(gcpManagedControlPlane.Namespace, gcpManagedControlPlane.Name))`
`277`	`277`
`278`		`- if !gcpManagedControlPlane.ObjectMeta.DeletionTimestamp.IsZero() {`
	`278`	`+ if !gcpManagedControlPlane.DeletionTimestamp.IsZero() {`
`279`	`279`	`log.Info("GCPManagedControlPlane has a deletion timestamp, skipping mapping")`
`280`	`280`	`return nil`
`281`	`281`	`}`
`@@ -319,7 +319,7 @@ func (r *GCPManagedClusterReconciler) dependencyCount(ctx context.Context, clust`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`managedMachinePools := &infrav1exp.GCPManagedMachinePoolList{}`
`322`		`- if err := r.Client.List(ctx, managedMachinePools, listOptions...); err != nil {`
	`322`	`+ if err := r.List(ctx, managedMachinePools, listOptions...); err != nil {`
`323`	`323`	`return 0, fmt.Errorf("failed to list managed machine pools for cluster %s/%s: %w", clusterNamespace, clusterName, err)`
`324`	`324`	`}`
`325`	`325`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ func (r *GCPManagedControlPlaneReconciler) Reconcile(ctx context.Context, req ct`
`92`	`92`
`93`	`93`	`// Get the control plane instance`
`94`	`94`	`gcpManagedControlPlane := &infrav1exp.GCPManagedControlPlane{}`
`95`		`- if err := r.Client.Get(ctx, req.NamespacedName, gcpManagedControlPlane); err != nil {`
	`95`	`+ if err := r.Get(ctx, req.NamespacedName, gcpManagedControlPlane); err != nil {`
`96`	`96`	`if apierrors.IsNotFound(err) {`
`97`	`97`	`return ctrl.Result{}, nil`
`98`	`98`	`}`
`@@ -121,7 +121,7 @@ func (r *GCPManagedControlPlaneReconciler) Reconcile(ctx context.Context, req ct`
`121`	`121`	`Namespace: gcpManagedControlPlane.Namespace,`
`122`	`122`	`Name: cluster.Spec.InfrastructureRef.Name,`
`123`	`123`	`}`
`124`		`- if err := r.Client.Get(ctx, key, managedCluster); err != nil {`
	`124`	`+ if err := r.Get(ctx, key, managedCluster); err != nil {`
`125`	`125`	`log.Error(err, "Failed to retrieve GCPManagedCluster from the API Server")`
`126`	`126`	`return ctrl.Result{}, err`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ func managedControlPlaneToManagedMachinePoolMapFunc(c client.Client, gvk schema.`
`112`	`112`	`panic(fmt.Sprintf("Expected a GCPManagedControlPlane but got a %T", o))`
`113`	`113`	`}`
`114`	`114`
`115`		`- if !gcpManagedControlPlane.ObjectMeta.DeletionTimestamp.IsZero() {`
	`115`	`+ if !gcpManagedControlPlane.DeletionTimestamp.IsZero() {`
`116`	`116`	`return nil`
`117`	`117`	`}`
`118`	`118`
`@@ -231,7 +231,7 @@ func (r *GCPManagedMachinePoolReconciler) Reconcile(ctx context.Context, req ctr`
`231`	`231`
`232`	`232`	`// Get the managed machine pool`
`233`	`233`	`gcpManagedMachinePool := &infrav1exp.GCPManagedMachinePool{}`
`234`		`- if err := r.Client.Get(ctx, req.NamespacedName, gcpManagedMachinePool); err != nil {`
	`234`	`+ if err := r.Get(ctx, req.NamespacedName, gcpManagedMachinePool); err != nil {`
`235`	`235`	`if apierrors.IsNotFound(err) {`
`236`	`236`	`return ctrl.Result{}, nil`
`237`	`237`	`}`
`@@ -266,7 +266,7 @@ func (r *GCPManagedMachinePoolReconciler) Reconcile(ctx context.Context, req ctr`
`266`	`266`	`Name: cluster.Spec.InfrastructureRef.Name,`
`267`	`267`	`}`
`268`	`268`	`gcpManagedCluster := &infrav1exp.GCPManagedCluster{}`
`269`		`- if err := r.Client.Get(ctx, gcpManagedClusterKey, gcpManagedCluster); err != nil {`
	`269`	`+ if err := r.Get(ctx, gcpManagedClusterKey, gcpManagedCluster); err != nil {`
`270`	`270`	`log.Error(err, "Failed to retrieve GCPManagedCluster from the API Server")`
`271`	`271`	`return ctrl.Result{}, err`
`272`	`272`	`}`
`@@ -276,7 +276,7 @@ func (r *GCPManagedMachinePoolReconciler) Reconcile(ctx context.Context, req ctr`
`276`	`276`	`Name: cluster.Spec.ControlPlaneRef.Name,`
`277`	`277`	`}`
`278`	`278`	`gcpManagedControlPlane := &infrav1exp.GCPManagedControlPlane{}`
`279`		`- if err := r.Client.Get(ctx, gcpManagedControlPlaneKey, gcpManagedControlPlane); err != nil {`
	`279`	`+ if err := r.Get(ctx, gcpManagedControlPlaneKey, gcpManagedControlPlane); err != nil {`
`280`	`280`	`log.Info("Failed to retrieve ManagedControlPlane from ManagedMachinePool")`
`281`	`281`	`return reconcile.Result{}, nil`
`282`	`282`	`}`