Elastic Agent: Set status.ObservedGeneration from metadata.Generation

pkg/controller/agent/controller.go

@@ -144,14 +144,13 @@ func (r *ReconcileAgent) Reconcile(ctx context.Context, request reconcile.Reques
 		return reconcile.Result{}, nil
 	}
 
-	results, status := r.doReconcile(ctx, *agent)
+	status, results := r.doReconcile(ctx, *agent)
 
-	statusErr := updateStatus(*agent, r.Client, status)
-	if statusErr != nil {
-		if apierrors.IsConflict(statusErr) {
+	if err := updateStatus(*agent, r.Client, status); err != nil {
+		if apierrors.IsConflict(err) {
 			return results.WithResult(reconcile.Result{Requeue: true}).Aggregate()
 		}
-		results = results.WithError(statusErr)
+		results = results.WithError(err)
 	}
 
 	result, err := results.Aggregate()
@@ -160,36 +159,33 @@ func (r *ReconcileAgent) Reconcile(ctx context.Context, request reconcile.Reques
 	return result, err
 }
 
-func (r *ReconcileAgent) doReconcile(ctx context.Context, agent agentv1alpha1.Agent) (*reconciler.Results, agentv1alpha1.AgentStatus) {
+func (r *ReconcileAgent) doReconcile(ctx context.Context, agent agentv1alpha1.Agent) (agentv1alpha1.AgentStatus, *reconciler.Results) {
 	defer tracing.Span(&ctx)()
 	results := reconciler.NewResult(ctx)
 	status := newStatus(agent)
 
 	areAssocsConfigured, err := association.AreConfiguredIfSet(agent.GetAssociations(), r.recorder)
 	if err != nil {
-		return results.WithError(err), status
+		return status, results.WithError(err)
 	}
 	if !areAssocsConfigured {
-		return results, status
+		return status, results
 	}
 
 	// Run basic validations as a fallback in case webhook is disabled.
 	if err := r.validate(ctx, agent); err != nil {
 		results = results.WithError(err)
-		return results, status
+		return status, results
 	}
 
-	driverResults := internalReconcile(Params{
+	return internalReconcile(Params{
 		Context:        ctx,
 		Client:         r.Client,
 		EventRecorder:  r.recorder,
 		Watches:        r.dynamicWatches,
 		Agent:          agent,
 		OperatorParams: r.Parameters,
-	}, &status)
-
-	results = results.WithResults(driverResults)
-	return results, status
+	}, status)
 }
 
 func (r *ReconcileAgent) validate(ctx context.Context, agent agentv1alpha1.Agent) error {

pkg/controller/agent/driver.go

@@ -83,25 +83,25 @@ func newStatus(agent agentv1alpha1.Agent) agentv1alpha1.AgentStatus {
 	return status
 }
 
-func internalReconcile(params Params, status *agentv1alpha1.AgentStatus) *reconciler.Results {
+func internalReconcile(params Params, status agentv1alpha1.AgentStatus) (agentv1alpha1.AgentStatus, *reconciler.Results) {
 	defer tracing.Span(&params.Context)()
 	results := reconciler.NewResult(params.Context)
 
 	agentVersion, err := version.Parse(params.Agent.Spec.Version)
 	if err != nil {
-		return results.WithError(err)
+		return status, results.WithError(err)
 	}
 	assocAllowed, err := association.AllowVersion(agentVersion, &params.Agent, params.Logger(), params.EventRecorder)
 	if err != nil {
-		return results.WithError(err)
+		return status, results.WithError(err)
 	}
 	if !assocAllowed {
-		return results // will eventually retry
+		return status, results // will eventually retry
 	}
 
 	svc, err := reconcileService(params)
 	if err != nil {
-		return results.WithError(err)
+		return status, results.WithError(err)
 	}
 
 	configHash := fnv.New32a()
@@ -122,24 +122,24 @@ func internalReconcile(params Params, status *agentv1alpha1.AgentStatus) *reconc
 			ExtraHTTPSANs:         []commonv1.SubjectAlternativeName{{DNS: fmt.Sprintf("*.%s.%s.svc", HTTPServiceName(params.Agent.Name), params.Agent.Namespace)}},
 		}.ReconcileCAAndHTTPCerts(params.Context)
 		if caResults.HasError() {
-			return results.WithResults(caResults)
+			return status, results.WithResults(caResults)
 		}
 		_, _ = configHash.Write(fleetCerts.Data[certificates.CertFileName])
 	}
 	if res := reconcileConfig(params, configHash); res.HasError() {
-		return results.WithResults(res)
+		return status, results.WithResults(res)
 	}
 
 	// we need to deref the secret here (if any) to include it in the configHash otherwise Agent will not be rolled on content changes
 	if err := commonassociation.WriteAssocsToConfigHash(params.Client, params.Agent.GetAssociations(), configHash); err != nil {
-		return results.WithError(err)
+		return status, results.WithError(err)
 	}
 
 	podTemplate, err := buildPodTemplate(params, fleetCerts, configHash)
 	if err != nil {
-		return results.WithError(err)
+		return status, results.WithError(err)
 	}
-	return results.WithResults(reconcilePodVehicle(params, podTemplate, status))
+	return reconcilePodVehicle(params, podTemplate, status)
 }
 
 func reconcileService(params Params) (*corev1.Service, error) {

pkg/controller/agent/reconcile.go

@@ -17,6 +17,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 
+	"github.com/pkg/errors"
+
 	agentv1alpha1 "github.com/elastic/cloud-on-k8s/pkg/apis/agent/v1alpha1"
 	"github.com/elastic/cloud-on-k8s/pkg/controller/common"
 	"github.com/elastic/cloud-on-k8s/pkg/controller/common/daemonset"
@@ -27,7 +29,7 @@ import (
 	"github.com/elastic/cloud-on-k8s/pkg/utils/pointer"
 )
 
-func reconcilePodVehicle(params Params, podTemplate corev1.PodTemplateSpec, status *agentv1alpha1.AgentStatus) *reconciler.Results {
+func reconcilePodVehicle(params Params, podTemplate corev1.PodTemplateSpec, status agentv1alpha1.AgentStatus) (agentv1alpha1.AgentStatus, *reconciler.Results) {
 	defer tracing.Span(&params.Context)()
 	results := reconciler.NewResult(params.Context)
 
@@ -62,7 +64,7 @@ func reconcilePodVehicle(params Params, podTemplate corev1.PodTemplateSpec, stat
 	})
 
 	if err != nil {
-		return results.WithError(err)
+		return status, results.WithError(err)
 	}
 
 	// clean up the other one
@@ -75,16 +77,11 @@ func reconcilePodVehicle(params Params, podTemplate corev1.PodTemplateSpec, stat
 		results.WithError(err)
 	}
 
-	err = calculateStatus(&params, ready, desired, status)
-	if err != nil {
-		params.Logger().Error(
-			err, "Error while calculating new status",
-			"namespace", params.Agent.Namespace,
-			"agent_name", params.Agent.Name,
-		)
+	if err = calculateStatus(&params, ready, desired, &status); err != nil {
+		err = errors.Wrap(err, "while calculating status")
 	}
 
-	return results.WithError(err)
+	return status, results.WithError(err)
 }
 
 func reconcileDeployment(rp ReconciliationParams) (int32, int32, error) {