@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/serverGroup/details/scalingPolicy/upsert/alarm/DimensionsEditor.tsx

@@ -7,8 +7,6 @@ import { CloudMetricsReader, ReactSelectInput, TextInput, useData } from '@spinn
 
 import type { IScalingPolicyAlarmView } from '../../../../../domain';
 
-import './dimensionsEditor.less';
-
 export interface IDimensionsEditorProps {
   alarm: IScalingPolicyAlarmView;
   namespaceUpdated?: Subject<void>;

package/src/serverGroup/details/scalingProcesses/ModifyScalingProcessesModal.spec.tsx

@@ -0,0 +1,74 @@
+import { TaskExecutor } from '@spinnaker/core';
+
+import { ModifyScalingProcessesModal, buildScalingProcessJobs } from './ModifyScalingProcessesModal';
+
+describe('ModifyScalingProcessesModal', () => {
+  const serverGroup = { name: 'deck-main-v001', account: 'test', region: 'us-east-1' } as any;
+
+  it('creates separate resume and suspend jobs for changed processes only', () => {
+    const initial = [
+      { name: 'Launch', enabled: true },
+      { name: 'Terminate', enabled: false },
+      { name: 'HealthCheck', enabled: true },
+    ] as any;
+    const edited = [
+      { name: 'Launch', enabled: false },
+      { name: 'Terminate', enabled: true },
+      { name: 'HealthCheck', enabled: true },
+    ] as any;
+
+    expect(buildScalingProcessJobs(initial, edited, serverGroup, 'maintenance')).toEqual([
+      {
+        type: 'modifyScalingProcess',
+        action: 'resume',
+        processes: ['Terminate'],
+        asgName: 'deck-main-v001',
+        regions: ['us-east-1'],
+        credentials: 'test',
+        cloudProvider: 'aws',
+        reason: 'maintenance',
+      },
+      {
+        type: 'modifyScalingProcess',
+        action: 'suspend',
+        processes: ['Launch'],
+        asgName: 'deck-main-v001',
+        regions: ['us-east-1'],
+        credentials: 'test',
+        cloudProvider: 'aws',
+        reason: 'maintenance',
+      },
+    ]);
+  });
+
+  it('does not create jobs when process state is unchanged', () => {
+    const processes = [{ name: 'Launch', enabled: true }] as any;
+
+    expect(buildScalingProcessJobs(processes, [{ ...processes[0] }], serverGroup)).toEqual([]);
+  });
+
+  it('submits the changed-state diff through the task monitor', () => {
+    const execute = spyOn(TaskExecutor, 'executeTask').and.returnValue(Promise.resolve({} as any));
+    const application = { name: 'deck', serverGroups: { refresh: jasmine.createSpy('refresh') } } as any;
+    const modal = new ModifyScalingProcessesModal({
+      application,
+      serverGroup: {
+        ...serverGroup,
+        asg: { suspendedProcesses: [] },
+      },
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+    } as any) as any;
+    modal.state.processes[0].enabled = false;
+    modal.state.reason = 'maintenance';
+    modal.state.taskMonitor = { submit: (method: () => any) => method() };
+
+    modal.submit();
+
+    expect(execute).toHaveBeenCalledWith({
+      application,
+      description: 'Update Auto Scaling Processes for deck-main-v001',
+      job: [jasmine.objectContaining({ action: 'suspend', processes: ['Launch'], reason: 'maintenance' })],
+    });
+  });
+});

package/src/serverGroup/details/scalingProcesses/ModifyScalingProcessesModal.tsx

@@ -0,0 +1,140 @@
+import React from 'react';
+import { Modal } from 'react-bootstrap';
+
+import type { Application, IJob, IModalComponentProps } from '@spinnaker/core';
+import {
+  confirmNotManaged,
+  HelpField,
+  ModalClose,
+  ReactModal,
+  TaskExecutor,
+  TaskMonitor,
+  TaskMonitorWrapper,
+  TaskReason,
+} from '@spinnaker/core';
+
+import { AutoScalingProcessService } from './AutoScalingProcessService';
+import { AwsModalFooter } from '../../../common/AwsModalFooter';
+import type { IAmazonServerGroup, IScalingProcess } from '../../../domain';
+
+export interface IModifyScalingProcessesModalProps extends IModalComponentProps {
+  application: Application;
+  serverGroup: IAmazonServerGroup;
+}
+
+interface IModifyScalingProcessesModalState {
+  processes: IScalingProcess[];
+  reason?: string;
+  taskMonitor: TaskMonitor;
+}
+
+export function buildScalingProcessJobs(
+  initial: IScalingProcess[],
+  edited: IScalingProcess[],
+  serverGroup: IAmazonServerGroup,
+  reason?: string,
+): IJob[] {
+  const changed = edited.filter(
+    (process) => initial.find((candidate) => candidate.name === process.name)?.enabled !== process.enabled,
+  );
+  const resumed = changed.filter((process) => process.enabled).map((process) => process.name);
+  const suspended = changed.filter((process) => !process.enabled).map((process) => process.name);
+  const job = (action: 'resume' | 'suspend', processes: string[]): IJob => ({
+    type: 'modifyScalingProcess',
+    action,
+    processes,
+    asgName: serverGroup.name,
+    regions: [serverGroup.region],
+    credentials: serverGroup.account,
+    cloudProvider: 'aws',
+    reason,
+  });
+
+  return [resumed.length && job('resume', resumed), suspended.length && job('suspend', suspended)].filter(
+    Boolean,
+  ) as IJob[];
+}
+
+export class ModifyScalingProcessesModal extends React.Component<
+  IModifyScalingProcessesModalProps,
+  IModifyScalingProcessesModalState
+> {
+  public static show(props: IModifyScalingProcessesModalProps) {
+    return confirmNotManaged(props.serverGroup, props.application).then(
+      (notManaged) => notManaged && ReactModal.show(ModifyScalingProcessesModal, props),
+    );
+  }
+
+  private initialProcesses = AutoScalingProcessService.normalizeScalingProcesses(this.props.serverGroup);
+
+  public state: IModifyScalingProcessesModalState = {
+    processes: this.initialProcesses.map((process) => ({ ...process })),
+    taskMonitor: new TaskMonitor({
+      application: this.props.application,
+      title: `Update Auto Scaling Processes for ${this.props.serverGroup.name}`,
+      onDismiss: this.props.dismissModal,
+      onTaskComplete: () => this.props.application.serverGroups.refresh(),
+    }),
+  };
+
+  private setProcessEnabled = (index: number, enabled: boolean) => {
+    const processes = this.state.processes.map((process, candidateIndex) =>
+      candidateIndex === index ? { ...process, enabled } : process,
+    );
+    this.setState({ processes });
+  };
+
+  private getJobs = () =>
+    buildScalingProcessJobs(this.initialProcesses, this.state.processes, this.props.serverGroup, this.state.reason);
+
+  private submit = () => {
+    const { application, serverGroup } = this.props;
+    const job = this.getJobs();
+    this.state.taskMonitor.submit(() =>
+      TaskExecutor.executeTask({
+        application,
+        description: `Update Auto Scaling Processes for ${serverGroup.name}`,
+        job,
+      }),
+    );
+  };
+
+  public render() {
+    const { dismissModal, serverGroup } = this.props;
+    return (
+      <>
+        <TaskMonitorWrapper monitor={this.state.taskMonitor} />
+        <ModalClose dismiss={dismissModal} />
+        <Modal.Header>
+          <Modal.Title>Modify Scaling Processes for {serverGroup.name}</Modal.Title>
+        </Modal.Header>
+        <Modal.Body className="container-fluid form-horizontal">
+          <div className="form-group">
+            <div className="col-sm-offset-2 col-sm-10">
+              {this.state.processes.map((process, index) => (
+                <div className="checkbox" key={process.name}>
+                  <label>
+                    <input
+                      checked={process.enabled}
+                      onChange={(event) => this.setProcessEnabled(index, event.target.checked)}
+                      type="checkbox"
+                    />{' '}
+                    {process.name}
+                  </label>{' '}
+                  <HelpField content={process.description} placement="right" />
+                </div>
+              ))}
+            </div>
+          </div>
+          <TaskReason reason={this.state.reason} onChange={(reason) => this.setState({ reason })} />
+        </Modal.Body>
+        <AwsModalFooter
+          account={serverGroup.account}
+          isValid={this.getJobs().length > 0}
+          onCancel={dismissModal}
+          onSubmit={this.submit}
+        />
+      </>
+    );
+  }
+}

package/src/serverGroup/details/scalingProcesses/index.ts

@@ -0,0 +1,2 @@
+export * from './AutoScalingProcessService';
+export * from './ModifyScalingProcessesModal';

package/src/serverGroup/details/scheduledActions/EditScheduledActionsModal.spec.tsx

@@ -0,0 +1,115 @@
+import { TaskExecutor } from '@spinnaker/core';
+
+import {
+  EditScheduledActionsModal,
+  buildScheduledActionsJob,
+  isScheduledActionValid,
+} from './EditScheduledActionsModal';
+
+describe('EditScheduledActionsModal', () => {
+  const serverGroup = { name: 'deck-main-v001', account: 'test', region: 'us-east-1' } as any;
+
+  it('validates recurrence and capacity rows', () => {
+    expect(isScheduledActionValid({ recurrence: '', minSize: 1 })).toBe(false);
+    expect(isScheduledActionValid({ recurrence: '0 12 * * *' })).toBe(false);
+    expect(isScheduledActionValid({ recurrence: '0 12 * * *', minSize: 4, maxSize: 2 })).toBe(false);
+    expect(isScheduledActionValid({ recurrence: '0 12 * * *', minSize: 2, desiredCapacity: 1 })).toBe(false);
+    expect(isScheduledActionValid({ recurrence: '0 12 * * *', minSize: 1, maxSize: 4, desiredCapacity: 5 })).toBe(
+      false,
+    );
+    expect(isScheduledActionValid({ recurrence: '0 12 * * *', desiredCapacity: 3 })).toBe(true);
+  });
+
+  it('rejects non-finite, non-integer, and negative capacities', () => {
+    const fields = ['minSize', 'maxSize', 'desiredCapacity'] as const;
+    const invalidValues = [NaN, Infinity, -Infinity, 1.5, -1];
+
+    fields.forEach((field) =>
+      invalidValues.forEach((value) =>
+        expect(isScheduledActionValid({ recurrence: '0 12 * * *', [field]: value })).toBe(false),
+      ),
+    );
+  });
+
+  it('builds a complete scheduled-actions replacement job', () => {
+    const actions = [
+      {
+        recurrence: '0 12 * * *',
+        minSize: 1,
+        maxSize: 4,
+        desiredCapacity: 2,
+        scheduledActionName: 'cached-name',
+        startTime: '2026-07-12T12:00:00Z',
+        endTime: '2026-07-13T12:00:00Z',
+        time: '2026-07-12T12:00:00Z',
+      },
+    ];
+
+    expect(buildScheduledActionsJob(serverGroup, actions)).toEqual({
+      type: 'upsertAsgScheduledActions',
+      asgs: [{ asgName: 'deck-main-v001', region: 'us-east-1' }],
+      scheduledActions: [{ recurrence: '0 12 * * *', minSize: 1, maxSize: 4, desiredCapacity: 2 }],
+      credentials: 'test',
+    });
+  });
+
+  it('projects cached scheduled actions onto editable fields at initialization', () => {
+    const application = { name: 'deck', serverGroups: { refresh: jasmine.createSpy('refresh') } } as any;
+    const modal = new EditScheduledActionsModal({
+      application,
+      serverGroup: {
+        ...serverGroup,
+        scheduledActions: [
+          {
+            recurrence: '0 12 * * *',
+            minSize: 1,
+            maxSize: 4,
+            desiredCapacity: 2,
+            scheduledActionName: 'cached-name',
+            startTime: '2026-07-12T12:00:00Z',
+            endTime: '2026-07-13T12:00:00Z',
+            time: '2026-07-12T12:00:00Z',
+          },
+        ],
+      },
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+    } as any) as any;
+
+    expect(modal.state.scheduledActions).toEqual([
+      { recurrence: '0 12 * * *', minSize: 1, maxSize: 4, desiredCapacity: 2 },
+    ]);
+  });
+
+  it('adds, edits, removes, and submits capacity rows', () => {
+    const execute = spyOn(TaskExecutor, 'executeTask').and.returnValue(Promise.resolve({} as any));
+    const application = { name: 'deck', serverGroups: { refresh: jasmine.createSpy('refresh') } } as any;
+    const modal = new EditScheduledActionsModal({
+      application,
+      serverGroup: { ...serverGroup, scheduledActions: [{ recurrence: 'old', minSize: 1 }] },
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+    } as any) as any;
+    modal.setState = (update: any) => {
+      const next = typeof update === 'function' ? update(modal.state) : update;
+      modal.state = { ...modal.state, ...next };
+    };
+
+    modal.addScheduledAction();
+    modal.updateScheduledAction(1, 'recurrence', '0 12 * * *');
+    modal.updateScheduledAction(1, 'desiredCapacity', 3);
+    modal.removeScheduledAction(0);
+    modal.state.taskMonitor = { submit: (method: () => any) => method() };
+    modal.submit();
+
+    expect(execute).toHaveBeenCalledWith({
+      application,
+      description: 'Update Scheduled Actions for deck-main-v001',
+      job: [
+        jasmine.objectContaining({
+          scheduledActions: [{ recurrence: '0 12 * * *', minSize: undefined, maxSize: undefined, desiredCapacity: 3 }],
+        }),
+      ],
+    });
+  });
+});

package/src/serverGroup/details/scheduledActions/EditScheduledActionsModal.tsx

@@ -0,0 +1,205 @@
+import React from 'react';
+import { Modal } from 'react-bootstrap';
+
+import type { Application, IJob, IModalComponentProps } from '@spinnaker/core';
+import {
+  confirmNotManaged,
+  ModalClose,
+  ReactModal,
+  TaskExecutor,
+  TaskMonitor,
+  TaskMonitorWrapper,
+} from '@spinnaker/core';
+
+import { AwsModalFooter } from '../../../common/AwsModalFooter';
+import type { IAmazonServerGroupView } from '../../../domain';
+
+export interface IScheduledActionValues {
+  recurrence?: string | number;
+  minSize?: number;
+  maxSize?: number;
+  desiredCapacity?: number;
+}
+
+export interface IEditScheduledActionsModalProps extends IModalComponentProps {
+  application: Application;
+  serverGroup: IAmazonServerGroupView;
+}
+
+interface IEditScheduledActionsModalState {
+  scheduledActions: IScheduledActionValues[];
+  taskMonitor: TaskMonitor;
+}
+
+function projectScheduledAction(action: IScheduledActionValues): IScheduledActionValues {
+  return {
+    recurrence: action.recurrence,
+    minSize: action.minSize,
+    maxSize: action.maxSize,
+    desiredCapacity: action.desiredCapacity,
+  };
+}
+
+export function isScheduledActionValid(action: IScheduledActionValues): boolean {
+  const capacities = [action.minSize, action.maxSize, action.desiredCapacity];
+  if (!String(action.recurrence ?? '').trim() || capacities.every((capacity) => capacity === undefined)) {
+    return false;
+  }
+  if (
+    capacities.some(
+      (capacity) =>
+        capacity !== undefined && (!Number.isFinite(capacity) || !Number.isInteger(capacity) || capacity < 0),
+    )
+  ) {
+    return false;
+  }
+  if (action.minSize !== undefined && action.maxSize !== undefined && action.minSize > action.maxSize) {
+    return false;
+  }
+  if (action.desiredCapacity !== undefined && action.minSize !== undefined && action.desiredCapacity < action.minSize) {
+    return false;
+  }
+  if (action.desiredCapacity !== undefined && action.maxSize !== undefined && action.desiredCapacity > action.maxSize) {
+    return false;
+  }
+  return true;
+}
+
+export function buildScheduledActionsJob(
+  serverGroup: IAmazonServerGroupView,
+  scheduledActions: IScheduledActionValues[],
+): IJob {
+  return {
+    type: 'upsertAsgScheduledActions',
+    asgs: [{ asgName: serverGroup.name, region: serverGroup.region }],
+    scheduledActions: scheduledActions.map(projectScheduledAction),
+    credentials: serverGroup.account,
+  };
+}
+
+export class EditScheduledActionsModal extends React.Component<
+  IEditScheduledActionsModalProps,
+  IEditScheduledActionsModalState
+> {
+  public static show(props: IEditScheduledActionsModalProps) {
+    return confirmNotManaged(props.serverGroup, props.application).then(
+      (notManaged) => notManaged && ReactModal.show(EditScheduledActionsModal, props, { dialogClassName: 'modal-lg' }),
+    );
+  }
+
+  public state: IEditScheduledActionsModalState = {
+    scheduledActions: (this.props.serverGroup.scheduledActions || []).map(projectScheduledAction),
+    taskMonitor: new TaskMonitor({
+      application: this.props.application,
+      title: `Update Scheduled Actions for ${this.props.serverGroup.name}`,
+      onDismiss: this.props.dismissModal,
+      onTaskComplete: () => this.props.application.serverGroups.refresh(),
+    }),
+  };
+
+  private addScheduledAction = () => {
+    this.setState(({ scheduledActions }) => ({ scheduledActions: [...scheduledActions, {}] }));
+  };
+
+  private removeScheduledAction = (index: number) => {
+    this.setState(({ scheduledActions }) => ({
+      scheduledActions: scheduledActions.filter((_action, candidateIndex) => candidateIndex !== index),
+    }));
+  };
+
+  private updateScheduledAction = (index: number, field: keyof IScheduledActionValues, value: string | number) => {
+    this.setState(({ scheduledActions }) => ({
+      scheduledActions: scheduledActions.map((action, candidateIndex) =>
+        candidateIndex === index ? { ...action, [field]: value === '' ? undefined : value } : action,
+      ),
+    }));
+  };
+
+  private submit = () => {
+    const { application, serverGroup } = this.props;
+    this.state.taskMonitor.submit(() =>
+      TaskExecutor.executeTask({
+        application,
+        description: `Update Scheduled Actions for ${serverGroup.name}`,
+        job: [buildScheduledActionsJob(serverGroup, this.state.scheduledActions)],
+      }),
+    );
+  };
+
+  private renderNumberInput(index: number, field: keyof IScheduledActionValues, value?: number) {
+    return (
+      <input
+        className="form-control input-sm"
+        min={0}
+        onChange={(event) =>
+          this.updateScheduledAction(index, field, event.target.value === '' ? '' : Number(event.target.value))
+        }
+        type="number"
+        value={value ?? ''}
+      />
+    );
+  }
+
+  public render() {
+    const { dismissModal, serverGroup } = this.props;
+    const valid = this.state.scheduledActions.every(isScheduledActionValid);
+    return (
+      <>
+        <TaskMonitorWrapper monitor={this.state.taskMonitor} />
+        <ModalClose dismiss={dismissModal} />
+        <Modal.Header>
+          <Modal.Title>Edit Scheduled Actions for {serverGroup.name}</Modal.Title>
+        </Modal.Header>
+        <Modal.Body className="container-fluid">
+          <p>You must specify at least one of: Min Size, Max Size, Desired Capacity.</p>
+          <p>
+            <strong>Note:</strong> CRON expressions are evaluated in UTC.
+          </p>
+          <table className="table table-condensed packed">
+            <thead>
+              <tr>
+                <th>Recurrence (CRON)</th>
+                <th>Min Size</th>
+                <th>Max Size</th>
+                <th>Desired Capacity</th>
+                <th />
+              </tr>
+            </thead>
+            <tbody>
+              {this.state.scheduledActions.map((action, index) => (
+                <tr key={index}>
+                  <td>
+                    <input
+                      className="form-control input-sm no-spel"
+                      onChange={(event) => this.updateScheduledAction(index, 'recurrence', event.target.value)}
+                      required={true}
+                      type="text"
+                      value={action.recurrence ?? ''}
+                    />
+                  </td>
+                  <td>{this.renderNumberInput(index, 'minSize', action.minSize)}</td>
+                  <td>{this.renderNumberInput(index, 'maxSize', action.maxSize)}</td>
+                  <td>{this.renderNumberInput(index, 'desiredCapacity', action.desiredCapacity)}</td>
+                  <td>
+                    <button
+                      aria-label="Remove scheduled action"
+                      className="btn btn-link"
+                      onClick={() => this.removeScheduledAction(index)}
+                      type="button"
+                    >
+                      <span className="glyphicon glyphicon-trash" />
+                    </button>
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+          <button className="add-new col-md-12" onClick={this.addScheduledAction} type="button">
+            <span className="glyphicon glyphicon-plus-sign" /> Add new Scheduled Action
+          </button>
+        </Modal.Body>
+        <AwsModalFooter account={serverGroup.account} isValid={valid} onCancel={dismissModal} onSubmit={this.submit} />
+      </>
+    );
+  }
+}

package/src/serverGroup/details/scheduledActions/index.ts

@@ -0,0 +1 @@
+export * from './EditScheduledActionsModal';

package/src/serverGroup/details/sections/AdvancedSettingsDetailsSection.tsx

@@ -1,26 +1,19 @@
 import React from 'react';
 
-import { CollapsibleSection, confirmNotManaged, ModalInjector } from '@spinnaker/core';
+import { CollapsibleSection, DeckRuntimeContext } from '@spinnaker/core';
 import { HelpField } from '@spinnaker/core';
 
 import type { IAmazonServerGroupDetailsSectionProps } from './IAmazonServerGroupDetailsSectionProps';
+import { EditAsgAdvancedSettingsModal } from '../advancedSettings';
 import { AWSProviderSettings } from '../../../aws.settings';
 
 export class AdvancedSettingsDetailsSection extends React.Component<IAmazonServerGroupDetailsSectionProps> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
   private editAdvancedSettings = (): void => {
-    const { app, serverGroup } = this.props;
-    confirmNotManaged(serverGroup, app).then(
-      (notManaged) =>
-        notManaged &&
-        ModalInjector.modalService.open({
-          templateUrl: require('../advancedSettings/editAsgAdvancedSettings.modal.html'),
-          controller: 'EditAsgAdvancedSettingsCtrl as ctrl',
-          resolve: {
-            application: () => app,
-            serverGroup: () => serverGroup,
-          },
-        }),
-    );
+    const { app: application, serverGroup } = this.props;
+    EditAsgAdvancedSettingsModal.show({ application, serverGroup }, this.context.services);
   };
 
   public render(): JSX.Element {

package/src/serverGroup/details/sections/AmazonCapacityDetailsSection.tsx

@@ -1,7 +1,13 @@
 import React from 'react';
 
 import type { ICapacity } from '@spinnaker/core';
-import { CapacityDetailsSection, CollapsibleSection, Overridable, ViewScalingActivitiesLink } from '@spinnaker/core';
+import {
+  CapacityDetailsSection,
+  CollapsibleSection,
+  DeckRuntimeContext,
+  Overridable,
+  ViewScalingActivitiesLink,
+} from '@spinnaker/core';
 
 import type { IAmazonServerGroupDetailsSectionProps } from './IAmazonServerGroupDetailsSectionProps';
 import { AWSProviderSettings } from '../../../aws.settings';
@@ -9,6 +15,9 @@ import { AmazonResizeServerGroupModal } from '../resize/AmazonResizeServerGroupM
 
 @Overridable('amazon.serverGroup.CapacityDetailsSection')
 export class AmazonCapacityDetailsSection extends React.Component<IAmazonServerGroupDetailsSectionProps> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
   public render(): JSX.Element {
     const { serverGroup, app: application } = this.props;
 
@@ -24,7 +33,10 @@ export class AmazonCapacityDetailsSection extends React.Component<IAmazonServerG
 
         <div>
           {AWSProviderSettings.adHocInfraWritesEnabled && (
-            <a className="clickable" onClick={() => AmazonResizeServerGroupModal.show({ application, serverGroup })}>
+            <a
+              className="clickable"
+              onClick={() => AmazonResizeServerGroupModal.show({ application, serverGroup }, this.context.services)}
+            >
               Resize Server Group
             </a>
           )}