@spinnaker/google 2026.2.2 → 2026.3.0

package/src/serverGroup/details/autoscalingPolicy/modal/GceUpsertAutoscalingPolicyModal.tsx

@@ -0,0 +1,196 @@
+import { cloneDeep } from 'lodash';
+import React from 'react';
+
+import type { Application, IModalComponentProps } from '@spinnaker/core';
+import { ModalClose, ReactModal, SubmitButton, TaskMonitor, TaskMonitorWrapper } from '@spinnaker/core';
+
+import type { IGceAutoscalingPolicy, IGcePolicyServerGroup } from '../../../../autoscalingPolicy';
+import {
+  GceAutoscalingPolicyEditor,
+  GceAutoscalingPolicyWriter,
+  GcePredictiveMethod,
+} from '../../../../autoscalingPolicy';
+import { GCEProviderSettings } from '../../../../gce.settings';
+
+const MAX_INT = 2147483647;
+const MAX_SCHEDULE_DURATION_SECONDS = 14 * 24 * 60 * 60;
+
+function isIntegerInRange(value: unknown, minimum: number, maximum = MAX_INT): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isFinite(value) &&
+    Number.isInteger(value) &&
+    value >= minimum &&
+    value <= maximum
+  );
+}
+
+function isUtilizationTarget(value: unknown, maximum?: number): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 && (maximum === undefined || value < maximum);
+}
+
+function isSingleInstanceAssignment(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+
+function isValidCustomMetric(metric: NonNullable<IGceAutoscalingPolicy['customMetricUtilizations']>[number]): boolean {
+  if (!metric.metric?.trim() || !metric.metricExportScope) {
+    return false;
+  }
+  if (
+    metric.metricExportScope === 'SINGLE_TIME_SERIES_PER_GROUP' &&
+    metric.scalingpolicy === 'SINGLE_INSTANCE_ASSIGNMENT'
+  ) {
+    return isSingleInstanceAssignment(metric.singleInstanceAssignment);
+  }
+  if (metric.metricExportScope === 'SINGLE_TIME_SERIES_PER_GROUP' && metric.scalingpolicy !== 'UTILIZATION_TARGET') {
+    return false;
+  }
+  return isUtilizationTarget(metric.utilizationTarget) && Boolean(metric.utilizationTargetType);
+}
+
+function hasValidMetrics(policy: IGceAutoscalingPolicy): boolean {
+  const cpuConfigured = Boolean(policy.cpuUtilization && Object.keys(policy.cpuUtilization).length);
+  const loadBalancingConfigured = Boolean(
+    policy.loadBalancingUtilization && Object.keys(policy.loadBalancingUtilization).length,
+  );
+  const customMetrics = policy.customMetricUtilizations || [];
+  const cpuValid = !cpuConfigured || isUtilizationTarget(policy.cpuUtilization?.utilizationTarget, 1);
+  const loadBalancingValid =
+    !loadBalancingConfigured || isUtilizationTarget(policy.loadBalancingUtilization?.utilizationTarget, 1);
+  const customMetricsValid = customMetrics.every(isValidCustomMetric);
+  return (
+    cpuValid &&
+    loadBalancingValid &&
+    customMetricsValid &&
+    ((cpuConfigured && cpuValid) || (loadBalancingConfigured && loadBalancingValid) || customMetrics.length > 0)
+  );
+}
+
+function hasValidSchedules(policy: IGceAutoscalingPolicy): boolean {
+  return (policy.scalingSchedules || []).every(
+    (schedule) =>
+      Boolean(schedule.scheduleName?.trim()) &&
+      isIntegerInRange(schedule.minimumRequiredInstances, 0, policy.maxNumReplicas) &&
+      Boolean(schedule.scheduleCron?.trim()) &&
+      Boolean(schedule.timezone?.trim()) &&
+      isIntegerInRange(schedule.duration, 301, MAX_SCHEDULE_DURATION_SECONDS),
+  );
+}
+
+function hasValidScaleInControl(policy: IGceAutoscalingPolicy): boolean {
+  if (!policy.scaleInControl) {
+    return true;
+  }
+  const { maxScaledInReplicas, timeWindowSec } = policy.scaleInControl;
+  const hasFixed = maxScaledInReplicas?.fixed !== undefined;
+  const hasPercent = maxScaledInReplicas?.percent !== undefined;
+  if (hasFixed === hasPercent || !isIntegerInRange(timeWindowSec, 60, 3600)) {
+    return false;
+  }
+  return hasPercent
+    ? isIntegerInRange(maxScaledInReplicas?.percent, 0, 100)
+    : isIntegerInRange(maxScaledInReplicas?.fixed, 0);
+}
+
+export interface IGceUpsertAutoscalingPolicyModalProps extends IModalComponentProps {
+  application: Application;
+  serverGroup: IGcePolicyServerGroup & { capacity?: { min?: number; max?: number } };
+  policy?: IGceAutoscalingPolicy;
+}
+
+interface IGceUpsertAutoscalingPolicyModalState {
+  policy: IGceAutoscalingPolicy;
+  taskMonitor: TaskMonitor;
+}
+
+function initialPolicy(props: IGceUpsertAutoscalingPolicyModalProps): IGceAutoscalingPolicy {
+  return cloneDeep(
+    props.policy || {
+      minNumReplicas: props.serverGroup.capacity?.min ?? 0,
+      maxNumReplicas: props.serverGroup.capacity?.max ?? 1,
+      coolDownPeriodSec: 60,
+      mode: 'ON',
+      cpuUtilization: { utilizationTarget: 0.6 },
+    },
+  );
+}
+
+export class GceUpsertAutoscalingPolicyModal extends React.Component<
+  IGceUpsertAutoscalingPolicyModalProps,
+  IGceUpsertAutoscalingPolicyModalState
+> {
+  public static show(props: IGceUpsertAutoscalingPolicyModalProps): Promise<void> {
+    return ReactModal.show(GceUpsertAutoscalingPolicyModal, props, { dialogClassName: 'modal-lg' });
+  }
+
+  public constructor(props: IGceUpsertAutoscalingPolicyModalProps) {
+    super(props);
+    const action = props.policy ? 'Edit' : 'New';
+    this.state = {
+      policy: initialPolicy(props),
+      taskMonitor: new TaskMonitor({
+        application: props.application,
+        title: `${action} scaling policy for ${props.serverGroup.name}`,
+        onDismiss: () => props.dismissModal?.(),
+        onTaskComplete: () => {
+          props.application.serverGroups?.refresh?.();
+          props.closeModal?.();
+        },
+      }),
+    };
+  }
+
+  private submit = (): void => {
+    this.state.taskMonitor.submit(() =>
+      GceAutoscalingPolicyWriter.upsertAutoscalingPolicy(
+        this.props.application,
+        this.props.serverGroup,
+        this.state.policy,
+      ),
+    );
+  };
+
+  public render(): JSX.Element {
+    const isNew = !this.props.policy;
+    return (
+      <>
+        <TaskMonitorWrapper monitor={this.state.taskMonitor} />
+        <ModalClose dismiss={this.props.dismissModal} />
+        <div className="modal-header">
+          <h4 className="modal-title">{isNew ? 'New' : 'Edit'} autoscaling policy</h4>
+        </div>
+        <div className="modal-body">
+          <GceAutoscalingPolicyEditor policy={this.state.policy} onChange={(policy) => this.setState({ policy })} />
+        </div>
+        <div className="modal-footer">
+          <button className="btn btn-default" type="button" onClick={() => this.props.dismissModal?.()}>
+            Cancel
+          </button>
+          <SubmitButton
+            isDisabled={!this.isValid()}
+            label={isNew ? 'Create' : 'Update'}
+            onClick={this.submit}
+            submitting={this.state.taskMonitor.submitting}
+          />
+        </div>
+      </>
+    );
+  }
+
+  private isValid(): boolean {
+    const { policy } = this.state;
+    const predictiveEnabled = policy.cpuUtilization?.predictiveMethod === GcePredictiveMethod.STANDARD;
+    return (
+      isIntegerInRange(policy.minNumReplicas, 0) &&
+      isIntegerInRange(policy.maxNumReplicas, 0) &&
+      policy.minNumReplicas <= policy.maxNumReplicas &&
+      isIntegerInRange(policy.coolDownPeriodSec, 15) &&
+      hasValidMetrics(policy) &&
+      hasValidSchedules(policy) &&
+      hasValidScaleInControl(policy) &&
+      (!predictiveEnabled || Boolean(GCEProviderSettings.feature.predictiveAutoscaling)) &&
+      (!predictiveEnabled || isUtilizationTarget(policy.cpuUtilization?.utilizationTarget, 1))
+    );
+  }
+}

package/src/serverGroup/details/gceServerGroupDetails.spec.tsx

@@ -0,0 +1,290 @@
+import { mount as enzymeMount, shallow } from 'enzyme';
+import React from 'react';
+
+import { CloudProviderRegistry, CollapsibleSection, DeckRuntimeContext, ManagedMenuItem } from '@spinnaker/core';
+
+import { GceAutoscalingPolicyWriter } from '../../autoscalingPolicy';
+import { registerGoogleProvider } from '../../gce.module';
+import { GceCloneServerGroupModal } from '../configure/wizard/GceCloneServerGroupModal';
+import { GceAutoHealingPolicyDetails } from './autoHealingPolicy';
+import { GceAutoscalingPolicyDetails } from './autoscalingPolicy';
+import {
+  GceServerGroupActions,
+  GceServerGroupLaunchConfigSection,
+  gceServerGroupDetailsSections,
+} from './gceServerGroupDetails';
+import { GceInstanceFlexibilityPolicyDetails } from './GceInstanceFlexibilityPolicyDetails';
+import { GceResizeServerGroupModal } from './resize/GceResizeServerGroupModal';
+import { GceRollbackServerGroupModal } from './rollback/GceRollbackServerGroupModal';
+
+describe('GCE server group details integration', () => {
+  let runtimeServices: any;
+  const RuntimeWrapper = ({ children }: React.PropsWithChildren<{}>) => (
+    <DeckRuntimeContext.Provider value={{ services: runtimeServices } as any}>{children}</DeckRuntimeContext.Provider>
+  );
+  const mount = (component: React.ReactElement) => enzymeMount(component, { wrappingComponent: RuntimeWrapper });
+
+  beforeEach(() => {
+    runtimeServices = {
+      serverGroupCommandBuilder: {},
+      serverGroupWriter: {},
+    };
+  });
+  const serverGroup = {
+    account: 'prod',
+    app: 'fnord',
+    autoscalingMessages: ['autoscaler active'],
+    autoscalingPolicy: { maxNumReplicas: 5, minNumReplicas: 1 },
+    autoHealingPolicy: { healthCheck: 'fnord-health-check', initialDelaySec: 300 },
+    cluster: 'fnord-main',
+    isDisabled: false,
+    name: 'fnord-main-v004',
+    region: 'us-central1',
+  } as any;
+  const eligibleRollbackCandidate = {
+    ...serverGroup,
+    autoscalingPolicy: undefined,
+    autoHealingPolicy: undefined,
+    isDisabled: true,
+    name: 'fnord-main-v003',
+  };
+  const app = {
+    attributes: {},
+    name: 'fnord',
+    serverGroups: {
+      data: [
+        eligibleRollbackCandidate,
+        { ...eligibleRollbackCandidate, app: 'other', name: 'other-main-v003' },
+        { ...eligibleRollbackCandidate, isDisabled: false, name: 'fnord-main-v002' },
+      ],
+      refresh: jasmine.createSpy('refresh'),
+    },
+  } as any;
+
+  const managedAction = (wrapper: any, label: string) =>
+    wrapper.find(ManagedMenuItem).filterWhere((item: any) => item.prop('children') === label);
+
+  const linkAction = (wrapper: any, label: string) =>
+    wrapper.find('a').filterWhere((link: any) => link.text() === label);
+
+  it('registers autoscaling and auto-healing sections backed by the completed details components', () => {
+    registerGoogleProvider();
+
+    expect(CloudProviderRegistry.getValue('gce', 'serverGroup.detailsSections')).toEqual(gceServerGroupDetailsSections);
+
+    const renderedSections = gceServerGroupDetailsSections.map((Section) =>
+      shallow(<Section app={app} serverGroup={serverGroup} />),
+    );
+    const autoscaling = renderedSections.find(
+      (section) => section.find(CollapsibleSection).prop('heading') === 'Autoscaling',
+    );
+    const autoHealing = renderedSections.find(
+      (section) => section.find(CollapsibleSection).prop('heading') === 'Auto-healing',
+    );
+
+    expect(autoscaling.find(GceAutoscalingPolicyDetails).props()).toEqual(
+      jasmine.objectContaining({ application: app, policy: serverGroup.autoscalingPolicy, serverGroup }),
+    );
+    expect(autoHealing.find(GceAutoHealingPolicyDetails).props()).toEqual(
+      jasmine.objectContaining({ application: app, policy: serverGroup.autoHealingPolicy, serverGroup }),
+    );
+  });
+
+  it('keeps policy summaries read-only when GCE ad-hoc infrastructure writes are disabled', () => {
+    spyOn(CloudProviderRegistry, 'isDisabled').and.returnValue(true);
+    const renderedSections = gceServerGroupDetailsSections.map((Section) =>
+      shallow(<Section app={app} serverGroup={serverGroup} />),
+    );
+    const autoscalingSection = renderedSections.find(
+      (section) => section.find(CollapsibleSection).prop('heading') === 'Autoscaling',
+    );
+    const autoHealingSection = renderedSections.find(
+      (section) => section.find(CollapsibleSection).prop('heading') === 'Auto-healing',
+    );
+    const autoscaling = shallow(autoscalingSection.find(GceAutoscalingPolicyDetails).getElement());
+    const autoHealing = shallow(autoHealingSection.find(GceAutoHealingPolicyDetails).getElement());
+
+    expect(autoscaling.text()).toContain('Min # VMs');
+    expect(autoscaling.find('[data-testid="edit-autoscaling-policy"]').length).toBe(0);
+    expect(autoscaling.find('[data-testid="delete-autoscaling-policy"]').length).toBe(0);
+    expect(autoHealing.text()).toContain('fnord-health-check');
+    expect(autoHealing.find('[data-testid="edit-auto-healing-policy"]').length).toBe(0);
+    expect(autoHealing.find('[data-testid="delete-auto-healing-policy"]').length).toBe(0);
+  });
+
+  it('does not offer policy creation when GCE ad-hoc infrastructure writes are disabled', () => {
+    spyOn(CloudProviderRegistry, 'isDisabled').and.returnValue(true);
+    const serverGroupWithoutPolicies = {
+      ...serverGroup,
+      autoscalingPolicy: undefined,
+      autoHealingPolicy: undefined,
+    };
+    const renderedSections = gceServerGroupDetailsSections.map((Section) =>
+      shallow(<Section app={app} serverGroup={serverGroupWithoutPolicies} />),
+    );
+    const autoscalingSection = renderedSections.find(
+      (section) => section.find(CollapsibleSection).prop('heading') === 'Autoscaling',
+    );
+    const autoHealingSection = renderedSections.find(
+      (section) => section.find(CollapsibleSection).prop('heading') === 'Auto-healing',
+    );
+    const autoscaling = shallow(autoscalingSection.find(GceAutoscalingPolicyDetails).getElement());
+    const autoHealing = shallow(autoHealingSection.find(GceAutoHealingPolicyDetails).getElement());
+
+    expect(autoscaling.find('[data-testid="add-autoscaling-policy"]').length).toBe(0);
+    expect(autoHealing.find('[data-testid="add-auto-healing-policy"]').length).toBe(0);
+  });
+
+  it('renders target shape and instance flexibility in the launch configuration without nesting definition lists', () => {
+    const instanceFlexibilityPolicy = {
+      instanceSelections: {
+        preferred: { rank: 1, machineTypes: ['n2-standard-8'] },
+      },
+    };
+    const wrapper = shallow(
+      <GceServerGroupLaunchConfigSection
+        app={app}
+        serverGroup={{
+          ...serverGroup,
+          distributionPolicy: { targetShape: 'BALANCED' },
+          instanceFlexibilityPolicy,
+        }}
+      />,
+    );
+
+    expect(wrapper.find('dt').filterWhere((term) => term.text() === 'Target shape').length).toBe(1);
+    expect(wrapper.find('dd').filterWhere((definition) => definition.text() === 'BALANCED').length).toBe(1);
+    expect(wrapper.find(GceInstanceFlexibilityPolicyDetails).prop('instanceFlexibilityPolicy')).toBe(
+      instanceFlexibilityPolicy,
+    );
+    expect(wrapper.find('dl dl').length).toBe(0);
+  });
+
+  it('renders shielded settings with stable, legacy, then top-level field precedence', () => {
+    const wrapper = shallow(
+      <GceServerGroupLaunchConfigSection
+        app={app}
+        serverGroup={{
+          ...serverGroup,
+          shieldedInstanceConfig: { enableSecureBoot: false },
+          shieldedVmConfig: { enableSecureBoot: true, enableVtpm: false },
+          enableVtpm: true,
+          enableIntegrityMonitoring: false,
+        }}
+      />,
+    );
+    const definitions = (label: string) => {
+      const index = wrapper
+        .find('dt')
+        .map((candidate) => candidate.text())
+        .indexOf(label);
+      return index < 0 ? undefined : wrapper.find('dd').at(index).text();
+    };
+
+    expect(definitions('Secure Boot')).toBe('false');
+    expect(definitions('vTPM')).toBe('false');
+    expect(definitions('Integrity Monitoring')).toBe('false');
+  });
+
+  it('adds rollback and resize without changing existing enabled action visibility', () => {
+    const wrapper = mount(<GceServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    expect(managedAction(wrapper, 'Rollback').length).toBe(1);
+    expect(managedAction(wrapper, 'Resize').length).toBe(1);
+    expect(linkAction(wrapper, 'Clone').length).toBe(1);
+    expect(linkAction(wrapper, 'Disable').length).toBe(1);
+    expect(linkAction(wrapper, 'Enable').length).toBe(0);
+    expect(linkAction(wrapper, 'Destroy').length).toBe(1);
+  });
+
+  it('opens clone with the command builder and runtime services from Deck context', async () => {
+    const command = { application: serverGroup.app, stack: 'main' };
+    runtimeServices.serverGroupCommandBuilder = {
+      buildServerGroupCommandFromExisting: jasmine
+        .createSpy('buildServerGroupCommandFromExisting')
+        .and.resolveTo(command),
+    };
+    const show = spyOn(GceCloneServerGroupModal, 'show').and.resolveTo({} as any);
+    const wrapper = mount(<GceServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    linkAction(wrapper, 'Clone').simulate('click');
+    await Promise.resolve();
+
+    expect(runtimeServices.serverGroupCommandBuilder.buildServerGroupCommandFromExisting).toHaveBeenCalledWith(
+      app,
+      serverGroup,
+    );
+    expect(show).toHaveBeenCalledWith(
+      { application: app, command, title: `Clone ${serverGroup.name}` },
+      runtimeServices,
+    );
+  });
+
+  it('keeps rollback hidden for a disabled server group without changing existing disabled action visibility', () => {
+    const wrapper = mount(<GceServerGroupActions app={app} serverGroup={{ ...serverGroup, isDisabled: true }} />);
+
+    expect(managedAction(wrapper, 'Rollback').length).toBe(0);
+    expect(managedAction(wrapper, 'Resize').length).toBe(1);
+    expect(linkAction(wrapper, 'Disable').length).toBe(0);
+    expect(linkAction(wrapper, 'Enable').length).toBe(1);
+  });
+
+  it('opens rollback with filtered candidates and the existing server group writer', () => {
+    const show = spyOn(GceRollbackServerGroupModal, 'show').and.returnValue(Promise.resolve({} as any));
+    const wrapper = mount(<GceServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    managedAction(wrapper, 'Rollback').prop('onClick')();
+
+    expect(show).toHaveBeenCalledOnceWith({
+      application: app,
+      serverGroup,
+      serverGroups: [eligibleRollbackCandidate],
+      serverGroupWriter: runtimeServices.serverGroupWriter,
+    });
+  });
+
+  it('keeps rollback available when there are no candidates and delegates empty handling to the modal', () => {
+    const appWithoutCandidates = { ...app, serverGroups: { ...app.serverGroups, data: [] } };
+    const show = spyOn(GceRollbackServerGroupModal, 'show').and.returnValue(Promise.resolve({} as any));
+    const wrapper = mount(<GceServerGroupActions app={appWithoutCandidates} serverGroup={serverGroup} />);
+
+    expect(managedAction(wrapper, 'Rollback').length).toBe(1);
+    managedAction(wrapper, 'Rollback').prop('onClick')();
+
+    expect(show).toHaveBeenCalledOnceWith(
+      jasmine.objectContaining({ application: appWithoutCandidates, serverGroup, serverGroups: [] }),
+    );
+  });
+
+  it('opens resize with the completed writers', () => {
+    const show = spyOn(GceResizeServerGroupModal, 'show').and.returnValue(Promise.resolve());
+    const wrapper = mount(<GceServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    managedAction(wrapper, 'Resize').prop('onClick')();
+
+    expect(show).toHaveBeenCalledOnceWith({
+      application: app,
+      autoscalingPolicyWriter: GceAutoscalingPolicyWriter,
+      serverGroup,
+      serverGroupWriter: runtimeServices.serverGroupWriter,
+    });
+  });
+
+  it('protects rollback and resize with the managed-resource interstitial', () => {
+    const wrapper = mount(<GceServerGroupActions app={app} serverGroup={{ ...serverGroup, isManaged: true }} />);
+
+    ['Rollback', 'Resize'].forEach((label) => {
+      expect(managedAction(wrapper, label).props()).toEqual(
+        jasmine.objectContaining({ application: app, resource: jasmine.objectContaining({ isManaged: true }) }),
+      );
+    });
+  });
+
+  it('hides server group actions when GCE ad-hoc infrastructure writes are disabled', () => {
+    spyOn(CloudProviderRegistry, 'isDisabled').and.returnValue(true);
+
+    const wrapper = mount(<GceServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    expect(wrapper.isEmptyRender()).toBe(true);
+  });
+});