Refine default conditions and printer columns for instances,

initial work on bringing network subnet claim orchestration
up to this operator.

Author: joshlreese

api/v1alpha/instance_types.go

@@ -385,6 +385,11 @@ const (
 	InstanceReady = "Ready"
 )
 
+const (
+	// InstanceReadyReasonSchedulingGatesPresent indicates that the instance is not ready because scheduling gates are present.
+	InstanceReadyReasonSchedulingGatesPresent = "SchedulingGatesPresent"
+)
+
 type InstanceTemplateSpec struct {
 	// Metadata of the instances created from this template
 	//
@@ -401,8 +406,8 @@ type InstanceTemplateSpec struct {
 
 // Instance is the Schema for the instances API
 // +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp"
-// +kubebuilder:printcolumn:name="Available",type=string,JSONPath=`.status.conditions[?(@.type=="Available")].status`
-// +kubebuilder:printcolumn:name="Reason",type=string,JSONPath=`.status.conditions[?(@.type=="Available")].reason`
+// +kubebuilder:printcolumn:name="Ready",type=string,JSONPath=`.status.conditions[?(@.type=="Ready")].status`
+// +kubebuilder:printcolumn:name="Reason",type=string,JSONPath=`.status.conditions[?(@.type=="Ready")].reason`
 // +kubebuilder:printcolumn:name="Network IP",type=string,JSONPath=`.status.networkInterfaces[0].assignments.networkIP`,priority=1
 // +kubebuilder:printcolumn:name="External IP",type=string,JSONPath=`.status.networkInterfaces[0].assignments.externalIP`,priority=1
 type Instance struct {
@@ -414,7 +419,7 @@ type Instance struct {
 
 	// Status defines the current state of an Instance.
 	//
-	// +kubebuilder:default={conditions:{{type:"Ready",status:"Unknown",reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}}
+	// +kubebuilder:default={conditions:{{type:"Running",status:"Unknown",reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"},{type:"Ready",status:"Unknown",reason:"Pending", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}}
 	Status InstanceStatus `json:"status,omitempty"`
 }
 

config/crd/bases/compute.datumapis.com_instances.yaml

@@ -18,10 +18,10 @@ spec:
     - jsonPath: .metadata.creationTimestamp
       name: Age
       type: date
-    - jsonPath: .status.conditions[?(@.type=="Available")].status
-      name: Available
+    - jsonPath: .status.conditions[?(@.type=="Ready")].status
+      name: Ready
       type: string
-    - jsonPath: .status.conditions[?(@.type=="Available")].reason
+    - jsonPath: .status.conditions[?(@.type=="Ready")].reason
       name: Reason
       type: string
     - jsonPath: .status.networkInterfaces[0].assignments.networkIP
@@ -811,6 +811,11 @@ spec:
           status:
             default:
               conditions:
+              - lastTransitionTime: "1970-01-01T00:00:00Z"
+                message: Waiting for controller
+                reason: Pending
+                status: Unknown
+                type: Running
               - lastTransitionTime: "1970-01-01T00:00:00Z"
                 message: Waiting for controller
                 reason: Pending

internal/controller/instance_controller.go

@@ -5,12 +5,12 @@ package controller
 import (
 	"context"
 	"fmt"
+	"strings"
 
-	"k8s.io/apimachinery/pkg/api/equality"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 	mcbuilder "sigs.k8s.io/multicluster-runtime/pkg/builder"
 	mccontext "sigs.k8s.io/multicluster-runtime/pkg/context"
@@ -53,42 +53,28 @@ func (r *InstanceReconciler) Reconcile(ctx context.Context, req mcreconcile.Requ
 	logger.Info("reconciling instance")
 	defer logger.Info("reconcile complete")
 
-	// Ensure the instance has labels necessary for being able to identify
-	// instances associated with a specific workload or workload deployment via
-	// label selectors.
-	//
-	// This logic will not be necessary once we complete the work defined in
-	// https://github.com/datum-cloud/enhancements/issues/28
+	if len(instance.Spec.Controller.SchedulingGates) > 0 {
+		// Update Ready condition to False, Reason to "SchedulingGatesPresent"
+		// and Message to "Scheduling gates present"
 
-	workloadDeploymentRef := metav1.GetControllerOf(&instance)
-	if workloadDeploymentRef == nil {
-		return ctrl.Result{}, fmt.Errorf("failed to get controller owner of Instance")
-	}
-
-	var workloadDeployment computev1alpha.WorkloadDeployment
-	workloadDeploymentObjectKey := client.ObjectKey{
-		Namespace: instance.Namespace,
-		Name:      workloadDeploymentRef.Name,
-	}
-	if err := cl.GetClient().Get(ctx, workloadDeploymentObjectKey, &workloadDeployment); err != nil {
-		return ctrl.Result{}, err
-	}
-
-	workloadRef := metav1.GetControllerOf(&workloadDeployment)
-	if workloadRef == nil {
-		return ctrl.Result{}, fmt.Errorf("failed to get controller owner of WorkloadDeployment")
-	}
-
-	updated := instance.DeepCopy()
-	if updated.Labels == nil {
-		updated.Labels = map[string]string{}
-	}
-	updated.Labels[computev1alpha.WorkloadUIDLabel] = string(workloadRef.UID)
-	updated.Labels[computev1alpha.WorkloadDeploymentUIDLabel] = string(workloadDeploymentRef.UID)
+		// Collect a list of scheduling gate names
+		var schedulingGateNames []string
+		for _, gate := range instance.Spec.Controller.SchedulingGates {
+			schedulingGateNames = append(schedulingGateNames, gate.Name)
+		}
 
-	if !equality.Semantic.DeepEqual(updated, instance) {
-		if err := cl.GetClient().Update(ctx, updated); err != nil {
-			return ctrl.Result{}, fmt.Errorf("failed updating instance: %w", err)
+		changed := apimeta.SetStatusCondition(&instance.Status.Conditions, metav1.Condition{
+			Type:               computev1alpha.InstanceReady,
+			Status:             metav1.ConditionFalse,
+			Reason:             computev1alpha.InstanceReadyReasonSchedulingGatesPresent,
+			Message:            fmt.Sprintf("Scheduling gates present: %s", strings.Join(schedulingGateNames, ", ")),
+			ObservedGeneration: instance.Generation,
+		})
+
+		if changed {
+			if err := cl.GetClient().Status().Update(ctx, &instance); err != nil {
+				return ctrl.Result{}, fmt.Errorf("failed updating instance status: %w", err)
+			}
 		}
 	}
 

internal/controller/result.go

@@ -0,0 +1,79 @@
+package controller
+
+import (
+	"context"
+	"errors"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+type Result struct {
+	// Result contains the result of a Reconciler invocation.
+	ctrl.Result
+
+	// Err contains an error of a Reconciler invocation
+	Err error
+
+	// StopProcessing indicates that the caller should not continue processing and
+	// let the Reconciler go to sleep without an explicit requeue, expecting a
+	// Watch to trigger a future reconciliation call.
+	StopProcessing bool
+
+	syncStatus map[client.Object]client.Client
+}
+
+func (r *Result) Merge(other Result) Result {
+	if other.Err != nil {
+		r.Err = errors.Join(r.Err, other.Err)
+	}
+	if other.Result != (ctrl.Result{}) {
+		r.Result = other.Result
+	}
+	if other.StopProcessing {
+		r.StopProcessing = true
+	}
+	if other.syncStatus != nil {
+		if r.syncStatus == nil {
+			r.syncStatus = make(map[client.Object]client.Client)
+		}
+		for k, v := range other.syncStatus {
+			r.syncStatus[k] = v
+		}
+	}
+
+	return *r
+}
+
+func (r *Result) AddStatusUpdate(c client.Client, obj client.Object) {
+	if r.syncStatus == nil {
+		r.syncStatus = make(map[client.Object]client.Client)
+	}
+	r.syncStatus[obj] = c
+}
+
+func (r Result) ShouldReturn() bool {
+	return r.Err != nil || !r.Result.IsZero() || r.StopProcessing
+}
+
+func (r Result) Complete(ctx context.Context) (ctrl.Result, error) {
+	if r.syncStatus != nil {
+		var errs []error
+		for obj, client := range r.syncStatus {
+			if err := client.Status().Update(ctx, obj); err != nil {
+				if r.Err == nil && apierrors.IsConflict(err) {
+					r.Requeue = true
+				} else {
+					errs = append(errs, err)
+				}
+			}
+		}
+
+		if len(errs) > 0 {
+			r.Err = errors.Join(append([]error{r.Err}, errs...)...)
+		}
+	}
+
+	return r.Result, r.Err
+}