temp changes adding conditions

Author: michaelhtm

api/v1alpha1/conditions.go

@@ -24,22 +24,6 @@ type ConditionType string
 
 func (c ConditionType) String() string { return string(c) }
 
-const (
-	// ResourceGraphDefinitionConditionTypeGraphVerified indicates the state of the directed
-	// acyclic graph (DAG) that kro uses to manage the resources in a
-	// ResourceGraphDefinition.
-	ResourceGraphDefinitionConditionTypeGraphVerified ConditionType = "GraphVerified"
-	// ResourceGraphDefinitionConditionTypeCustomResourceDefinitionSynced indicates the state of the
-	// CustomResourceDefinition (CRD) that kro uses to manage the resources in a
-	// ResourceGraphDefinition.
-	ResourceGraphDefinitionConditionTypeCustomResourceDefinitionSynced ConditionType = "CustomResourceDefinitionSynced"
-	// ResourceGraphDefinitionConditionTypeReconcilerReady indicates the state of the reconciler.
-	// Whenever an ResourceGraphDefinition resource is created, kro will spin up a
-	// reconciler for that resource. This condition indicates the state of the
-	// reconciler.
-	ResourceGraphDefinitionConditionTypeReconcilerReady ConditionType = "ReconcilerReady"
-)
-
 // Condition is the common struct used by all CRDs managed by ACK service
 // controllers to indicate terminal states  of the CR and its backend AWS
 // service API resource

pkg/controller/resourcegraphdefinition/controller.go

@@ -155,38 +155,46 @@ func (r *ResourceGraphDefinitionReconciler) findRGDsForCRD(ctx context.Context,
 	}
 }
 
-func (r *ResourceGraphDefinitionReconciler) Reconcile(ctx context.Context, o *v1alpha1.ResourceGraphDefinition) (res ctrl.Result, reconcileErr error) {
+func (r *ResourceGraphDefinitionReconciler) Reconcile(ctx context.Context, o *v1alpha1.ResourceGraphDefinition) (res ctrl.Result, err error) {
 	var topologicalOrder []string
 	var resourcesInformation []v1alpha1.ResourceInformation
 	// defer function will ensure any errors that occur during reconcile will eventually be
 	// patched to the resource
 	defer func() {
 		// if the updateStatus error is a k8s NotFound error we want to skip it.
 		// If not, we will merge it to the returned error
-		if err := r.updateStatus(ctx, o, topologicalOrder, resourcesInformation); err != nil {
-			// we don't want to reconcile if resource is deleted
-			if !apierrors.IsNotFound(err) {
-				reconcileErr = errors.Join(reconcileErr, err)
+		if patchErr := r.updateStatus(ctx, o, topologicalOrder, resourcesInformation); patchErr != nil {
+			if apierrors.IsNotFound(patchErr) {
+				// we don't want to return an error and requeue if
+				// rgd is not found (deleted)
+				err = nil
 			} else {
-				reconcileErr = nil
+				err = errors.Join(patchErr, err)
 			}
 		}
 	}()
+	mark := NewConditionsMarkerFor(o)
 	if !o.DeletionTimestamp.IsZero() {
 		if err := r.cleanupResourceGraphDefinition(ctx, o); err != nil {
+			mark.ResourceGraphNotCleanedUp(err.Error())
 			return ctrl.Result{}, err
 		}
+		mark.ResourceGraphCleanedUp()
 		if err := r.setUnmanaged(ctx, o); err != nil {
+			mark.ResourceGraphUnfinalized(err.Error())
 			return ctrl.Result{}, err
 		}
+		mark.ResourceGraphFinalized("removed")
 		return ctrl.Result{}, nil
 	}
 
 	if err := r.setManaged(ctx, o); err != nil {
+		mark.ResourceGraphUnfinalized(err.Error())
 		return ctrl.Result{}, err
 	}
+	mark.ResourceGraphFinalized("added")
 
-	topologicalOrder, resourcesInformation, reconcileErr = r.reconcileResourceGraphDefinition(ctx, o)
+	topologicalOrder, resourcesInformation, err = r.reconcileResourceGraphDefinition(ctx, o)
 
-	return ctrl.Result{}, reconcileErr
+	return ctrl.Result{}, err
 }

pkg/controller/resourcegraphdefinition/controller_status.go

@@ -106,21 +106,24 @@ func (r *ResourceGraphDefinitionReconciler) setUnmanaged(ctx context.Context, rg
 }
 
 const (
-	Ready                 = "Ready"
-	ResourceGraphAccepted = "ResourceGraphAccepted"
-	KindReady             = "KindReady"
-	ControllerReady       = "ControllerReady"
+	Ready                  = "Ready"
+	ResourceGraphAccepted  = "ResourceGraphAccepted"
+	KindReady              = "KindReady"
+	ControllerReady        = "ControllerReady"
+	ResourceGraphFinalized = "ResourceGraphFinalized"
+	ResourceGraphCleanedUp = "ResourceGraphCleanedUp"
 )
 
-var rgdConditionTypes = apis.NewReadyConditions(ResourceGraphAccepted, KindReady, ControllerReady)
+var rgdConditionTypes = apis.NewReadyConditions(ResourceGraphAccepted, KindReady, ControllerReady, ResourceGraphFinalized)
 
 // NewConditionsMarkerFor creates a marker to manage conditions and sub-conditions for ResourceGraphDefinitions.
 //
 // ```
 // Ready
 //	├─ ResourceGraphAccepted - This controller has accepted the spec.schema and spec.resources.
 //	├─ KindReady - The CRD status created on behalf of this RGD.
-//	└─ ControllerReady - The status of the controller thread reconciling this resource.
+//	├─ ControllerReady - The status of the controller thread reconciling this resource.
+//  └─ ResourceGraphFinalized - The RGD was successfully finalized
 // ```
 
 func NewConditionsMarkerFor(o apis.Object) *ConditionsMarker {
@@ -159,6 +162,26 @@ func (m *ConditionsMarker) KindReady(kind string) {
 	m.cs.SetTrueWithReason(KindReady, "Ready", fmt.Sprintf("kind %s has been accepted and ready", kind))
 }
 
+// ResourceGraphUnfinalized signals the RGD finalizer failed to add/remove
+func (m *ConditionsMarker) ResourceGraphUnfinalized(msg string) {
+	m.cs.SetFalse(ResourceGraphFinalized, "Failed", msg)
+}
+
+// ResourceGraphFinalized signals the RGD finalizer was successfully added/removed
+func (m *ConditionsMarker) ResourceGraphFinalized(addedOrRemoved string) {
+	m.cs.SetTrueWithReason(ResourceGraphFinalized, "Success", fmt.Sprintf("resourcegraph finalizer has been successfully %s", addedOrRemoved))
+}
+
+// ResourceGraphCleanedUp signals the RGD was cleaned up successfully
+func (m *ConditionsMarker) ResourceGraphCleanedUp() {
+	m.cs.SetTrueWithReason(ResourceGraphCleanedUp, "Success", "resourcegraph cleaned up successfully")
+}
+
+// ResourceGraphNotCleanedUp signals the RGD failed to cleanup successfully
+func (m *ConditionsMarker) ResourceGraphNotCleanedUp(msg string) {
+	m.cs.SetFalse(ResourceGraphCleanedUp, "Failed", msg)
+}
+
 // ControllerFailedToStart signals the microcontroller had an issue when starting.
 func (m *ConditionsMarker) ControllerFailedToStart(msg string) {
 	m.cs.SetFalse(ControllerReady, "FailedToStart", msg)