@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/pipeline/stages/invokeLambda/index.ts

@@ -1,18 +1,14 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { module } from 'angular';
-
 import { Registry, SETTINGS } from '@spinnaker/core';
 
 import { lambdaInvokeStage } from './LambdaInvokeStage';
 
 export * from './LambdaInvokeStage';
 
-export const AMAZON_PIPELINE_STAGES_LAMBDA_INVOKE = 'spinnaker.amazon.pipeline.stage.Aws.LambdaInvokeStage';
-
-module(AMAZON_PIPELINE_STAGES_LAMBDA_INVOKE, []).config(function () {
+export function registerLambdaInvokeStage(): void {
   if (SETTINGS.feature.lambdaAdditionalStages) {
     Registry.pipeline.registerStage(lambdaInvokeStage);
   }
-});
+}

package/src/pipeline/stages/modifyScalingProcess/ModifyScalingProcessStageConfig.tsx

@@ -0,0 +1,146 @@
+import React from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  ChecklistInput,
+  StageConfigField,
+  StageConstants,
+} from '@spinnaker/core';
+
+const ACTIONS = [
+  { label: 'Suspend', value: 'suspend' },
+  { label: 'Resume', value: 'resume' },
+];
+
+const SCALING_PROCESSES = [
+  'Launch',
+  'Terminate',
+  'AddToLoadBalancer',
+  'AlarmNotification',
+  'AZRebalance',
+  'HealthCheck',
+  'ReplaceUnhealthy',
+  'ScheduledActions',
+];
+
+export function ModifyScalingProcessStageConfig({
+  application,
+  pipeline,
+  stage,
+  updateStage,
+  updateStageField,
+}: IStageConfigProps) {
+  const [accounts, setAccounts] = React.useState<IAccount[]>([]);
+
+  React.useEffect(() => {
+    let mounted = true;
+    AccountService.listAccounts('aws').then((loadedAccounts) => mounted && setAccounts(loadedAccounts));
+    return () => {
+      mounted = false;
+    };
+  }, []);
+
+  React.useEffect(() => {
+    const defaults: Record<string, any> = {};
+    const defaultCredentials = application.defaultCredentials.aws;
+    const defaultRegion = application.defaultRegions.aws;
+
+    if (!stage.cloudProvider) {
+      defaults.cloudProvider = 'aws';
+    }
+    if (!stage.processes) {
+      defaults.processes = [];
+    }
+    if (!stage.regions) {
+      defaults.regions = defaultRegion ? [defaultRegion] : [];
+    } else if (!stage.regions.length && defaultRegion) {
+      defaults.regions = [defaultRegion];
+    }
+    if (!stage.credentials && defaultCredentials) {
+      defaults.credentials = defaultCredentials;
+    }
+    if (!stage.action) {
+      defaults.action = ACTIONS[0].value;
+    }
+    if (!stage.target) {
+      defaults.target = StageConstants.TARGET_LIST[0].val;
+    }
+    if (stage.suspendProcesses !== undefined || stage.resumeProcesses !== undefined) {
+      defaults.suspendProcesses = undefined;
+      defaults.resumeProcesses = undefined;
+    }
+    if (Object.keys(defaults).length) {
+      updateStageField(defaults);
+    }
+  }, [
+    application.defaultCredentials.aws,
+    application.defaultRegions.aws,
+    stage.action,
+    stage.cloudProvider,
+    stage.credentials,
+    stage.processes,
+    stage.regions,
+    stage.resumeProcesses,
+    stage.suspendProcesses,
+    stage.target,
+    updateStageField,
+  ]);
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={{ ...stage }}
+          onComponentUpdate={updateStage}
+        />
+      )}
+      <StageConfigField label="Target">
+        <select
+          className="form-control input-sm"
+          name="target"
+          onChange={(event) => updateStageField({ target: event.target.value })}
+          value={stage.target || StageConstants.TARGET_LIST[0].val}
+        >
+          {StageConstants.TARGET_LIST.map((target) => (
+            <option key={target.val} title={target.description} value={target.val}>
+              {target.label}
+            </option>
+          ))}
+        </select>
+      </StageConfigField>
+      <StageConfigField label="Action">
+        <select
+          className="form-control input-sm"
+          name="action"
+          onChange={(event) =>
+            updateStageField({
+              action: event.target.value,
+              suspendProcesses: undefined,
+              resumeProcesses: undefined,
+            })
+          }
+          value={stage.action || ACTIONS[0].value}
+        >
+          {ACTIONS.map((action) => (
+            <option key={action.value} value={action.value}>
+              {action.label}
+            </option>
+          ))}
+        </select>
+      </StageConfigField>
+      <StageConfigField label="Processes">
+        <ChecklistInput
+          name="processes"
+          onChange={(event: any) => updateStageField({ processes: event.target.value })}
+          showSelectAll={true}
+          stringOptions={SCALING_PROCESSES}
+          value={stage.processes || []}
+        />
+      </StageConfigField>
+    </div>
+  );
+}

package/src/pipeline/stages/modifyScalingProcess/modifyScalingProcessStage.js

@@ -1,98 +1,27 @@
-'use strict';
-
-import { module } from 'angular';
-import { AccountService, Registry, StageConstants } from '@spinnaker/core';
-
-export const AMAZON_PIPELINE_STAGES_MODIFYSCALINGPROCESS_MODIFYSCALINGPROCESSSTAGE =
-  'spinnaker.amazon.pipeline.stage.modifyScalingProcessStage';
-export const name = AMAZON_PIPELINE_STAGES_MODIFYSCALINGPROCESS_MODIFYSCALINGPROCESSSTAGE; // for backwards compatibility
-module(AMAZON_PIPELINE_STAGES_MODIFYSCALINGPROCESS_MODIFYSCALINGPROCESSSTAGE, [])
-  .config(function () {
-    Registry.pipeline.registerStage({
-      label: 'Modify Scaling Process',
-      description: 'Suspend/Resume Scaling Processes',
-      key: 'modifyAwsScalingProcess',
-      alias: 'modifyScalingProcess',
-      controller: 'ModifyScalingProcessStageCtrl',
-      templateUrl: require('./modifyScalingProcessStage.html'),
-      executionDetailsUrl: require('./modifyScalingProcessExecutionDetails.html'),
-      executionConfigSections: ['modifyScalingProcessesConfig', 'taskStatus'],
-      validators: [
-        { type: 'requiredField', fieldName: 'cluster' },
-        { type: 'requiredField', fieldName: 'target' },
-        { type: 'requiredField', fieldName: 'action' },
-        { type: 'requiredField', fieldName: 'regions' },
-        { type: 'requiredField', fieldName: 'processes' },
-        { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
-      ],
-      cloudProvider: 'aws',
-      strategy: true,
-    });
-  })
-  .controller('ModifyScalingProcessStageCtrl', [
-    '$scope',
-    'stage',
-    function ($scope, stage) {
-      $scope.stage = stage;
-
-      $scope.state = {
-        accounts: false,
-        regionsLoaded: false,
-      };
-
-      AccountService.listAccounts('aws').then(function (accounts) {
-        $scope.accounts = accounts;
-        $scope.state.accounts = true;
-      });
-
-      $scope.targets = StageConstants.TARGET_LIST;
-
-      $scope.actions = [
-        {
-          label: 'Suspend',
-          val: 'suspend',
-        },
-        {
-          label: 'Resume',
-          val: 'resume',
-        },
-      ];
-      $scope.processes = [
-        'Launch',
-        'Terminate',
-        'AddToLoadBalancer',
-        'AlarmNotification',
-        'AZRebalance',
-        'HealthCheck',
-        'ReplaceUnhealthy',
-        'ScheduledActions',
-      ];
-
-      stage.processes = stage.processes || [];
-      stage.regions = stage.regions || [];
-      stage.action = stage.action || $scope.actions[0].val;
-      stage.target = stage.target || $scope.targets[0].val;
-      stage.cloudProvider = 'aws';
-
-      if (!stage.credentials && $scope.application.defaultCredentials.aws) {
-        stage.credentials = $scope.application.defaultCredentials.aws;
-      }
-      if (!stage.regions.length && $scope.application.defaultRegions.aws) {
-        stage.regions.push($scope.application.defaultRegions.aws);
-      }
-
-      $scope.toggleProcess = function (process) {
-        if (!stage.processes) {
-          stage.processes = [];
-        }
-        const idx = stage.processes.indexOf(process);
-        if (idx > -1) {
-          stage.processes.splice(idx, 1);
-        } else {
-          stage.processes.push(process);
-        }
-      };
-
-      $scope.$watch('stage.credentials', $scope.accountUpdated);
-    },
-  ]);
+import { Registry } from '@spinnaker/core';
+
+import { ModifyScalingProcessStageConfig } from './ModifyScalingProcessStageConfig';
+
+export const awsModifyScalingProcessStage = {
+  label: 'Modify Scaling Process',
+  description: 'Suspend/Resume Scaling Processes',
+  key: 'modifyAwsScalingProcess',
+  alias: 'modifyScalingProcess',
+  component: ModifyScalingProcessStageConfig,
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'action' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'processes' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+  cloudProvider: 'aws',
+  strategy: true,
+};
+
+export function registerAwsModifyScalingProcessStage() {
+  Registry.pipeline.registerStage(awsModifyScalingProcessStage);
+}
+
+registerAwsModifyScalingProcessStage();

package/src/pipeline/stages/modifyScalingProcess/modifyScalingProcessStage.spec.tsx

@@ -0,0 +1,167 @@
+import { mount, shallow } from 'enzyme';
+import React from 'react';
+
+import { AccountRegionClusterSelector, AccountService, ChecklistInput, StageConstants } from '@spinnaker/core';
+
+import { AmazonStageConfig } from '../AmazonStageConfig';
+import { awsModifyScalingProcessStage } from './modifyScalingProcessStage';
+
+describe('AWS Modify Scaling Process stage', () => {
+  function renderEditor(stage: any = {}, pipeline: any = {}) {
+    const updateStageField = jasmine.createSpy('updateStageField');
+    const updateStage = jasmine.createSpy('updateStage');
+    const StageConfig = awsModifyScalingProcessStage.component;
+    const stageModel = { type: 'modifyAwsScalingProcess', cloudProviderType: 'aws', ...stage };
+    const wrapper = shallow(
+      <StageConfig
+        {...({
+          application: { defaultCredentials: {}, defaultRegions: {}, getDataSource: () => ({ data: [] }) },
+          pipeline,
+          stage: stageModel,
+          updateStage,
+          updateStageField,
+        } as any)}
+      />,
+    );
+
+    return { stage: stageModel, updateStage, updateStageField, wrapper };
+  }
+
+  it('registers a dedicated stage editor', () => {
+    expect(awsModifyScalingProcessStage.component).not.toBe(AmazonStageConfig);
+  });
+
+  it('renders the AWS server group selectors for a pipeline stage', () => {
+    const { wrapper } = renderEditor({ target: 'current_asg' });
+    const target = wrapper.find('select[name="target"]');
+
+    expect(wrapper.find(AccountRegionClusterSelector).exists()).toBe(true);
+    expect(target.exists()).toBe(true);
+    if (!wrapper.find(AccountRegionClusterSelector).exists() || !target.exists()) {
+      return;
+    }
+    expect(target.find('option').map((option) => option.prop('value'))).toEqual(
+      StageConstants.TARGET_LIST.map((option) => option.val),
+    );
+    expect(target.prop('value')).toBe('current_asg');
+  });
+
+  it('reports account, region, and cluster changes from an unmutated stage', () => {
+    const { stage, updateStage, updateStageField, wrapper } = renderEditor({
+      credentials: 'test',
+      regions: ['eu-west-1'],
+      cluster: 'app-main',
+    });
+    const selector = wrapper.find(AccountRegionClusterSelector);
+    const selectorStage = selector.prop('component');
+
+    expect(selectorStage).not.toBe(stage);
+    selectorStage.credentials = 'prod';
+    selectorStage.regions = ['us-east-1'];
+    selectorStage.cluster = 'app-prod';
+    selector.prop('onComponentUpdate')(selectorStage);
+
+    expect(stage).toEqual(
+      jasmine.objectContaining({ credentials: 'test', regions: ['eu-west-1'], cluster: 'app-main' }),
+    );
+    expect(updateStage).toHaveBeenCalledWith(
+      jasmine.objectContaining({ credentials: 'prod', regions: ['us-east-1'], cluster: 'app-prod' }),
+    );
+    expect(updateStageField).not.toHaveBeenCalled();
+  });
+
+  it('uses the AWS scaling process names and preserves process arrays', () => {
+    const processes = ['Launch', 'AZRebalance'];
+    const nextProcesses = ['Terminate', 'ScheduledActions'];
+    const { updateStageField, wrapper } = renderEditor({ processes });
+    const checklist = wrapper.find(ChecklistInput).filterWhere((input) => input.prop('name') === 'processes');
+
+    expect(checklist.exists()).toBe(true);
+    if (!checklist.exists()) {
+      return;
+    }
+    expect(checklist.prop('stringOptions')).toEqual([
+      'Launch',
+      'Terminate',
+      'AddToLoadBalancer',
+      'AlarmNotification',
+      'AZRebalance',
+      'HealthCheck',
+      'ReplaceUnhealthy',
+      'ScheduledActions',
+    ]);
+    expect(checklist.prop('value')).toBe(processes);
+
+    checklist.prop('onChange')({ target: { value: nextProcesses } } as any);
+
+    expect(updateStageField).toHaveBeenCalledWith({ processes: nextProcesses });
+  });
+
+  it('supports suspend and resume while clearing only legacy action fields', () => {
+    const processes = ['Launch', 'HealthCheck'];
+    const stage = {
+      action: 'suspend',
+      processes,
+      suspendProcesses: ['Terminate'],
+      resumeProcesses: ['AZRebalance'],
+    };
+    const { updateStageField, wrapper } = renderEditor(stage);
+    const action = wrapper.find('select[name="action"]');
+
+    expect(action.exists()).toBe(true);
+    if (!action.exists()) {
+      return;
+    }
+    expect(action.find('option').map((option) => [option.prop('value'), option.text()])).toEqual([
+      ['suspend', 'Suspend'],
+      ['resume', 'Resume'],
+    ]);
+
+    action.simulate('change', { target: { value: 'resume' } });
+
+    const changes = updateStageField.calls.mostRecent().args[0];
+    expect(changes).toEqual({ action: 'resume', suspendProcesses: undefined, resumeProcesses: undefined });
+    expect(Object.prototype.hasOwnProperty.call(changes, 'processes')).toBe(false);
+    expect(stage.processes).toBe(processes);
+  });
+
+  it('normalizes legacy process fields when reopening without changing action', () => {
+    spyOn(AccountService, 'listAccounts').and.returnValue(Promise.resolve([]));
+    const processes = ['Launch', 'ScheduledActions'];
+    const stage = {
+      type: 'modifyAwsScalingProcess',
+      cloudProvider: 'aws',
+      cloudProviderType: 'aws',
+      credentials: 'test',
+      regions: ['eu-west-1'],
+      cluster: 'app-main',
+      target: 'current_asg',
+      action: 'suspend',
+      processes,
+      suspendProcesses: ['Terminate'],
+      resumeProcesses: ['AZRebalance'],
+    };
+    const updateStageField = jasmine.createSpy('updateStageField');
+    const StageConfig = awsModifyScalingProcessStage.component;
+    const wrapper = mount(
+      <StageConfig
+        {...({
+          application: { defaultCredentials: {}, defaultRegions: {} },
+          pipeline: { strategy: true },
+          stage,
+          updateStage: jasmine.createSpy('updateStage'),
+          updateStageField,
+        } as any)}
+      />,
+    );
+
+    expect(updateStageField).toHaveBeenCalledWith({
+      suspendProcesses: undefined,
+      resumeProcesses: undefined,
+    });
+    expect(Object.prototype.hasOwnProperty.call(updateStageField.calls.mostRecent().args[0], 'processes')).toBe(false);
+    expect(stage.processes).toBe(processes);
+
+    wrapper.unmount();
+  });
+});

package/src/pipeline/stages/modifyWarmPool/ModifyWarmPoolStageConfig.tsx

@@ -0,0 +1,157 @@
+import React from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import { AccountRegionClusterSelector, AccountService, StageConfigField, StageConstants } from '@spinnaker/core';
+
+const ACTIONS = [
+  { label: 'Upsert', value: 'upsert' },
+  { label: 'Delete', value: 'delete' },
+];
+
+const POOL_STATES = ['Stopped', 'Running', 'Hibernated'];
+
+export function ModifyWarmPoolStageConfig({
+  application,
+  pipeline,
+  stage,
+  updateStage,
+  updateStageField,
+}: IStageConfigProps) {
+  const [accounts, setAccounts] = React.useState<IAccount[]>([]);
+
+  React.useEffect(() => {
+    let mounted = true;
+    AccountService.listAccounts('aws').then((loadedAccounts) => mounted && setAccounts(loadedAccounts));
+    return () => {
+      mounted = false;
+    };
+  }, []);
+
+  React.useEffect(() => {
+    const defaults: Record<string, any> = {};
+    const defaultCredentials = application.defaultCredentials.aws;
+    const defaultRegion = application.defaultRegions.aws;
+
+    if (!stage.cloudProvider) {
+      defaults.cloudProvider = 'aws';
+    }
+    if (!stage.regions) {
+      defaults.regions = defaultRegion ? [defaultRegion] : [];
+    } else if (!stage.regions.length && defaultRegion) {
+      defaults.regions = [defaultRegion];
+    }
+    if (!stage.credentials && defaultCredentials) {
+      defaults.credentials = defaultCredentials;
+    }
+    if (!stage.action) {
+      defaults.action = ACTIONS[0].value;
+    }
+    if (!stage.target) {
+      defaults.target = StageConstants.TARGET_LIST[0].val;
+    }
+    if (!stage.poolState) {
+      defaults.poolState = POOL_STATES[0];
+    }
+    if (Object.keys(defaults).length) {
+      updateStageField(defaults);
+    }
+  }, [
+    application.defaultCredentials.aws,
+    application.defaultRegions.aws,
+    stage.action,
+    stage.cloudProvider,
+    stage.credentials,
+    stage.poolState,
+    stage.regions,
+    stage.target,
+    updateStageField,
+  ]);
+
+  const isUpsert = (stage.action || ACTIONS[0].value) === 'upsert';
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={{ ...stage }}
+          onComponentUpdate={updateStage}
+        />
+      )}
+      <StageConfigField label="Target">
+        <select
+          className="form-control input-sm"
+          name="target"
+          onChange={(event) => updateStageField({ target: event.target.value })}
+          value={stage.target || StageConstants.TARGET_LIST[0].val}
+        >
+          {StageConstants.TARGET_LIST.map((target) => (
+            <option key={target.val} title={target.description} value={target.val}>
+              {target.label}
+            </option>
+          ))}
+        </select>
+      </StageConfigField>
+      <StageConfigField label="Action">
+        <select
+          className="form-control input-sm"
+          name="action"
+          onChange={(event) => updateStageField({ action: event.target.value })}
+          value={stage.action || ACTIONS[0].value}
+        >
+          {ACTIONS.map((action) => (
+            <option key={action.value} value={action.value}>
+              {action.label}
+            </option>
+          ))}
+        </select>
+      </StageConfigField>
+      {isUpsert && (
+        <>
+          <StageConfigField label="Min Size">
+            <input
+              className="form-control input-sm"
+              type="number"
+              min={0}
+              name="minSize"
+              onChange={(event) => updateStageField({ minSize: Number(event.target.value) })}
+              value={stage.minSize ?? 0}
+            />
+          </StageConfigField>
+          <StageConfigField label="Max Group Prepared Capacity">
+            <input
+              className="form-control input-sm"
+              type="number"
+              min={-1}
+              name="maxGroupPreparedCapacity"
+              onChange={(event) => updateStageField({ maxGroupPreparedCapacity: Number(event.target.value) })}
+              value={stage.maxGroupPreparedCapacity ?? -1}
+            />
+          </StageConfigField>
+          <StageConfigField label="Instance State">
+            <select
+              className="form-control input-sm"
+              name="poolState"
+              onChange={(event) => updateStageField({ poolState: event.target.value })}
+              value={stage.poolState || POOL_STATES[0]}
+            >
+              {POOL_STATES.map((state) => (
+                <option key={state} value={state}>
+                  {state}
+                </option>
+              ))}
+            </select>
+          </StageConfigField>
+          <StageConfigField label="Reuse Instances on Scale In">
+            <input
+              type="checkbox"
+              checked={!!stage.reuseOnScaleIn}
+              onChange={(event) => updateStageField({ reuseOnScaleIn: event.target.checked })}
+            />
+          </StageConfigField>
+        </>
+      )}
+    </div>
+  );
+}

package/src/pipeline/stages/modifyWarmPool/modifyWarmPoolStage.js

@@ -0,0 +1,26 @@
+import { Registry } from '@spinnaker/core';
+
+import { ModifyWarmPoolStageConfig } from './ModifyWarmPoolStageConfig';
+
+export const awsModifyWarmPoolStage = {
+  label: 'Modify Warm Pool',
+  description: 'Upsert or delete an Auto Scaling Group warm pool',
+  key: 'modifyWarmPool',
+  component: ModifyWarmPoolStageConfig,
+  executionConfigSections: ['modifyWarmPoolConfig', 'taskStatus'],
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'action' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+  cloudProvider: 'aws',
+  strategy: true,
+};
+
+export function registerAwsModifyWarmPoolStage() {
+  Registry.pipeline.registerStage(awsModifyWarmPoolStage);
+}
+
+registerAwsModifyWarmPoolStage();