Skip to content

Commit 65e4efa

Browse files
pintonunespintonunes
committed
added observed generation to reconciler
1 parent 19d95a6 commit 65e4efa

File tree

1 file changed

+63
-27
lines changed

1 file changed

+63
-27
lines changed

‎pkg/reconciler/managed/reconciler.go‎

Lines changed: 63 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -880,7 +880,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
880880
log.Debug("Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation", "annotation", meta.AnnotationKeyReconciliationPaused)
881881
record.Event(managed, event.Normal(reasonReconciliationPaused, "Reconciliation is paused either through the `spec.managementPolicies` or the pause annotation",
882882
"annotation", meta.AnnotationKeyReconciliationPaused))
883-
managed.SetConditions(xpv1.ReconcilePaused())
883+
managed.SetConditions(xpv1.ReconcilePaused().WithObservedGeneration(managed.GetGeneration()))
884884
// if the pause annotation is removed or the management policies changed, we will have a chance to reconcile
885885
// again and resume and if status update fails, we will reconcile again to retry to update the status
886886
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
900900
return reconcile.Result{Requeue: true}, nil
901901
}
902902
record.Event(managed, event.Warning(reasonManagementPolicyInvalid, err))
903-
managed.SetConditions(xpv1.ReconcileError(err))
903+
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
904904
return reconcile.Result{}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
905905
}
906906

@@ -925,7 +925,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
925925
return reconcile.Result{Requeue: true}, nil
926926
}
927927
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()),
931+
)
929932
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
930933
}
931934
if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {
@@ -937,7 +940,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
937940
if kerrors.IsConflict(err) {
938941
return reconcile.Result{Requeue: true}, nil
939942
}
940-
managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
943+
managed.SetConditions(
944+
xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
945+
xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()),
946+
)
941947
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
942948
}
943949

@@ -959,7 +965,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
959965
return reconcile.Result{Requeue: true}, nil
960966
}
961967
record.Event(managed, event.Warning(reasonCannotInitialize, err))
962-
managed.SetConditions(xpv1.ReconcileError(err))
968+
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
963969
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
964970
}
965971

@@ -970,7 +976,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
970976
if meta.ExternalCreateIncomplete(managed) {
971977
log.Debug(errCreateIncomplete)
972978
record.Event(managed, event.Warning(reasonCannotInitialize, errors.New(errCreateIncomplete)))
973-
managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.New(errCreateIncomplete)))
979+
managed.SetConditions(
980+
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
981+
xpv1.ReconcileError(errors.New(errCreateIncomplete)).WithObservedGeneration(managed.GetGeneration()),
982+
)
974983
return reconcile.Result{Requeue: false}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
975984
}
976985

@@ -995,7 +1004,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
9951004
return reconcile.Result{Requeue: true}, nil
9961005
}
9971006
record.Event(managed, event.Warning(reasonCannotResolveRefs, err))
998-
managed.SetConditions(xpv1.ReconcileError(err))
1007+
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
9991008
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
10001009
}
10011010
}
@@ -1012,7 +1021,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
10121021
return reconcile.Result{Requeue: true}, nil
10131022
}
10141023
record.Event(managed, event.Warning(reasonCannotConnect, err))
1015-
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)))
1024+
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileConnect)).WithObservedGeneration(managed.GetGeneration()))
10161025
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
10171026
}
10181027
defer func() {
@@ -1040,15 +1049,15 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
10401049
return reconcile.Result{Requeue: true}, nil
10411050
}
10421051
record.Event(managed, event.Warning(reasonCannotObserve, err))
1043-
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)))
1052+
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileObserve)).WithObservedGeneration(managed.GetGeneration()))
10441053
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
10451054
}
10461055

10471056
// In the observe-only mode, !observation.ResourceExists will be an error
10481057
// case, and we will explicitly return this information to the user.
10491058
if !observation.ResourceExists && policy.ShouldOnlyObserve() {
10501059
record.Event(managed, event.Warning(reasonCannotObserve, errors.New(errExternalResourceNotExist)))
1051-
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)))
1060+
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(errors.New(errExternalResourceNotExist), errReconcileObserve)).WithObservedGeneration(managed.GetGeneration()))
10521061
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
10531062
}
10541063

@@ -1086,7 +1095,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
10861095
log.Info(errRecordChangeLog, "error", err)
10871096
}
10881097
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()),
1101+
)
10901102
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
10911103
}
10921104

@@ -1102,7 +1114,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11021114
log.Info(errRecordChangeLog, "error", err)
11031115
}
11041116
record.Event(managed, event.Normal(reasonDeleted, "Successfully requested deletion of external resource"))
1105-
managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileSuccess())
1117+
managed.SetConditions(
1118+
xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
1119+
xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()),
1120+
)
11061121
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11071122
}
11081123
if err := r.managed.UnpublishConnection(ctx, managed, observation.ConnectionDetails); err != nil {
@@ -1115,7 +1130,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11151130
return reconcile.Result{Requeue: true}, nil
11161131
}
11171132
record.Event(managed, event.Warning(reasonCannotUnpublish, err))
1118-
managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
1133+
managed.SetConditions(
1134+
xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
1135+
xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()),
1136+
)
11191137
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11201138
}
11211139
if err := r.managed.RemoveFinalizer(ctx, managed); err != nil {
@@ -1127,7 +1145,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11271145
if kerrors.IsConflict(err) {
11281146
return reconcile.Result{Requeue: true}, nil
11291147
}
1130-
managed.SetConditions(xpv1.Deleting(), xpv1.ReconcileError(err))
1148+
managed.SetConditions(
1149+
xpv1.Deleting().WithObservedGeneration(managed.GetGeneration()),
1150+
xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()),
1151+
)
11311152
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11321153
}
11331154

@@ -1149,7 +1170,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11491170
return reconcile.Result{Requeue: true}, nil
11501171
}
11511172
record.Event(managed, event.Warning(reasonCannotPublish, err))
1152-
managed.SetConditions(xpv1.ReconcileError(err))
1173+
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
11531174
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11541175
}
11551176

@@ -1161,7 +1182,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11611182
if kerrors.IsConflict(err) {
11621183
return reconcile.Result{Requeue: true}, nil
11631184
}
1164-
managed.SetConditions(xpv1.ReconcileError(err))
1185+
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
11651186
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11661187
}
11671188

@@ -1180,7 +1201,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
11801201
return reconcile.Result{Requeue: true}, nil
11811202
}
11821203
record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManaged)))
1183-
managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
1204+
managed.SetConditions(
1205+
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1206+
xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)).WithObservedGeneration(managed.GetGeneration()),
1207+
)
11841208
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
11851209
}
11861210

@@ -1217,7 +1241,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12171241
if err := r.change.Log(ctx, managedPreOp, v1alpha1.OperationType_OPERATION_TYPE_CREATE, err, creation.AdditionalDetails); err != nil {
12181242
log.Info(errRecordChangeLog, "error", err)
12191243
}
1220-
managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)))
1244+
managed.SetConditions(
1245+
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1246+
xpv1.ReconcileError(errors.Wrap(err, errReconcileCreate)).WithObservedGeneration(managed.GetGeneration()),
1247+
)
12211248
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
12221249
}
12231250

@@ -1246,7 +1273,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12461273
return reconcile.Result{Requeue: true}, nil
12471274
}
12481275
record.Event(managed, event.Warning(reasonCannotUpdateManaged, errors.Wrap(err, errUpdateManagedAnnotations)))
1249-
managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)))
1276+
managed.SetConditions(
1277+
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1278+
xpv1.ReconcileError(errors.Wrap(err, errUpdateManagedAnnotations)).WithObservedGeneration(managed.GetGeneration()),
1279+
)
12501280
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
12511281
}
12521282

@@ -1259,7 +1289,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12591289
return reconcile.Result{Requeue: true}, nil
12601290
}
12611291
record.Event(managed, event.Warning(reasonCannotPublish, err))
1262-
managed.SetConditions(xpv1.Creating(), xpv1.ReconcileError(err))
1292+
managed.SetConditions(
1293+
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1294+
xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()),
1295+
)
12631296
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
12641297
}
12651298

@@ -1269,7 +1302,10 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12691302
// ready for use.
12701303
log.Debug("Successfully requested creation of external resource")
12711304
record.Event(managed, event.Normal(reasonCreated, "Successfully requested creation of external resource"))
1272-
managed.SetConditions(xpv1.Creating(), xpv1.ReconcileSuccess())
1305+
managed.SetConditions(
1306+
xpv1.Creating().WithObservedGeneration(managed.GetGeneration()),
1307+
xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()),
1308+
)
12731309
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
12741310
}
12751311

@@ -1284,7 +1320,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12841320
if err := r.client.Update(ctx, managed); err != nil {
12851321
log.Debug(errUpdateManaged, "error", err)
12861322
record.Event(managed, event.Warning(reasonCannotUpdateManaged, err))
1287-
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)))
1323+
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errUpdateManaged)).WithObservedGeneration(managed.GetGeneration()))
12881324
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
12891325
}
12901326
}
@@ -1298,7 +1334,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
12981334
// https://github.com/crossplane/crossplane/issues/289
12991335
reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)
13001336
log.Debug("External resource is up to date", "requeue-after", time.Now().Add(reconcileAfter))
1301-
managed.SetConditions(xpv1.ReconcileSuccess())
1337+
managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
13021338
r.metricRecorder.recordFirstTimeReady(managed)
13031339

13041340
// record that we intentionally did not update the managed resource
@@ -1318,7 +1354,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
13181354
if !policy.ShouldUpdate() {
13191355
reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)
13201356
log.Debug("Skipping update due to managementPolicies. Reconciliation succeeded", "requeue-after", time.Now().Add(reconcileAfter))
1321-
managed.SetConditions(xpv1.ReconcileSuccess())
1357+
managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
13221358
return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13231359
}
13241360

@@ -1334,7 +1370,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
13341370
log.Info(errRecordChangeLog, "error", err)
13351371
}
13361372
record.Event(managed, event.Warning(reasonCannotUpdate, err))
1337-
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)))
1373+
managed.SetConditions(xpv1.ReconcileError(errors.Wrap(err, errReconcileUpdate)).WithObservedGeneration(managed.GetGeneration()))
13381374
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13391375
}
13401376

@@ -1350,7 +1386,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
13501386
// not, we requeue explicitly, which will trigger backoff.
13511387
log.Debug("Cannot publish connection details", "error", err)
13521388
record.Event(managed, event.Warning(reasonCannotPublish, err))
1353-
managed.SetConditions(xpv1.ReconcileError(err))
1389+
managed.SetConditions(xpv1.ReconcileError(err).WithObservedGeneration(managed.GetGeneration()))
13541390
return reconcile.Result{Requeue: true}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13551391
}
13561392

@@ -1362,6 +1398,6 @@ func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (resu
13621398
reconcileAfter := r.pollIntervalHook(managed, r.pollInterval)
13631399
log.Debug("Successfully requested update of external resource", "requeue-after", time.Now().Add(reconcileAfter))
13641400
record.Event(managed, event.Normal(reasonUpdated, "Successfully requested update of external resource"))
1365-
managed.SetConditions(xpv1.ReconcileSuccess())
1401+
managed.SetConditions(xpv1.ReconcileSuccess().WithObservedGeneration(managed.GetGeneration()))
13661402
return reconcile.Result{RequeueAfter: reconcileAfter}, errors.Wrap(r.client.Status().Update(ctx, managed), errUpdateManagedStatus)
13671403
}

0 commit comments

Comments
 (0)