Skip to content

Commit eab2492

Browse files
n3wscottn3wscott
committed
Update to use the new condtions manager for observedGeneration
Signed-off-by: Scott Nichols <n3wscott@upbound.io>
1 parent 9ede9c1 commit eab2492

File tree

1 file changed

+30
-51
lines changed

1 file changed

+30
-51
lines changed

‎pkg/reconciler/managed/reconciler.go‎

Lines changed: 30 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,7 @@ import (
3131

3232
"github.com/crossplane/crossplane-runtime/apis/changelogs/proto/v1alpha1"
3333
xpv1 "github.com/crossplane/crossplane-runtime/apis/common/v1"
34+
"github.com/crossplane/crossplane-runtime/pkg/conditions"
3435
"github.com/crossplane/crossplane-runtime/pkg/errors"
3536
"github.com/crossplane/crossplane-runtime/pkg/event"
3637
"github.com/crossplane/crossplane-runtime/pkg/feature"
@@ -562,6 +563,8 @@ type Reconciler struct {
562563
external mrExternal
563564
managed mrManaged
564565

566+
conditions conditions.Manager
567+
565568
supportedManagementPolicies []sets.Set[xpv1.ManagementAction]
566569

567570
log logging.Logger
@@ -821,6 +824,7 @@ func NewReconciler(m manager.Manager, of resource.ManagedKind, o ...ReconcilerOp
821824
record: event.NewNopRecorder(),
822825
metricRecorder: NewNopMetricRecorder(),
823826
change: newNopChangeLogger(),
827+
conditions: conditions.New(),
824828
}
825829

826830
for _, ro := range o {
@@ -855,6 +859,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
855859
}
856860

857861
r.metricRecorder.recordFirstTimeReconciled(managed)
862+
status := r.conditions.For(managed)
858863

859864
record := r.record.WithAnnotations("external-name", meta.GetExternalName(managed))
860865
log = log.WithValues(
@@ -880,7 +885,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
880885
log.Debug("Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation", "annotation", meta.AnnotationKeyReconciliationPaused)
881886
record.Event(managed, event.Normal(reasonReconciliationPaused, "Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation",
882887
"annotation", meta.AnnotationKeyReconciliationPaused))
883-
managed.SetConditions(xpv1.ReconcilePaused().WithObservedGeneration(managed.GetGeneration()))
888+
status.Mark(xpv1.ReconcilePaused())
884889
// if the pause annotation is removed or the management policies changed, we will have a chance to reconcile
885890
// again and resume and if status update fails, we will reconcile again to retry to update the status
886891
return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
@@ -900,7 +905,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
900905
return reconcile.Result{Requeue: true}, nil
901906
}
902907
record.Event(managed, event.Warning(reasonManagementPolicyInvalid, err))
903-
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
908+
status.Mark(xpv1.ReconcileError(err))
904909
return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
905910
}
906911

@@ -925,9 +930,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
925930
return reconcile.Result{Requeue: true}, nil
926931
}
927932
record.Event(managed, event.Warning(reasonCannotUnpublish, err))
928-
managed.SetConditions(
929-
xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
930-
xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
933+
status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))
931934
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
932935
}
933936
if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {
@@ -939,9 +942,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
939942
if kerrors.IsConflict(err) {
940943
return reconcile.Result{Requeue: true}, nil
941944
}
942-
managed.SetConditions(
943-
xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
944-
xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
945+
status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))
945946
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
946947
}
947948

@@ -963,7 +964,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
963964
return reconcile.Result{Requeue: true}, nil
964965
}
965966
record.Event(managed, event.Warning(reasonCannotInitialize, err))
966-
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
967+
status.Mark(xpv1.ReconcileError(err))
967968
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
968969
}
969970

@@ -974,9 +975,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
974975
if meta.ExternalCreateIncomplete(managed) {
975976
log.Debug(errCreateIncomplete)
976977
record.Event(managed, event.Warning(reasonCannotInitialize, errors.New(errCreateIncomplete)))
977-
managed.SetConditions(
978-
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
979-
xpv1.ReconcileError(errors.New(errCreateIncomplete)).WithObservedGeneration(managed.GetGeneration()))
978+
status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.New(errCreateIncomplete)))
980979
return reconcile.Result{Requeue: false}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
981980
}
982981

@@ -1001,7 +1000,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
10011000
return reconcile.Result{Requeue: true}, nil
10021001
}
10031002
record.Event(managed, event.Warning(reasonCannotResolveRefs, err))
1004-
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
1003+
status.Mark(xpv1.ReconcileError(err))
10051004
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
10061005
}
10071006
}
@@ -1018,8 +1017,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
10181017
return reconcile.Result{Requeue: true}, nil
10191018
}
10201019
record.Event(managed, event.Warning(reasonCannotConnect, err))
1021-
managed.SetConditions(
1022-
xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)).WithObservedGeneration(managed.GetGeneration()))
1020+
status.Mark(xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)))
10231021
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
10241022
}
10251023
defer func() {
@@ -1047,17 +1045,15 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
10471045
return reconcile.Result{Requeue: true}, nil
10481046
}
10491047
record.Event(managed, event.Warning(reasonCannotObserve, err))
1050-
managed.SetConditions(
1051-
xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)).WithObservedGeneration(managed.GetGeneration()))
1048+
status.Mark(xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)))
10521049
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
10531050
}
10541051

10551052
// In the observe-only mode, !observation.ResourceExists will be an error
10561053
// case, and we will explicitly return this information to the user.
10571054
if !observation.ResourceExists && policy.ShouldOnlyObserve() {
10581055
record.Event(managed, event.Warning(reasonCannotObserve, errors.New(errExternalResourceNotExist)))
1059-
managed.SetConditions(
1060-
xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)).WithObservedGeneration(managed.GetGeneration()))
1056+
status.Mark(xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)))
10611057
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
10621058
}
10631059

@@ -1095,9 +1091,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
10951091
log.Info(errRecordChangeLog, "error", err)
10961092
}
10971093
record.Event(managed, event.Warning(reasonCannotDelete, err))
1098-
managed.SetConditions(
1099-
xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
1100-
xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)).WithObservedGeneration(managed.GetGeneration()))
1094+
status.Mark(xpv1.Deleting(), xpv1.ReconcileError(errors.Wrap(err, errReconcileDelete)))
11011095
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11021096
}
11031097

@@ -1128,9 +1122,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11281122
return reconcile.Result{Requeue: true}, nil
11291123
}
11301124
record.Event(managed, event.Warning(reasonCannotUnpublish, err))
1131-
managed.SetConditions(
1132-
xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
1133-
xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
1125+
status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))
11341126
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11351127
}
11361128
if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {
@@ -1142,9 +1134,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11421134
if kerrors.IsConflict(err) {
11431135
return reconcile.Result{Requeue: true}, nil
11441136
}
1145-
managed.SetConditions(
1146-
xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
1147-
xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
1137+
status.Mark(xpv1.Deleting(), xpv1.ReconcileError(err))
11481138
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11491139
}
11501140

@@ -1166,7 +1156,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11661156
return reconcile.Result{Requeue: true}, nil
11671157
}
11681158
record.Event(managed, event.Warning(reasonCannotPublish, err))
1169-
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
1159+
status.Mark(xpv1.ReconcileError(err))
11701160
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11711161
}
11721162

@@ -1178,7 +1168,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11781168
if kerrors.IsConflict(err) {
11791169
return reconcile.Result{Requeue: true}, nil
11801170
}
1181-
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
1171+
status.Mark(xpv1.ReconcileError(err))
11821172
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11831173
}
11841174

@@ -1197,9 +1187,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11971187
return reconcile.Result{Requeue: true}, nil
11981188
}
11991189
record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManaged)))
1200-
managed.SetConditions(
1201-
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1202-
xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)).WithObservedGeneration(managed.GetGeneration()))
1190+
status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
12031191
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
12041192
}
12051193

@@ -1236,9 +1224,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12361224
if err := r.change.Log(ctx, managedPreOp, v1alpha1.OperationType_OPERATION_TYPE_CREATE, err, creation.AdditionalDetails); err != nil {
12371225
log.Info(errRecordChangeLog, "error", err)
12381226
}
1239-
managed.SetConditions(
1240-
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1241-
xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)).WithObservedGeneration(managed.GetGeneration()))
1227+
status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)))
12421228
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
12431229
}
12441230

@@ -1267,9 +1253,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12671253
return reconcile.Result{Requeue: true}, nil
12681254
}
12691255
record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManagedAnnotations)))
1270-
managed.SetConditions(
1271-
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1272-
xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)).WithObservedGeneration(managed.GetGeneration()))
1256+
status.Mark(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)))
12731257
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
12741258
}
12751259

@@ -1282,9 +1266,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12821266
return reconcile.Result{Requeue: true}, nil
12831267
}
12841268
record.Event(managed, event.Warning(reasonCannotPublish, err))
1285-
managed.SetConditions(
1286-
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1287-
xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
1269+
status.Mark(xpv1.Creating(), xpv1.ReconcileError(err))
12881270
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
12891271
}
12901272

@@ -1294,9 +1276,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12941276
// ready for use.
12951277
log.Debug("Successfully requested creation of external resource")
12961278
record.Event(managed, event.Normal(reasonCreated, "Successfully requested creation of external resource"))
1297-
managed.SetConditions(
1298-
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1299-
xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
1279+
status.Mark(xpv1.Creating(), xpv1.ReconcileSuccess())
13001280
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13011281
}
13021282

@@ -1311,8 +1291,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
13111291
if err := r.client.Update(ctx, managed); err != nil {
13121292
log.Debug(errUpdateManaged, "error", err)
13131293
record.Event(managed, event.Warning(reasonCannotUpdateManaged, err))
1314-
managed.SetConditions(
1315-
xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)).WithObservedGeneration(managed.GetGeneration()))
1294+
status.Mark(xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
13161295
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13171296
}
13181297
}
@@ -1346,7 +1325,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
13461325
if !policy.ShouldUpdate() {
13471326
reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)
13481327
log.Debug("Skipping update due to managementPolicies. Reconciliation succeeded", "requeue-after", time.Now().Add(reconcileAfter))
1349-
managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
1328+
status.Mark(xpv1.ReconcileSuccess())
13501329
return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13511330
}
13521331

@@ -1362,7 +1341,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
13621341
log.Info(errRecordChangeLog, "error", err)
13631342
}
13641343
record.Event(managed, event.Warning(reasonCannotUpdate, err))
1365-
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)).WithObservedGeneration(managed.GetGeneration()))
1344+
status.Mark(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)))
13661345
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13671346
}
13681347

@@ -1378,7 +1357,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
13781357
// not, we requeue explicitly, which will trigger backoff.
13791358
log.Debug("Cannot publish connection details", "error", err)
13801359
record.Event(managed, event.Warning(reasonCannotPublish, err))
1381-
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
1360+
status.Mark(xpv1.ReconcileError(err))
13821361
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13831362
}
13841363

@@ -1390,6 +1369,6 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
13901369
reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)
13911370
log.Debug("Successfully requested update of external resource", "requeue-after", time.Now().Add(reconcileAfter))
13921371
record.Event(managed, event.Normal(reasonUpdated, "Successfully requested update of external resource"))
1393-
managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
1372+
status.Mark(xpv1.ReconcileSuccess())
13941373
return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13951374
}

0 commit comments

Comments
 (0)