HPA Form View in RHOCP Web Console Incorrectly Requires Both CPU and Memory Metrics

Author: cajieh

frontend/packages/dev-console/src/components/hpa/HPADetailsForm.tsx

@@ -24,23 +24,35 @@ const HPADetailsForm: React.FC = () => {
     _event: React.FormEvent<HTMLInputElement>,
     value: string,
   ) => {
-    const numValue = parseInt(value, 10);
-
     const hpa: HorizontalPodAutoscalerKind = field.value;
     const { metric, index } = getMetricByType(hpa, type);
     const hpaMetrics = hpa.spec.metrics || [];
 
+    // If field is empty, set utilization to undefined (will be filtered at submit)
+    const numValue = value ? parseInt(value, 10) : undefined;
+
     const updatedMetrics = [...hpaMetrics];
-    updatedMetrics[index] = {
-      ...metric,
-      resource: {
-        ...metric.resource,
-        target: {
-          ...metric.resource.target,
-          averageUtilization: numValue,
-        },
-      },
-    };
+    updatedMetrics[index] = metric
+      ? {
+          ...metric,
+          resource: {
+            ...metric.resource,
+            target: {
+              ...metric.resource.target,
+              averageUtilization: numValue,
+            },
+          },
+        }
+      : {
+          type: 'Resource',
+          resource: {
+            name: type,
+            target: {
+              type: 'Utilization',
+              averageUtilization: numValue,
+            },
+          },
+        };
 
     setFieldValue(name, {
       ...hpa,

frontend/packages/dev-console/src/components/hpa/__tests__/hpa-utils.spec.ts

@@ -103,19 +103,16 @@ describe('getYAMLData gets back an hpa structured editor string', () => {
 });
 
 describe('getMetricByType returns an appropriate metric and the index it is at', () => {
-  it('expect no metrics to return a default metric as a new metric on the end', () => {
-    const { metric } = getMetricByType(hpaExamples.noMetrics, 'memory');
-    expect(metric).toBeTruthy();
-    expect(metric.resource.name).toBe('memory');
-    expect(metric.resource.target.averageUtilization).toBe(50);
+  it('expect no metrics to return null when metric does not exist', () => {
+    const { metric, index } = getMetricByType(hpaExamples.noMetrics, 'memory');
+    expect(metric).toBeNull();
+    expect(index).toBe(0); // index should be at the end of empty array
   });
 
-  it('expect to get back a default memory metric when only cpu metric is available', () => {
+  it('expect to get back null when only cpu metric is available and requesting memory', () => {
     const { metric, index } = getMetricByType(hpaExamples.cpuScaled, 'memory');
-    expect(metric).toBeTruthy();
-    expect(metric.resource.name).toBe('memory');
-    expect(metric.resource.target.averageUtilization).toBe(50);
-    expect(index).toBe(1);
+    expect(metric).toBeNull();
+    expect(index).toBe(1); // index should be at the end of the metrics array
   });
 
   it('expect to get back the cpu metric when it is available', () => {

frontend/packages/dev-console/src/components/hpa/hpa-utils.ts

@@ -55,7 +55,7 @@ const getDefaultMetric = (type: SupportedMetricTypes): HPAMetric => ({
   resource: {
     name: type,
     target: {
-      averageUtilization: 50,
+      averageUtilization: 80,
       type: 'Utilization',
     },
   },
@@ -73,7 +73,7 @@ export const getFormData = (
 ): HorizontalPodAutoscalerKind => {
   const hpa: HorizontalPodAutoscalerKind = existingHPA || safeYAMLToJS(defaultHPAYAML);
   if (!existingHPA) {
-    // If we are working off the default, zero out cpu metrics to make it easier to use non-cpu metrics with the default
+    // Initialize new HPAs with a default CPU value of 80%.
     hpa.spec.metrics = [getDefaultMetric('cpu')];
   }
 
@@ -95,10 +95,11 @@ export const getYAMLData = (
 export const getMetricByType = (
   hpa: HorizontalPodAutoscalerKind,
   type: SupportedMetricTypes,
-): { metric: HPAMetric; index: number } => {
+): { metric: HPAMetric | null; index: number } => {
   const hpaMetrics = hpa.spec.metrics || [];
   const metricIndex = hpaMetrics.findIndex((m) => m.resource?.name?.toLowerCase() === type);
-  const metric: HPAMetric = hpaMetrics[metricIndex] || getDefaultMetric(type);
+  // Don't create a default metric if it doesn't exist - allow single-metric HPAs
+  const metric: HPAMetric | null = metricIndex !== -1 ? hpaMetrics[metricIndex] : null;
 
   return { metric, index: metricIndex === -1 ? hpaMetrics.length : metricIndex };
 };
@@ -116,16 +117,32 @@ export const sanityForSubmit = (
   targetResource: K8sResourceKind,
   hpa: HorizontalPodAutoscalerKind,
 ): HorizontalPodAutoscalerKind => {
-  const validHPA = merge(
-    {},
-    hpa,
-    // Make sure it's against _this_ namespace
-    { metadata: { namespace: targetResource.metadata.namespace } },
-    // Make sure we kept the target we started with
-    { spec: { scaleTargetRef: createScaleTargetRef(targetResource) } },
-  );
-
-  return validHPA;
+  // Filter out CPU/Memory metrics where utilization is undefined/null (field was empty)
+  // Keep metrics with any set value (including 0, NaN) - let API validate them
+  const filteredMetrics = hpa.spec?.metrics?.filter((metric) => {
+    const metricName = metric?.resource?.name?.toLowerCase();
+    const isCpuOrMemory = metricName === 'cpu' || metricName === 'memory';
+
+    if (!isCpuOrMemory) {
+      return true; // Keep custom metrics
+    }
+
+    const utilization = metric?.resource?.target?.averageUtilization;
+    return utilization !== undefined && utilization !== null;
+  });
+
+  return {
+    ...hpa,
+    metadata: {
+      ...hpa.metadata,
+      namespace: targetResource.metadata.namespace,
+    },
+    spec: {
+      ...hpa.spec,
+      scaleTargetRef: createScaleTargetRef(targetResource),
+      metrics: filteredMetrics,
+    },
+  };
 };
 
 export const hasCustomMetrics = (hpa?: HorizontalPodAutoscalerKind): boolean => {

frontend/public/models/yaml-templates.ts

@@ -218,7 +218,7 @@ spec:
     resource:
       name: cpu
       target:
-        averageUtilization: 50
+        averageUtilization: 80
         type: Utilization
 `,
   )