map deployment status according to that of operator

Author: varshaprasad96

config/samples/operators_v1alpha1_operator.yaml

@@ -10,4 +10,4 @@ metadata:
   name: operator-sample
 spec:
   # TODO(user): Add fields here
-  packageName: prometheus
+  packageName: lightbend-console-operator

controllers/operator_controller.go

@@ -162,14 +162,35 @@ func (r *OperatorReconciler) reconcile(ctx context.Context, op *operatorsv1alpha
 		return ctrl.Result{}, err
 	}
 
-	// update operator status
+	// convert existing unstructured object into bundleDeployment for easier mapping of status.
+	existingTypedBundleDeployment := &rukpakv1alpha1.BundleDeployment{}
+	if err := runtime.DefaultUnstructuredConverter.FromUnstructured(dep.UnstructuredContent(), existingTypedBundleDeployment); err != nil {
+		return ctrl.Result{}, err
+	}
+
+	// update operator status:
+	// 1. If the Operator "Ready" status is "Unknown": The status of successful bundleDeployment is unknown, requeue the request.
+	// 2. If the Operator "Ready" status is "True": Update the "successful resolution" status and return the result.
+	// 3. If the Operator "Ready" status is "False": There is error observed from Rukpak. Update the status accordingly.
+	status, message := verifyBDStatus(existingTypedBundleDeployment)
+	var reason string
+	if status == metav1.ConditionTrue || status == metav1.ConditionUnknown {
+		reason = operatorsv1alpha1.ReasonResolutionSucceeded
+	} else {
+		reason = operatorsv1alpha1.ReasonBundleDeploymentFailed
+	}
+
 	apimeta.SetStatusCondition(&op.Status.Conditions, metav1.Condition{
 		Type:               operatorsv1alpha1.TypeReady,
-		Status:             metav1.ConditionTrue,
-		Reason:             operatorsv1alpha1.ReasonResolutionSucceeded,
-		Message:            "resolution was successful",
+		Status:             status,
+		Reason:             reason,
+		Message:            message,
 		ObservedGeneration: op.GetGeneration(),
 	})
+
+	if status == metav1.ConditionUnknown || status == metav1.ConditionFalse {
+		return ctrl.Result{Requeue: true}, nil
+	}
 	return ctrl.Result{}, nil
 }
 
@@ -259,14 +280,11 @@ func (r *OperatorReconciler) ensureBundleDeployment(ctx context.Context, desired
 	// If the existing BD already has everything that the desired BD has, no need to contact the API server.
 	// Make sure the status of the existingBD from the server is as expected.
 	if equality.Semantic.DeepDerivative(desiredBundleDeployment, existingBundleDeployment) {
-		return verifySuccessfulBDStatus(existingBundleDeployment)
-	}
-
-	if err = r.Client.Patch(ctx, desiredBundleDeployment, client.Apply, client.ForceOwnership, client.FieldOwner("operator-controller")); err != nil {
-		return err
+		*desiredBundleDeployment = *existingBundleDeployment
+		return nil
 	}
 
-	return verifySuccessfulBDStatus(desiredBundleDeployment)
+	return r.Client.Patch(ctx, desiredBundleDeployment, client.Apply, client.ForceOwnership, client.FieldOwner("operator-controller"))
 }
 
 func (r *OperatorReconciler) existingBundleDeploymentUnstructured(ctx context.Context, name string) (*unstructured.Unstructured, error) {
@@ -284,29 +302,26 @@ func (r *OperatorReconciler) existingBundleDeploymentUnstructured(ctx context.Co
 	return &unstructured.Unstructured{Object: unstrExistingBundleDeploymentObj}, nil
 }
 
-func verifySuccessfulBDStatus(dep *unstructured.Unstructured) error {
-	// convert the unstructured object from patch call to typed bundledeployment to make checking of Status easier.
-	existingTypedBundleDeployment := &rukpakv1alpha1.BundleDeployment{}
+// verifyBDStatus reads the various possibilities of status in bundle deployment and translates
+// into corresponding operator condition status and message.
+func verifyBDStatus(dep *rukpakv1alpha1.BundleDeployment) (metav1.ConditionStatus, string) {
+	isValidBundleCond := apimeta.FindStatusCondition(dep.Status.Conditions, rukpakv1alpha1.TypeHasValidBundle)
+	isInstalledCond := apimeta.FindStatusCondition(dep.Status.Conditions, rukpakv1alpha1.TypeInstalled)
 
-	if err := runtime.DefaultUnstructuredConverter.FromUnstructured(dep.UnstructuredContent(), existingTypedBundleDeployment); err != nil {
-		return err
+	if isValidBundleCond == nil && isInstalledCond == nil {
+		return metav1.ConditionUnknown, fmt.Sprintf("waiting for bundleDeployment %q status to be updated", dep.Name)
 	}
 
-	ers := []error{}
-	conditions := existingTypedBundleDeployment.Status.Conditions
+	if isValidBundleCond != nil && isValidBundleCond.Status == metav1.ConditionFalse {
+		return metav1.ConditionFalse, isValidBundleCond.Message
+	}
 
-	// Do we error here?
-	if conditions == nil || len(conditions) == 0 {
-		return nil
+	if isInstalledCond != nil && isInstalledCond.Status == metav1.ConditionFalse {
+		return metav1.ConditionFalse, isInstalledCond.Message
 	}
 
-	for _, condition := range conditions {
-		// Currently we are checking for only these two types, if any other condition is added to Rukpak, validate accordingly.
-		if condition.Type == rukpakv1alpha1.TypeHasValidBundle || condition.Type == rukpakv1alpha1.TypeInstalled {
-			if condition.Status == metav1.ConditionFalse {
-				ers = append(ers, fmt.Errorf("error observed by Rukpak: %v", condition.Message))
-			}
-		}
+	if isInstalledCond != nil && isInstalledCond.Status == metav1.ConditionTrue {
+		return metav1.ConditionTrue, "resolution was successful"
 	}
-	return utilerrors.NewAggregate(ers)
+	return metav1.ConditionUnknown, fmt.Sprintf("waiting for rukpak to install bundleDeployment successfully %s", dep.Name)
 }

controllers/operator_controller_test.go

@@ -347,8 +347,7 @@ var _ = Describe("Reconcile Test", func() {
 				By("running reconcile")
 				res, err := reconciler.Reconcile(ctx, ctrl.Request{NamespacedName: opKey})
 				Expect(res).To(Equal(ctrl.Result{}))
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring(`error observed by Rukpak`))
+				Expect(err).NotTo(HaveOccurred())
 
 				By("fetching the updated operator after reconcile")
 				op := &operatorsv1alpha1.Operator{}