Update managed reconciler to store observedGeneration on conditions and also update that controllers unit tests

n3wscott · n3wscott · commit 69e6d0bc6ee8 · 2025-05-01T16:12:09.000-07:00
diff --git a/apis/common/v1/condition.go b/apis/common/v1/condition.go
@@ -101,7 +101,8 @@ func (c Condition) Equal(other Condition) bool {
 	return c.Type == other.Type &&
 		c.Status == other.Status &&
 		c.Reason == other.Reason &&
-		c.Message == other.Message
+		c.Message == other.Message &&
+		c.ObservedGeneration == other.ObservedGeneration
 }
 
 // WithMessage returns a condition by adding the provided message to existing
@@ -169,26 +170,23 @@ func (s *ConditionedStatus) GetCondition(ct ConditionType) Condition {
 // ignoring the last transition time, to those already set.
 // Observed generation is updated if higher than the existing one.
 func (s *ConditionedStatus) SetConditions(c ...Condition) {
-	for _, new := range c {
+	for _, cond := range c {
 		exists := false
 		for i, existing := range s.Conditions {
-			if existing.Type != new.Type {
+			if existing.Type != cond.Type {
 				continue
 			}
 
-			if existing.Equal(new) {
+			if existing.Equal(cond) {
 				exists = true
-				if existing.ObservedGeneration < new.ObservedGeneration {
-					existing.ObservedGeneration = new.ObservedGeneration
-				}
 				continue
 			}
 
-			s.Conditions[i] = new
+			s.Conditions[i] = cond
 			exists = true
 		}
 		if !exists {
-			s.Conditions = append(s.Conditions, new)
+			s.Conditions = append(s.Conditions, cond)
 		}
 	}
 }
diff --git a/apis/common/v1/condition_test.go b/apis/common/v1/condition_test.go
@@ -32,6 +32,25 @@ func TestConditionEqual(t *testing.T) {
 		b    Condition
 		want bool
 	}{
+		"Identical": {
+			a: Condition{
+				Type:               TypeReady,
+				Status:             corev1.ConditionTrue,
+				LastTransitionTime: metav1.Now(),
+				Reason:             ReasonCreating,
+				Message:            "UnitTest",
+				ObservedGeneration: 1,
+			},
+			b: Condition{
+				Type:               TypeReady,
+				Status:             corev1.ConditionTrue,
+				LastTransitionTime: metav1.Now(),
+				Reason:             ReasonCreating,
+				Message:            "UnitTest",
+				ObservedGeneration: 1,
+			},
+			want: true,
+		},
 		"IdenticalIgnoringTimestamp": {
 			a:    Condition{Type: TypeReady, LastTransitionTime: metav1.Now()},
 			b:    Condition{Type: TypeReady, LastTransitionTime: metav1.Now()},
@@ -57,6 +76,11 @@ func TestConditionEqual(t *testing.T) {
 			b:    Condition{Message: "uncool"},
 			want: false,
 		},
+		"DifferentObservedGeneration": {
+			a:    Condition{ObservedGeneration: 1},
+			b:    Condition{},
+			want: false,
+		},
 		"CheckReconcilePaused": {
 			a: ReconcilePaused(),
 			b: Condition{
@@ -139,6 +163,11 @@ func TestSetConditions(t *testing.T) {
 			c:    []Condition{Available()},
 			want: NewConditionedStatus(Available()),
 		},
+		"ObservedGenerationIsUpdated": {
+			cs:   NewConditionedStatus(Available().WithObservedGeneration(1)),
+			c:    []Condition{Available().WithObservedGeneration(2)},
+			want: NewConditionedStatus(Available().WithObservedGeneration(2)),
+		},
 		"TypeIsDifferent": {
 			cs:   NewConditionedStatus(Creating()),
 			c:    []Condition{Available()},
diff --git a/pkg/reconciler/managed/reconciler.go b/pkg/reconciler/managed/reconciler.go
@@ -180,7 +180,7 @@ type ConnectionDetailsFetcher interface {
 	FetchConnection(ctx context.Context, so resource.ConnectionSecretOwner) (ConnectionDetails, error)
 }
 
-// A Initializer establishes ownership of the supplied Managed resource.
+// Initializer establishes ownership of the supplied Managed resource.
 // This typically involves the operations that are run before calling any
 // ExternalClient methods.
 type Initializer interface {
@@ -880,7 +880,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 		log.Debug("Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation", "annotation", meta.AnnotationKeyReconciliationPaused)
 		record.Event(managed, event.Normal(reasonReconciliationPaused, "Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation",
 			"annotation", meta.AnnotationKeyReconciliationPaused))
-		managed.SetConditions(xpv1.ReconcilePaused())
+		managed.SetConditions(xpv1.ReconcilePaused().WithObservedGeneration(managed.GetGeneration()))
 		// if the pause annotation is removed or the management policies changed, we will have a chance to reconcile
 		// again and resume and if status update fails, we will reconcile again to retry to update the status
 		return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
@@ -900,7 +900,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			return reconcile.Result{Requeue: true}, nil
 		}
 		record.Event(managed, event.Warning(reasonManagementPolicyInvalid, err))
-		managed.SetConditions(xpv1.ReconcileError(err))
+		managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -925,7 +925,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 				return reconcile.Result{Requeue: true}, nil
 			}
 			record.Event(managed, event.Warning(reasonCannotUnpublish, err))
-			managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
+			managed.SetConditions(
+				xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
+				xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 		if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {
@@ -937,7 +939,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			if kerrors.IsConflict(err) {
 				return reconcile.Result{Requeue: true}, nil
 			}
-			managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
+			managed.SetConditions(
+				xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
+				xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -959,7 +963,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			return reconcile.Result{Requeue: true}, nil
 		}
 		record.Event(managed, event.Warning(reasonCannotInitialize, err))
-		managed.SetConditions(xpv1.ReconcileError(err))
+		managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -970,7 +974,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 	if meta.ExternalCreateIncomplete(managed) {
 		log.Debug(errCreateIncomplete)
 		record.Event(managed, event.Warning(reasonCannotInitialize, errors.New(errCreateIncomplete)))
-		managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.New(errCreateIncomplete)))
+		managed.SetConditions(
+			xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
+			xpv1.ReconcileError(errors.New(errCreateIncomplete)).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: false}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -995,7 +1001,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 				return reconcile.Result{Requeue: true}, nil
 			}
 			record.Event(managed, event.Warning(reasonCannotResolveRefs, err))
-			managed.SetConditions(xpv1.ReconcileError(err))
+			managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 	}
@@ -1012,7 +1018,8 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			return reconcile.Result{Requeue: true}, nil
 		}
 		record.Event(managed, event.Warning(reasonCannotConnect, err))
-		managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)))
+		managed.SetConditions(
+			xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 	defer func() {
@@ -1040,15 +1047,17 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			return reconcile.Result{Requeue: true}, nil
 		}
 		record.Event(managed, event.Warning(reasonCannotObserve, err))
-		managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)))
+		managed.SetConditions(
+			xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
 	// In the observe-only mode, !observation.ResourceExists will be an error
 	// case, and we will explicitly return this information to the user.
 	if !observation.ResourceExists && policy.ShouldOnlyObserve() {
 		record.Event(managed, event.Warning(reasonCannotObserve, errors.New(errExternalResourceNotExist)))
-		managed.SetConditions(xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)))
+		managed.SetConditions(
+			xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1086,7 +1095,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 					log.Info(errRecordChangeLog, "error", err)
 				}
 				record.Event(managed, event.Warning(reasonCannotDelete, err))
-				managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)))
+				managed.SetConditions(
+					xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
+					xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)).WithObservedGeneration(managed.GetGeneration()))
 				return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 			}
 
@@ -1102,7 +1113,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 				log.Info(errRecordChangeLog, "error", err)
 			}
 			record.Event(managed, event.Normal(reasonDeleted, "Successfully requested deletion of external resource"))
-			managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileSuccess())
+			managed.SetConditions(
+				xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
+				xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 		if err := r.managed.UnpublishConnection(ctx, managed, observation.ConnectionDetails); err != nil {
@@ -1115,7 +1128,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 				return reconcile.Result{Requeue: true}, nil
 			}
 			record.Event(managed, event.Warning(reasonCannotUnpublish, err))
-			managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
+			managed.SetConditions(
+				xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
+				xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 		if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {
@@ -1127,7 +1142,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			if kerrors.IsConflict(err) {
 				return reconcile.Result{Requeue: true}, nil
 			}
-			managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
+			managed.SetConditions(
+				xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
+				xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1149,7 +1166,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			return reconcile.Result{Requeue: true}, nil
 		}
 		record.Event(managed, event.Warning(reasonCannotPublish, err))
-		managed.SetConditions(xpv1.ReconcileError(err))
+		managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1161,7 +1178,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 		if kerrors.IsConflict(err) {
 			return reconcile.Result{Requeue: true}, nil
 		}
-		managed.SetConditions(xpv1.ReconcileError(err))
+		managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1180,7 +1197,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 				return reconcile.Result{Requeue: true}, nil
 			}
 			record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManaged)))
-			managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
+			managed.SetConditions(
+				xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
+				xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1217,7 +1236,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			if err := r.change.Log(ctx, managedPreOp, v1alpha1.OperationType_OPERATION_TYPE_CREATE, err, creation.AdditionalDetails); err != nil {
 				log.Info(errRecordChangeLog, "error", err)
 			}
-			managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)))
+			managed.SetConditions(
+				xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
+				xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1246,7 +1267,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 				return reconcile.Result{Requeue: true}, nil
 			}
 			record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManagedAnnotations)))
-			managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)))
+			managed.SetConditions(
+				xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
+				xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1259,7 +1282,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 				return reconcile.Result{Requeue: true}, nil
 			}
 			record.Event(managed, event.Warning(reasonCannotPublish, err))
-			managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(err))
+			managed.SetConditions(
+				xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
+				xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1269,7 +1294,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 		// ready for use.
 		log.Debug("Successfully requested creation of external resource")
 		record.Event(managed, event.Normal(reasonCreated, "Successfully requested creation of external resource"))
-		managed.SetConditions(xpv1.Creating(), xpv1.ReconcileSuccess())
+		managed.SetConditions(
+			xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
+			xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1284,7 +1311,8 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 		if err := r.client.Update(ctx, managed); err != nil {
 			log.Debug(errUpdateManaged, "error", err)
 			record.Event(managed, event.Warning(reasonCannotUpdateManaged, err))
-			managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
+			managed.SetConditions(
+				xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)).WithObservedGeneration(managed.GetGeneration()))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 	}
@@ -1298,7 +1326,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 		// https://github.com/crossplane/crossplane/issues/289
 		reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)
 		log.Debug("External resource is up to date", "requeue-after", time.Now().Add(reconcileAfter))
-		managed.SetConditions(xpv1.ReconcileSuccess())
+		managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
 		r.metricRecorder.recordFirstTimeReady(managed)
 
 		// record that we intentionally did not update the managed resource
@@ -1318,7 +1346,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 	if !policy.ShouldUpdate() {
 		reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)
 		log.Debug("Skipping update due to managementPolicies. Reconciliation succeeded", "requeue-after", time.Now().Add(reconcileAfter))
-		managed.SetConditions(xpv1.ReconcileSuccess())
+		managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1334,7 +1362,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			log.Info(errRecordChangeLog, "error", err)
 		}
 		record.Event(managed, event.Warning(reasonCannotUpdate, err))
-		managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)))
+		managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1350,7 +1378,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 		// not, we requeue explicitly, which will trigger backoff.
 		log.Debug("Cannot publish connection details", "error", err)
 		record.Event(managed, event.Warning(reasonCannotPublish, err))
-		managed.SetConditions(xpv1.ReconcileError(err))
+		managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1362,6 +1390,6 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 	reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)
 	log.Debug("Successfully requested update of external resource", "requeue-after", time.Now().Add(reconcileAfter))
 	record.Event(managed, event.Normal(reasonUpdated, "Successfully requested update of external resource"))
-	managed.SetConditions(xpv1.ReconcileSuccess())
+	managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
 	return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 }
diff --git a/pkg/reconciler/managed/reconciler_test.go b/pkg/reconciler/managed/reconciler_test.go

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,8 @@ func (c Condition) Equal(other Condition) bool {`
`101`	`101`	`return c.Type == other.Type &&`
`102`	`102`	`c.Status == other.Status &&`
`103`	`103`	`c.Reason == other.Reason &&`
`104`		`- c.Message == other.Message`
	`104`	`+ c.Message == other.Message &&`
	`105`	`+ c.ObservedGeneration == other.ObservedGeneration`
`105`	`106`	`}`
`106`	`107`
`107`	`108`	`// WithMessage returns a condition by adding the provided message to existing`
`@@ -169,26 +170,23 @@ func (s *ConditionedStatus) GetCondition(ct ConditionType) Condition {`
`169`	`170`	`// ignoring the last transition time, to those already set.`
`170`	`171`	`// Observed generation is updated if higher than the existing one.`
`171`	`172`	`func (s *ConditionedStatus) SetConditions(c ...Condition) {`
`172`		`- for _, new := range c {`
	`173`	`+ for _, cond := range c {`
`173`	`174`	`exists := false`
`174`	`175`	`for i, existing := range s.Conditions {`
`175`		`- if existing.Type != new.Type {`
	`176`	`+ if existing.Type != cond.Type {`
`176`	`177`	`continue`
`177`	`178`	`}`
`178`	`179`
`179`		`- if existing.Equal(new) {`
	`180`	`+ if existing.Equal(cond) {`
`180`	`181`	`exists = true`
`181`		`- if existing.ObservedGeneration < new.ObservedGeneration {`
`182`		`- existing.ObservedGeneration = new.ObservedGeneration`
`183`		`- }`
`184`	`182`	`continue`
`185`	`183`	`}`
`186`	`184`
`187`		`- s.Conditions[i] = new`
	`185`	`+ s.Conditions[i] = cond`
`188`	`186`	`exists = true`
`189`	`187`	`}`
`190`	`188`	`if !exists {`
`191`		`- s.Conditions = append(s.Conditions, new)`
	`189`	`+ s.Conditions = append(s.Conditions, cond)`
`192`	`190`	`}`
`193`	`191`	`}`
`194`	`192`	`}`
Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ type ConnectionDetailsFetcher interface {`
`180`	`180`	`FetchConnection(ctx context.Context, so resource.ConnectionSecretOwner) (ConnectionDetails, error)`
`181`	`181`	`}`
`182`	`182`
`183`		`-// A Initializer establishes ownership of the supplied Managed resource.`
	`183`	`+// Initializer establishes ownership of the supplied Managed resource.`
`184`	`184`	`// This typically involves the operations that are run before calling any`
`185`	`185`	`// ExternalClient methods.`
`186`	`186`	`type Initializer interface {`
`@@ -880,7 +880,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`880`	`880`	log.Debug("Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation", "annotation", meta.AnnotationKeyReconciliationPaused)
`881`	`881`	record.Event(managed, event.Normal(reasonReconciliationPaused, "Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation",
`882`	`882`	`"annotation", meta.AnnotationKeyReconciliationPaused))`
`883`		`- managed.SetConditions(xpv1.ReconcilePaused())`
	`883`	`+ managed.SetConditions(xpv1.ReconcilePaused().WithObservedGeneration(managed.GetGeneration()))`
`884`	`884`	`// if the pause annotation is removed or the management policies changed, we will have a chance to reconcile`
`885`	`885`	`// again and resume and if status update fails, we will reconcile again to retry to update the status`
`886`	`886`	`return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`@@ -900,7 +900,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`900`	`900`	`return reconcile.Result{Requeue: true}, nil`
`901`	`901`	`}`
`902`	`902`	`record.Event(managed, event.Warning(reasonManagementPolicyInvalid, err))`
`903`		`- managed.SetConditions(xpv1.ReconcileError(err))`
	`903`	`+ managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`904`	`904`	`return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`905`	`905`	`}`
`906`	`906`
`@@ -925,7 +925,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`925`	`925`	`return reconcile.Result{Requeue: true}, nil`
`926`	`926`	`}`
`927`	`927`	`record.Event(managed, event.Warning(reasonCannotUnpublish, err))`
`928`		`- managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))`
	`928`	`+ managed.SetConditions(`
	`929`	`+ xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),`
	`930`	`+ xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`929`	`931`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`930`	`932`	`}`
`931`	`933`	`if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {`
`@@ -937,7 +939,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`937`	`939`	`if kerrors.IsConflict(err) {`
`938`	`940`	`return reconcile.Result{Requeue: true}, nil`
`939`	`941`	`}`
`940`		`- managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))`
	`942`	`+ managed.SetConditions(`
	`943`	`+ xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),`
	`944`	`+ xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`941`	`945`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`942`	`946`	`}`
`943`	`947`
`@@ -959,7 +963,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`959`	`963`	`return reconcile.Result{Requeue: true}, nil`
`960`	`964`	`}`
`961`	`965`	`record.Event(managed, event.Warning(reasonCannotInitialize, err))`
`962`		`- managed.SetConditions(xpv1.ReconcileError(err))`
	`966`	`+ managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`963`	`967`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`964`	`968`	`}`
`965`	`969`
`@@ -970,7 +974,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`970`	`974`	`if meta.ExternalCreateIncomplete(managed) {`
`971`	`975`	`log.Debug(errCreateIncomplete)`
`972`	`976`	`record.Event(managed, event.Warning(reasonCannotInitialize, errors.New(errCreateIncomplete)))`
`973`		`- managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.New(errCreateIncomplete)))`
	`977`	`+ managed.SetConditions(`
	`978`	`+ xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),`
	`979`	`+ xpv1.ReconcileError(errors.New(errCreateIncomplete)).WithObservedGeneration(managed.GetGeneration()))`
`974`	`980`	`return reconcile.Result{Requeue: false}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`975`	`981`	`}`
`976`	`982`
`@@ -995,7 +1001,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`995`	`1001`	`return reconcile.Result{Requeue: true}, nil`
`996`	`1002`	`}`
`997`	`1003`	`record.Event(managed, event.Warning(reasonCannotResolveRefs, err))`
`998`		`- managed.SetConditions(xpv1.ReconcileError(err))`
	`1004`	`+ managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`999`	`1005`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1000`	`1006`	`}`
`1001`	`1007`	`}`
`@@ -1012,7 +1018,8 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1012`	`1018`	`return reconcile.Result{Requeue: true}, nil`
`1013`	`1019`	`}`
`1014`	`1020`	`record.Event(managed, event.Warning(reasonCannotConnect, err))`
`1015`		`- managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)))`
	`1021`	`+ managed.SetConditions(`
	`1022`	`+ xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)).WithObservedGeneration(managed.GetGeneration()))`
`1016`	`1023`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1017`	`1024`	`}`
`1018`	`1025`	`defer func() {`
`@@ -1040,15 +1047,17 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1040`	`1047`	`return reconcile.Result{Requeue: true}, nil`
`1041`	`1048`	`}`
`1042`	`1049`	`record.Event(managed, event.Warning(reasonCannotObserve, err))`
`1043`		`- managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)))`
	`1050`	`+ managed.SetConditions(`
	`1051`	`+ xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)).WithObservedGeneration(managed.GetGeneration()))`
`1044`	`1052`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1045`	`1053`	`}`
`1046`	`1054`
`1047`	`1055`	`// In the observe-only mode, !observation.ResourceExists will be an error`
`1048`	`1056`	`// case, and we will explicitly return this information to the user.`
`1049`	`1057`	`if !observation.ResourceExists && policy.ShouldOnlyObserve() {`
`1050`	`1058`	`record.Event(managed, event.Warning(reasonCannotObserve, errors.New(errExternalResourceNotExist)))`
`1051`		`- managed.SetConditions(xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)))`
	`1059`	`+ managed.SetConditions(`
	`1060`	`+ xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)).WithObservedGeneration(managed.GetGeneration()))`
`1052`	`1061`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1053`	`1062`	`}`
`1054`	`1063`
`@@ -1086,7 +1095,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1086`	`1095`	`log.Info(errRecordChangeLog, "error", err)`
`1087`	`1096`	`}`
`1088`	`1097`	`record.Event(managed, event.Warning(reasonCannotDelete, err))`
`1089`		`- managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)))`
	`1098`	`+ managed.SetConditions(`
	`1099`	`+ xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),`
	`1100`	`+ xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)).WithObservedGeneration(managed.GetGeneration()))`
`1090`	`1101`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1091`	`1102`	`}`
`1092`	`1103`
`@@ -1102,7 +1113,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1102`	`1113`	`log.Info(errRecordChangeLog, "error", err)`
`1103`	`1114`	`}`
`1104`	`1115`	`record.Event(managed, event.Normal(reasonDeleted, "Successfully requested deletion of external resource"))`
`1105`		`- managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileSuccess())`
	`1116`	`+ managed.SetConditions(`
	`1117`	`+ xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),`
	`1118`	`+ xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))`
`1106`	`1119`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1107`	`1120`	`}`
`1108`	`1121`	`if err := r.managed.UnpublishConnection(ctx, managed, observation.ConnectionDetails); err != nil {`
`@@ -1115,7 +1128,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1115`	`1128`	`return reconcile.Result{Requeue: true}, nil`
`1116`	`1129`	`}`
`1117`	`1130`	`record.Event(managed, event.Warning(reasonCannotUnpublish, err))`
`1118`		`- managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))`
	`1131`	`+ managed.SetConditions(`
	`1132`	`+ xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),`
	`1133`	`+ xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`1119`	`1134`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1120`	`1135`	`}`
`1121`	`1136`	`if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {`
`@@ -1127,7 +1142,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1127`	`1142`	`if kerrors.IsConflict(err) {`
`1128`	`1143`	`return reconcile.Result{Requeue: true}, nil`
`1129`	`1144`	`}`
`1130`		`- managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))`
	`1145`	`+ managed.SetConditions(`
	`1146`	`+ xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),`
	`1147`	`+ xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`1131`	`1148`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1132`	`1149`	`}`
`1133`	`1150`
`@@ -1149,7 +1166,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1149`	`1166`	`return reconcile.Result{Requeue: true}, nil`
`1150`	`1167`	`}`
`1151`	`1168`	`record.Event(managed, event.Warning(reasonCannotPublish, err))`
`1152`		`- managed.SetConditions(xpv1.ReconcileError(err))`
	`1169`	`+ managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`1153`	`1170`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1154`	`1171`	`}`
`1155`	`1172`
`@@ -1161,7 +1178,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1161`	`1178`	`if kerrors.IsConflict(err) {`
`1162`	`1179`	`return reconcile.Result{Requeue: true}, nil`
`1163`	`1180`	`}`
`1164`		`- managed.SetConditions(xpv1.ReconcileError(err))`
	`1181`	`+ managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`1165`	`1182`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1166`	`1183`	`}`
`1167`	`1184`
`@@ -1180,7 +1197,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1180`	`1197`	`return reconcile.Result{Requeue: true}, nil`
`1181`	`1198`	`}`
`1182`	`1199`	`record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManaged)))`
`1183`		`- managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))`
	`1200`	`+ managed.SetConditions(`
	`1201`	`+ xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),`
	`1202`	`+ xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)).WithObservedGeneration(managed.GetGeneration()))`
`1184`	`1203`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1185`	`1204`	`}`
`1186`	`1205`
`@@ -1217,7 +1236,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1217`	`1236`	`if err := r.change.Log(ctx, managedPreOp, v1alpha1.OperationType_OPERATION_TYPE_CREATE, err, creation.AdditionalDetails); err != nil {`
`1218`	`1237`	`log.Info(errRecordChangeLog, "error", err)`
`1219`	`1238`	`}`
`1220`		`- managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)))`
	`1239`	`+ managed.SetConditions(`
	`1240`	`+ xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),`
	`1241`	`+ xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)).WithObservedGeneration(managed.GetGeneration()))`
`1221`	`1242`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1222`	`1243`	`}`
`1223`	`1244`
`@@ -1246,7 +1267,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1246`	`1267`	`return reconcile.Result{Requeue: true}, nil`
`1247`	`1268`	`}`
`1248`	`1269`	`record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManagedAnnotations)))`
`1249`		`- managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)))`
	`1270`	`+ managed.SetConditions(`
	`1271`	`+ xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),`
	`1272`	`+ xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)).WithObservedGeneration(managed.GetGeneration()))`
`1250`	`1273`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1251`	`1274`	`}`
`1252`	`1275`
`@@ -1259,7 +1282,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1259`	`1282`	`return reconcile.Result{Requeue: true}, nil`
`1260`	`1283`	`}`
`1261`	`1284`	`record.Event(managed, event.Warning(reasonCannotPublish, err))`
`1262`		`- managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(err))`
	`1285`	`+ managed.SetConditions(`
	`1286`	`+ xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),`
	`1287`	`+ xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`1263`	`1288`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1264`	`1289`	`}`
`1265`	`1290`
`@@ -1269,7 +1294,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1269`	`1294`	`// ready for use.`
`1270`	`1295`	`log.Debug("Successfully requested creation of external resource")`
`1271`	`1296`	`record.Event(managed, event.Normal(reasonCreated, "Successfully requested creation of external resource"))`
`1272`		`- managed.SetConditions(xpv1.Creating(), xpv1.ReconcileSuccess())`
	`1297`	`+ managed.SetConditions(`
	`1298`	`+ xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),`
	`1299`	`+ xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))`
`1273`	`1300`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1274`	`1301`	`}`
`1275`	`1302`
`@@ -1284,7 +1311,8 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1284`	`1311`	`if err := r.client.Update(ctx, managed); err != nil {`
`1285`	`1312`	`log.Debug(errUpdateManaged, "error", err)`
`1286`	`1313`	`record.Event(managed, event.Warning(reasonCannotUpdateManaged, err))`
`1287`		`- managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))`
	`1314`	`+ managed.SetConditions(`
	`1315`	`+ xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)).WithObservedGeneration(managed.GetGeneration()))`
`1288`	`1316`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1289`	`1317`	`}`
`1290`	`1318`	`}`
`@@ -1298,7 +1326,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1298`	`1326`	`// https://github.com/crossplane/crossplane/issues/289`
`1299`	`1327`	`reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)`
`1300`	`1328`	`log.Debug("External resource is up to date", "requeue-after", time.Now().Add(reconcileAfter))`
`1301`		`- managed.SetConditions(xpv1.ReconcileSuccess())`
	`1329`	`+ managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))`
`1302`	`1330`	`r.metricRecorder.recordFirstTimeReady(managed)`
`1303`	`1331`
`1304`	`1332`	`// record that we intentionally did not update the managed resource`
`@@ -1318,7 +1346,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1318`	`1346`	`if !policy.ShouldUpdate() {`
`1319`	`1347`	`reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)`
`1320`	`1348`	`log.Debug("Skipping update due to managementPolicies. Reconciliation succeeded", "requeue-after", time.Now().Add(reconcileAfter))`
`1321`		`- managed.SetConditions(xpv1.ReconcileSuccess())`
	`1349`	`+ managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))`
`1322`	`1350`	`return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1323`	`1351`	`}`
`1324`	`1352`
`@@ -1334,7 +1362,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1334`	`1362`	`log.Info(errRecordChangeLog, "error", err)`
`1335`	`1363`	`}`
`1336`	`1364`	`record.Event(managed, event.Warning(reasonCannotUpdate, err))`
`1337`		`- managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)))`
	`1365`	`+ managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)).WithObservedGeneration(managed.GetGeneration()))`
`1338`	`1366`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1339`	`1367`	`}`
`1340`	`1368`
`@@ -1350,7 +1378,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1350`	`1378`	`// not, we requeue explicitly, which will trigger backoff.`
`1351`	`1379`	`log.Debug("Cannot publish connection details", "error", err)`
`1352`	`1380`	`record.Event(managed, event.Warning(reasonCannotPublish, err))`
`1353`		`- managed.SetConditions(xpv1.ReconcileError(err))`
	`1381`	`+ managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))`
`1354`	`1382`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1355`	`1383`	`}`
`1356`	`1384`
`@@ -1362,6 +1390,6 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1362`	`1390`	`reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)`
`1363`	`1391`	`log.Debug("Successfully requested update of external resource", "requeue-after", time.Now().Add(reconcileAfter))`
`1364`	`1392`	`record.Event(managed, event.Normal(reasonUpdated, "Successfully requested update of external resource"))`
`1365`		`- managed.SetConditions(xpv1.ReconcileSuccess())`
	`1393`	`+ managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))`
`1366`	`1394`	`return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1367`	`1395`	`}`