Support Claw CR idling

Author: alexeykazakov

deploy/crds/README.adoc

@@ -10,4 +10,7 @@ Copy from a cluster with CNV operator installed
 Copy from a cluster with Ansible Automation Platform operator installed
 
 == serving CRDs
-Copy from a cluster with Serverless operator installed
+Copy from a cluster with Serverless operator installed
+
+== claws CRD
+Copy from the claw-operator repo (config/crd/bases/claw.sandbox.redhat.com_claws.yaml)

deploy/crds/claw.sandbox.redhat.com_claws.yaml

@@ -0,0 +1,40 @@
+kind: CustomResourceDefinition
+apiVersion: apiextensions.k8s.io/v1
+metadata:
+  name: claws.claw.sandbox.redhat.com
+spec:
+  group: claw.sandbox.redhat.com
+  names:
+    plural: claws
+    singular: claw
+    kind: Claw
+    listKind: ClawList
+  scope: Namespaced
+  versions:
+    - name: v1alpha1
+      served: true
+      storage: true
+      schema:
+        openAPIV3Schema:
+          description: Claw is the Schema for the claws API
+          type: object
+          properties:
+            apiVersion:
+              type: string
+            kind:
+              type: string
+            metadata:
+              type: object
+            spec:
+              description: Spec defines the desired state of Claw
+              type: object
+              properties:
+                idle:
+                  description: Scale down replicas to put Claw into an idle mode
+                  type: boolean
+            status:
+              description: Status defines the observed state of Claw
+              type: object
+              x-kubernetes-preserve-unknown-fields: true
+      subresources:
+        status: {}

test/e2e/parallel/user_workloads_test.go

@@ -101,6 +101,10 @@ func TestIdlerAndPriorityClass(t *testing.T) {
 	_, err = memberAwait.WaitForAAP(t, "test-idler-aap", idler.Name, clnt.Resource(aapRes), true)
 	require.NoError(t, err)
 
+	// Wait for the Claw resource to be idled (spec.idle: true)
+	_, err = memberAwait.WaitForClaw(t, "test-idler-claw", idler.Name, clnt.Resource(clawRes), true)
+	require.NoError(t, err)
+
 	// Wait for the InferenceService to be deleted - the expected action to idle
 	// the workload is by deleting the InferenceService that is old enough.
 	// The pods are idled as well, which is verified in the previous step - after some time,
@@ -181,6 +185,9 @@ func prepareWorkloads(t *testing.T, memberAwait *wait.MemberAwaitility, namespac
 	servingRuntimeDeployment := createKServeWorkloads(t, memberAwait, "test-idler-kserve", namespace)
 	n = n + int(*servingRuntimeDeployment.Spec.Replicas)
 
+	clawDeployment := createClaw(t, memberAwait, "test-idler-claw", namespace)
+	n = n + int(*clawDeployment.Spec.Replicas)
+
 	pods, err := memberAwait.WaitForPods(t, namespace, n, append(additionalPodCriteria, wait.PodRunning(),
 		wait.WithPodLabel("idler", "idler"))...)
 	require.NoError(t, err)
@@ -208,6 +215,7 @@ func createDeployment(t *testing.T, memberAwait *wait.MemberAwaitility, namespac
 }
 
 var aapRes = schema.GroupVersionResource{Group: "aap.ansible.com", Version: "v1alpha1", Resource: "ansibleautomationplatforms"}
+var clawRes = schema.GroupVersionResource{Group: "claw.sandbox.redhat.com", Version: "v1alpha1", Resource: "claws"}
 var servingRuntimeRes = schema.GroupVersionResource{Group: "serving.kserve.io", Version: "v1alpha1", Resource: "servingruntimes"}
 var inferenceServiceRes = schema.GroupVersionResource{Group: "serving.kserve.io", Version: "v1beta1", Resource: "inferenceservices"}
 var dataVolumeRes = schema.GroupVersionResource{Group: "cdi.kubevirt.io", Version: "v1beta1", Resource: "datavolumes"}
@@ -244,6 +252,51 @@ func createAAP(t *testing.T, memberAwait *wait.MemberAwaitility, name, namespace
 	return deployment
 }
 
+// createClaw creates an instance of claws.claw.sandbox.redhat.com with one deployment owned by this instance
+// returns the underlying deployment
+func createClaw(t *testing.T, memberAwait *wait.MemberAwaitility, name, namespace string) *appsv1.Deployment {
+	clnt, err := dynamic.NewForConfig(memberAwait.RestConfig)
+	require.NoError(t, err)
+
+	claw := clawResource(name)
+	createdClaw, err := clnt.Resource(clawRes).Namespace(namespace).Create(context.TODO(), claw, metav1.CreateOptions{})
+	require.NoError(t, err)
+
+	replicas := int32(2)
+	deployment := &appsv1.Deployment{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+		Spec: appsv1.DeploymentSpec{
+			Selector: &metav1.LabelSelector{MatchLabels: selectorLabels(name)},
+			Replicas: &replicas,
+			Template: podTemplateSpec(name),
+		},
+	}
+	err = controllerutil.SetOwnerReference(createdClaw, deployment, scheme.Scheme)
+	require.NoError(t, err)
+	err = memberAwait.Create(t, deployment)
+	require.NoError(t, err)
+
+	return deployment
+}
+
+func clawResource(name string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": "claw.sandbox.redhat.com/v1alpha1",
+			"kind":       "Claw",
+			"metadata": map[string]interface{}{
+				"name": name,
+			},
+			"spec": map[string]interface{}{
+				"idle": false,
+			},
+		},
+	}
+}
+
 func createReplicaSet(t *testing.T, memberAwait *wait.MemberAwaitility, namespace string) *appsv1.ReplicaSet {
 	// Standalone ReplicaSet
 	replicas := int32(2)

testsupport/wait/member.go

@@ -1541,6 +1541,28 @@ func (a *MemberAwaitility) WaitForAAP(t *testing.T, name, namespace string, aapR
 	return aap, err
 }
 
+// WaitForClaw waits for the Claw resource to reach the expected idle state (spec.idle)
+func (a *MemberAwaitility) WaitForClaw(t *testing.T, name, namespace string, clawRes dynamic.NamespaceableResourceInterface, expectedIdled bool) (*unstructured.Unstructured, error) {
+	t.Logf("waiting for Claw '%s' in namespace '%s'", name, namespace)
+	var claw *unstructured.Unstructured
+	err := wait.PollUntilContextTimeout(context.TODO(), a.RetryInterval, a.Timeout, true, func(ctx context.Context) (bool, error) {
+		var err error
+		claw, err = clawRes.Namespace(namespace).Get(context.Background(), name, metav1.GetOptions{})
+		if err != nil {
+			if errors.IsNotFound(err) {
+				return false, nil
+			}
+			return false, err
+		}
+		idled, _, err := unstructured.NestedBool(claw.UnstructuredContent(), "spec", "idle")
+		if err != nil {
+			return true, err
+		}
+		return expectedIdled == idled, nil
+	})
+	return claw, err
+}
+
 // WaitUntilInferenceServiceDeleted waits for the InferenceService resource to be deleted (idled)
 func (a *MemberAwaitility) WaitUntilInferenceServiceDeleted(t *testing.T, name, namespace string, inferenceServiceRes dynamic.NamespaceableResourceInterface) error {
 	t.Logf("waiting for InferenceService '%s' to be deleted in namespace '%s'", name, namespace)