@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/aws.module.spec.ts

@@ -0,0 +1,296 @@
+import type { IStageTypeConfig } from '@spinnaker/core';
+import { CloudProviderRegistry, Registry } from '@spinnaker/core';
+
+import './index';
+import { AwsFunctionTransformer } from './function/function.transformer';
+import { AwsImageReader } from './image';
+import { AwsInstanceTypeService } from './instance/awsInstanceType.service';
+import { AwsLoadBalancerTransformer } from './loadBalancer';
+import { AmazonStageConfig, getAmazonStageFields } from './pipeline/stages/AmazonStageConfig';
+import { awsBakeStage, AwsBakeStageConfig } from './pipeline/stages/bake/AwsBakeStageConfig';
+import { AwsCloneServerGroupStageConfig } from './pipeline/stages/cloneServerGroup/AwsCloneServerGroupStageConfig';
+import { DeployCloudFormationStackStageConfig } from './pipeline/stages/deployCloudFormation/DeployCloudFormationStackStageConfig';
+import { AwsDisableAsgStageConfig } from './pipeline/stages/disableAsg/AwsDisableAsgStageConfig';
+import { AwsDisableClusterStageConfig } from './pipeline/stages/disableCluster/AwsDisableClusterStageConfig';
+import { AwsEnableAsgStageConfig } from './pipeline/stages/enableAsg/AwsEnableAsgStageConfig';
+import { AwsFindImageFromTagsStageConfig } from './pipeline/stages/findImageFromTags/AwsFindImageFromTagsStageConfig';
+import { ModifyScalingProcessStageConfig } from './pipeline/stages/modifyScalingProcess/ModifyScalingProcessStageConfig';
+import { AwsResizeAsgStageConfig } from './pipeline/stages/resizeAsg/AwsResizeAsgStageConfig';
+import { AwsRollbackClusterStageConfig } from './pipeline/stages/rollbackCluster/AwsRollbackClusterStageConfig';
+import { AwsScaleDownClusterStageConfig } from './pipeline/stages/scaleDownCluster/AwsScaleDownClusterStageConfig';
+import { AwsShrinkClusterStageConfig } from './pipeline/stages/shrinkCluster/AwsShrinkClusterStageConfig';
+import { AwsTagImageStageConfig } from './pipeline/stages/tagImage/awsTagImageStage';
+import { registerAmazonPipelineStages } from './aws.module';
+import { AwsSecurityGroupReader } from './securityGroup/securityGroup.reader';
+import { AwsSecurityGroupTransformer } from './securityGroup/securityGroup.transformer';
+import { AwsServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import {
+  AwsServerGroupConfigurationService,
+  AwsServerGroupConfigurationServiceDelegate,
+} from './serverGroup/configure/serverGroupConfiguration.service';
+import { AwsServerGroupTransformer } from './serverGroup/serverGroup.transformer';
+
+describe('Amazon package registration', () => {
+  function expectRegistered(path: string): void {
+    expect(CloudProviderRegistry.getValue('aws', path)).withContext(path).not.toBeNull();
+  }
+
+  function expectNonEmptyRegistration(path: string): void {
+    const value = CloudProviderRegistry.getValue('aws', path);
+    const entries = Array.isArray(value) ? value : [];
+    expect(Array.isArray(value)).withContext(path).toBe(true);
+    expect(entries.length).withContext(path).toBeGreaterThan(0);
+  }
+
+  it('does not register function details as a provider override', () => {
+    const overrideValue = spyOn(CloudProviderRegistry, 'overrideValue');
+    const functionDetailsModule = require.resolve('./function/details/AmazonFunctionDetails');
+    delete require.cache[functionDetailsModule];
+
+    require('./function/details/AmazonFunctionDetails');
+
+    expect(overrideValue).not.toHaveBeenCalled();
+  });
+
+  it('registers AWS provider values', () => {
+    expect(CloudProviderRegistry.getValue('aws', 'image.reader')).toBe(AwsImageReader);
+    expect(CloudProviderRegistry.getValue('aws', 'serverGroup.transformer')).toBe(AwsServerGroupTransformer);
+    expect(CloudProviderRegistry.getValue('aws', 'serverGroup.commandBuilder')).toBe(AwsServerGroupCommandBuilder);
+    expect(CloudProviderRegistry.getValue('aws', 'serverGroup.configurationService')).toBe(
+      AwsServerGroupConfigurationServiceDelegate,
+    );
+    expect(CloudProviderRegistry.getValue('aws', 'instance.instanceTypeService')).toBe(AwsInstanceTypeService);
+    expect(CloudProviderRegistry.getValue('aws', 'loadBalancer.transformer')).toBe(AwsLoadBalancerTransformer);
+    expect(CloudProviderRegistry.getValue('aws', 'function.transformer')).toBe(AwsFunctionTransformer);
+    expect(CloudProviderRegistry.getValue('aws', 'function.setTransformer')).toBe(AwsFunctionTransformer);
+    expect(CloudProviderRegistry.getValue('aws', 'securityGroup.reader')).toBe(AwsSecurityGroupReader);
+    expect(CloudProviderRegistry.getValue('aws', 'securityGroup.transformer')).toBe(AwsSecurityGroupTransformer);
+    expect(CloudProviderRegistry.getValue('aws', 'applicationProviderFields')).toEqual([
+      {
+        field: 'useAmiBlockDeviceMappings',
+        label: 'Prefer AMI Block Device Mappings',
+        type: 'boolean',
+      },
+    ]);
+
+    expectRegistered('serverGroup.CloneServerGroupModal');
+    expectRegistered('serverGroup.detailsGetter');
+    expectRegistered('serverGroup.detailsActions');
+    expectNonEmptyRegistration('serverGroup.detailsSections');
+    expectRegistered('instance.details');
+    expectRegistered('loadBalancer.CreateLoadBalancerModal');
+    expectRegistered('loadBalancer.useDetailsHook');
+    expectRegistered('loadBalancer.detailsActions');
+    expectNonEmptyRegistration('loadBalancer.detailsSections');
+    expectRegistered('loadBalancer.targetGroupDetails');
+    expectRegistered('function.details');
+    expectRegistered('function.CreateFunctionModal');
+    expectRegistered('securityGroup.CreateSecurityGroupModal');
+    expectRegistered('securityGroup.details');
+  });
+
+  it('registers AWS provider delegates as direct constructors', () => {
+    expect(typeof CloudProviderRegistry.getValue('aws', 'serverGroup.transformer')).toBe('function');
+    expect(typeof CloudProviderRegistry.getValue('aws', 'serverGroup.commandBuilder')).toBe('function');
+    expect(typeof CloudProviderRegistry.getValue('aws', 'serverGroup.configurationService')).toBe('function');
+    expect(typeof CloudProviderRegistry.getValue('aws', 'instance.instanceTypeService')).toBe('function');
+    expect(typeof CloudProviderRegistry.getValue('aws', 'loadBalancer.transformer')).toBe('function');
+    expect(typeof CloudProviderRegistry.getValue('aws', 'function.transformer')).toBe('function');
+    expect(typeof CloudProviderRegistry.getValue('aws', 'function.setTransformer')).toBe('function');
+    expect(typeof CloudProviderRegistry.getValue('aws', 'securityGroup.reader')).toBe('function');
+    expect(typeof CloudProviderRegistry.getValue('aws', 'securityGroup.transformer')).toBe('function');
+  });
+
+  it('constructs the server group configuration service with explicit dependencies', () => {
+    const securityGroupReader = { getAllSecurityGroups: jasmine.createSpy('getAllSecurityGroups') };
+    const cacheInitializer = {
+      refreshCache: jasmine.createSpy('refreshCache'),
+    };
+
+    const service = new AwsServerGroupConfigurationService(
+      securityGroupReader as any,
+      new AwsInstanceTypeService(),
+      cacheInitializer as any,
+    );
+
+    expect((service as any).securityGroupReader).toBe(securityGroupReader);
+    expect(() => service.applyOverrides('beforeConfiguration', {} as any)).not.toThrow();
+
+    const command = {
+      region: 'us-east-1',
+      virtualizationType: 'hvm',
+      vpcId: 'vpc-1',
+      amiArchitecture: 'x86_64',
+      backingData: {
+        instanceTypesInfo: {
+          'us-east-1': [
+            {
+              name: 'm5.large',
+              supportedVirtualizationTypes: ['hvm'],
+              supportedArchitectures: ['x86_64'],
+            },
+          ],
+        },
+        filtered: {},
+      },
+      launchTemplateOverridesForInstanceType: [],
+      viewState: { dirty: {} },
+    } as any;
+
+    expect(() => service.configureInstanceTypes(command)).not.toThrow();
+    expect(command.backingData.filtered.instanceTypes).toEqual(['m5.large']);
+  });
+
+  it('registers AWS pipeline stages with React components', () => {
+    const previousPipeline = Registry.pipeline;
+    const previousUrlBuilder = Registry.urlBuilder;
+
+    Registry.reinitialize();
+    try {
+      registerAmazonPipelineStages();
+
+      const stages = Registry.pipeline.getStageTypes();
+
+      const awsStages = stages.filter((stage) => stage.cloudProvider === 'aws');
+      const expectedStages = [
+        'bake',
+        'cloneServerGroup',
+        'deployCloudFormation',
+        'destroyServerGroup',
+        'disableCluster',
+        'disableServerGroup',
+        'enableServerGroup',
+        'findImage',
+        'findImageFromTags',
+        'modifyAwsScalingProcess',
+        'resizeServerGroup',
+        'rollbackCluster',
+        'scaleDownCluster',
+        'shrinkCluster',
+        'upsertImageTags',
+      ];
+
+      expectedStages.forEach((provides) => {
+        const stage = awsStages.find((candidate) => (candidate.provides || candidate.key) === provides);
+        expect(stage).withContext(`aws ${provides} stage`).toBeDefined();
+        expect(stage?.component).withContext(`aws ${provides} stage component`).toBeDefined();
+      });
+
+      const structuredStages: Array<{
+        component: IStageTypeConfig['component'];
+        key: string;
+      }> = [
+        {
+          key: 'bake',
+          component: AwsBakeStageConfig,
+        },
+        {
+          key: 'cloneServerGroup',
+          component: AwsCloneServerGroupStageConfig,
+        },
+        {
+          key: 'deployCloudFormation',
+          component: DeployCloudFormationStackStageConfig,
+        },
+        {
+          key: 'disableServerGroup',
+          component: AwsDisableAsgStageConfig,
+        },
+        {
+          key: 'disableCluster',
+          component: AwsDisableClusterStageConfig,
+        },
+        {
+          key: 'enableServerGroup',
+          component: AwsEnableAsgStageConfig,
+        },
+        {
+          key: 'upsertImageTags',
+          component: AwsTagImageStageConfig,
+        },
+        {
+          key: 'findImageFromTags',
+          component: AwsFindImageFromTagsStageConfig,
+        },
+        {
+          key: 'resizeServerGroup',
+          component: AwsResizeAsgStageConfig,
+        },
+        {
+          key: 'rollbackCluster',
+          component: AwsRollbackClusterStageConfig,
+        },
+        {
+          key: 'scaleDownCluster',
+          component: AwsScaleDownClusterStageConfig,
+        },
+        {
+          key: 'shrinkCluster',
+          component: AwsShrinkClusterStageConfig,
+        },
+        {
+          key: 'modifyAwsScalingProcess',
+          component: ModifyScalingProcessStageConfig,
+        },
+      ];
+
+      structuredStages.forEach(({ component, key }) => {
+        const stage = awsStages.find((candidate) => (candidate.key || candidate.provides) === key);
+        expect(stage).withContext(`aws ${key} structured stage`).toBeDefined();
+        expect(stage?.key).withContext(`aws ${key} stage key`).toBe(key);
+        expect(stage?.cloudProvider).withContext(`aws ${key} cloud provider`).toBe('aws');
+        expect(stage?.component).withContext(`aws ${key} config component`).toBe(component);
+      });
+
+      const deployCloudFormation = awsStages.find((stage) => stage.key === 'deployCloudFormation');
+      expect(deployCloudFormation?.executionDetailsSections?.length)
+        .withContext('aws deployCloudFormation React execution details')
+        .toBeGreaterThan(0);
+
+      ['destroyServerGroup', 'findImage'].forEach((key) => {
+        const stage = awsStages.find((candidate) => (candidate.key || candidate.provides) === key);
+        expect(stage?.component).withContext(`aws ${key} generic stage component`).toBe(AmazonStageConfig);
+      });
+    } finally {
+      Registry.pipeline = previousPipeline;
+      Registry.urlBuilder = previousUrlBuilder;
+    }
+  });
+
+  it('does not duplicate AWS pipeline stages on module import', () => {
+    const awsStages = Registry.pipeline.getStageTypes().filter((stage) => stage.cloudProvider === 'aws');
+    const expectedStages = [
+      'bake',
+      'cloneServerGroup',
+      'deployCloudFormation',
+      'destroyServerGroup',
+      'disableCluster',
+      'disableServerGroup',
+      'enableServerGroup',
+      'findImage',
+      'findImageFromTags',
+      'modifyAwsScalingProcess',
+      'resizeServerGroup',
+      'rollbackCluster',
+      'scaleDownCluster',
+      'shrinkCluster',
+      'upsertImageTags',
+    ];
+
+    expectedStages.forEach((provides) => {
+      const registrations = awsStages.filter((stage) => (stage.provides || stage.key) === provides);
+      expect(registrations.length).withContext(`aws ${provides} registration count`).toBe(1);
+    });
+  });
+
+  it('renders required AWS stage-specific config fields', () => {
+    expect(awsBakeStage.validators.map((validator: any) => validator.fieldName)).toContain('package');
+    expect(getAmazonStageFields({ type: 'findImage' } as any).map((field) => field.fieldName)).toEqual([
+      'credentials',
+      'regions',
+      'cluster',
+      'selectionStrategy',
+      'onlyEnabled',
+    ]);
+  });
+});

package/src/aws.module.ts

@@ -1,55 +1,52 @@
-import { module } from 'angular';
-
-import { CloudProviderRegistry, DeploymentStrategyRegistry } from '@spinnaker/core';
+import { CloudProviderRegistry, DeploymentStrategyRegistry, Registry } from '@spinnaker/core';
 
 import { AWSProviderSettings } from './aws.settings';
-import { COMMON_MODULE } from './common/common.module';
 import './deploymentStrategy/rollingPush.strategy';
 import { AmazonFunctionDetails } from './function';
 import { CreateLambdaFunction } from './function';
 import { AwsFunctionTransformer } from './function';
-import { AWS_FUNCTION_MODULE } from './function/function.module';
 import './help/amazon.help';
 import { AwsImageReader } from './image';
-import { AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE } from './instance/awsInstanceType.service';
-import { AMAZON_INSTANCE_INFORMATION_COMPONENT } from './instance/details/amazonInstanceInformation.component';
-import { AMAZON_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER } from './instance/details/instance.details.controller';
-import { INSTANCE_DNS_COMPONENT } from './instance/details/instanceDns.component';
-import { INSTANCE_SECURITY_GROUPS_COMPONENT } from './instance/details/instanceSecurityGroups.component';
-import { INSTANCE_STATUS_COMPONENT } from './instance/details/instanceStatus.component';
-import { INSTANCE_TAGS_COMPONENT } from './instance/details/instanceTags.component';
+import { AwsInstanceTypeService } from './instance/awsInstanceType.service';
+import { AmazonInstanceDetails } from './instance/details/AmazonInstanceDetails';
 import { AmazonLoadBalancerClusterContainer } from './loadBalancer';
 import { AmazonLoadBalancersTag } from './loadBalancer';
 import { AmazonLoadBalancerChoiceModal } from './loadBalancer';
 import { AwsLoadBalancerTransformer } from './loadBalancer';
-import { AWS_LOAD_BALANCER_MODULE } from './loadBalancer/loadBalancer.module';
+import {
+  AmazonLoadBalancerActions,
+  amazonLoadBalancerDetailsSections,
+  TargetGroupDetails,
+  useAmazonLoadBalancerDetails,
+} from './loadBalancer';
 import amazonLogo from './logo/amazon.logo.svg';
-import { AMAZON_PIPELINE_STAGES_BAKE_AWSBAKESTAGE } from './pipeline/stages/bake/awsBakeStage';
-import { AMAZON_PIPELINE_STAGES_CLONESERVERGROUP_AWSCLONESERVERGROUPSTAGE } from './pipeline/stages/cloneServerGroup/awsCloneServerGroupStage';
-import { AMAZON_PIPELINE_STAGES_LAMBDA_DELETE } from './pipeline/stages/deleteLambda';
-import { CLOUD_FORMATION_CHANGE_SET_INFO } from './pipeline/stages/deployCloudFormation/CloudFormationChangeSetInfo';
-import { CLOUDFORMATION_TEMPLATE_ENTRY } from './pipeline/stages/deployCloudFormation/cloudFormationTemplateEntry.component';
-import { DEPLOY_CLOUDFORMATION_STACK_STAGE } from './pipeline/stages/deployCloudFormation/deployCloudFormationStackStage';
-import { AWS_EVALUATE_CLOUD_FORMATION_CHANGE_SET_EXECUTION_SERVICE } from './pipeline/stages/deployCloudFormation/evaluateCloudFormationChangeSetExecution.service';
-import { AMAZON_PIPELINE_STAGES_LAMBDA_DEPLOY } from './pipeline/stages/deployLambda';
-import { AMAZON_PIPELINE_STAGES_DESTROYASG_AWSDESTROYASGSTAGE } from './pipeline/stages/destroyAsg/awsDestroyAsgStage';
-import { AMAZON_PIPELINE_STAGES_DISABLEASG_AWSDISABLEASGSTAGE } from './pipeline/stages/disableAsg/awsDisableAsgStage';
-import { AMAZON_PIPELINE_STAGES_DISABLECLUSTER_AWSDISABLECLUSTERSTAGE } from './pipeline/stages/disableCluster/awsDisableClusterStage';
-import { AMAZON_PIPELINE_STAGES_ENABLEASG_AWSENABLEASGSTAGE } from './pipeline/stages/enableAsg/awsEnableAsgStage';
-import { AMAZON_PIPELINE_STAGES_FINDAMI_AWSFINDAMISTAGE } from './pipeline/stages/findAmi/awsFindAmiStage';
-import { AMAZON_PIPELINE_STAGES_FINDIMAGEFROMTAGS_AWSFINDIMAGEFROMTAGSSTAGE } from './pipeline/stages/findImageFromTags/awsFindImageFromTagsStage';
-import { AMAZON_PIPELINE_STAGES_LAMBDA_INVOKE } from './pipeline/stages/invokeLambda';
-import { AMAZON_PIPELINE_STAGES_MODIFYSCALINGPROCESS_MODIFYSCALINGPROCESSSTAGE } from './pipeline/stages/modifyScalingProcess/modifyScalingProcessStage';
-import { AMAZON_PIPELINE_STAGES_RESIZEASG_AWSRESIZEASGSTAGE } from './pipeline/stages/resizeAsg/awsResizeAsgStage';
-import { AMAZON_PIPELINE_STAGES_ROLLBACKCLUSTER_AWSROLLBACKCLUSTERSTAGE } from './pipeline/stages/rollbackCluster/awsRollbackClusterStage';
-import { AMAZON_PIPELINE_STAGES_LAMBDA_ROUTE } from './pipeline/stages/routeLambda';
-import { AMAZON_PIPELINE_STAGES_SCALEDOWNCLUSTER_AWSSCALEDOWNCLUSTERSTAGE } from './pipeline/stages/scaleDownCluster/awsScaleDownClusterStage';
-import { AMAZON_PIPELINE_STAGES_SHRINKCLUSTER_AWSSHRINKCLUSTERSTAGE } from './pipeline/stages/shrinkCluster/awsShrinkClusterStage';
-import { AMAZON_PIPELINE_STAGES_TAGIMAGE_AWSTAGIMAGESTAGE } from './pipeline/stages/tagImage/awsTagImageStage';
-import { AMAZON_PIPELINE_STAGES_LAMBDA_UPDATE } from './pipeline/stages/updateCodeLambda';
-import { AWS_REACT_MODULE } from './reactShims/aws.react.module';
-import { AMAZON_SEARCH_SEARCHRESULTFORMATTER } from './search/searchResultFormatter';
-import { AWS_SECURITY_GROUP_MODULE } from './securityGroup/securityGroup.module';
+import { registerAwsBakeStage } from './pipeline/stages/bake/AwsBakeStageConfig';
+import { registerAwsCloneServerGroupStage } from './pipeline/stages/cloneServerGroup/AwsCloneServerGroupStageConfig';
+import { registerLambdaDeleteStage } from './pipeline/stages/deleteLambda';
+import { registerDeployCloudFormationStackStage } from './pipeline/stages/deployCloudFormation/deployCloudFormationStackStage';
+import { registerLambdaDeployStage } from './pipeline/stages/deployLambda';
+import { registerAwsDestroyAsgStage } from './pipeline/stages/destroyAsg/awsDestroyAsgStage';
+import { registerAwsDisableAsgStage } from './pipeline/stages/disableAsg/AwsDisableAsgStageConfig';
+import { registerAwsDisableClusterStage } from './pipeline/stages/disableCluster/AwsDisableClusterStageConfig';
+import { registerAwsEnableAsgStage } from './pipeline/stages/enableAsg/AwsEnableAsgStageConfig';
+import { registerAwsFindAmiStage } from './pipeline/stages/findAmi/awsFindAmiStage';
+import { registerAwsFindImageFromTagsStage } from './pipeline/stages/findImageFromTags/awsFindImageFromTagsStage';
+import { registerLambdaInvokeStage } from './pipeline/stages/invokeLambda';
+import { registerAwsModifyScalingProcessStage } from './pipeline/stages/modifyScalingProcess/modifyScalingProcessStage';
+import { registerAwsModifyWarmPoolStage } from './pipeline/stages/modifyWarmPool/modifyWarmPoolStage';
+import { registerAwsResizeAsgStage } from './pipeline/stages/resizeAsg/awsResizeAsgStage';
+import { registerAwsRollbackClusterStage } from './pipeline/stages/rollbackCluster/AwsRollbackClusterStageConfig';
+import { registerLambdaRouteStage } from './pipeline/stages/routeLambda';
+import { registerAwsScaleDownClusterStage } from './pipeline/stages/scaleDownCluster/AwsScaleDownClusterStageConfig';
+import { registerAwsShrinkClusterStage } from './pipeline/stages/shrinkCluster/AwsShrinkClusterStageConfig';
+import { registerAwsTagImageStage } from './pipeline/stages/tagImage/awsTagImageStage';
+import { registerLambdaUpdateStage } from './pipeline/stages/updateCodeLambda';
+import { AmazonSecurityGroupModal } from './securityGroup/configure/AmazonSecurityGroupModal';
+import { AmazonSecurityGroupDetails } from './securityGroup/details/AmazonSecurityGroupDetails';
+import { AwsSecurityGroupReader } from './securityGroup/securityGroup.reader';
+import { AwsSecurityGroupTransformer } from './securityGroup/securityGroup.transformer';
+import { AwsServerGroupCommandBuilder } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import { AwsServerGroupConfigurationServiceDelegate } from './serverGroup/configure/serverGroupConfiguration.service';
 import { AmazonCloneServerGroupModal } from './serverGroup/configure/wizard/AmazonCloneServerGroupModal';
 import { AmazonServerGroupActions } from './serverGroup/details/AmazonServerGroupActions';
 import { amazonServerGroupDetailsGetter } from './serverGroup/details/amazonServerGroupDetailsGetter';
@@ -73,69 +70,32 @@ import {
   ScheduledActionsDetailsSection,
   SecurityGroupsDetailsSection,
   TagsDetailsSection,
+  WarmPoolDetailsSection,
 } from './serverGroup/details/sections';
-import { SERVER_GROUP_DETAILS_MODULE } from './serverGroup/details/serverGroupDetails.module';
-import { AWS_SERVER_GROUP_TRANSFORMER } from './serverGroup/serverGroup.transformer';
-import { SUBNET_RENDERER } from './subnet/subnet.renderer';
+import { AwsServerGroupTransformer } from './serverGroup/serverGroup.transformer';
 import './validation/ApplicationNameValidator';
-import { VPC_MODULE } from './vpc/vpc.module';
 
 import './logo/aws.logo.less';
 
-export const AMAZON_MODULE = 'spinnaker.amazon';
-module(AMAZON_MODULE, [
-  AWS_REACT_MODULE,
-  AMAZON_PIPELINE_STAGES_BAKE_AWSBAKESTAGE,
-  AMAZON_PIPELINE_STAGES_CLONESERVERGROUP_AWSCLONESERVERGROUPSTAGE,
-  AMAZON_PIPELINE_STAGES_DESTROYASG_AWSDESTROYASGSTAGE,
-  AMAZON_PIPELINE_STAGES_DISABLEASG_AWSDISABLEASGSTAGE,
-  AMAZON_PIPELINE_STAGES_DISABLECLUSTER_AWSDISABLECLUSTERSTAGE,
-  AMAZON_PIPELINE_STAGES_ROLLBACKCLUSTER_AWSROLLBACKCLUSTERSTAGE,
-  AMAZON_PIPELINE_STAGES_ENABLEASG_AWSENABLEASGSTAGE,
-  AMAZON_PIPELINE_STAGES_FINDAMI_AWSFINDAMISTAGE,
-  AMAZON_PIPELINE_STAGES_FINDIMAGEFROMTAGS_AWSFINDIMAGEFROMTAGSSTAGE,
-  AMAZON_PIPELINE_STAGES_MODIFYSCALINGPROCESS_MODIFYSCALINGPROCESSSTAGE,
-  AMAZON_PIPELINE_STAGES_RESIZEASG_AWSRESIZEASGSTAGE,
-  AMAZON_PIPELINE_STAGES_SCALEDOWNCLUSTER_AWSSCALEDOWNCLUSTERSTAGE,
-  AMAZON_PIPELINE_STAGES_SHRINKCLUSTER_AWSSHRINKCLUSTERSTAGE,
-  AMAZON_PIPELINE_STAGES_TAGIMAGE_AWSTAGIMAGESTAGE,
-  SERVER_GROUP_DETAILS_MODULE,
-  COMMON_MODULE,
-  AWS_SERVER_GROUP_TRANSFORMER,
-  AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE,
-  AWS_LOAD_BALANCER_MODULE,
-  AWS_FUNCTION_MODULE,
-  AMAZON_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER,
-  AWS_SECURITY_GROUP_MODULE,
-  SUBNET_RENDERER,
-  VPC_MODULE,
-  AMAZON_SEARCH_SEARCHRESULTFORMATTER,
-  DEPLOY_CLOUDFORMATION_STACK_STAGE,
-  CLOUDFORMATION_TEMPLATE_ENTRY,
-  CLOUD_FORMATION_CHANGE_SET_INFO,
-  AWS_EVALUATE_CLOUD_FORMATION_CHANGE_SET_EXECUTION_SERVICE,
-  INSTANCE_STATUS_COMPONENT,
-  INSTANCE_TAGS_COMPONENT,
-  INSTANCE_SECURITY_GROUPS_COMPONENT,
-  INSTANCE_DNS_COMPONENT,
-  AMAZON_INSTANCE_INFORMATION_COMPONENT,
-  AMAZON_PIPELINE_STAGES_LAMBDA_DELETE,
-  AMAZON_PIPELINE_STAGES_LAMBDA_DEPLOY,
-  AMAZON_PIPELINE_STAGES_LAMBDA_INVOKE,
-  AMAZON_PIPELINE_STAGES_LAMBDA_UPDATE,
-  AMAZON_PIPELINE_STAGES_LAMBDA_ROUTE,
-]).config(() => {
+export function registerAmazonProvider(): void {
   CloudProviderRegistry.registerProvider('aws', {
     name: 'Amazon',
     adHocInfrastructureWritesEnabled: AWSProviderSettings.adHocInfraWritesEnabled,
     logo: {
       path: amazonLogo,
     },
+    applicationProviderFields: [
+      {
+        field: 'useAmiBlockDeviceMappings',
+        label: 'Prefer AMI Block Device Mappings',
+        type: 'boolean',
+      },
+    ],
     image: {
       reader: AwsImageReader,
     },
     serverGroup: {
-      transformer: 'awsServerGroupTransformer',
+      transformer: AwsServerGroupTransformer,
       detailsActions: AmazonServerGroupActions,
       detailsGetter: amazonServerGroupDetailsGetter,
       detailsSections: [
@@ -149,58 +109,93 @@ module(AMAZON_MODULE, [
         ScalingProcessesDetailsSection,
         ScalingPoliciesDetailsSection,
         ScheduledActionsDetailsSection,
+        WarmPoolDetailsSection,
         TagsDetailsSection,
         PackageDetailsSection,
         AdvancedSettingsDetailsSection,
         LogsDetailsSection,
       ],
       CloneServerGroupModal: AmazonCloneServerGroupModal,
-      commandBuilder: 'awsServerGroupCommandBuilder',
-      configurationService: 'awsServerGroupConfigurationService',
+      commandBuilder: AwsServerGroupCommandBuilder,
+      configurationService: AwsServerGroupConfigurationServiceDelegate,
+      instanceTypeService: AwsInstanceTypeService,
       scalingActivitiesEnabled: true,
       TargetTrackingChart,
       UpsertStepPolicyModal: AmazonUpsertScalingPolicyModal,
       UpsertTargetTrackingModal: AmazonUpsertTargetTrackingModal,
     },
     instance: {
-      instanceTypeService: 'awsInstanceTypeService',
-      detailsTemplateUrl: require('./instance/details/instanceDetails.html'),
-      detailsController: 'awsInstanceDetailsCtrl',
+      instanceTypeService: AwsInstanceTypeService,
+      details: AmazonInstanceDetails,
     },
     loadBalancer: {
       transformer: AwsLoadBalancerTransformer,
-      detailsTemplateUrl: require('./loadBalancer/details/loadBalancerDetails.html'),
-      detailsController: 'awsLoadBalancerDetailsCtrl',
       CreateLoadBalancerModal: AmazonLoadBalancerChoiceModal,
-      targetGroupDetailsTemplateUrl: require('./loadBalancer/details/targetGroupDetails.html'),
-      targetGroupDetailsController: 'awsTargetGroupDetailsCtrl',
+      useDetailsHook: useAmazonLoadBalancerDetails,
+      detailsActions: AmazonLoadBalancerActions,
+      detailsSections: amazonLoadBalancerDetailsSections,
+      targetGroupDetails: TargetGroupDetails,
       ClusterContainer: AmazonLoadBalancerClusterContainer,
       LoadBalancersTag: AmazonLoadBalancersTag,
     },
     function: {
       details: AmazonFunctionDetails,
       CreateFunctionModal: CreateLambdaFunction,
+      setTransformer: AwsFunctionTransformer,
       transformer: AwsFunctionTransformer,
     },
     securityGroup: {
-      transformer: 'awsSecurityGroupTransformer',
-      reader: 'awsSecurityGroupReader',
-      detailsTemplateUrl: require('./securityGroup/details/securityGroupDetail.html'),
-      detailsController: 'awsSecurityGroupDetailsCtrl',
-      createSecurityGroupTemplateUrl: require('./securityGroup/configure/createSecurityGroup.html'),
-      createSecurityGroupController: 'awsCreateSecurityGroupCtrl',
-    },
-    subnet: {
-      renderer: 'awsSubnetRenderer',
-    },
-    search: {
-      resultFormatter: 'awsSearchResultFormatter',
-    },
-    applicationProviderFields: {
-      templateUrl: require('./applicationProviderFields/awsFields.html'),
+      transformer: AwsSecurityGroupTransformer,
+      reader: AwsSecurityGroupReader,
+      CreateSecurityGroupModal: AmazonSecurityGroupModal,
+      details: AmazonSecurityGroupDetails,
     },
   });
-});
+}
+
+function registerPipelineStageOnce(
+  stageKey: string,
+  registerStage: () => void,
+  cloudProvider: string | null = 'aws',
+): void {
+  const isRegistered = Registry.pipeline.getStageTypes().some((stage) => {
+    const registeredStageKey = stage.provides || stage.key;
+    const cloudProviderMatches = cloudProvider === null || stage.cloudProvider === cloudProvider;
+
+    return registeredStageKey === stageKey && cloudProviderMatches;
+  });
+
+  if (!isRegistered) {
+    registerStage();
+  }
+}
+
+export function registerAmazonPipelineStages(): void {
+  registerPipelineStageOnce('bake', registerAwsBakeStage);
+  registerPipelineStageOnce('cloneServerGroup', registerAwsCloneServerGroupStage);
+  registerPipelineStageOnce('deployCloudFormation', registerDeployCloudFormationStackStage);
+  registerPipelineStageOnce('destroyServerGroup', registerAwsDestroyAsgStage);
+  registerPipelineStageOnce('disableServerGroup', registerAwsDisableAsgStage);
+  registerPipelineStageOnce('disableCluster', registerAwsDisableClusterStage);
+  registerPipelineStageOnce('enableServerGroup', registerAwsEnableAsgStage);
+  registerPipelineStageOnce('findImage', registerAwsFindAmiStage);
+  registerPipelineStageOnce('findImageFromTags', registerAwsFindImageFromTagsStage);
+  registerPipelineStageOnce('Aws.LambdaDeleteStage', registerLambdaDeleteStage, null);
+  registerPipelineStageOnce('Aws.LambdaDeploymentStage', registerLambdaDeployStage, null);
+  registerPipelineStageOnce('Aws.LambdaInvokeStage', registerLambdaInvokeStage, null);
+  registerPipelineStageOnce('modifyAwsScalingProcess', registerAwsModifyScalingProcessStage);
+  registerPipelineStageOnce('modifyWarmPool', registerAwsModifyWarmPoolStage);
+  registerPipelineStageOnce('resizeServerGroup', registerAwsResizeAsgStage);
+  registerPipelineStageOnce('rollbackCluster', registerAwsRollbackClusterStage);
+  registerPipelineStageOnce('Aws.LambdaUpdateCodeStage', registerLambdaUpdateStage, null);
+  registerPipelineStageOnce('Aws.LambdaTrafficRoutingStage', registerLambdaRouteStage, null);
+  registerPipelineStageOnce('scaleDownCluster', registerAwsScaleDownClusterStage);
+  registerPipelineStageOnce('shrinkCluster', registerAwsShrinkClusterStage);
+  registerPipelineStageOnce('upsertImageTags', registerAwsTagImageStage);
+}
+
+registerAmazonProvider();
+registerAmazonPipelineStages();
 
 DeploymentStrategyRegistry.registerProvider('aws', [
   'custom',

package/src/aws.services.ts

@@ -0,0 +1,21 @@
+import { FunctionReader } from '@spinnaker/core';
+
+import { AwsFunctionTransformer } from './function';
+import { AwsInstanceTypeService } from './instance/awsInstanceType.service';
+import { AwsServerGroupTransformer } from './serverGroup/serverGroup.transformer';
+
+let awsInstanceTypeService: AwsInstanceTypeService;
+let awsServerGroupTransformer: AwsServerGroupTransformer;
+let functionReader: FunctionReader;
+
+export const AwsServices = {
+  get awsInstanceTypeService() {
+    return (awsInstanceTypeService = awsInstanceTypeService || new AwsInstanceTypeService());
+  },
+  get awsServerGroupTransformer() {
+    return (awsServerGroupTransformer = awsServerGroupTransformer || new AwsServerGroupTransformer());
+  },
+  get functionReader() {
+    return (functionReader = functionReader || new FunctionReader(new AwsFunctionTransformer()));
+  },
+};

package/src/certificates/AmazonCertificateReader.ts

@@ -4,7 +4,7 @@ import { AccountService, CertificateReader } from '@spinnaker/core';
 import type { IAmazonCertificate } from '../domain';
 
 export class AmazonCertificateReader {
-  public static listCertificates(): PromiseLike<{ [accountId: string]: IAmazonCertificate[] }> {
+  public static listCertificates(): Promise<{ [accountId: string]: IAmazonCertificate[] }> {
     return CertificateReader.listCertificatesByProvider('aws').then((certificates: IAmazonCertificate[]) => {
       // This account grouping should really go into clouddriver but since it's not, put it here for now.
       return AccountService.listAllAccounts('aws').then((allAccountDetails) => {

package/src/domain/IAmazonServerGroup.ts

@@ -13,6 +13,14 @@ export interface IAmazonAsgTag {
   resourceType: string;
 }
 
+export interface IAmazonWarmPoolConfiguration {
+  minSize?: number;
+  maxGroupPreparedCapacity?: number;
+  poolState?: 'Stopped' | 'Running' | 'Hibernated';
+  instanceReusePolicy?: { reuseOnScaleIn?: boolean };
+  status?: string;
+}
+
 export interface IAmazonAsg extends IAsg {
   availabilityZones: string[];
   autoScalingGroupName: string;
@@ -26,6 +34,7 @@ export interface IAmazonAsg extends IAsg {
   suspendedProcesses?: ISuspendedProcess[];
   capacityRebalance?: boolean;
   tags: IAmazonAsgTag[];
+  warmPoolConfiguration?: IAmazonWarmPoolConfiguration;
 }
 
 export interface IAmazonServerGroup extends IServerGroup {