@spinnaker/google 2026.2.2 → 2026.3.0

package/src/serverGroup/details/resize/GceResizeServerGroupModal.tsx

@@ -0,0 +1,346 @@
+import React from 'react';
+
+import type { Application, IModalComponentProps, IServerGroup, IServerGroupJob, ITask } from '@spinnaker/core';
+import {
+  ModalClose,
+  PlatformHealthOverride,
+  ReactModal,
+  TaskMonitor,
+  TaskMonitorWrapper,
+  TaskReason,
+  UserVerification,
+  ValidationMessage,
+} from '@spinnaker/core';
+
+import type { IGceAutoscalingPolicy } from '../../../autoscalingPolicy/IGceAutoscalingPolicy';
+
+export interface IGceResizeValues {
+  interestingHealthProviderNames?: string[];
+  newMaxNumReplicas?: number;
+  newMinNumReplicas?: number;
+  newSize?: number;
+  reason?: string;
+}
+
+export type GceResizeErrors = Partial<Record<keyof IGceResizeValues, string>>;
+
+export interface IGceFixedResizeJob extends IServerGroupJob {
+  interestingHealthProviderNames?: string[];
+  reason?: string;
+  targetSize: number;
+}
+
+export interface IGceAutoscalerResizeRequest {
+  params: {
+    interestingHealthProviderNames?: string[];
+    reason?: string;
+  };
+  policy: IGceAutoscalingPolicy & {
+    maxNumReplicas: number;
+    minNumReplicas: number;
+  };
+}
+
+export interface IGceAutoscalingPolicyWriter {
+  upsertAutoscalingPolicy(
+    application: Application,
+    serverGroup: IServerGroup,
+    policy: IGceAutoscalerResizeRequest['policy'],
+    params: IGceAutoscalerResizeRequest['params'],
+  ): Promise<ITask>;
+}
+
+export interface IGceResizeServerGroupWriter {
+  resizeServerGroup(serverGroup: IServerGroup, application: Application, command: IGceFixedResizeJob): Promise<ITask>;
+}
+
+export interface IGceResizeServerGroupModalProps extends IModalComponentProps {
+  application: Application;
+  autoscalingPolicyWriter: IGceAutoscalingPolicyWriter;
+  serverGroup: IServerGroup;
+  serverGroupWriter: IGceResizeServerGroupWriter;
+}
+
+interface IGceResizeServerGroupModalState {
+  taskMonitor: TaskMonitor;
+  values: IGceResizeValues;
+  verified: boolean;
+}
+
+export function buildGceAutoscalerResizeRequest(
+  values: IGceResizeValues & { newMaxNumReplicas: number; newMinNumReplicas: number },
+): IGceAutoscalerResizeRequest {
+  return {
+    params: {
+      interestingHealthProviderNames: values.interestingHealthProviderNames,
+      reason: values.reason,
+    },
+    policy: {
+      maxNumReplicas: values.newMaxNumReplicas,
+      minNumReplicas: values.newMinNumReplicas,
+    },
+  };
+}
+
+export function buildGceFixedResizeJob(
+  serverGroup: IServerGroup,
+  values: IGceResizeValues & { newSize: number },
+): IGceFixedResizeJob {
+  return {
+    capacity: { desired: values.newSize, max: values.newSize, min: values.newSize },
+    interestingHealthProviderNames: values.interestingHealthProviderNames,
+    reason: values.reason,
+    region: serverGroup.region,
+    serverGroupName: serverGroup.name,
+    targetSize: values.newSize,
+  };
+}
+
+export function validateGceResizeValues(serverGroup: IServerGroup, values: IGceResizeValues): GceResizeErrors {
+  if (!serverGroup.autoscalingPolicy && values.newSize === undefined) {
+    return { newSize: 'Size is required' };
+  }
+
+  if (
+    !serverGroup.autoscalingPolicy &&
+    values.newSize !== undefined &&
+    (!Number.isInteger(values.newSize) || values.newSize < 0)
+  ) {
+    return { newSize: 'Size must be a finite non-negative integer' };
+  }
+
+  if (serverGroup.autoscalingPolicy) {
+    const errors: GceResizeErrors = {};
+    if (values.newMinNumReplicas === undefined) {
+      errors.newMinNumReplicas = 'Min is required';
+    }
+    if (values.newMaxNumReplicas === undefined) {
+      errors.newMaxNumReplicas = 'Max is required';
+    }
+    if (Object.keys(errors).length) {
+      return errors;
+    }
+    if (!Number.isInteger(values.newMinNumReplicas) || values.newMinNumReplicas < 0) {
+      errors.newMinNumReplicas = 'Min must be a finite non-negative integer';
+    }
+    if (!Number.isInteger(values.newMaxNumReplicas) || values.newMaxNumReplicas < 0) {
+      errors.newMaxNumReplicas = 'Max must be a finite non-negative integer';
+    }
+    if (Object.keys(errors).length) {
+      return errors;
+    }
+  }
+
+  if (
+    serverGroup.autoscalingPolicy &&
+    values.newMinNumReplicas !== undefined &&
+    values.newMaxNumReplicas !== undefined &&
+    values.newMinNumReplicas > values.newMaxNumReplicas
+  ) {
+    return {
+      newMaxNumReplicas: 'Min cannot be larger than Max',
+      newMinNumReplicas: 'Min cannot be larger than Max',
+    };
+  }
+
+  return {};
+}
+
+export class GceResizeServerGroupModal extends React.Component<
+  IGceResizeServerGroupModalProps,
+  IGceResizeServerGroupModalState
+> {
+  public static show(props: IGceResizeServerGroupModalProps): Promise<void> {
+    return ReactModal.show(GceResizeServerGroupModal, props);
+  }
+
+  constructor(props: IGceResizeServerGroupModalProps) {
+    super(props);
+    const { application } = props;
+    this.state = {
+      taskMonitor: new TaskMonitor({
+        application,
+        title: `Resizing ${props.serverGroup.name}`,
+        onDismiss: () => this.props.dismissModal(),
+        onTaskComplete: () => application.serverGroups.refresh(),
+      }),
+      values: {
+        interestingHealthProviderNames:
+          application.attributes?.platformHealthOnlyShowOverride && application.attributes?.platformHealthOnly
+            ? ['Google']
+            : undefined,
+      },
+      verified: false,
+    };
+  }
+
+  private isValid = (): boolean =>
+    this.state.verified && Object.keys(validateGceResizeValues(this.props.serverGroup, this.state.values)).length === 0;
+
+  private submit = (): void => {
+    if (!this.isValid()) {
+      return;
+    }
+
+    const { application, autoscalingPolicyWriter, serverGroup, serverGroupWriter } = this.props;
+    if (serverGroup.autoscalingPolicy) {
+      const { params, policy } = buildGceAutoscalerResizeRequest(
+        this.state.values as IGceResizeValues & { newMaxNumReplicas: number; newMinNumReplicas: number },
+      );
+      this.state.taskMonitor.submit(() =>
+        autoscalingPolicyWriter.upsertAutoscalingPolicy(application, serverGroup, policy, params),
+      );
+      return;
+    }
+
+    const command = buildGceFixedResizeJob(serverGroup, this.state.values as IGceResizeValues & { newSize: number });
+    this.state.taskMonitor.submit(() => serverGroupWriter.resizeServerGroup(serverGroup, application, command));
+  };
+
+  public render(): JSX.Element {
+    const { application, serverGroup } = this.props;
+    const { values } = this.state;
+    const currentSize = serverGroup.asg?.desiredCapacity ?? serverGroup.capacity?.desired;
+    const errorMessage = Object.values(validateGceResizeValues(serverGroup, values))[0];
+
+    return (
+      <>
+        <TaskMonitorWrapper monitor={this.state.taskMonitor} />
+        <ModalClose dismiss={this.props.dismissModal} />
+        <div className="modal-header">
+          <h4 className="modal-title">Resize {serverGroup.name}</h4>
+        </div>
+        <div className="modal-body">
+          <form className="form-horizontal">
+            {serverGroup.autoscalingPolicy ? (
+              <>
+                <p>Sets min and max instance counts for this server group's autoscaling policy.</p>
+                <div className="form-group">
+                  <div className="col-md-2 col-md-offset-3">
+                    <b>Min</b>
+                  </div>
+                  <div className="col-md-2">
+                    <b>Max</b>
+                  </div>
+                </div>
+                <div className="form-group">
+                  <label className="col-md-3 sm-label-right">Current</label>
+                  <div className="col-md-2">
+                    <input
+                      className="form-control input-sm"
+                      disabled={true}
+                      type="number"
+                      value={serverGroup.autoscalingPolicy.minNumReplicas}
+                    />
+                  </div>
+                  <div className="col-md-2">
+                    <input
+                      className="form-control input-sm"
+                      disabled={true}
+                      type="number"
+                      value={serverGroup.autoscalingPolicy.maxNumReplicas}
+                    />
+                  </div>
+                </div>
+                <div className="form-group">
+                  <label className="col-md-3 sm-label-right">Resize to</label>
+                  <div className="col-md-2">
+                    <input
+                      className="form-control input-sm"
+                      min={0}
+                      name="newMinNumReplicas"
+                      onChange={(event) =>
+                        this.setState({
+                          values: {
+                            ...values,
+                            newMinNumReplicas: event.target.value === '' ? undefined : Number(event.target.value),
+                          },
+                        })
+                      }
+                      type="number"
+                      value={values.newMinNumReplicas ?? ''}
+                    />
+                  </div>
+                  <div className="col-md-2">
+                    <input
+                      className="form-control input-sm"
+                      min={0}
+                      name="newMaxNumReplicas"
+                      onChange={(event) =>
+                        this.setState({
+                          values: {
+                            ...values,
+                            newMaxNumReplicas: event.target.value === '' ? undefined : Number(event.target.value),
+                          },
+                        })
+                      }
+                      type="number"
+                      value={values.newMaxNumReplicas ?? ''}
+                    />
+                  </div>
+                </div>
+              </>
+            ) : (
+              <>
+                <p>Sets desired instance count for this server group.</p>
+                <div className="form-group">
+                  <label className="col-md-3 sm-label-right">Current size</label>
+                  <div className="col-md-4">
+                    <input className="form-control input-sm" disabled={true} type="number" value={currentSize} />
+                  </div>
+                </div>
+                <div className="form-group">
+                  <label className="col-md-3 sm-label-right" htmlFor="gce-resize-new-size">
+                    Resize to
+                  </label>
+                  <div className="col-md-4">
+                    <input
+                      className="form-control input-sm"
+                      id="gce-resize-new-size"
+                      min={0}
+                      name="newSize"
+                      onChange={(event) =>
+                        this.setState({
+                          values: {
+                            ...values,
+                            newSize: event.target.value === '' ? undefined : Number(event.target.value),
+                          },
+                        })
+                      }
+                      type="number"
+                      value={values.newSize ?? ''}
+                    />
+                  </div>
+                </div>
+              </>
+            )}
+            {errorMessage && <ValidationMessage message={errorMessage} type="error" />}
+            {application.attributes?.platformHealthOnlyShowOverride && (
+              <PlatformHealthOverride
+                interestingHealthProviderNames={values.interestingHealthProviderNames}
+                onChange={(interestingHealthProviderNames) =>
+                  this.setState({ values: { ...values, interestingHealthProviderNames } })
+                }
+                platformHealthType="Google"
+                showHelpDetails={true}
+              />
+            )}
+            <TaskReason
+              reason={values.reason}
+              onChange={(reason) => this.setState({ values: { ...values, reason } })}
+            />
+          </form>
+        </div>
+        <div className="modal-footer">
+          <UserVerification account={serverGroup.account} onValidChange={(verified) => this.setState({ verified })} />
+          <button className="btn btn-default" onClick={this.props.dismissModal} type="button">
+            Cancel
+          </button>
+          <button className="btn btn-primary" disabled={!this.isValid()} onClick={this.submit} type="button">
+            Submit
+          </button>
+        </div>
+      </>
+    );
+  }
+}

package/src/serverGroup/details/rollback/GceRollbackServerGroupModal.spec.tsx

@@ -0,0 +1,168 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import { PlatformHealthOverride, TaskReason, UserVerification } from '@spinnaker/core';
+
+import {
+  buildGceRollbackJob,
+  GceRollbackServerGroupModal,
+  getGceRollbackCandidates,
+} from './GceRollbackServerGroupModal';
+
+describe('GceRollbackServerGroupModal', () => {
+  const application = { name: 'fnord' } as any;
+  const serverGroup = {
+    account: 'prod',
+    app: 'fnord',
+    cluster: 'fnord-main',
+    name: 'fnord-main-v004',
+    region: 'us-central1',
+  } as any;
+
+  it('keeps only disabled candidates in the same application, cluster, account, and region', () => {
+    const eligible = {
+      account: 'prod',
+      app: 'fnord',
+      cluster: 'fnord-main',
+      isDisabled: true,
+      name: 'fnord-main-v003',
+      region: 'us-central1',
+    };
+    const candidates = [
+      eligible,
+      { ...eligible, app: 'other', name: 'other-main-v003' },
+      { ...eligible, cluster: 'fnord-test', name: 'fnord-test-v003' },
+      { ...eligible, account: 'staging', name: 'fnord-main-v003-staging' },
+      { ...eligible, region: 'europe-west1', name: 'fnord-main-v003-eu' },
+      { ...eligible, isDisabled: false, name: 'fnord-main-v002' },
+    ] as any[];
+
+    expect(getGceRollbackCandidates(application, serverGroup, candidates)).toEqual([eligible]);
+  });
+
+  it('sorts rollback candidates newest first', () => {
+    const candidate = {
+      account: 'prod',
+      app: 'fnord',
+      cluster: 'fnord-main',
+      isDisabled: true,
+      region: 'us-central1',
+    };
+
+    const result = getGceRollbackCandidates(application, serverGroup, [
+      { ...candidate, name: 'fnord-main-v001' },
+      { ...candidate, name: 'fnord-main-v003' },
+      { ...candidate, name: 'fnord-main-v002' },
+    ] as any[]);
+
+    expect(result.map(({ name }) => name)).toEqual(['fnord-main-v003', 'fnord-main-v002', 'fnord-main-v001']);
+  });
+
+  it('builds the exact explicit rollback job with reason and health override', () => {
+    const job = buildGceRollbackJob({ attributes: { platformHealthOnlyShowOverride: true } } as any, serverGroup, {
+      interestingHealthProviderNames: ['Google'],
+      reason: 'bad release',
+      restoreServerGroupName: 'fnord-main-v003',
+    });
+
+    expect(job).toEqual({
+      interestingHealthProviderNames: ['Google'],
+      platformHealthOnlyShowOverride: true,
+      reason: 'bad release',
+      rollbackContext: {
+        restoreServerGroupName: 'fnord-main-v003',
+        rollbackServerGroupName: 'fnord-main-v004',
+      },
+      rollbackType: 'EXPLICIT',
+    });
+  });
+
+  it('renders reason, account verification, and the Google platform-health override', () => {
+    const wrapper = shallow(
+      <GceRollbackServerGroupModal
+        application={
+          {
+            attributes: { platformHealthOnly: true, platformHealthOnlyShowOverride: true },
+            name: 'fnord',
+          } as any
+        }
+        dismissModal={jasmine.createSpy('dismissModal')}
+        serverGroup={serverGroup}
+        serverGroups={[]}
+        serverGroupWriter={{ rollbackServerGroup: jasmine.createSpy('rollbackServerGroup') } as any}
+      />,
+    );
+
+    expect(wrapper.find(TaskReason).exists()).toBe(true);
+    expect(wrapper.find(UserVerification).prop('account')).toBe('prod');
+    expect(wrapper.find(PlatformHealthOverride).props()).toEqual(
+      jasmine.objectContaining({
+        interestingHealthProviderNames: ['Google'],
+        platformHealthType: 'Google',
+      }),
+    );
+  });
+
+  it('submits the exact rollback writer job only after account verification', () => {
+    const applicationWithHealthOverride = {
+      attributes: { platformHealthOnly: true, platformHealthOnlyShowOverride: true },
+      name: 'fnord',
+      serverGroups: { refresh: jasmine.createSpy('refresh') },
+    } as any;
+    const candidate = {
+      account: 'prod',
+      app: 'fnord',
+      cluster: 'fnord-main',
+      isDisabled: true,
+      name: 'fnord-main-v003',
+      region: 'us-central1',
+    } as any;
+    const rollbackServerGroup = jasmine.createSpy('rollbackServerGroup').and.returnValue(Promise.resolve({}));
+    const wrapper = shallow(
+      <GceRollbackServerGroupModal
+        application={applicationWithHealthOverride}
+        dismissModal={jasmine.createSpy('dismissModal')}
+        serverGroup={serverGroup}
+        serverGroups={[candidate]}
+        serverGroupWriter={{ rollbackServerGroup }}
+      />,
+    );
+    const monitor = (wrapper.state() as any).taskMonitor;
+    spyOn(monitor, 'submit').and.callFake((submitMethod: () => PromiseLike<any>) => submitMethod());
+
+    wrapper.find('select').simulate('change', { target: { value: candidate.name } });
+    wrapper.find(TaskReason).prop('onChange')('bad release');
+    expect(wrapper.find('button.btn-primary').prop('disabled')).toBe(true);
+
+    wrapper.find(UserVerification).prop('onValidChange')(true);
+    wrapper.find('button.btn-primary').simulate('click');
+
+    expect(rollbackServerGroup).toHaveBeenCalledWith(serverGroup, applicationWithHealthOverride, {
+      interestingHealthProviderNames: ['Google'],
+      platformHealthOnlyShowOverride: true,
+      reason: 'bad release',
+      rollbackContext: {
+        restoreServerGroupName: 'fnord-main-v003',
+        rollbackServerGroupName: 'fnord-main-v004',
+      },
+      rollbackType: 'EXPLICIT',
+    });
+  });
+
+  it('dismisses the modal from the task monitor', () => {
+    const dismissModal = jasmine.createSpy('dismissModal');
+    const wrapper = shallow(
+      <GceRollbackServerGroupModal
+        application={{ name: 'fnord', serverGroups: { refresh: jasmine.createSpy('refresh') } } as any}
+        dismissModal={dismissModal}
+        serverGroup={serverGroup}
+        serverGroups={[]}
+        serverGroupWriter={{ rollbackServerGroup: jasmine.createSpy('rollbackServerGroup') } as any}
+      />,
+    );
+
+    (wrapper.state() as any).taskMonitor.closeModal();
+
+    expect(dismissModal).toHaveBeenCalled();
+  });
+});