@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/pipeline/stages/scaleDownCluster/AwsScaleDownClusterStageConfig.tsx

@@ -0,0 +1,121 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import { AccountRegionClusterSelector, AccountService, Registry, StageConfigField } from '@spinnaker/core';
+
+function pluralize(str: string, val: number): string {
+  return val === 1 ? str : `${str}s`;
+}
+
+export function AwsScaleDownClusterStageConfig(props: IStageConfigProps) {
+  const { application, pipeline, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'aws') {
+      changes.cloudProvider = 'aws';
+    }
+    if (!stage.credentials && application.defaultCredentials?.aws) {
+      changes.credentials = application.defaultCredentials.aws;
+    }
+    if (stage.remainingFullSizeServerGroups === undefined) {
+      changes.remainingFullSizeServerGroups = 1;
+    }
+    if (stage.allowScaleDownActive === undefined) {
+      changes.allowScaleDownActive = false;
+    }
+    if (stage.preferLargerOverNewer === undefined) {
+      changes.preferLargerOverNewer = 'false';
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('aws').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={stage}
+          onComponentUpdate={stageFieldUpdated}
+        />
+      )}
+      <StageConfigField label="Scale Down Options">
+        <div className="form-inline">
+          <p>
+            Keep the{' '}
+            <input
+              className="form-control input-sm"
+              min={0}
+              onChange={(event) => updateStageField({ remainingFullSizeServerGroups: Number(event.target.value) })}
+              required
+              style={{ width: 50 }}
+              type="number"
+              value={stage.remainingFullSizeServerGroups ?? ''}
+            />{' '}
+            <select
+              className="form-control input-sm"
+              onChange={(event) => updateStageField({ preferLargerOverNewer: event.target.value })}
+              style={{ width: 100 }}
+              value={stage.preferLargerOverNewer ?? 'false'}
+            >
+              <option value="true">largest</option>
+              <option value="false">newest</option>
+            </select>{' '}
+            {pluralize('server group', stage.remainingFullSizeServerGroups)} at current size.
+          </p>
+          <p>The remaining server groups will be scaled down to zero instances.</p>
+        </div>
+      </StageConfigField>
+      <div className="form-group">
+        <div className="col-md-offset-3 col-md-6 checkbox">
+          <label>
+            <input
+              checked={!!stage.allowScaleDownActive}
+              onChange={(event) => updateStageField({ allowScaleDownActive: event.target.checked })}
+              type="checkbox"
+            />
+            Allow scale down of active server groups
+          </label>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export const awsScaleDownClusterStage = {
+  key: 'scaleDownCluster',
+  provides: 'scaleDownCluster',
+  cloudProvider: 'aws',
+  component: AwsScaleDownClusterStageConfig,
+  accountExtractor: (stage: any) => [stage.context.credentials],
+  configAccountExtractor: (stage: any) => [stage.credentials],
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    {
+      type: 'requiredField',
+      fieldName: 'remainingFullSizeServerGroups',
+      fieldLabel: 'Keep [X] full size Server Groups',
+    },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+  strategy: true,
+};
+
+export function registerAwsScaleDownClusterStage() {
+  Registry.pipeline.registerStage(awsScaleDownClusterStage);
+}
+
+registerAwsScaleDownClusterStage();

package/src/pipeline/stages/shrinkCluster/AwsShrinkClusterStageConfig.tsx

@@ -0,0 +1,136 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  PlatformHealthOverride,
+  Registry,
+  StageConfigField,
+} from '@spinnaker/core';
+
+function pluralize(str: string, val: number): string {
+  return val === 1 ? str : `${str}s`;
+}
+
+export function AwsShrinkClusterStageConfig(props: IStageConfigProps) {
+  const { application, pipeline, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'aws') {
+      changes.cloudProvider = 'aws';
+    }
+    if (!stage.credentials && application.defaultCredentials?.aws) {
+      changes.credentials = application.defaultCredentials.aws;
+    }
+    if (stage.shrinkToSize === undefined) {
+      changes.shrinkToSize = 1;
+    }
+    if (stage.allowDeleteActive === undefined) {
+      changes.allowDeleteActive = false;
+    }
+    if (stage.retainLargerOverNewer === undefined) {
+      changes.retainLargerOverNewer = 'false';
+    }
+    if (
+      stage.isNew &&
+      application.attributes.platformHealthOnlyShowOverride &&
+      application.attributes.platformHealthOnly &&
+      stage.interestingHealthProviderNames === undefined
+    ) {
+      changes.interestingHealthProviderNames = ['Amazon'];
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('aws').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={stage}
+          onComponentUpdate={stageFieldUpdated}
+        />
+      )}
+      <StageConfigField label="Shrink Options">
+        <div className="form-inline">
+          Shrink to{' '}
+          <input
+            className="form-control input-sm"
+            min={0}
+            onChange={(event) => updateStageField({ shrinkToSize: Number(event.target.value) })}
+            required
+            style={{ width: 50 }}
+            type="number"
+            value={stage.shrinkToSize ?? ''}
+          />{' '}
+          {pluralize('server group', stage.shrinkToSize)}, keeping the{' '}
+          <select
+            className="form-control input-sm"
+            onChange={(event) => updateStageField({ retainLargerOverNewer: event.target.value })}
+            style={{ width: 100 }}
+            value={stage.retainLargerOverNewer ?? 'false'}
+          >
+            <option value="true">largest</option>
+            <option value="false">newest</option>
+          </select>
+        </div>
+      </StageConfigField>
+      <div className="form-group">
+        <div className="col-md-offset-3 col-md-6 checkbox">
+          <label>
+            <input
+              checked={!!stage.allowDeleteActive}
+              onChange={(event) => updateStageField({ allowDeleteActive: event.target.checked })}
+              type="checkbox"
+            />
+            Allow deletion of active server groups
+          </label>
+        </div>
+      </div>
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <StageConfigField label="Task Completion">
+          <PlatformHealthOverride
+            interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+            onChange={(interestingHealthProviderNames) => updateStageField({ interestingHealthProviderNames })}
+            platformHealthType="Amazon"
+          />
+        </StageConfigField>
+      )}
+    </div>
+  );
+}
+
+export const awsShrinkClusterStage = {
+  key: 'shrinkCluster',
+  provides: 'shrinkCluster',
+  cloudProvider: 'aws',
+  component: AwsShrinkClusterStageConfig,
+  accountExtractor: (stage: any) => [stage.context.credentials],
+  configAccountExtractor: (stage: any) => [stage.credentials],
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'shrinkToSize', fieldLabel: 'shrink to [X] Server Groups' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+};
+
+export function registerAwsShrinkClusterStage() {
+  Registry.pipeline.registerStage(awsShrinkClusterStage);
+}
+
+registerAwsShrinkClusterStage();

package/src/pipeline/stages/tagImage/awsTagImageStage.spec.tsx

@@ -0,0 +1,167 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { AccountService, MapEditor } from '@spinnaker/core';
+
+import { AmazonStageConfig } from '../AmazonStageConfig';
+import { awsTagImageStage } from './awsTagImageStage';
+
+describe('AwsTagImageStageConfig', () => {
+  const application = {
+    defaultCredentials: {},
+    defaultRegions: {},
+    getDataSource: () => ({ data: [] }),
+  } as any;
+
+  beforeEach(() => {
+    spyOn(AccountService, 'listAccounts').and.returnValue(Promise.resolve([]) as any);
+    spyOn(AccountService, 'getUniqueAttributeForAllAccounts').and.returnValue(Promise.resolve([]) as any);
+  });
+
+  function renderStage(stageOverrides: Record<string, any> = {}) {
+    const bake = { name: 'Bake image', refId: 'bake-ref', requisiteStageRefIds: [], type: 'bake' };
+    const findImage = {
+      name: 'Find image',
+      refId: 'find-image-ref',
+      requisiteStageRefIds: [],
+      type: 'findImageFromTags',
+    };
+    const wait = { name: 'Wait', refId: 'wait-ref', requisiteStageRefIds: ['find-image-ref'], type: 'wait' };
+    const unrelatedBake = {
+      name: 'Unrelated bake',
+      refId: 'unrelated-bake-ref',
+      requisiteStageRefIds: [],
+      type: 'bake',
+    };
+    const stage = {
+      cloudProvider: 'aws',
+      consideredStages: ['bake-ref', 'stale-ref'],
+      name: 'Tag image',
+      refId: 'tag-image-ref',
+      requisiteStageRefIds: ['bake-ref', 'wait-ref'],
+      tags: { Owner: '', 'legacy:key': 'persisted' },
+      type: 'upsertImageTags',
+      ...stageOverrides,
+    };
+    const pipeline = { stages: [bake, findImage, wait, unrelatedBake, stage] } as any;
+    const updateStageField = jasmine.createSpy('updateStageField');
+    const StageComponent = awsTagImageStage.component as React.ComponentType<any>;
+
+    const wrapper = mount(
+      <StageComponent
+        application={application}
+        pipeline={pipeline}
+        stage={stage}
+        stageFieldUpdated={jasmine.createSpy('stageFieldUpdated')}
+        updateStage={jasmine.createSpy('updateStage')}
+        updateStageField={updateStageField}
+      />,
+    );
+
+    return { stage, updateStageField, wrapper };
+  }
+
+  it('registers a dedicated editor instead of the generic Amazon stage editor', () => {
+    expect(awsTagImageStage.component).not.toBe(AmazonStageConfig);
+  });
+
+  it('persists missing defaults once without causing an update loop', () => {
+    const { stage, updateStageField, wrapper } = renderStage({ cloudProvider: undefined, tags: undefined });
+
+    expect(updateStageField.calls.allArgs()).toEqual([[{ cloudProvider: 'aws', tags: {} }]]);
+
+    wrapper.setProps({ stage: { ...stage, cloudProvider: 'aws', tags: {} } });
+
+    expect(updateStageField).toHaveBeenCalledTimes(1);
+  });
+
+  it('preserves an explicit cloud provider while initializing missing tags', () => {
+    const { updateStageField } = renderStage({ cloudProvider: 'aws-custom', tags: undefined });
+
+    expect(updateStageField.calls.allArgs()).toEqual([[{ tags: {} }]]);
+  });
+
+  it('preserves explicit tags while initializing a missing cloud provider', () => {
+    const tags = { Owner: '', unknown: 'persisted' };
+    const { updateStageField, wrapper } = renderStage({ cloudProvider: undefined, tags });
+
+    expect(updateStageField.calls.allArgs()).toEqual([[{ cloudProvider: 'aws' }]]);
+    expect(wrapper.find(MapEditor).prop('model')).toBe(tags);
+  });
+
+  it('round-trips added, edited, and removed tags as structured objects', () => {
+    const { stage, updateStageField, wrapper } = renderStage();
+    const mapEditor = wrapper.find(MapEditor);
+
+    expect(mapEditor.exists()).toBe(true);
+    if (!mapEditor.exists()) {
+      return;
+    }
+
+    expect(mapEditor.prop('allowEmpty')).toBe(true);
+    expect(mapEditor.prop('model')).toEqual(stage.tags);
+
+    const added = { ...stage.tags, Environment: 'production' };
+    const edited = { ...added, 'legacy:key': 'updated' };
+    const removed = { Owner: '', 'legacy:key': 'updated' };
+    mapEditor.prop('onChange')(added, false);
+    mapEditor.prop('onChange')(edited, false);
+    mapEditor.prop('onChange')(removed, false);
+
+    expect(updateStageField.calls.allArgs()).toEqual([[{ tags: added }], [{ tags: edited }], [{ tags: removed }]]);
+  });
+
+  it('offers only direct and indirect upstream image-producing stage refIds', () => {
+    const { wrapper } = renderStage();
+    const refIds = wrapper
+      .find('input[type="checkbox"]')
+      .map((input) => input.prop('value'))
+      .sort();
+
+    expect(refIds).toEqual(['bake-ref', 'find-image-ref', 'stale-ref']);
+  });
+
+  it('shows a selected stale stage ref as unavailable', () => {
+    const { wrapper } = renderStage();
+    const staleStage = wrapper.find('input[type="checkbox"][value="stale-ref"]');
+
+    expect(staleStage.exists()).toBe(true);
+    if (!staleStage.exists()) {
+      return;
+    }
+
+    expect(staleStage.prop('checked')).toBe(true);
+    expect(staleStage.prop('disabled')).toBe(true);
+    expect(staleStage.closest('label').text()).toContain('stale-ref (unavailable)');
+  });
+
+  it('preserves a stale stage ref when selecting an available stage', () => {
+    const { updateStageField, wrapper } = renderStage();
+    const findImage = wrapper.find('input[type="checkbox"][value="find-image-ref"]');
+
+    expect(findImage.exists()).toBe(true);
+    if (!findImage.exists()) {
+      return;
+    }
+
+    findImage.simulate('change', { target: { checked: true } });
+
+    expect(updateStageField).toHaveBeenCalledWith({
+      consideredStages: ['bake-ref', 'stale-ref', 'find-image-ref'],
+    });
+  });
+
+  it('preserves a stale stage ref when deselecting an available stage', () => {
+    const { updateStageField, wrapper } = renderStage();
+    const bake = wrapper.find('input[type="checkbox"][value="bake-ref"]');
+
+    expect(bake.exists()).toBe(true);
+    if (!bake.exists()) {
+      return;
+    }
+
+    bake.simulate('change', { target: { checked: false } });
+
+    expect(updateStageField).toHaveBeenCalledWith({ consideredStages: ['stale-ref'] });
+  });
+});

package/src/pipeline/stages/tagImage/awsTagImageStage.tsx

@@ -0,0 +1,94 @@
+import React from 'react';
+
+import type { IStageConfigProps, IStageTypeConfig } from '@spinnaker/core';
+import { MapEditor, PipelineConfigService, Registry, StageConfigField, StageConstants } from '@spinnaker/core';
+
+type StageRefId = string | number;
+
+function toggleConsideredStage(current: StageRefId[], refId: StageRefId, checked: boolean): StageRefId[] {
+  if (checked && !current.includes(refId)) {
+    return [...current, refId];
+  }
+  if (!checked) {
+    return current.filter((candidate) => candidate !== refId);
+  }
+  return current;
+}
+
+export function AwsTagImageStageConfig({ pipeline, stage, updateStageField }: IStageConfigProps) {
+  const consideredStages: StageRefId[] = stage.consideredStages || [];
+  const imageProducingStages = PipelineConfigService.getAllUpstreamDependencies(
+    pipeline,
+    stage,
+  ).filter((upstreamStage) => StageConstants.IMAGE_PRODUCING_STAGES.includes(upstreamStage.type));
+  const availableRefIds = new Set(imageProducingStages.map((upstreamStage) => upstreamStage.refId));
+  const staleRefIds = consideredStages.filter((refId) => !availableRefIds.has(refId));
+
+  React.useEffect(() => {
+    const defaults: Record<string, any> = {};
+    if (stage.cloudProvider === undefined) {
+      defaults.cloudProvider = 'aws';
+    }
+    if (stage.tags === undefined) {
+      defaults.tags = {};
+    }
+    if (Object.keys(defaults).length) {
+      updateStageField(defaults);
+    }
+  }, [stage.cloudProvider, stage.tags, updateStageField]);
+
+  return (
+    <div className="form-horizontal">
+      <StageConfigField label="Tags">
+        <MapEditor
+          allowEmpty={true}
+          model={stage.tags || {}}
+          onChange={(tags) => updateStageField({ tags })}
+          pipeline={pipeline}
+        />
+      </StageConfigField>
+      <StageConfigField helpKey="aws.tagImage.consideredStages" label="Stages (optional)">
+        <div className="checkbox">
+          {imageProducingStages.map((upstreamStage) => (
+            <label key={upstreamStage.refId} style={{ display: 'block' }}>
+              <input
+                checked={consideredStages.includes(upstreamStage.refId)}
+                onChange={(event) =>
+                  updateStageField({
+                    consideredStages: toggleConsideredStage(
+                      consideredStages,
+                      upstreamStage.refId,
+                      event.target.checked,
+                    ),
+                  })
+                }
+                type="checkbox"
+                value={upstreamStage.refId}
+              />{' '}
+              {upstreamStage.name || upstreamStage.refId}
+            </label>
+          ))}
+          {staleRefIds.map((refId) => (
+            <label key={refId} style={{ display: 'block' }}>
+              <input checked={true} disabled={true} readOnly={true} type="checkbox" value={refId} /> {refId}{' '}
+              (unavailable)
+            </label>
+          ))}
+        </div>
+      </StageConfigField>
+    </div>
+  );
+}
+
+export const awsTagImageStage = {
+  key: 'upsertImageTags',
+  provides: 'upsertImageTags',
+  cloudProvider: 'aws',
+  component: AwsTagImageStageConfig,
+} as IStageTypeConfig;
+
+export function registerAwsTagImageStage() {
+  Registry.pipeline.registerStage(awsTagImageStage);
+}
+
+registerAwsTagImageStage();

package/src/pipeline/stages/updateCodeLambda/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 { lambdaUpdateCodeStage } from './LambdaUpdateCodeStage';
 
 export * from './LambdaUpdateCodeStage';
 
-export const AMAZON_PIPELINE_STAGES_LAMBDA_UPDATE = 'spinnaker.amazon.pipeline.stage.Aws.LambdaUpdateCodeStage';
-
-module(AMAZON_PIPELINE_STAGES_LAMBDA_UPDATE, []).config(function () {
+export function registerLambdaUpdateStage(): void {
   if (SETTINGS.feature.lambdaAdditionalStages) {
     Registry.pipeline.registerStage(lambdaUpdateCodeStage);
   }
-});
+}