fix for issue # 119

Author: barney-s

api/v1alpha1/sandbox_types.go

@@ -119,8 +119,46 @@ type SandboxSpec struct {
 	Replicas *int32 `json:"replicas,omitempty"`
 }
 
+
+// SandboxPhase is a label for the condition of a sandbox at the current time.
+type SandboxPhase string
+
+// These are the valid phases of a sandbox.
+const (
+	// SandboxPending means the sandbox has been accepted by the system, but one or more of the components
+	// has not been created. This includes time before pods have been scheduled as well as time spent
+	// pulling images over the network, which can take a while.
+	SandboxPending SandboxPhase = "Pending"
+	// SandboxRunning means the sandbox has been bound to a node and all of the containers have been started.
+	// At least one container is still running or is in the process of being restarted.
+	SandboxRunning SandboxPhase = "Running"
+	// SandboxPaused means the sandbox has been paused.
+	SandboxPaused SandboxPhase = "Paused"
+	// SandboxTerminating means the sandbox is terminating.
+	SandboxTerminating SandboxPhase = "Terminating"
+	// SandboxFailed means the sandbox has terminated with an error.
+	SandboxFailed SandboxPhase = "Failed"
+)
+
 // SandboxStatus defines the observed state of Sandbox.
 type SandboxStatus struct {
+	// The phase of a Sandbox is a simple, high-level summary of where the Sandbox is in its lifecycle.
+	// The conditions array, the reason and message fields, and the individual container status arrays contain
+	// more detail about the pod's status.
+	// There are five possible phase values:
+	//
+	// Pending: The Sandbox has been accepted by the Kubernetes system, but one or more of the components
+	// has not been created. This includes time before pods have been scheduled as well as time spent pulling
+	// images over the network, which can take a while.
+	// Running: The Sandbox has been bound to a node, and all of the Pods have been created. At least
+	// one Pod is still running, or is in the process of being restarted.
+	// Paused: The Sandbox has been paused.
+	// Terminating: The Sandbox is terminating.
+	// Failed: The Sandbox has terminated with an error.
+	//
+	// +optional
+	Phase SandboxPhase `json:"phase,omitempty"`
+
 	// FQDN that is valid for default cluster settings
 	// Limitation: Hardcoded to the domain .cluster.local
 	// e.g. sandbox-example.default.svc.cluster.local
@@ -140,6 +178,7 @@ type SandboxStatus struct {
 	LabelSelector string `json:"selector,omitempty"`
 }
 
+
 // +kubebuilder:object:root=true
 // +kubebuilder:subresource:status
 // +kubebuilder:subresource:scale:specpath=.spec.replicas,statuspath=.status.replicas,selectorpath=.status.selector

controllers/sandbox_controller.go

@@ -141,11 +141,13 @@ func (r *SandboxReconciler) reconcileChildResources(ctx context.Context, sandbox
 		sandbox.Status.Replicas = 1
 		sandbox.Status.LabelSelector = fmt.Sprintf("%s=%s", sandboxLabel, NameHash(sandbox.Name))
 	}
+	sandbox.Status.Phase = r.calculatePhase(sandbox, pod)
 
 	// Reconcile Service
 	svc, err := r.reconcileService(ctx, sandbox, nameHash)
 	allErrors = errors.Join(allErrors, err)
 
+
 	// compute and set overall Ready condition
 	readyCondition := r.computeReadyCondition(sandbox, allErrors, svc, pod)
 	meta.SetStatusCondition(&sandbox.Status.Conditions, readyCondition)
@@ -213,6 +215,29 @@ func (r *SandboxReconciler) computeReadyCondition(sandbox *sandboxv1alpha1.Sandb
 	return readyCondition
 }
 
+func (r *SandboxReconciler) calculatePhase(sandbox *sandboxv1alpha1.Sandbox, pod *corev1.Pod) sandboxv1alpha1.SandboxPhase {
+	if sandbox.Spec.Replicas != nil && *sandbox.Spec.Replicas == 0 {
+		return sandboxv1alpha1.SandboxPaused
+	}
+
+	if pod == nil {
+		return sandboxv1alpha1.SandboxPending
+	}
+
+	switch pod.Status.Phase {
+	case corev1.PodRunning:
+		return sandboxv1alpha1.SandboxRunning
+	case corev1.PodPending:
+		return sandboxv1alpha1.SandboxPending
+	case corev1.PodFailed:
+		return sandboxv1alpha1.SandboxFailed
+	case corev1.PodSucceeded:
+		return sandboxv1alpha1.SandboxTerminating
+	}
+	return sandboxv1alpha1.SandboxPending
+}
+
+
 func (r *SandboxReconciler) updateStatus(ctx context.Context, oldStatus *sandboxv1alpha1.SandboxStatus, sandbox *sandboxv1alpha1.Sandbox) error {
 	log := log.FromContext(ctx)
 
@@ -431,6 +456,7 @@ func (r *SandboxReconciler) handleSandboxExpiry(ctx context.Context, sandbox *sa
 		Message:            "Sandbox has expired",
 	})
 
+	sandbox.Status.Phase = sandboxv1alpha1.SandboxTerminating
 	sandbox.Status.Replicas = 0
 	sandbox.Status.LabelSelector = ""
 

controllers/sandbox_controller_test.go

@@ -227,6 +227,7 @@ func TestReconcile(t *testing.T) {
 			},
 			// Verify Sandbox status
 			wantStatus: sandboxv1alpha1.SandboxStatus{
+				Phase:         sandboxv1alpha1.SandboxPending,
 				Service:       sandboxName,
 				ServiceFQDN:   "sandbox-name.sandbox-ns.svc.cluster.local",
 				Replicas:      1,
@@ -320,6 +321,7 @@ func TestReconcile(t *testing.T) {
 			},
 			// Verify Sandbox status
 			wantStatus: sandboxv1alpha1.SandboxStatus{
+				Phase:         sandboxv1alpha1.SandboxPending,
 				Service:       sandboxName,
 				ServiceFQDN:   "sandbox-name.sandbox-ns.svc.cluster.local",
 				Replicas:      1,
@@ -406,6 +408,91 @@ func TestReconcile(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "sandbox spec with 0 replicas",
+			// Input sandbox spec
+			sandboxSpec: sandboxv1alpha1.SandboxSpec{
+				Replicas: ptr.To(int32(0)),
+				PodTemplate: sandboxv1alpha1.PodTemplate{
+					Spec: corev1.PodSpec{
+						Containers: []corev1.Container{
+							{
+								Name: "test-container",
+							},
+						},
+					},
+				},
+			},
+			// Verify Sandbox status
+			wantStatus: sandboxv1alpha1.SandboxStatus{
+				Phase:         sandboxv1alpha1.SandboxPaused,
+				Service:       sandboxName,
+				ServiceFQDN:   "sandbox-name.sandbox-ns.svc.cluster.local",
+				Replicas:      0,
+				LabelSelector: "",
+				Conditions: []metav1.Condition{
+					{
+						Type:               "Ready",
+						Status:             "True",
+						ObservedGeneration: 1,
+						Reason:             "DependenciesReady",
+						Message:            "Pod does not exist, replicas is 0; Service Exists",
+					},
+				},
+			},
+			wantObjs: []client.Object{
+				// Verify Service
+				&corev1.Service{
+					ObjectMeta: metav1.ObjectMeta{
+						Name:            sandboxName,
+						Namespace:       sandboxNs,
+						ResourceVersion: "1",
+						Labels: map[string]string{
+							"agents.x-k8s.io/sandbox-name-hash": "ab179450",
+						},
+						OwnerReferences: []metav1.OwnerReference{sandboxControllerRef(sandboxName)},
+					},
+					Spec: corev1.ServiceSpec{
+						Selector: map[string]string{
+							"agents.x-k8s.io/sandbox-name-hash": "ab179450",
+						},
+						ClusterIP: "None",
+					},
+				},
+			},
+		},
+		{
+			name: "expired sandbox",
+			// Input sandbox spec
+			sandboxSpec: sandboxv1alpha1.SandboxSpec{
+				ShutdownTime: ptr.To(metav1.NewTime(time.Now().Add(-10 * time.Second))),
+				PodTemplate: sandboxv1alpha1.PodTemplate{
+					Spec: corev1.PodSpec{
+						Containers: []corev1.Container{
+							{
+								Name: "test-container",
+							},
+						},
+					},
+				},
+			},
+			// Verify Sandbox status
+			wantStatus: sandboxv1alpha1.SandboxStatus{
+				Phase:         sandboxv1alpha1.SandboxTerminating,
+				Replicas:      0,
+				LabelSelector: "",
+				Conditions: []metav1.Condition{
+					{
+						Type:               "Ready",
+						Status:             "False",
+						ObservedGeneration: 1,
+						Reason:             "SandboxExpired",
+						Message:            "Sandbox has expired",
+					},
+				},
+			},
+			wantObjs: []client.Object{},
+		},
 	}
 
 	for _, tc := range testCases {