@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/pipeline/stages/cloneServerGroup/AwsCloneServerGroupStageConfig.tsx

@@ -0,0 +1,275 @@
+import { get, set } from 'lodash';
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  AppListExtractor,
+  DeploymentStrategySelector,
+  HelpField,
+  NameUtils,
+  PlatformHealthOverride,
+  Registry,
+  StageConfigField,
+  StageConstants,
+  TargetSelect,
+} from '@spinnaker/core';
+
+const capacityFields = ['min', 'max', 'desired'] as const;
+
+export function AwsCloneServerGroupStageConfig(props: IStageConfigProps) {
+  const { application, pipeline, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (!stage.application) {
+      changes.application = application.name;
+    }
+    if (stage.cloudProvider !== 'aws') {
+      changes.cloudProvider = 'aws';
+    }
+    if (stage.cloudProviderType !== 'aws') {
+      changes.cloudProviderType = 'aws';
+    }
+    if (!stage.credentials && application.defaultCredentials?.aws) {
+      changes.credentials = application.defaultCredentials.aws;
+    }
+    if (stage.target === undefined) {
+      changes.target = StageConstants.TARGET_LIST[0].val;
+    }
+    if (stage.useSourceCapacity === undefined) {
+      changes.useSourceCapacity = true;
+    }
+    if (
+      stage.isNew &&
+      application.attributes.platformHealthOnlyShowOverride &&
+      application.attributes.platformHealthOnly &&
+      stage.interestingHealthProviderNames === undefined
+    ) {
+      changes.interestingHealthProviderNames = ['Amazon'];
+    }
+    if (stage.isNew) {
+      changes.useAmiBlockDeviceMappings = get(
+        application,
+        'attributes.providerSettings.aws.useAmiBlockDeviceMappings',
+        false,
+      );
+      changes.copySourceCustomBlockDeviceMappings = false;
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('aws').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  useEffect(() => {
+    if (stage.targetCluster) {
+      const filterByCluster = AppListExtractor.monikerClusterNameFilter(stage.targetCluster);
+      const moniker = AppListExtractor.getMonikers([application], filterByCluster)[0];
+      if (moniker) {
+        updateStageField({ stack: moniker.stack, freeFormDetails: moniker.detail });
+      } else {
+        const nameParts = NameUtils.parseClusterName(stage.targetCluster);
+        updateStageField({ stack: nameParts.stack, freeFormDetails: nameParts.freeFormDetails });
+      }
+    } else if (stage.stack || stage.freeFormDetails) {
+      updateStageField({ stack: '', freeFormDetails: '' });
+    }
+  }, [stage.targetCluster]);
+
+  const toggleSuspendedProcess = (process: string) => {
+    const suspendedProcesses: string[] = stage.suspendedProcesses ? [...stage.suspendedProcesses] : [];
+    const index = suspendedProcesses.indexOf(process);
+    if (index === -1) {
+      suspendedProcesses.push(process);
+    } else {
+      suspendedProcesses.splice(index, 1);
+    }
+    updateStageField({ suspendedProcesses });
+  };
+
+  const blockDeviceMappingsSource = stage.copySourceCustomBlockDeviceMappings
+    ? 'source'
+    : stage.useAmiBlockDeviceMappings
+    ? 'ami'
+    : 'default';
+
+  const selectBlockDeviceMappingsSource = (selection: string) => {
+    if (selection === 'source') {
+      updateStageField({ copySourceCustomBlockDeviceMappings: true, useAmiBlockDeviceMappings: false });
+    } else if (selection === 'ami') {
+      updateStageField({ copySourceCustomBlockDeviceMappings: false, useAmiBlockDeviceMappings: true });
+    } else {
+      updateStageField({ copySourceCustomBlockDeviceMappings: false, useAmiBlockDeviceMappings: false });
+    }
+  };
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          clusterField="targetCluster"
+          component={stage}
+          onComponentUpdate={stageFieldUpdated}
+          singleRegion="true"
+        />
+      )}
+      <StageConfigField label="Target">
+        <TargetSelect
+          model={{ target: stage.target }}
+          onChange={(target: string) => updateStageField({ target })}
+          options={StageConstants.TARGET_LIST}
+        />
+      </StageConfigField>
+      <StageConfigField label="Capacity">
+        <div className="radio">
+          <label>
+            <input
+              checked={stage.useSourceCapacity !== false}
+              onChange={() => updateStageField({ useSourceCapacity: true, capacity: undefined })}
+              type="radio"
+            />
+            Copy the capacity from the current server group <HelpField id="serverGroupCapacity.useSourceCapacityTrue" />
+          </label>
+        </div>
+        <div className="radio">
+          <label>
+            <input
+              checked={stage.useSourceCapacity === false}
+              onChange={() => updateStageField({ useSourceCapacity: false })}
+              type="radio"
+            />
+            Let me specify the capacity <HelpField id="serverGroupCapacity.useSourceCapacityFalse" />
+          </label>
+        </div>
+      </StageConfigField>
+      {stage.useSourceCapacity === false && (
+        <>
+          <div className="form-group">
+            <div className="col-md-2 col-md-offset-3">Min</div>
+            <div className="col-md-2">Max</div>
+            <div className="col-md-2">Desired</div>
+          </div>
+          <div className="form-group">
+            {capacityFields.map((field) => (
+              <div className="col-md-2" style={field === 'min' ? { marginLeft: '25%' } : undefined} key={field}>
+                <input
+                  className="form-control input-sm"
+                  onChange={(event) =>
+                    updateStageField({
+                      capacity: {
+                        ...stage.capacity,
+                        [field]: event.target.value === '' ? undefined : Number(event.target.value),
+                      },
+                    })
+                  }
+                  required
+                  type="number"
+                  value={stage.capacity?.[field] ?? ''}
+                />
+              </div>
+            ))}
+          </div>
+        </>
+      )}
+      <StageConfigField label="Traffic" helpKey="aws.serverGroup.traffic">
+        <div className="checkbox">
+          <label>
+            <input
+              checked={!(stage.suspendedProcesses || []).includes('AddToLoadBalancer')}
+              onChange={() => toggleSuspendedProcess('AddToLoadBalancer')}
+              type="checkbox"
+            />
+            Send client requests to new instances
+          </label>
+        </div>
+      </StageConfigField>
+      <StageConfigField label="AMI Block Device Mappings">
+        <div className="radio">
+          <div>
+            <label>
+              <input
+                checked={blockDeviceMappingsSource === 'source'}
+                name="blockDeviceMappingsSource"
+                onChange={() => selectBlockDeviceMappingsSource('source')}
+                type="radio"
+              />
+              Copy from current server group <HelpField id="aws.blockDeviceMappings.useSource" />
+            </label>
+          </div>
+          <div>
+            <label>
+              <input
+                checked={blockDeviceMappingsSource === 'ami'}
+                name="blockDeviceMappingsSource"
+                onChange={() => selectBlockDeviceMappingsSource('ami')}
+                type="radio"
+              />
+              Prefer AMI block device mappings <HelpField id="aws.blockDeviceMappings.useAMI" />
+            </label>
+          </div>
+          <div>
+            <label>
+              <input
+                checked={blockDeviceMappingsSource === 'default'}
+                name="blockDeviceMappingsSource"
+                onChange={() => selectBlockDeviceMappingsSource('default')}
+                type="radio"
+              />
+              Defaults for selected instance type <HelpField id="aws.blockDeviceMappings.useDefaults" />
+            </label>
+          </div>
+        </div>
+      </StageConfigField>
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <StageConfigField label="Task Completion">
+          <PlatformHealthOverride
+            interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+            onChange={(interestingHealthProviderNames) => updateStageField({ interestingHealthProviderNames })}
+            platformHealthType="Amazon"
+          />
+        </StageConfigField>
+      )}
+      <DeploymentStrategySelector
+        command={stage as any}
+        fieldColumns="6"
+        onFieldChange={(key, value) => {
+          set(stage, key, value);
+          stageFieldUpdated();
+        }}
+        onStrategyChange={() => stageFieldUpdated()}
+      />
+    </div>
+  );
+}
+
+export const awsCloneServerGroupStage = {
+  key: 'cloneServerGroup',
+  provides: 'cloneServerGroup',
+  cloudProvider: 'aws',
+  component: AwsCloneServerGroupStageConfig,
+  accountExtractor: (stage: any) => [stage.context.credentials],
+  validators: [
+    { type: 'requiredField', fieldName: 'targetCluster', fieldLabel: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'region' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+};
+
+export function registerAwsCloneServerGroupStage() {
+  Registry.pipeline.registerStage(awsCloneServerGroupStage);
+}
+
+registerAwsCloneServerGroupStage();

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

@@ -1,17 +1,13 @@
 // 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 { lambdaDeleteStage } from './LambdaDeleteStage';
 export * from './LambdaDeleteStage';
 
-export const AMAZON_PIPELINE_STAGES_LAMBDA_DELETE = 'spinnaker.amazon.pipeline.stage.Aws.LambdaDeleteStage';
-
-module(AMAZON_PIPELINE_STAGES_LAMBDA_DELETE, []).config(function () {
+export function registerLambdaDeleteStage(): void {
   if (SETTINGS.feature.lambdaAdditionalStages) {
     Registry.pipeline.registerStage(lambdaDeleteStage);
   }
-});
+}

package/src/pipeline/stages/deployCloudFormation/CloudFormationChangeSetInfo.tsx

@@ -1,36 +1,27 @@
-import { module } from 'angular';
-import React, { useState } from 'react';
-import { react2angular } from 'react2angular';
+import React from 'react';
 
-import type { IStage, IStageConfigProps } from '@spinnaker/core';
-import { CheckboxInput, ReactSelectInput, StageConfigField, TextInput, withErrorBoundary } from '@spinnaker/core';
+import type { IStage } from '@spinnaker/core';
+import { CheckboxInput, ReactSelectInput, StageConfigField, TextInput } from '@spinnaker/core';
 
 export interface ICloudFormationChangeSetInfoProps {
-  stage: IStage[];
-  stageconfig: IStageConfigProps;
+  stage: IStage;
+  updateStageField: (changes: { [key: string]: any }) => void;
 }
 
 export const CloudFormationChangeSetInfo = (props: ICloudFormationChangeSetInfoProps) => {
-  const { stage, stageconfig } = props;
-  const [changeSetName, setChangeSetName] = useState(
-    (stage as any).changeSetName ? (stage as any).changeSetName : "ChangeSet-${execution['id']}",
-  );
-  const [executeChangeSet, setExecuteChangeSet] = useState((stage as any).executeChangeSet);
-  const [actionOnReplacement, setActionOnReplacement] = useState((stage as any).actionOnReplacement);
+  const { stage, updateStageField } = props;
+  const changeSetName = stage.changeSetName || "ChangeSet-${execution['id']}";
 
   const modifyChangeSetName = (value: string) => {
-    setChangeSetName(value);
-    stageconfig.updateStageField({ changeSetName: value });
+    updateStageField({ changeSetName: value });
   };
 
   const toggleExecuteChangeSet = (checked: boolean) => {
-    setExecuteChangeSet(checked);
-    stageconfig.updateStageField({ executeChangeSet: checked });
+    updateStageField({ executeChangeSet: checked });
   };
 
   const modifyActionOnReplacement = (value: string) => {
-    setActionOnReplacement(value);
-    stageconfig.updateStageField({ actionOnReplacement: value });
+    updateStageField({ actionOnReplacement: value });
   };
 
   const actionOnReplacementOptions = [
@@ -53,13 +44,13 @@ export const CloudFormationChangeSetInfo = (props: ICloudFormationChangeSetInfoP
         />
       </StageConfigField>
       <StageConfigField label="Execute ChangeSet">
-        <CheckboxInput checked={executeChangeSet} onChange={(e) => toggleExecuteChangeSet(e.target.checked)} />
+        <CheckboxInput checked={stage.executeChangeSet} onChange={(e) => toggleExecuteChangeSet(e.target.checked)} />
       </StageConfigField>
-      {executeChangeSet && (
-        <StageConfigField label="If ChangeSet contains a replacement" help-key="aws.cloudformation.changeSet.options">
+      {stage.executeChangeSet && (
+        <StageConfigField label="If ChangeSet contains a replacement" helpKey="aws.cloudformation.changeSet.options">
           <ReactSelectInput
             clearable={false}
-            value={actionOnReplacement}
+            value={stage.actionOnReplacement}
             options={actionOnReplacementOptions}
             onChange={(e) => modifyActionOnReplacement(e.target.value)}
           />
@@ -68,13 +59,3 @@ export const CloudFormationChangeSetInfo = (props: ICloudFormationChangeSetInfoP
     </div>
   );
 };
-
-export const CLOUD_FORMATION_CHANGE_SET_INFO = 'spinnaker.amazon.cloudformation.changetset.info.component';
-
-module(CLOUD_FORMATION_CHANGE_SET_INFO, []).component(
-  'cloudFormationChangeSetInfo',
-  react2angular(withErrorBoundary(CloudFormationChangeSetInfo, 'cloudFormationChangeSetInfo'), [
-    'stage',
-    'stageconfig',
-  ]),
-);

package/src/pipeline/stages/deployCloudFormation/DeployCloudFormationStackStageConfig.tsx

@@ -0,0 +1,264 @@
+import React from 'react';
+
+import type { IAccount, IArtifact, IExpectedArtifact, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountSelectInput,
+  AccountService,
+  ChecklistInput,
+  MapEditor,
+  ReactSelectInput,
+  StageArtifactSelectorDelegate,
+  StageConfigField,
+  yamlDocumentsToString,
+  YamlEditor,
+} from '@spinnaker/core';
+
+import { CloudFormationChangeSetInfo } from './CloudFormationChangeSetInfo';
+
+const capabilities = ['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM', 'CAPABILITY_AUTO_EXPAND'];
+
+function templateBodyAsYaml(templateBody: any): string {
+  if (typeof templateBody === 'string') {
+    return templateBody;
+  }
+  if (templateBody == null) {
+    return '';
+  }
+  return yamlDocumentsToString(Array.isArray(templateBody) ? templateBody : [templateBody]);
+}
+
+export function DeployCloudFormationStackStageConfig({
+  application,
+  pipeline,
+  stage,
+  updateStageField,
+}: IStageConfigProps) {
+  const [accounts, setAccounts] = React.useState<IAccount[]>([]);
+  const [regions, setRegions] = React.useState<string[]>([]);
+  const [templateEditorState, setTemplateEditorState] = React.useState(() => ({
+    refId: stage.refId,
+    rawTemplateBody: templateBodyAsYaml(stage.templateBody),
+  }));
+  const source = stage.source || 'text';
+  const selectedAccount = stage.credentials || stage.account || '';
+  const accountNames = [selectedAccount, ...accounts.map((account) => account.name)].filter(
+    (account, index, allAccounts) => account && allAccounts.indexOf(account) === index,
+  );
+  const regionNames = [...(stage.regions || []), ...regions].filter(
+    (region, index, allRegions) => region && allRegions.indexOf(region) === index,
+  );
+
+  if (templateEditorState.refId !== stage.refId) {
+    setTemplateEditorState({
+      refId: stage.refId,
+      rawTemplateBody: templateBodyAsYaml(stage.templateBody),
+    });
+  }
+
+  React.useEffect(() => {
+    const changes: Record<string, any> = {};
+    const defaults: Record<string, any> = {
+      capabilities: [],
+      cloudProvider: 'aws',
+      parameters: {},
+      regions: application.defaultRegions?.aws ? [application.defaultRegions.aws] : [],
+      source: 'text',
+      tags: {},
+    };
+
+    Object.entries(defaults).forEach(([field, value]) => {
+      if (stage[field] === undefined) {
+        changes[field] = value;
+      }
+    });
+
+    const defaultCredentials = application.defaultCredentials?.aws;
+    if (defaultCredentials) {
+      if (stage.credentials === undefined) {
+        changes.credentials = defaultCredentials;
+      }
+      if (stage.account === undefined) {
+        changes.account = defaultCredentials;
+      }
+    }
+
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  React.useEffect(() => {
+    let mounted = true;
+    Promise.all([
+      AccountService.getAllAccountDetailsForProvider('aws'),
+      AccountService.getUniqueAttributeForAllAccounts('aws', 'regions'),
+    ]).then(([loadedAccounts, loadedRegions]) => {
+      if (mounted) {
+        setAccounts(loadedAccounts);
+        setRegions(loadedRegions);
+      }
+    });
+    return () => {
+      mounted = false;
+    };
+  }, []);
+
+  const onStackArtifactEdited = (stackArtifact: IArtifact) => {
+    updateStageField({ stackArtifactId: null, stackArtifact });
+  };
+
+  const onStackArtifactSelected = (expectedArtifact: IExpectedArtifact) => {
+    updateStageField({
+      stackArtifactId: expectedArtifact.id,
+      stackArtifactAccount: expectedArtifact.matchArtifact?.artifactAccount || null,
+      stackArtifact: null,
+    });
+  };
+
+  return (
+    <div className="container-fluid form-horizontal">
+      <h4>Basic Settings</h4>
+      <StageConfigField label="Account">
+        <AccountSelectInput
+          accounts={accountNames}
+          name="credentials"
+          onChange={(event: React.ChangeEvent<HTMLSelectElement>) =>
+            updateStageField({ credentials: event.target.value, account: event.target.value })
+          }
+          provider="aws"
+          value={selectedAccount}
+        />
+      </StageConfigField>
+      <StageConfigField label="Regions">
+        <ChecklistInput
+          inline={true}
+          name="regions"
+          onChange={(event: React.ChangeEvent<HTMLInputElement>) => updateStageField({ regions: event.target.value })}
+          showSelectAll={true}
+          stringOptions={regionNames}
+          value={stage.regions || []}
+        />
+      </StageConfigField>
+
+      <h4>Template Configuration</h4>
+      <StageConfigField label="Stack name">
+        <input
+          className="form-control input-sm"
+          name="stackName"
+          onChange={(event) => updateStageField({ stackName: event.target.value })}
+          required={true}
+          type="text"
+          value={stage.stackName || ''}
+        />
+        <label>
+          <input
+            checked={!!stage.isChangeSet}
+            name="isChangeSet"
+            onChange={(event) => updateStageField({ isChangeSet: event.target.checked })}
+            type="checkbox"
+          />{' '}
+          <strong>Create CloudFormation ChangeSet</strong>
+        </label>
+      </StageConfigField>
+      <StageConfigField label="IAM role ARN">
+        <input
+          className="form-control input-sm"
+          name="roleARN"
+          onChange={(event) => updateStageField({ roleARN: event.target.value })}
+          type="text"
+          value={stage.roleARN || ''}
+        />
+      </StageConfigField>
+      <StageConfigField label="Source" helpKey="aws.cloudformation.source">
+        <label>
+          <input
+            checked={source === 'text'}
+            name="source"
+            onChange={() =>
+              updateStageField({
+                source: 'text',
+                stackArtifactId: null,
+                stackArtifactAccount: null,
+                stackArtifact: null,
+              })
+            }
+            type="radio"
+            value="text"
+          />{' '}
+          Text
+        </label>
+        <br />
+        <label>
+          <input
+            checked={source === 'artifact'}
+            name="source"
+            onChange={() => updateStageField({ source: 'artifact' })}
+            type="radio"
+            value="artifact"
+          />{' '}
+          Artifact
+        </label>
+      </StageConfigField>
+
+      {source === 'text' && (
+        <YamlEditor
+          onChange={(raw, templateBody) => {
+            setTemplateEditorState({ refId: stage.refId, rawTemplateBody: raw });
+            if (templateBody !== null) {
+              updateStageField({ templateBody });
+            }
+          }}
+          value={templateEditorState.rawTemplateBody}
+        />
+      )}
+      {source === 'artifact' && (
+        <StageArtifactSelectorDelegate
+          artifact={stage.stackArtifact}
+          excludedArtifactTypePatterns={[]}
+          expectedArtifactId={stage.stackArtifactId}
+          fieldColumns={8}
+          helpKey="aws.cloudformation.expectedArtifact"
+          label="Expected Artifact"
+          onArtifactEdited={onStackArtifactEdited}
+          onExpectedArtifactSelected={onStackArtifactSelected}
+          pipeline={pipeline}
+          stage={stage}
+        />
+      )}
+      {stage.isChangeSet && <CloudFormationChangeSetInfo stage={stage} updateStageField={updateStageField} />}
+
+      <hr />
+      <StageConfigField label="Parameters" fieldColumns={6}>
+        <MapEditor
+          addButtonLabel="Add parameter"
+          model={stage.parameters ?? {}}
+          onChange={(parameters) => updateStageField({ parameters })}
+          pipeline={pipeline}
+          valueCanContainSpel={true}
+        />
+      </StageConfigField>
+      <hr />
+      <StageConfigField label="Tags" fieldColumns={6}>
+        <MapEditor
+          addButtonLabel="Add tag"
+          model={stage.tags ?? {}}
+          onChange={(tags) => updateStageField({ tags })}
+          pipeline={pipeline}
+          valueCanContainSpel={true}
+        />
+      </StageConfigField>
+      <hr />
+      <StageConfigField label="Capabilities" fieldColumns={6}>
+        <ReactSelectInput
+          multi={true}
+          name="capabilities"
+          onChange={(event: React.ChangeEvent<HTMLInputElement>) =>
+            updateStageField({ capabilities: event.target.value })
+          }
+          stringOptions={capabilities}
+          value={stage.capabilities}
+        />
+      </StageConfigField>
+    </div>
+  );
+}