Merge pull request #2816 from NikhilSharmaWe/statusUpdate

✨deploy-image/v1alpha: add code for updating controller status when the deployment is created successfully

Author: k8s-ci-robot

pkg/plugins/golang/deploy-image/v1alpha1/scaffolds/internal/templates/api/types.go

@@ -60,6 +60,7 @@ func (f *Types) SetTemplateDefaults() error {
 	return nil
 }
 
+//nolint:lll
 const typesTemplate = `{{ .Boilerplate }}
 
 package {{ .Resource.Version }}
@@ -92,8 +93,16 @@ type {{ .Resource.Kind }}Spec struct {
 
 // {{ .Resource.Kind }}Status defines the observed state of {{ .Resource.Kind }}
 type {{ .Resource.Kind }}Status struct {
-	// INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
-	// Important: Run "make" to regenerate code after modifying this file
+	// Represents the observations of a {{ .Resource.Kind }}'s current state.
+	// {{ .Resource.Kind }}.status.conditions.type are: "Available", "Progressing", and "Degraded"
+	// {{ .Resource.Kind }}.status.conditions.status are one of True, False, Unknown.
+	// {{ .Resource.Kind }}.status.conditions.reason the value should be a CamelCase string and producers of specific
+	// condition types may define expected values and meanings for this field, and whether the values
+	// are considered a guaranteed API.
+	// {{ .Resource.Kind }}.status.conditions.Message is a human readable message indicating details about the transition.
+	// For further information see: https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md#typical-status-properties
+
+	Conditions []metav1.Condition ` + "`" + `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"` + "`" + `
 }
 
 //+kubebuilder:object:root=true

pkg/plugins/golang/deploy-image/v1alpha1/scaffolds/internal/templates/controllers/controller.go

@@ -75,6 +75,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/client-go/tools/record"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -88,6 +89,14 @@ import (
 
 const {{ lower .Resource.Kind }}Finalizer = "{{ .Resource.Group }}.{{ .Resource.Domain }}/finalizer"
 
+// Definitions to manage status conditions
+const (
+	// typeAvailable{{ .Resource.Kind }} represents the status of the Deployment reconciliation
+	typeAvailable{{ .Resource.Kind }} = "Available"
+	// typeDegraded{{ .Resource.Kind }} represents the status used when the custom resource is deleted and the finalizer operations are must to occur. 
+	typeDegraded{{ .Resource.Kind }} = "Degraded"
+)
+
 // {{ .Resource.Kind }}Reconciler reconciles a {{ .Resource.Kind }} object
 type {{ .Resource.Kind }}Reconciler struct {
 	client.Client
@@ -138,6 +147,25 @@ func (r *{{ .Resource.Kind }}Reconciler) Reconcile(ctx context.Context, req ctrl
 		return ctrl.Result{}, err
 	}
 
+	// Let's just set the status as Unknown when no status are available
+	if {{ lower .Resource.Kind }}.Status.Conditions == nil || len({{ lower .Resource.Kind }}.Status.Conditions) == 0 {
+		meta.SetStatusCondition(&{{ lower .Resource.Kind }}.Status.Conditions, metav1.Condition{Type: typeAvailable{{ .Resource.Kind }}, Status: metav1.ConditionUnknown, Reason: "Reconciling", Message: "Starting reconciliation"})
+		if err = r.Status().Update(ctx, {{ lower .Resource.Kind }}); err != nil {
+			log.Error(err, "Failed to update {{ .Resource.Kind }} status")
+			return ctrl.Result{}, err
+		}
+
+		// Let's re-fetch the {{ lower .Resource.Kind }} Custom Resource after update the status 
+		// so that we have the latest state of the resource on the cluster and we will avoid
+		// raise the issue "the object has been modified, please apply
+		// your changes to the latest version and try again" which would re-trigger the reconciliation
+		// if we try to update it again in the following operations
+		if err := r.Get(ctx, req.NamespacedName, {{ lower .Resource.Kind }}); err != nil {
+			log.Error(err, "Failed to re-fetch {{ lower .Resource.Kind }}")
+			return ctrl.Result{}, err
+		}
+	}
+
 	// Let's add a finalizer. Then, we can define some operations which should
 	// occurs before the custom resource to be deleted.
 	// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/finalizers
@@ -160,8 +188,43 @@ func (r *{{ .Resource.Kind }}Reconciler) Reconcile(ctx context.Context, req ctrl
 	if is{{ .Resource.Kind }}MarkedToBeDeleted {
 		if controllerutil.ContainsFinalizer({{ lower .Resource.Kind }}, {{ lower .Resource.Kind }}Finalizer) {
 			log.Info("Performing Finalizer Operations for {{ .Resource.Kind }} before delete CR")
+
+			// Let's add here an status "Downgrade" to define that this resource begin its process to be terminated.
+			meta.SetStatusCondition(&{{ lower .Resource.Kind }}.Status.Conditions, metav1.Condition{Type: typeDegraded{{ .Resource.Kind }},
+				Status: metav1.ConditionUnknown, Reason: "Finalizing",
+				Message: fmt.Sprintf("Performing finalizer operations for the custom resource: %s ", {{ lower .Resource.Kind }}.Name)})
+
+			if err := r.Status().Update(ctx, {{ lower .Resource.Kind }}); err != nil {
+				log.Error(err, "Failed to update {{ .Resource.Kind }} status")
+				return ctrl.Result{}, err
+			}
+
+			// Perform all operations required before remove the finalizer and allow
+			// the Kubernetes API to remove the custom custom resource.
 			r.doFinalizerOperationsFor{{ .Resource.Kind }}({{ lower .Resource.Kind }})
 
+			// TODO(user): If you add operations to the doFinalizerOperationsFor{{ .Resource.Kind }} method 
+			// then you need to ensure that all worked fine before deleting and updating the Downgrade status
+			// otherwise, you should requeue here.
+
+			// Re-fetch the {{ lower .Resource.Kind }} Custom Resource before update the status 
+			// so that we have the latest state of the resource on the cluster and we will avoid
+			// raise the issue "the object has been modified, please apply
+			// your changes to the latest version and try again" which would re-trigger the reconciliation
+			if err := r.Get(ctx, req.NamespacedName, {{ lower .Resource.Kind }}); err != nil {
+				log.Error(err, "Failed to re-fetch {{ lower .Resource.Kind }}")
+				return ctrl.Result{}, err
+			}
+
+			meta.SetStatusCondition(&{{ lower .Resource.Kind }}.Status.Conditions, metav1.Condition{Type: typeDegraded{{ .Resource.Kind }},
+				Status: metav1.ConditionTrue, Reason: "Finalizing",
+				Message: fmt.Sprintf("Finalizer operations for custom resource %s name were successfully accomplished", {{ lower .Resource.Kind }}.Name)})
+			
+			if err := r.Status().Update(ctx, {{ lower .Resource.Kind }}); err != nil {
+				log.Error(err, "Failed to update {{ .Resource.Kind }} status")
+				return ctrl.Result{}, err
+			}
+
 			log.Info("Removing Finalizer for {{ .Resource.Kind }} after successfully perform the operations")
 			if ok:= controllerutil.RemoveFinalizer({{ lower .Resource.Kind }}, {{ lower .Resource.Kind }}Finalizer); !ok{
 				log.Error(err, "Failed to remove finalizer for {{ .Resource.Kind }}")
@@ -184,6 +247,17 @@ func (r *{{ .Resource.Kind }}Reconciler) Reconcile(ctx context.Context, req ctrl
 		dep, err := r.deploymentFor{{ .Resource.Kind }}({{ lower .Resource.Kind }})
 		if err != nil {
 			log.Error(err, "Failed to define new Deployment resource for {{ .Resource.Kind }}")
+
+			// The following implementation will update the status
+			meta.SetStatusCondition(&{{ lower .Resource.Kind }}.Status.Conditions, metav1.Condition{Type: typeAvailable{{ .Resource.Kind }},
+				Status: metav1.ConditionFalse, Reason: "Reconciling",
+				Message: fmt.Sprintf("Failed to create Deployment for the custom resource (%s): (%s)", {{ lower .Resource.Kind }}.Name, err)})
+
+			if err := r.Status().Update(ctx, {{ lower .Resource.Kind }}); err != nil {
+				log.Error(err, "Failed to update {{ .Resource.Kind }} status")
+				return ctrl.Result{}, err
+			}
+
 			return ctrl.Result{}, err
 		}
 
@@ -215,15 +289,45 @@ func (r *{{ .Resource.Kind }}Reconciler) Reconcile(ctx context.Context, req ctrl
 		if err = r.Update(ctx, found); err != nil {
 			log.Error(err, "Failed to update Deployment", 
 				"Deployment.Namespace", found.Namespace, "Deployment.Name", found.Name)
+
+			// Re-fetch the {{ lower .Resource.Kind }} Custom Resource before update the status 
+			// so that we have the latest state of the resource on the cluster and we will avoid
+			// raise the issue "the object has been modified, please apply
+			// your changes to the latest version and try again" which would re-trigger the reconciliation
+			if err := r.Get(ctx, req.NamespacedName, {{ lower .Resource.Kind }}); err != nil {
+				log.Error(err, "Failed to re-fetch {{ lower .Resource.Kind }}")
+				return ctrl.Result{}, err
+			}
+
+			// The following implementation will update the status
+			meta.SetStatusCondition(&{{ lower .Resource.Kind }}.Status.Conditions, metav1.Condition{Type: typeAvailable{{ .Resource.Kind }},
+				Status: metav1.ConditionFalse, Reason: "Resizing",
+				Message: fmt.Sprintf("Failed to update the size for the custom resource (%s): (%s)", {{ lower .Resource.Kind }}.Name, err)})
+
+			if err := r.Status().Update(ctx, {{ lower .Resource.Kind }}); err != nil {
+				log.Error(err, "Failed to update {{ .Resource.Kind }} status")
+				return ctrl.Result{}, err
+			}
+
 			return ctrl.Result{}, err
 		}
 
-		// Since it fails we want to re-queue the reconciliation
-		// The reconciliation will only stop when we be able to ensure 
-		// the desired state on the cluster
+		// Now, that we update the size we want to requeue the reconciliation
+		// so that we can ensure that we have the latest state of the resource before
+		// update. Also, it will help ensure the desired state on the cluster
 		return ctrl.Result{Requeue: true}, nil
 	}
 
+	// The following implementation will update the status
+	meta.SetStatusCondition(&{{ lower .Resource.Kind }}.Status.Conditions, metav1.Condition{Type: typeAvailable{{ .Resource.Kind }},
+		Status: metav1.ConditionTrue, Reason: "Reconciling",
+		Message: fmt.Sprintf("Deployment for custom resource (%s) with %d replicas created successfully", {{ lower .Resource.Kind }}.Name, size)})
+
+	if err := r.Status().Update(ctx, {{ lower .Resource.Kind }}); err != nil {
+		log.Error(err, "Failed to update {{ .Resource.Kind }} status")
+		return ctrl.Result{}, err
+	}
+
 	return ctrl.Result{}, nil
 }
 
@@ -244,7 +348,7 @@ func (r *{{ .Resource.Kind }}Reconciler) doFinalizerOperationsFor{{ .Resource.Ki
 	r.Recorder.Event(cr, "Warning", "Deleting",
 		fmt.Sprintf("Custom Resource %s is being deleted from the namespace %s",
 		cr.Name,
-		cr.Namespace))
+		cr.Namespace),)
 }
 
 // deploymentFor{{ .Resource.Kind }} returns a {{ .Resource.Kind }} Deployment object

test/e2e/deployimage/plugin_cluster_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package deployimage
 
 import (
+	"errors"
 	"fmt"
 	"os/exec"
 	"path/filepath"
@@ -263,6 +264,20 @@ func Run(kbc *utils.TestContext) {
 	}
 	EventuallyWithOffset(1, getMemcachedPodStatus, time.Minute, time.Second).Should(Succeed())
 
+	By("validating that the status of the custom resource created is updated or not")
+	var status string
+	getStatus := func() error {
+		status, err = kbc.Kubectl.Get(true, strings.ToLower(kbc.Kind),
+			strings.ToLower(kbc.Kind)+"-sample",
+			"-o", "jsonpath={.status.conditions}")
+		ExpectWithOffset(2, err).NotTo(HaveOccurred())
+		if !strings.Contains(status, "Available") {
+			return errors.New(`status condition with type "Available" should be set`)
+		}
+		return nil
+	}
+	Eventually(getStatus, time.Minute, time.Second).Should(Succeed())
+
 	//Testing the finalizer
 	EventuallyWithOffset(1, func() error {
 		_, err = kbc.Kubectl.Delete(true, "-f", sampleFilePath)

testdata/project-v3-with-deploy-image/api/v1alpha1/busybox_types.go

@@ -39,8 +39,16 @@ type BusyboxSpec struct {
 
 // BusyboxStatus defines the observed state of Busybox
 type BusyboxStatus struct {
-	// INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
-	// Important: Run "make" to regenerate code after modifying this file
+	// Represents the observations of a Busybox's current state.
+	// Busybox.status.conditions.type are: "Available", "Progressing", and "Degraded"
+	// Busybox.status.conditions.status are one of True, False, Unknown.
+	// Busybox.status.conditions.reason the value should be a CamelCase string and producers of specific
+	// condition types may define expected values and meanings for this field, and whether the values
+	// are considered a guaranteed API.
+	// Busybox.status.conditions.Message is a human readable message indicating details about the transition.
+	// For further information see: https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md#typical-status-properties
+
+	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
 }
 
 //+kubebuilder:object:root=true

testdata/project-v3-with-deploy-image/api/v1alpha1/memcached_types.go

@@ -42,8 +42,16 @@ type MemcachedSpec struct {
 
 // MemcachedStatus defines the observed state of Memcached
 type MemcachedStatus struct {
-	// INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
-	// Important: Run "make" to regenerate code after modifying this file
+	// Represents the observations of a Memcached's current state.
+	// Memcached.status.conditions.type are: "Available", "Progressing", and "Degraded"
+	// Memcached.status.conditions.status are one of True, False, Unknown.
+	// Memcached.status.conditions.reason the value should be a CamelCase string and producers of specific
+	// condition types may define expected values and meanings for this field, and whether the values
+	// are considered a guaranteed API.
+	// Memcached.status.conditions.Message is a human readable message indicating details about the transition.
+	// For further information see: https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md#typical-status-properties
+
+	Conditions []metav1.Condition `json:"conditions,omitempty" patchStrategy:"merge" patchMergeKey:"type" protobuf:"bytes,1,rep,name=conditions"`
 }
 
 //+kubebuilder:object:root=true

testdata/project-v3-with-deploy-image/api/v1alpha1/zz_generated.deepcopy.go

@@ -46,6 +46,75 @@ spec:
             type: object
           status:
             description: BusyboxStatus defines the observed state of Busybox
+            properties:
+              conditions:
+                items:
+                  description: "Condition contains details for one aspect of the current
+                    state of this API Resource. --- This struct is intended for direct
+                    use as an array at the field path .status.conditions.  For example,
+                    type FooStatus struct{ // Represents the observations of a foo's
+                    current state. // Known .status.conditions.type are: \"Available\",
+                    \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge
+                    // +listType=map // +listMapKey=type Conditions []metav1.Condition
+                    `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\"
+                    protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }"
+                  properties:
+                    lastTransitionTime:
+                      description: lastTransitionTime is the last time the condition
+                        transitioned from one status to another. This should be when
+                        the underlying condition changed.  If that is not known, then
+                        using the time when the API field changed is acceptable.
+                      format: date-time
+                      type: string
+                    message:
+                      description: message is a human readable message indicating
+                        details about the transition. This may be an empty string.
+                      maxLength: 32768
+                      type: string
+                    observedGeneration:
+                      description: observedGeneration represents the .metadata.generation
+                        that the condition was set based upon. For instance, if .metadata.generation
+                        is currently 12, but the .status.conditions[x].observedGeneration
+                        is 9, the condition is out of date with respect to the current
+                        state of the instance.
+                      format: int64
+                      minimum: 0
+                      type: integer
+                    reason:
+                      description: reason contains a programmatic identifier indicating
+                        the reason for the condition's last transition. Producers
+                        of specific condition types may define expected values and
+                        meanings for this field, and whether the values are considered
+                        a guaranteed API. The value should be a CamelCase string.
+                        This field may not be empty.
+                      maxLength: 1024
+                      minLength: 1
+                      pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
+                      type: string
+                    status:
+                      description: status of the condition, one of True, False, Unknown.
+                      enum:
+                      - "True"
+                      - "False"
+                      - Unknown
+                      type: string
+                    type:
+                      description: type of condition in CamelCase or in foo.example.com/CamelCase.
+                        --- Many .condition.type values are consistent across resources
+                        like Available, but because arbitrary conditions can be useful
+                        (see .node.status.conditions), the ability to deconflict is
+                        important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
+                      maxLength: 316
+                      pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$
+                      type: string
+                  required:
+                  - lastTransitionTime
+                  - message
+                  - reason
+                  - status
+                  - type
+                  type: object
+                type: array
             type: object
         type: object
     served: true