rebase

n3wscott · n3wscott · commit 680888f52821 · 2025-05-05T15:51:47.000-07:00
Signed-off-by: Scott Nichols &lt;n3wscott@upbound.io&gt;
diff --git a/pkg/reconciler/managed/reconciler.go b/pkg/reconciler/managed/reconciler.go
@@ -824,7 +824,7 @@ func NewReconciler(m manager.Manager, of resource.ManagedKind, o ...ReconcilerOp
 		record:                      event.NewNopRecorder(),
 		metricRecorder:              NewNopMetricRecorder(),
 		change:                      newNopChangeLogger(),
-		conditions:                  conditions.New(),
+		conditions:                  new(conditions.ObservedGenerationPropagationManager),
 	}
 
 	for _, ro := range o {
@@ -885,7 +885,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))
-		status.Mark(xpv1.ReconcilePaused())
+		status.MarkConditions(xpv1.ReconcilePaused())
 		// 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)
@@ -905,7 +905,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))
-		status.Mark(xpv1.ReconcileError(err))
+		status.MarkConditions(xpv1.ReconcileError(err))
 		return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -930,7 +930,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 				return reconcile.Result{Requeue: true}, nil
 			}
 			record.Event(managed, event.Warning(reasonCannotUnpublish, err))
-			status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))
+			status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 		if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {
@@ -942,7 +942,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			if kerrors.IsConflict(err) {
 				return reconcile.Result{Requeue: true}, nil
 			}
-			status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))
+			status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -964,7 +964,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))
-		status.Mark(xpv1.ReconcileError(err))
+		status.MarkConditions(xpv1.ReconcileError(err))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -975,7 +975,7 @@ 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)))
-		status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.New(errCreateIncomplete)))
+		status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(errors.New(errCreateIncomplete)))
 		return reconcile.Result{Requeue: false}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1000,7 +1000,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))
-			status.Mark(xpv1.ReconcileError(err))
+			status.MarkConditions(xpv1.ReconcileError(err))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 	}
@@ -1017,7 +1017,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			return reconcile.Result{Requeue: true}, nil
 		}
 		record.Event(managed, event.Warning(reasonCannotConnect, err))
-		status.Mark(xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)))
+		status.MarkConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 	defer func() {
@@ -1045,15 +1045,15 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			return reconcile.Result{Requeue: true}, nil
 		}
 		record.Event(managed, event.Warning(reasonCannotObserve, err))
-		status.Mark(xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)))
+		status.MarkConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)))
 		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)))
-		status.Mark(xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)))
+		status.MarkConditions(xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1091,7 +1091,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 					log.Info(errRecordChangeLog, "error", err)
 				}
 				record.Event(managed, event.Warning(reasonCannotDelete, err))
-				status.Mark(xpv1.Deleting(), xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)))
+				status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)))
 				return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 			}
 
@@ -1122,7 +1122,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 				return reconcile.Result{Requeue: true}, nil
 			}
 			record.Event(managed, event.Warning(reasonCannotUnpublish, err))
-			status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))
+			status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 		if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {
@@ -1134,7 +1134,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			if kerrors.IsConflict(err) {
 				return reconcile.Result{Requeue: true}, nil
 			}
-			status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))
+			status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1156,7 +1156,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))
-		status.Mark(xpv1.ReconcileError(err))
+		status.MarkConditions(xpv1.ReconcileError(err))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1168,7 +1168,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 		if kerrors.IsConflict(err) {
 			return reconcile.Result{Requeue: true}, nil
 		}
-		status.Mark(xpv1.ReconcileError(err))
+		status.MarkConditions(xpv1.ReconcileError(err))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1187,7 +1187,7 @@ 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)))
-			status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
+			status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1224,7 +1224,7 @@ 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)
 			}
-			status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)))
+			status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1253,7 +1253,7 @@ 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)))
-			status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)))
+			status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1266,7 +1266,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))
-			status.Mark(xpv1.Creating(), xpv1.ReconcileError(err))
+			status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(err))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 
@@ -1276,7 +1276,7 @@ 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"))
-		status.Mark(xpv1.Creating(), xpv1.ReconcileSuccess())
+		status.MarkConditions(xpv1.Creating(), xpv1.ReconcileSuccess())
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1291,7 +1291,7 @@ 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))
-			status.Mark(xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
+			status.MarkConditions(xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
 			return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 		}
 	}
@@ -1325,7 +1325,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))
-		status.Mark(xpv1.ReconcileSuccess())
+		status.MarkConditions(xpv1.ReconcileSuccess())
 		return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1341,7 +1341,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
 			log.Info(errRecordChangeLog, "error", err)
 		}
 		record.Event(managed, event.Warning(reasonCannotUpdate, err))
-		status.Mark(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)))
+		status.MarkConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1357,7 +1357,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))
-		status.Mark(xpv1.ReconcileError(err))
+		status.MarkConditions(xpv1.ReconcileError(err))
 		return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 	}
 
@@ -1369,6 +1369,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"))
-	status.Mark(xpv1.ReconcileSuccess())
+	status.MarkConditions(xpv1.ReconcileSuccess())
 	return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
 }

Original file line number	Diff line number	Diff line change
`@@ -824,7 +824,7 @@ func NewReconciler(m manager.Manager, of resource.ManagedKind, o ...ReconcilerOp`
`824`	`824`	`record: event.NewNopRecorder(),`
`825`	`825`	`metricRecorder: NewNopMetricRecorder(),`
`826`	`826`	`change: newNopChangeLogger(),`
`827`		`- conditions: conditions.New(),`
	`827`	`+ conditions: new(conditions.ObservedGenerationPropagationManager),`
`828`	`828`	`}`
`829`	`829`
`830`	`830`	`for _, ro := range o {`
`@@ -885,7 +885,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`885`	`885`	log.Debug("Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation", "annotation", meta.AnnotationKeyReconciliationPaused)
`886`	`886`	record.Event(managed, event.Normal(reasonReconciliationPaused, "Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation",
`887`	`887`	`"annotation", meta.AnnotationKeyReconciliationPaused))`
`888`		`- status.Mark(xpv1.ReconcilePaused())`
	`888`	`+ status.MarkConditions(xpv1.ReconcilePaused())`
`889`	`889`	`// if the pause annotation is removed or the management policies changed, we will have a chance to reconcile`
`890`	`890`	`// again and resume and if status update fails, we will reconcile again to retry to update the status`
`891`	`891`	`return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`@@ -905,7 +905,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`905`	`905`	`return reconcile.Result{Requeue: true}, nil`
`906`	`906`	`}`
`907`	`907`	`record.Event(managed, event.Warning(reasonManagementPolicyInvalid, err))`
`908`		`- status.Mark(xpv1.ReconcileError(err))`
	`908`	`+ status.MarkConditions(xpv1.ReconcileError(err))`
`909`	`909`	`return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`910`	`910`	`}`
`911`	`911`
`@@ -930,7 +930,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`930`	`930`	`return reconcile.Result{Requeue: true}, nil`
`931`	`931`	`}`
`932`	`932`	`record.Event(managed, event.Warning(reasonCannotUnpublish, err))`
`933`		`- status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))`
	`933`	`+ status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(err))`
`934`	`934`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`935`	`935`	`}`
`936`	`936`	`if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {`
`@@ -942,7 +942,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`942`	`942`	`if kerrors.IsConflict(err) {`
`943`	`943`	`return reconcile.Result{Requeue: true}, nil`
`944`	`944`	`}`
`945`		`- status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))`
	`945`	`+ status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(err))`
`946`	`946`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`947`	`947`	`}`
`948`	`948`
`@@ -964,7 +964,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`964`	`964`	`return reconcile.Result{Requeue: true}, nil`
`965`	`965`	`}`
`966`	`966`	`record.Event(managed, event.Warning(reasonCannotInitialize, err))`
`967`		`- status.Mark(xpv1.ReconcileError(err))`
	`967`	`+ status.MarkConditions(xpv1.ReconcileError(err))`
`968`	`968`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`969`	`969`	`}`
`970`	`970`
`@@ -975,7 +975,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`975`	`975`	`if meta.ExternalCreateIncomplete(managed) {`
`976`	`976`	`log.Debug(errCreateIncomplete)`
`977`	`977`	`record.Event(managed, event.Warning(reasonCannotInitialize, errors.New(errCreateIncomplete)))`
`978`		`- status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.New(errCreateIncomplete)))`
	`978`	`+ status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(errors.New(errCreateIncomplete)))`
`979`	`979`	`return reconcile.Result{Requeue: false}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`980`	`980`	`}`
`981`	`981`
`@@ -1000,7 +1000,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1000`	`1000`	`return reconcile.Result{Requeue: true}, nil`
`1001`	`1001`	`}`
`1002`	`1002`	`record.Event(managed, event.Warning(reasonCannotResolveRefs, err))`
`1003`		`- status.Mark(xpv1.ReconcileError(err))`
	`1003`	`+ status.MarkConditions(xpv1.ReconcileError(err))`
`1004`	`1004`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1005`	`1005`	`}`
`1006`	`1006`	`}`
`@@ -1017,7 +1017,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1017`	`1017`	`return reconcile.Result{Requeue: true}, nil`
`1018`	`1018`	`}`
`1019`	`1019`	`record.Event(managed, event.Warning(reasonCannotConnect, err))`
`1020`		`- status.Mark(xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)))`
	`1020`	`+ status.MarkConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)))`
`1021`	`1021`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1022`	`1022`	`}`
`1023`	`1023`	`defer func() {`
`@@ -1045,15 +1045,15 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1045`	`1045`	`return reconcile.Result{Requeue: true}, nil`
`1046`	`1046`	`}`
`1047`	`1047`	`record.Event(managed, event.Warning(reasonCannotObserve, err))`
`1048`		`- status.Mark(xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)))`
	`1048`	`+ status.MarkConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)))`
`1049`	`1049`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1050`	`1050`	`}`
`1051`	`1051`
`1052`	`1052`	`// In the observe-only mode, !observation.ResourceExists will be an error`
`1053`	`1053`	`// case, and we will explicitly return this information to the user.`
`1054`	`1054`	`if !observation.ResourceExists && policy.ShouldOnlyObserve() {`
`1055`	`1055`	`record.Event(managed, event.Warning(reasonCannotObserve, errors.New(errExternalResourceNotExist)))`
`1056`		`- status.Mark(xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)))`
	`1056`	`+ status.MarkConditions(xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)))`
`1057`	`1057`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1058`	`1058`	`}`
`1059`	`1059`
`@@ -1091,7 +1091,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1091`	`1091`	`log.Info(errRecordChangeLog, "error", err)`
`1092`	`1092`	`}`
`1093`	`1093`	`record.Event(managed, event.Warning(reasonCannotDelete, err))`
`1094`		`- status.Mark(xpv1.Deleting(), xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)))`
	`1094`	`+ status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)))`
`1095`	`1095`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1096`	`1096`	`}`
`1097`	`1097`
`@@ -1122,7 +1122,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1122`	`1122`	`return reconcile.Result{Requeue: true}, nil`
`1123`	`1123`	`}`
`1124`	`1124`	`record.Event(managed, event.Warning(reasonCannotUnpublish, err))`
`1125`		`- status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))`
	`1125`	`+ status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(err))`
`1126`	`1126`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1127`	`1127`	`}`
`1128`	`1128`	`if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {`
`@@ -1134,7 +1134,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1134`	`1134`	`if kerrors.IsConflict(err) {`
`1135`	`1135`	`return reconcile.Result{Requeue: true}, nil`
`1136`	`1136`	`}`
`1137`		`- status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))`
	`1137`	`+ status.MarkConditions(xpv1.Deleting(), xpv1.ReconcileError(err))`
`1138`	`1138`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1139`	`1139`	`}`
`1140`	`1140`
`@@ -1156,7 +1156,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1156`	`1156`	`return reconcile.Result{Requeue: true}, nil`
`1157`	`1157`	`}`
`1158`	`1158`	`record.Event(managed, event.Warning(reasonCannotPublish, err))`
`1159`		`- status.Mark(xpv1.ReconcileError(err))`
	`1159`	`+ status.MarkConditions(xpv1.ReconcileError(err))`
`1160`	`1160`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1161`	`1161`	`}`
`1162`	`1162`
`@@ -1168,7 +1168,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1168`	`1168`	`if kerrors.IsConflict(err) {`
`1169`	`1169`	`return reconcile.Result{Requeue: true}, nil`
`1170`	`1170`	`}`
`1171`		`- status.Mark(xpv1.ReconcileError(err))`
	`1171`	`+ status.MarkConditions(xpv1.ReconcileError(err))`
`1172`	`1172`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1173`	`1173`	`}`
`1174`	`1174`
`@@ -1187,7 +1187,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1187`	`1187`	`return reconcile.Result{Requeue: true}, nil`
`1188`	`1188`	`}`
`1189`	`1189`	`record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManaged)))`
`1190`		`- status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))`
	`1190`	`+ status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))`
`1191`	`1191`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1192`	`1192`	`}`
`1193`	`1193`
`@@ -1224,7 +1224,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1224`	`1224`	`if err := r.change.Log(ctx, managedPreOp, v1alpha1.OperationType_OPERATION_TYPE_CREATE, err, creation.AdditionalDetails); err != nil {`
`1225`	`1225`	`log.Info(errRecordChangeLog, "error", err)`
`1226`	`1226`	`}`
`1227`		`- status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)))`
	`1227`	`+ status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)))`
`1228`	`1228`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1229`	`1229`	`}`
`1230`	`1230`
`@@ -1253,7 +1253,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1253`	`1253`	`return reconcile.Result{Requeue: true}, nil`
`1254`	`1254`	`}`
`1255`	`1255`	`record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManagedAnnotations)))`
`1256`		`- status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)))`
	`1256`	`+ status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)))`
`1257`	`1257`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1258`	`1258`	`}`
`1259`	`1259`
`@@ -1266,7 +1266,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1266`	`1266`	`return reconcile.Result{Requeue: true}, nil`
`1267`	`1267`	`}`
`1268`	`1268`	`record.Event(managed, event.Warning(reasonCannotPublish, err))`
`1269`		`- status.Mark(xpv1.Creating(), xpv1.ReconcileError(err))`
	`1269`	`+ status.MarkConditions(xpv1.Creating(), xpv1.ReconcileError(err))`
`1270`	`1270`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1271`	`1271`	`}`
`1272`	`1272`
`@@ -1276,7 +1276,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1276`	`1276`	`// ready for use.`
`1277`	`1277`	`log.Debug("Successfully requested creation of external resource")`
`1278`	`1278`	`record.Event(managed, event.Normal(reasonCreated, "Successfully requested creation of external resource"))`
`1279`		`- status.Mark(xpv1.Creating(), xpv1.ReconcileSuccess())`
	`1279`	`+ status.MarkConditions(xpv1.Creating(), xpv1.ReconcileSuccess())`
`1280`	`1280`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1281`	`1281`	`}`
`1282`	`1282`
`@@ -1291,7 +1291,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1291`	`1291`	`if err := r.client.Update(ctx, managed); err != nil {`
`1292`	`1292`	`log.Debug(errUpdateManaged, "error", err)`
`1293`	`1293`	`record.Event(managed, event.Warning(reasonCannotUpdateManaged, err))`
`1294`		`- status.Mark(xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))`
	`1294`	`+ status.MarkConditions(xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))`
`1295`	`1295`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1296`	`1296`	`}`
`1297`	`1297`	`}`
`@@ -1325,7 +1325,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1325`	`1325`	`if !policy.ShouldUpdate() {`
`1326`	`1326`	`reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)`
`1327`	`1327`	`log.Debug("Skipping update due to managementPolicies. Reconciliation succeeded", "requeue-after", time.Now().Add(reconcileAfter))`
`1328`		`- status.Mark(xpv1.ReconcileSuccess())`
	`1328`	`+ status.MarkConditions(xpv1.ReconcileSuccess())`
`1329`	`1329`	`return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1330`	`1330`	`}`
`1331`	`1331`
`@@ -1341,7 +1341,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1341`	`1341`	`log.Info(errRecordChangeLog, "error", err)`
`1342`	`1342`	`}`
`1343`	`1343`	`record.Event(managed, event.Warning(reasonCannotUpdate, err))`
`1344`		`- status.Mark(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)))`
	`1344`	`+ status.MarkConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)))`
`1345`	`1345`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1346`	`1346`	`}`
`1347`	`1347`
`@@ -1357,7 +1357,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1357`	`1357`	`// not, we requeue explicitly, which will trigger backoff.`
`1358`	`1358`	`log.Debug("Cannot publish connection details", "error", err)`
`1359`	`1359`	`record.Event(managed, event.Warning(reasonCannotPublish, err))`
`1360`		`- status.Mark(xpv1.ReconcileError(err))`
	`1360`	`+ status.MarkConditions(xpv1.ReconcileError(err))`
`1361`	`1361`	`return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1362`	`1362`	`}`
`1363`	`1363`
`@@ -1369,6 +1369,6 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu`
`1369`	`1369`	`reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)`
`1370`	`1370`	`log.Debug("Successfully requested update of external resource", "requeue-after", time.Now().Add(reconcileAfter))`
`1371`	`1371`	`record.Event(managed, event.Normal(reasonUpdated, "Successfully requested update of external resource"))`
`1372`		`- status.Mark(xpv1.ReconcileSuccess())`
	`1372`	`+ status.MarkConditions(xpv1.ReconcileSuccess())`
`1373`	`1373`	`return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)`
`1374`	`1374`	`}`