chore(lints): ran golangci-lint run --fix on codebase (#1725)

coillteoir · David Lynch · web-flow · commit 6faee1e0cf99 · 2026-04-01T14:56:08.000+01:00
Co-authored-by: David Lynch &lt;david.lynch@workday.com&gt;
diff --git a/controllers/tc009990_mtls_generate_creds_test.go b/controllers/tc009990_mtls_generate_creds_test.go
@@ -142,7 +142,7 @@ func Test_009990_mtls_generate_creds_test(t *testing.T) {
 	g.Expect(caValid).To(BeTrue())
 
 	By("verifying that the runner cert secret has the appropriate labels")
-	labels := runnerSecret.ObjectMeta.GetLabels()
+	labels := runnerSecret.GetLabels()
 	g.Expect(labels).To(HaveKey(infrav1.RunnerLabel))
 
 	By("verifying that the runner cert is valid for a range of hostnames in a given namespace")
diff --git a/controllers/tf_controller.go b/controllers/tf_controller.go
@@ -131,7 +131,7 @@ func (r *TerraformReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 	<-r.CertRotator.Ready
 
 	traceLog.Info("Validate TLS Cert")
-	if isCAValid, _ := r.CertRotator.IsCAValid(); isCAValid == false && r.CertRotator.TriggerCARotation != nil {
+	if isCAValid, _ := r.CertRotator.IsCAValid(); !isCAValid && r.CertRotator.TriggerCARotation != nil {
 		traceLog.Info("TLS Cert invalid")
 		readyCh := make(chan *mtls.TriggerResult)
 		traceLog.Info("Trigger Cert Rotation")
@@ -169,7 +169,7 @@ func (r *TerraformReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		}
 
 		// Record the duration of the reconciliation.
-		r.Metrics.RecordDuration(ctx, terraform, startTime)
+		r.RecordDuration(ctx, terraform, startTime)
 	}()
 
 	// Make sure the Finalizer exists
@@ -472,7 +472,7 @@ func (r *TerraformReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 
 	// Examine if the object is under deletion
 	traceLog.Info("Check for deletion timestamp to finalize")
-	if !terraform.ObjectMeta.DeletionTimestamp.IsZero() {
+	if !terraform.DeletionTimestamp.IsZero() {
 		traceLog.Info("Calling finalize function")
 		if terraform, result, err := r.finalize(ctx, patchHelper, terraform, runnerClient, sourceObj, reconciliationLoopID); err != nil {
 			traceLog.Info("Patch the status of the Terraform resource")
@@ -641,7 +641,7 @@ func (r *TerraformReconciler) shouldReconcile(terraform *infrav1.Terraform, sour
 }
 
 func isBeingDeleted(terraform *infrav1.Terraform) bool {
-	return !terraform.ObjectMeta.DeletionTimestamp.IsZero()
+	return !terraform.DeletionTimestamp.IsZero()
 }
 
 // SetupWithManager sets up the controller with the Manager.
@@ -733,7 +733,7 @@ func (r *TerraformReconciler) checkDependencies(ctx context.Context, terraform *
 
 		// Check whether the dependent Terraform isn't being deleted, and then add a
 		// a finalizer if it is missing
-		if tDep.ObjectMeta.DeletionTimestamp.IsZero() && !controllerutil.ContainsFinalizer(tDep, finalizerKey) {
+		if tDep.DeletionTimestamp.IsZero() && !controllerutil.ContainsFinalizer(tDep, finalizerKey) {
 			patch := client.MergeFrom(tDep.DeepCopy())
 			controllerutil.AddFinalizer(tDep, finalizerKey)
 			if err := r.Patch(context.Background(), tDep, patch, client.FieldOwner(r.FieldManager)); err != nil {
@@ -811,8 +811,8 @@ func (r *TerraformReconciler) requestsForRevisionChangeOf(indexKey string) handl
 		}
 		reqs := make([]reconcile.Request, len(sorted))
 		for i, t := range sorted {
-			reqs[i].NamespacedName.Name = t.Name
-			reqs[i].NamespacedName.Namespace = t.Namespace
+			reqs[i].Name = t.Name
+			reqs[i].Namespace = t.Namespace
 		}
 		return reqs
 	}
@@ -841,7 +841,7 @@ func (r *TerraformReconciler) getSource(ctx context.Context, terraform *infrav1.
 	switch terraform.Spec.SourceRef.Kind {
 	case sourcev1.GitRepositoryKind:
 		var repository sourcev1.GitRepository
-		err := r.Client.Get(ctx, sourceReference, &repository)
+		err := r.Get(ctx, sourceReference, &repository)
 		if err != nil {
 			if apierrors.IsNotFound(err) {
 				return sourceObj, err
@@ -851,7 +851,7 @@ func (r *TerraformReconciler) getSource(ctx context.Context, terraform *infrav1.
 		sourceObj = &repository
 	case sourcev1.BucketKind:
 		var bucket sourcev1.Bucket
-		err := r.Client.Get(ctx, sourceReference, &bucket)
+		err := r.Get(ctx, sourceReference, &bucket)
 		if err != nil {
 			if apierrors.IsNotFound(err) {
 				return sourceObj, err
@@ -861,7 +861,7 @@ func (r *TerraformReconciler) getSource(ctx context.Context, terraform *infrav1.
 		sourceObj = &bucket
 	case sourcev1.OCIRepositoryKind:
 		var repository sourcev1.OCIRepository
-		err := r.Client.Get(ctx, sourceReference, &repository)
+		err := r.Get(ctx, sourceReference, &repository)
 		if err != nil {
 			if apierrors.IsNotFound(err) {
 				return sourceObj, err
diff --git a/controllers/tf_controller_apply.go b/controllers/tf_controller_apply.go
@@ -100,7 +100,7 @@ func (r *TerraformReconciler) apply(ctx context.Context, patchHelper *patch.Seri
 
 	// this a special case, when backend is completely disabled.
 	// we need to use "destroy" command instead of apply
-	if r.backendCompletelyDisable(terraform) && terraform.Spec.Destroy == true {
+	if r.backendCompletelyDisable(terraform) && terraform.Spec.Destroy {
 		destroyReply, err := runnerClient.Destroy(ctx, &runner.DestroyRequest{
 			TfInstance: tfInstance,
 			Targets:    terraform.Spec.Targets,
@@ -120,7 +120,7 @@ func (r *TerraformReconciler) apply(ctx context.Context, patchHelper *patch.Seri
 				}
 			}
 
-			if eventSent == false {
+			if !eventSent {
 				msg := fmt.Sprintf("Destroy error: %s", err.Error())
 				r.Eventf(terraform, corev1.EventTypeWarning, infrav1.TFExecDestroyFailedReason, msg)
 			}
@@ -149,7 +149,7 @@ func (r *TerraformReconciler) apply(ctx context.Context, patchHelper *patch.Seri
 				}
 			}
 
-			if eventSent == false {
+			if !eventSent {
 				msg := fmt.Sprintf("Apply error: %s", err.Error())
 				r.Eventf(terraform, corev1.EventTypeWarning, infrav1.TFExecApplyFailedReason, msg)
 			}
@@ -167,7 +167,7 @@ func (r *TerraformReconciler) apply(ctx context.Context, patchHelper *patch.Seri
 		isDestroyApplied = terraform.Status.Plan.IsDestroyPlan
 
 		// if apply was successful, we need to update the inventory, but not if we are destroying
-		if terraform.Spec.EnableInventory && isDestroyApplied == false {
+		if terraform.Spec.EnableInventory && !isDestroyApplied {
 			getInventoryRequest := &runner.GetInventoryRequest{TfInstance: tfInstance}
 			getInventoryReply, err := runnerClient.GetInventory(ctx, getInventoryRequest)
 			if err != nil {
@@ -189,18 +189,18 @@ func (r *TerraformReconciler) apply(ctx context.Context, patchHelper *patch.Seri
 				})
 			}
 			log.Info(fmt.Sprintf("got inventory - entries count: %d", len(inventoryEntries)))
-		} else if terraform.Spec.EnableInventory == false {
+		} else if !terraform.Spec.EnableInventory {
 			log.Info("inventory is disabled")
 			terraform.Status.Inventory = nil
 		}
 	}
 
 	var msg string
 	if isDestroyApplied {
-		msg = fmt.Sprintf("Destroy applied successfully")
+		msg = "Destroy applied successfully"
 		r.Eventf(terraform, corev1.EventTypeNormal, infrav1.TFExecDestroySucceedReason, msg)
 	} else {
-		msg = fmt.Sprintf("Applied successfully")
+		msg = "Applied successfully"
 		r.Eventf(terraform, corev1.EventTypeNormal, infrav1.TFExecApplySucceedReason, msg)
 	}
 
diff --git a/controllers/tf_controller_backend.go b/controllers/tf_controller_backend.go
@@ -22,7 +22,7 @@ func (r *TerraformReconciler) backendCompletelyDisable(terraform *infrav1.Terraf
 		return true
 	}
 
-	return terraform.Spec.BackendConfig != nil && terraform.Spec.BackendConfig.Disable == true
+	return terraform.Spec.BackendConfig != nil && terraform.Spec.BackendConfig.Disable
 }
 
 func (r *TerraformReconciler) setupTerraform(ctx context.Context, patchHelper *patch.SerialPatcher, runnerClient runner.RunnerClient, terraform *infrav1.Terraform, sourceObj sourcev1.Source, revision string, reconciliationLoopID string) (*infrav1.Terraform, string, string, error) {
@@ -233,14 +233,14 @@ terraform {
 
 			if env.ValueFrom.SecretKeyRef != nil {
 				secret := corev1.Secret{}
-				err = r.Client.Get(ctx, types.NamespacedName{
+				err = r.Get(ctx, types.NamespacedName{
 					Namespace: terraform.GetObjectMeta().GetNamespace(),
 					Name:      env.ValueFrom.SecretKeyRef.Name,
 				}, &secret)
 				envs[env.Name] = string(secret.Data[env.ValueFrom.SecretKeyRef.Key])
 			} else if env.ValueFrom.ConfigMapKeyRef != nil {
 				cm := corev1.ConfigMap{}
-				err = r.Client.Get(ctx, types.NamespacedName{
+				err = r.Get(ctx, types.NamespacedName{
 					Namespace: terraform.GetObjectMeta().GetNamespace(),
 					Name:      env.ValueFrom.ConfigMapKeyRef.Name,
 				}, &cm)
diff --git a/controllers/tf_controller_drift_detect.go b/controllers/tf_controller_drift_detect.go
@@ -16,12 +16,12 @@ func (r *TerraformReconciler) shouldDetectDrift(terraform *infrav1.Terraform, re
 	// Please do not optimize this logic, as we'd like others to easily understand the logics behind this behaviour.
 
 	// return false when drift detection is disabled
-	if terraform.Spec.DisableDriftDetection == true {
+	if terraform.Spec.DisableDriftDetection {
 		return false
 	}
 
 	// not support when Destroy == true
-	if terraform.Spec.Destroy == true {
+	if terraform.Spec.Destroy {
 		return false
 	}
 
@@ -99,7 +99,7 @@ func (r *TerraformReconciler) detectDrift(ctx context.Context, terraform *infrav
 			}
 		}
 
-		if eventSent == false {
+		if !eventSent {
 			msg := fmt.Sprintf("Drift detection error: %s", err.Error())
 			r.Eventf(terraform, corev1.EventTypeWarning, infrav1.DriftDetectionFailedReason, msg)
 		}
diff --git a/controllers/tf_controller_finalizer.go b/controllers/tf_controller_finalizer.go
@@ -83,7 +83,7 @@ func (r *TerraformReconciler) finalize(ctx context.Context, patchHelper *patch.S
 			return terraform, controllerruntime.Result{Requeue: true}, err
 		}
 
-		if thereIsNothingToDestroy(terraform) == false {
+		if !thereIsNothingToDestroy(terraform) {
 			traceLog.Info("Apply the destroy plan")
 			terraform, err = r.apply(ctx, patchHelper, terraform, tfInstance, runnerClient, revision)
 			traceLog.Info("Check for error")
diff --git a/controllers/tf_controller_health_checks.go b/controllers/tf_controller_health_checks.go
@@ -31,9 +31,10 @@ func (r *TerraformReconciler) shouldDoHealthChecks(terraform *infrav1.Terraform)
 	var applyCondition metav1.Condition
 	var hcCondition metav1.Condition
 	for _, c := range terraform.Status.Conditions {
-		if c.Type == infrav1.ConditionTypeApply {
+		switch c.Type {
+		case infrav1.ConditionTypeApply:
 			applyCondition = c
-		} else if c.Type == infrav1.ConditionTypeHealthCheck {
+		case infrav1.ConditionTypeHealthCheck:
 			hcCondition = c
 		}
 	}
diff --git a/controllers/tf_controller_outputs.go b/controllers/tf_controller_outputs.go
@@ -35,13 +35,13 @@ func (r *TerraformReconciler) outputsMayBeDrifted(ctx context.Context, terraform
 	if terraform.Spec.WriteOutputsToSecret != nil {
 		outputsSecretKey := types.NamespacedName{Namespace: terraform.Namespace, Name: terraform.Spec.WriteOutputsToSecret.Name}
 		var outputsSecret corev1.Secret
-		err := r.Client.Get(ctx, outputsSecretKey, &outputsSecret)
+		err := r.Get(ctx, outputsSecretKey, &outputsSecret)
 		if err != nil && apierrors.IsNotFound(err) {
 			return true, nil
 		}
 
 		keysInSecret := []string{}
-		for k, _ := range outputsSecret.Data {
+		for k := range outputsSecret.Data {
 			keysInSecret = append(keysInSecret, k)
 		}
 		sort.Strings(keysInSecret)
@@ -168,7 +168,7 @@ func (r *TerraformReconciler) writeOutput(ctx context.Context, terraform *infrav
 		}
 	}
 
-	if len(data) == 0 || terraform.Spec.Destroy == true {
+	if len(data) == 0 || terraform.Spec.Destroy {
 		return infrav1.TerraformOutputsWritten(terraform, revision, "No Outputs written"), nil
 	}
 
@@ -193,7 +193,7 @@ func (r *TerraformReconciler) writeOutput(ctx context.Context, terraform *infrav
 
 	if writeOutputsReply.Changed {
 		keysWritten := []string{}
-		for k, _ := range data {
+		for k := range data {
 			keysWritten = append(keysWritten, k)
 		}
 		msg := fmt.Sprintf("Outputs written.\n%d output(s): %s", len(keysWritten), strings.Join(keysWritten, ", "))
diff --git a/controllers/tf_controller_plan.go b/controllers/tf_controller_plan.go
@@ -57,7 +57,7 @@ func (r *TerraformReconciler) plan(ctx context.Context, patchHelper *patch.Seria
 
 	// check if destroy is set to true or
 	// the object is being deleted and DestroyResourcesOnDeletion is set to true
-	if terraform.Spec.Destroy || (!terraform.ObjectMeta.DeletionTimestamp.IsZero() && terraform.Spec.DestroyResourcesOnDeletion) {
+	if terraform.Spec.Destroy || (!terraform.DeletionTimestamp.IsZero() && terraform.Spec.DestroyResourcesOnDeletion) {
 		log.Info("plan to destroy")
 		planRequest.Destroy = true
 	}
@@ -84,7 +84,7 @@ func (r *TerraformReconciler) plan(ctx context.Context, patchHelper *patch.Seria
 			}
 		}
 
-		if eventSent == false {
+		if !eventSent {
 			msg := fmt.Sprintf("Plan error: %s", err.Error())
 			r.Eventf(terraform, corev1.EventTypeWarning, infrav1.TFExecPlanFailedReason, msg)
 		}
@@ -101,7 +101,7 @@ func (r *TerraformReconciler) plan(ctx context.Context, patchHelper *patch.Seria
 	log.Info(fmt.Sprintf("plan: %s, found drift: %v", planReply.Message, drifted))
 
 	// currently the PlanCreated flag is only used here to determine if the destroy plan is empty
-	if planRequest.Destroy && planReply.PlanCreated == false {
+	if planRequest.Destroy && !planReply.PlanCreated {
 		// A corner case
 		// If the destroy plan is empty, we should not call apply
 		terraform = infrav1.TerraformPlannedNoChanges(terraform, revision, "No objects need to be destroyed")
@@ -145,7 +145,7 @@ func (r *TerraformReconciler) plan(ctx context.Context, patchHelper *patch.Seria
 		forceOrAutoApply := r.forceOrAutoApply(terraform)
 
 		// this is the manual mode, we fire the event to show how to apply the plan
-		if forceOrAutoApply == false {
+		if !forceOrAutoApply {
 			planId := planid.GetPlanID(revision)
 			approveMessage := planid.GetApproveMessage(planId, "Plan generated")
 			msg := fmt.Sprintf("Planned.\n%s", approveMessage)
diff --git a/controllers/tf_controller_reconcile.go b/controllers/tf_controller_reconcile.go
@@ -141,7 +141,7 @@ func (r *TerraformReconciler) reconcile(ctx context.Context, patchHelper *patch.
 		// immediately return if no drift - reconciliation will retry normally
 		if driftDetectionErr == nil {
 			// reconcile outputs only when outputs are missing
-			if outputsDrifted, err := r.outputsMayBeDrifted(ctx, terraform); outputsDrifted == true && err == nil {
+			if outputsDrifted, err := r.outputsMayBeDrifted(ctx, terraform); outputsDrifted && err == nil {
 				terraform, err = r.processOutputs(ctx, patchHelper, runnerClient, terraform, tfInstance, revision)
 				if err != nil {
 					log.Error(err, "error processing outputs")
@@ -287,7 +287,7 @@ func (r *TerraformReconciler) reconcile(ctx context.Context, patchHelper *patch.
 				Entries: inventoryEntries,
 			}
 		}
-	} else if terraform.Spec.EnableInventory == false {
+	} else if !terraform.Spec.EnableInventory {
 		log.Info("inventory is disabled")
 		terraform.Status.Inventory = nil
 	}
diff --git a/controllers/tf_controller_runner.go b/controllers/tf_controller_runner.go
@@ -536,14 +536,14 @@ func (r *TerraformReconciler) reconcileRunnerSecret(ctx context.Context, terrafo
 
 	// Check if the secret already exists
 	secret := &v1.Secret{}
-	if err := r.Client.Get(ctx, types.NamespacedName{Name: result.Secret.Name, Namespace: terraform.Namespace}, secret); err != nil {
+	if err := r.Get(ctx, types.NamespacedName{Name: result.Secret.Name, Namespace: terraform.Namespace}, secret); err != nil {
 		if errors.IsNotFound(err) {
 			// If secret does not exist, create it
 			result.Secret.SetResourceVersion("")
 			result.Secret.SetUID("")
 			result.Secret.SetGeneration(0)
 
-			if err := r.Client.Create(ctx, result.Secret); err != nil && !errors.IsAlreadyExists(err) {
+			if err := r.Create(ctx, result.Secret); err != nil && !errors.IsAlreadyExists(err) {
 				return nil, err
 			}
 		} else {
diff --git a/controllers/tf_controller_webhooks.go b/controllers/tf_controller_webhooks.go
@@ -66,21 +66,22 @@ func (r *TerraformReconciler) prepareWebhookPayload(terraform *infrav1.Terraform
 		return nil, err
 	}
 
-	if payloadType == "SpecAndPlan" {
+	switch payloadType {
+	case "SpecAndPlan":
 		obj, err = obj.Pipe(
 			yaml.Tee(yaml.Clear("status")),
 			yaml.Tee(
 				yaml.LookupCreate(yaml.MappingNode, "status"),
 				yaml.SetField("tfplan", planObj),
 			),
 		)
-	} else if payloadType == "SpecOnly" {
+	case "SpecOnly":
 		obj, err = obj.Pipe(
 			yaml.Tee(yaml.Clear("status")),
 		)
-	} else if payloadType == "PlanOnly" {
+	case "PlanOnly":
 		obj = planObj
-	} else {
+	default:
 		return nil, fmt.Errorf("unknown payload type: %s", payloadType)
 	}
 
@@ -118,7 +119,7 @@ func (r *TerraformReconciler) processPostPlanningWebhooks(ctx context.Context, t
 		log.Info("processing post-planning webhook", "webhook", webhook.URL)
 
 		// We skip webhook if it's not enabled
-		if webhook.IsEnabled() == false {
+		if !webhook.IsEnabled() {
 			continue
 		}
 
@@ -134,7 +135,7 @@ func (r *TerraformReconciler) processPostPlanningWebhooks(ctx context.Context, t
 
 		cli := cleanhttp.DefaultClient()
 
-		if disableWebhookTLSVerification == false {
+		if !disableWebhookTLSVerification {
 
 			log.Info("webhook TLS verification is enabled")
 
diff --git a/mtls/rotator.go b/mtls/rotator.go
@@ -224,10 +224,7 @@ tickerLoop:
 			}
 
 			// GC: garbage collect the old CA artifacts
-			for {
-				if len(cr.artifactCaches) == 0 {
-					break
-				}
+			for len(cr.artifactCaches) != 0 {
 
 				validUntil := cr.artifactCaches[0].ca.validUntil
 				// we must NOT use cr.lookaheadTime() here
diff --git a/runner.Dockerfile b/runner.Dockerfile
@@ -8,4 +8,4 @@ FROM $BASE_IMAGE
 COPY --from=tofu /usr/local/bin/tofu /usr/local/bin/tofu
 
 # Switch back to the non-root user after operations
-USER 65532:65532
+USER 65532:65532
diff --git a/runner/server.go b/runner/server.go
diff --git a/runner/server_generate_tf_vars.go b/runner/server_generate_tf_vars.go
diff --git a/runner/server_init.go b/runner/server_init.go
diff --git a/runner/server_outputs.go b/runner/server_outputs.go
diff --git a/runner/server_plan.go b/runner/server_plan.go
diff --git a/runner/server_save_tfplan.go b/runner/server_save_tfplan.go
diff --git a/runner/server_workspace_blob.go b/runner/server_workspace_blob.go

Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ func (r TerraformReconciler) apply(ctx context.Context, patchHelper patch.Seri`
`100`	`100`
`101`	`101`	`// this a special case, when backend is completely disabled.`
`102`	`102`	`// we need to use "destroy" command instead of apply`
`103`		`- if r.backendCompletelyDisable(terraform) && terraform.Spec.Destroy == true {`
	`103`	`+ if r.backendCompletelyDisable(terraform) && terraform.Spec.Destroy {`
`104`	`104`	`destroyReply, err := runnerClient.Destroy(ctx, &runner.DestroyRequest{`
`105`	`105`	`TfInstance: tfInstance,`
`106`	`106`	`Targets: terraform.Spec.Targets,`
`@@ -120,7 +120,7 @@ func (r TerraformReconciler) apply(ctx context.Context, patchHelper patch.Seri`
`120`	`120`	`}`
`121`	`121`	`}`
`122`	`122`
`123`		`- if eventSent == false {`
	`123`	`+ if !eventSent {`
`124`	`124`	`msg := fmt.Sprintf("Destroy error: %s", err.Error())`
`125`	`125`	`r.Eventf(terraform, corev1.EventTypeWarning, infrav1.TFExecDestroyFailedReason, msg)`
`126`	`126`	`}`
`@@ -149,7 +149,7 @@ func (r TerraformReconciler) apply(ctx context.Context, patchHelper patch.Seri`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`		`- if eventSent == false {`
	`152`	`+ if !eventSent {`
`153`	`153`	`msg := fmt.Sprintf("Apply error: %s", err.Error())`
`154`	`154`	`r.Eventf(terraform, corev1.EventTypeWarning, infrav1.TFExecApplyFailedReason, msg)`
`155`	`155`	`}`
`@@ -167,7 +167,7 @@ func (r TerraformReconciler) apply(ctx context.Context, patchHelper patch.Seri`
`167`	`167`	`isDestroyApplied = terraform.Status.Plan.IsDestroyPlan`
`168`	`168`
`169`	`169`	`// if apply was successful, we need to update the inventory, but not if we are destroying`
`170`		`- if terraform.Spec.EnableInventory && isDestroyApplied == false {`
	`170`	`+ if terraform.Spec.EnableInventory && !isDestroyApplied {`
`171`	`171`	`getInventoryRequest := &runner.GetInventoryRequest{TfInstance: tfInstance}`
`172`	`172`	`getInventoryReply, err := runnerClient.GetInventory(ctx, getInventoryRequest)`
`173`	`173`	`if err != nil {`
`@@ -189,18 +189,18 @@ func (r TerraformReconciler) apply(ctx context.Context, patchHelper patch.Seri`
`189`	`189`	`})`
`190`	`190`	`}`
`191`	`191`	`log.Info(fmt.Sprintf("got inventory - entries count: %d", len(inventoryEntries)))`
`192`		`- } else if terraform.Spec.EnableInventory == false {`
	`192`	`+ } else if !terraform.Spec.EnableInventory {`
`193`	`193`	`log.Info("inventory is disabled")`
`194`	`194`	`terraform.Status.Inventory = nil`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`var msg string`
`199`	`199`	`if isDestroyApplied {`
`200`		`- msg = fmt.Sprintf("Destroy applied successfully")`
	`200`	`+ msg = "Destroy applied successfully"`
`201`	`201`	`r.Eventf(terraform, corev1.EventTypeNormal, infrav1.TFExecDestroySucceedReason, msg)`
`202`	`202`	`} else {`
`203`		`- msg = fmt.Sprintf("Applied successfully")`
	`203`	`+ msg = "Applied successfully"`
`204`	`204`	`r.Eventf(terraform, corev1.EventTypeNormal, infrav1.TFExecApplySucceedReason, msg)`
`205`	`205`	`}`
`206`	`206`
Original file line number	Diff line number	Diff line change
`@@ -16,12 +16,12 @@ func (r TerraformReconciler) shouldDetectDrift(terraform infrav1.Terraform, re`
`16`	`16`	`// Please do not optimize this logic, as we'd like others to easily understand the logics behind this behaviour.`
`17`	`17`
`18`	`18`	`// return false when drift detection is disabled`
`19`		`- if terraform.Spec.DisableDriftDetection == true {`
	`19`	`+ if terraform.Spec.DisableDriftDetection {`
`20`	`20`	`return false`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`// not support when Destroy == true`
`24`		`- if terraform.Spec.Destroy == true {`
	`24`	`+ if terraform.Spec.Destroy {`
`25`	`25`	`return false`
`26`	`26`	`}`
`27`	`27`
`@@ -99,7 +99,7 @@ func (r TerraformReconciler) detectDrift(ctx context.Context, terraform infrav`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`- if eventSent == false {`
	`102`	`+ if !eventSent {`
`103`	`103`	`msg := fmt.Sprintf("Drift detection error: %s", err.Error())`
`104`	`104`	`r.Eventf(terraform, corev1.EventTypeWarning, infrav1.DriftDetectionFailedReason, msg)`
`105`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ func (r TerraformReconciler) finalize(ctx context.Context, patchHelper patch.S`
`83`	`83`	`return terraform, controllerruntime.Result{Requeue: true}, err`
`84`	`84`	`}`
`85`	`85`
`86`		`- if thereIsNothingToDestroy(terraform) == false {`
	`86`	`+ if !thereIsNothingToDestroy(terraform) {`
`87`	`87`	`traceLog.Info("Apply the destroy plan")`
`88`	`88`	`terraform, err = r.apply(ctx, patchHelper, terraform, tfInstance, runnerClient, revision)`
`89`	`89`	`traceLog.Info("Check for error")`
Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,10 @@ func (r TerraformReconciler) shouldDoHealthChecks(terraform infrav1.Terraform)`
`31`	`31`	`var applyCondition metav1.Condition`
`32`	`32`	`var hcCondition metav1.Condition`
`33`	`33`	`for _, c := range terraform.Status.Conditions {`
`34`		`- if c.Type == infrav1.ConditionTypeApply {`
	`34`	`+ switch c.Type {`
	`35`	`+ case infrav1.ConditionTypeApply:`
`35`	`36`	`applyCondition = c`
`36`		`- } else if c.Type == infrav1.ConditionTypeHealthCheck {`
	`37`	`+ case infrav1.ConditionTypeHealthCheck:`
`37`	`38`	`hcCondition = c`
`38`	`39`	`}`
`39`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,13 +35,13 @@ func (r *TerraformReconciler) outputsMayBeDrifted(ctx context.Context, terraform`
`35`	`35`	`if terraform.Spec.WriteOutputsToSecret != nil {`
`36`	`36`	`outputsSecretKey := types.NamespacedName{Namespace: terraform.Namespace, Name: terraform.Spec.WriteOutputsToSecret.Name}`
`37`	`37`	`var outputsSecret corev1.Secret`
`38`		`- err := r.Client.Get(ctx, outputsSecretKey, &outputsSecret)`
	`38`	`+ err := r.Get(ctx, outputsSecretKey, &outputsSecret)`
`39`	`39`	`if err != nil && apierrors.IsNotFound(err) {`
`40`	`40`	`return true, nil`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`keysInSecret := []string{}`
`44`		`- for k, _ := range outputsSecret.Data {`
	`44`	`+ for k := range outputsSecret.Data {`
`45`	`45`	`keysInSecret = append(keysInSecret, k)`
`46`	`46`	`}`
`47`	`47`	`sort.Strings(keysInSecret)`
`@@ -168,7 +168,7 @@ func (r TerraformReconciler) writeOutput(ctx context.Context, terraform infrav`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`
`171`		`- if len(data) == 0 \|\| terraform.Spec.Destroy == true {`
	`171`	`+ if len(data) == 0 \|\| terraform.Spec.Destroy {`
`172`	`172`	`return infrav1.TerraformOutputsWritten(terraform, revision, "No Outputs written"), nil`
`173`	`173`	`}`
`174`	`174`
`@@ -193,7 +193,7 @@ func (r TerraformReconciler) writeOutput(ctx context.Context, terraform infrav`
`193`	`193`
`194`	`194`	`if writeOutputsReply.Changed {`
`195`	`195`	`keysWritten := []string{}`
`196`		`- for k, _ := range data {`
	`196`	`+ for k := range data {`
`197`	`197`	`keysWritten = append(keysWritten, k)`
`198`	`198`	`}`
`199`	`199`	`msg := fmt.Sprintf("Outputs written.\n%d output(s): %s", len(keysWritten), strings.Join(keysWritten, ", "))`
Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ func (r TerraformReconciler) reconcile(ctx context.Context, patchHelper patch.`
`141`	`141`	`// immediately return if no drift - reconciliation will retry normally`
`142`	`142`	`if driftDetectionErr == nil {`
`143`	`143`	`// reconcile outputs only when outputs are missing`
`144`		`- if outputsDrifted, err := r.outputsMayBeDrifted(ctx, terraform); outputsDrifted == true && err == nil {`
	`144`	`+ if outputsDrifted, err := r.outputsMayBeDrifted(ctx, terraform); outputsDrifted && err == nil {`
`145`	`145`	`terraform, err = r.processOutputs(ctx, patchHelper, runnerClient, terraform, tfInstance, revision)`
`146`	`146`	`if err != nil {`
`147`	`147`	`log.Error(err, "error processing outputs")`
`@@ -287,7 +287,7 @@ func (r TerraformReconciler) reconcile(ctx context.Context, patchHelper patch.`
`287`	`287`	`Entries: inventoryEntries,`
`288`	`288`	`}`
`289`	`289`	`}`
`290`		`- } else if terraform.Spec.EnableInventory == false {`
	`290`	`+ } else if !terraform.Spec.EnableInventory {`
`291`	`291`	`log.Info("inventory is disabled")`
`292`	`292`	`terraform.Status.Inventory = nil`
`293`	`293`	`}`