Add status fields to FrontProxy

On-behalf-of: SAP <[email protected]>
Signed-off-by: Marvin Beckers <[email protected]>

Author: embik

config/crd/bases/operator.kcp.io_frontproxies.yaml

@@ -14,7 +14,17 @@ spec:
     singular: frontproxy
   scope: Namespaced
   versions:
-  - name: v1alpha1
+  - additionalPrinterColumns:
+    - jsonPath: .spec.rootShard.ref.name
+      name: RootShard
+      type: string
+    - jsonPath: .status.phase
+      name: Phase
+      type: string
+    - jsonPath: .metadata.creationTimestamp
+      name: Age
+      type: date
+    name: v1alpha1
     schema:
       openAPIV3Schema:
         description: FrontProxy is the Schema for the frontproxies API
@@ -187,6 +197,68 @@ spec:
             type: object
           status:
             description: FrontProxyStatus defines the observed state of FrontProxy
+            properties:
+              conditions:
+                items:
+                  description: Condition contains details for one aspect of the current
+                    state of this API Resource.
+                  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.
+                      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
+                x-kubernetes-list-map-keys:
+                - type
+                x-kubernetes-list-type: map
+              phase:
+                type: string
             type: object
         type: object
     served: true

internal/controller/frontproxy_controller.go

@@ -24,14 +24,19 @@ import (
 
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/equality"
+	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
+	kerrors "k8s.io/apimachinery/pkg/util/errors"
+	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 
 	"github.com/kcp-dev/kcp-operator/internal/reconciling"
+	"github.com/kcp-dev/kcp-operator/internal/resources"
 	"github.com/kcp-dev/kcp-operator/internal/resources/frontproxy"
 	operatorv1alpha1 "github.com/kcp-dev/kcp-operator/sdk/apis/operator/v1alpha1"
 )
@@ -59,70 +64,170 @@ func (r *FrontProxyReconciler) SetupWithManager(mgr ctrl.Manager) error {
 // +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete
 // +kubebuilder:rbac:groups=core,resources=services;configmaps;secrets,verbs=get;list;watch;create;update;patch;delete
 
-func (r *FrontProxyReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
+func (r *FrontProxyReconciler) Reconcile(ctx context.Context, req ctrl.Request) (res ctrl.Result, recErr error) {
 	logger := log.FromContext(ctx)
-
 	logger.Info("Reconciling FrontProxy object")
+
 	var frontProxy operatorv1alpha1.FrontProxy
 	if err := r.Client.Get(ctx, req.NamespacedName, &frontProxy); err != nil {
-		return ctrl.Result{}, fmt.Errorf("failed to find %s/%s: %w", req.Namespace, req.Name, err)
+		if client.IgnoreNotFound(err) != nil {
+			return ctrl.Result{}, fmt.Errorf("failed to find %s/%s: %w", req.Namespace, req.Name, err)
+		}
+
+		// Object has apparently been deleted already.
+		return ctrl.Result{}, nil
 	}
 
-	ownerRefWrapper := k8creconciling.OwnerRefWrapper(*metav1.NewControllerRef(&frontProxy, operatorv1alpha1.SchemeGroupVersion.WithKind("FrontProxy")))
+	defer func() {
+		if err := r.reconcileStatus(ctx, &frontProxy); err != nil {
+			recErr = kerrors.NewAggregate([]error{recErr, err})
+		}
+	}()
+
+	return ctrl.Result{}, r.reconcile(ctx, &frontProxy)
+}
+
+func (r *FrontProxyReconciler) reconcile(ctx context.Context, frontProxy *operatorv1alpha1.FrontProxy) error {
+	var errs []error
+
+	ownerRefWrapper := k8creconciling.OwnerRefWrapper(*metav1.NewControllerRef(frontProxy, operatorv1alpha1.SchemeGroupVersion.WithKind("FrontProxy")))
 
 	ref := frontProxy.Spec.RootShard.Reference
 	rootShard := &operatorv1alpha1.RootShard{}
 	switch {
 	case ref != nil:
-		if err := r.Client.Get(ctx, types.NamespacedName{Name: ref.Name, Namespace: req.Namespace}, rootShard); err != nil {
-			return ctrl.Result{}, fmt.Errorf("referenced RootShard '%s' could not be fetched", ref.Name)
+		if err := r.Client.Get(ctx, types.NamespacedName{Name: ref.Name, Namespace: frontProxy.Namespace}, rootShard); err != nil {
+			return fmt.Errorf("referenced RootShard '%s' could not be fetched", ref.Name)
 		}
 	default:
-		return ctrl.Result{}, fmt.Errorf("no valid RootShard in FrontProxy spec defined")
+		return fmt.Errorf("no valid RootShard in FrontProxy spec defined")
 	}
 
 	configMapReconcilers := []k8creconciling.NamedConfigMapReconcilerFactory{
-		frontproxy.ConfigmapReconciler(&frontProxy, rootShard),
+		frontproxy.ConfigmapReconciler(frontProxy, rootShard),
 	}
 
 	secretReconcilers := []k8creconciling.NamedSecretReconcilerFactory{
-		frontproxy.DynamicKubeconfigSecretReconciler(&frontProxy, rootShard),
+		frontproxy.DynamicKubeconfigSecretReconciler(frontProxy, rootShard),
 	}
 
 	certReconcilers := []reconciling.NamedCertificateReconcilerFactory{
-		frontproxy.ServerCertificateReconciler(&frontProxy, rootShard),
-		frontproxy.KubeconfigReconciler(&frontProxy, rootShard),
-		frontproxy.AdminKubeconfigReconciler(&frontProxy, rootShard),
-		frontproxy.RequestHeaderReconciler(&frontProxy, rootShard),
+		frontproxy.ServerCertificateReconciler(frontProxy, rootShard),
+		frontproxy.KubeconfigReconciler(frontProxy, rootShard),
+		frontproxy.AdminKubeconfigReconciler(frontProxy, rootShard),
+		frontproxy.RequestHeaderReconciler(frontProxy, rootShard),
 	}
 
 	deploymentReconcilers := []k8creconciling.NamedDeploymentReconcilerFactory{
-		frontproxy.DeploymentReconciler(&frontProxy, rootShard),
+		frontproxy.DeploymentReconciler(frontProxy, rootShard),
 	}
 
 	serviceReconcilers := []k8creconciling.NamedServiceReconcilerFactory{
-		frontproxy.ServiceReconciler(&frontProxy),
+		frontproxy.ServiceReconciler(frontProxy),
+	}
+
+	if err := k8creconciling.ReconcileConfigMaps(ctx, configMapReconcilers, frontProxy.Namespace, r.Client, ownerRefWrapper); err != nil {
+		errs = append(errs, err)
+	}
+
+	if err := k8creconciling.ReconcileSecrets(ctx, secretReconcilers, frontProxy.Namespace, r.Client, ownerRefWrapper); err != nil {
+		errs = append(errs, err)
+	}
+
+	if err := reconciling.ReconcileCertificates(ctx, certReconcilers, frontProxy.Namespace, r.Client, ownerRefWrapper); err != nil {
+		errs = append(errs, err)
+	}
+
+	if err := k8creconciling.ReconcileDeployments(ctx, deploymentReconcilers, frontProxy.Namespace, r.Client, ownerRefWrapper); err != nil {
+		errs = append(errs, err)
+	}
+
+	if err := k8creconciling.ReconcileServices(ctx, serviceReconcilers, frontProxy.Namespace, r.Client, ownerRefWrapper); err != nil {
+		errs = append(errs, err)
 	}
 
-	if err := k8creconciling.ReconcileConfigMaps(ctx, configMapReconcilers, req.Namespace, r.Client, ownerRefWrapper); err != nil {
-		return ctrl.Result{}, err
+	return kerrors.NewAggregate(errs)
+}
+
+func (r *FrontProxyReconciler) reconcileStatus(ctx context.Context, oldFrontProxy *operatorv1alpha1.FrontProxy) error {
+	frontProxy := oldFrontProxy.DeepCopy()
+	var errs []error
+
+	if frontProxy.Status.Phase == "" {
+		frontProxy.Status.Phase = operatorv1alpha1.FrontProxyPhaseProvisioning
+	}
+
+	if frontProxy.DeletionTimestamp != nil {
+		frontProxy.Status.Phase = operatorv1alpha1.FrontProxyPhaseDeleting
 	}
 
-	if err := k8creconciling.ReconcileSecrets(ctx, secretReconcilers, req.Namespace, r.Client, ownerRefWrapper); err != nil {
-		return ctrl.Result{}, err
+	if err := r.setAvailableCondition(ctx, frontProxy); err != nil {
+		errs = append(errs, err)
 	}
 
-	if err := reconciling.ReconcileCertificates(ctx, certReconcilers, req.Namespace, r.Client, ownerRefWrapper); err != nil {
-		return ctrl.Result{}, err
+	if cond := apimeta.FindStatusCondition(frontProxy.Status.Conditions, string(operatorv1alpha1.RootShardConditionTypeAvailable)); cond.Status == metav1.ConditionTrue {
+		frontProxy.Status.Phase = operatorv1alpha1.FrontProxyPhaseRunning
 	}
 
-	if err := k8creconciling.ReconcileDeployments(ctx, deploymentReconcilers, req.Namespace, r.Client, ownerRefWrapper); err != nil {
-		return ctrl.Result{}, err
+	// only patch the status if there are actual changes.
+	if !equality.Semantic.DeepEqual(oldFrontProxy.Status, frontProxy.Status) {
+		if err := r.Client.Status().Patch(ctx, frontProxy, client.MergeFrom(oldFrontProxy)); err != nil {
+			errs = append(errs, err)
+		}
 	}
 
-	if err := k8creconciling.ReconcileServices(ctx, serviceReconcilers, req.Namespace, r.Client, ownerRefWrapper); err != nil {
-		return ctrl.Result{}, err
+	return kerrors.NewAggregate(errs)
+}
+
+func (r *FrontProxyReconciler) setAvailableCondition(ctx context.Context, frontProxy *operatorv1alpha1.FrontProxy) error {
+
+	var dep appsv1.Deployment
+	depKey := types.NamespacedName{Namespace: frontProxy.Namespace, Name: resources.GetFrontProxyDeploymentName(frontProxy)}
+	if err := r.Client.Get(ctx, depKey, &dep); client.IgnoreNotFound(err) != nil {
+		return err
+	}
+
+	available := metav1.ConditionFalse
+	reason := operatorv1alpha1.FrontProxyConditionReasonDeploymentUnavailable
+	msg := fmt.Sprintf("Deployment %s", depKey)
+
+	if dep.Name != "" {
+		if dep.Status.UpdatedReplicas == dep.Status.ReadyReplicas && dep.Status.ReadyReplicas == ptr.Deref(dep.Spec.Replicas, 0) {
+			available = metav1.ConditionTrue
+			reason = operatorv1alpha1.FrontProxyConditionReasonReplicasUp
+			msg += " is fully up and running"
+		} else {
+			available = metav1.ConditionFalse
+			reason = operatorv1alpha1.FrontProxyConditionReasonReplicasUnavailable
+			msg += " is not in desired replica state"
+		}
+	} else {
+		msg += " does not exist"
+	}
+
+	if frontProxy.Status.Conditions == nil {
+		frontProxy.Status.Conditions = make([]metav1.Condition, 0)
+	}
+
+	cond := apimeta.FindStatusCondition(frontProxy.Status.Conditions, string(operatorv1alpha1.FrontProxyConditionTypeAvailable))
+
+	if cond == nil || cond.ObservedGeneration != frontProxy.Generation || cond.Status != available {
+		transitionTime := metav1.Now()
+		if cond != nil && cond.Status == available {
+			// We only need to set LastTransitionTime if we are actually toggling the status
+			// or if no transition time was set.
+			transitionTime = cond.LastTransitionTime
+		}
+
+		apimeta.SetStatusCondition(&frontProxy.Status.Conditions, metav1.Condition{
+			Type:               string(operatorv1alpha1.FrontProxyConditionTypeAvailable),
+			Status:             available,
+			ObservedGeneration: frontProxy.Generation,
+			LastTransitionTime: transitionTime,
+			Reason:             string(reason),
+			Message:            msg,
+		})
 	}
 
-	return ctrl.Result{}, nil
+	return nil
 }

sdk/apis/operator/v1alpha1/frontproxy_types.go

@@ -51,13 +51,41 @@ type ServiceSpec struct {
 
 // FrontProxyStatus defines the observed state of FrontProxy
 type FrontProxyStatus struct {
-	// INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
-	// Important: Run "make" to regenerate code after modifying this file
+	Phase FrontProxyPhase `json:"phase,omitempty"`
+
+	// +listType=map
+	// +listMapKey=type
+	Conditions []metav1.Condition `json:"conditions,omitempty"`
 }
 
+type FrontProxyPhase string
+
+const (
+	FrontProxyPhaseProvisioning FrontProxyPhase = "Provisioning"
+	FrontProxyPhaseRunning      FrontProxyPhase = "Running"
+	FrontProxyPhaseDeleting     FrontProxyPhase = "Deleting"
+)
+
+type FrontProxyConditionType string
+
+const (
+	FrontProxyConditionTypeAvailable FrontProxyConditionType = "Available"
+)
+
+type FrontProxyConditionReason string
+
+const (
+	FrontProxyConditionReasonDeploymentUnavailable FrontProxyConditionReason = "DeploymentUnavailable"
+	FrontProxyConditionReasonReplicasUp            FrontProxyConditionReason = "ReplicasUp"
+	FrontProxyConditionReasonReplicasUnavailable   FrontProxyConditionReason = "ReplicasUnavailable"
+)
+
 // +genclient
 // +kubebuilder:object:root=true
 // +kubebuilder:subresource:status
+// +kubebuilder:printcolumn:JSONPath=".spec.rootShard.ref.name",name="RootShard",type="string"
+// +kubebuilder:printcolumn:JSONPath=".status.phase",name="Phase",type="string"
+// +kubebuilder:printcolumn:JSONPath=".metadata.creationTimestamp",name="Age",type="date"
 
 // FrontProxy is the Schema for the frontproxies API
 type FrontProxy struct {