@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/serverGroup/configure/serverGroupCommandBuilder.spec.js

@@ -3,6 +3,7 @@
 import { AccountService, SubnetReader } from '@spinnaker/core';
 
 import { AWSProviderSettings } from '../../aws.settings';
+import { createAwsServerGroupCommandBuilder } from './serverGroupCommandBuilder.service';
 
 import {
   createMockAmazonServerGroupWithLt,
@@ -13,62 +14,50 @@ import {
 describe('awsServerGroupCommandBuilder', function () {
   const AccountServiceFixture = require('./AccountServiceFixtures');
 
-  beforeEach(window.module(require('./serverGroupCommandBuilder.service').name));
-
-  beforeEach(
-    window.inject(function (awsServerGroupCommandBuilder, $q, $rootScope, instanceTypeService) {
-      this.awsServerGroupCommandBuilder = awsServerGroupCommandBuilder;
-      this.$scope = $rootScope;
-      this.instanceTypeService = instanceTypeService;
-      this.$q = $q;
-      spyOn(AccountService, 'getPreferredZonesByAccount').and.returnValue(
-        $q.when(AccountServiceFixture.preferredZonesByAccount),
-      );
-      spyOn(AccountService, 'getCredentialsKeyedByAccount').and.returnValue(
-        $q.when(AccountServiceFixture.credentialsKeyedByAccount),
-      );
-      spyOn(SubnetReader, 'listSubnets').and.returnValue($q.when([]));
-      spyOn(AccountService, 'getAvailabilityZonesForAccountAndRegion').and.returnValue(this.$q.when(['a', 'b', 'c']));
-    }),
-  );
+  beforeEach(function () {
+    this.instanceTypeService = {
+      getCategoryForMultipleInstanceTypes: jasmine.createSpy('getCategoryForMultipleInstanceTypes'),
+    };
+    this.awsServerGroupCommandBuilder = createAwsServerGroupCommandBuilder(this.instanceTypeService);
+    spyOn(AccountService, 'getPreferredZonesByAccount').and.returnValue(
+      Promise.resolve(AccountServiceFixture.preferredZonesByAccount),
+    );
+    spyOn(AccountService, 'getCredentialsKeyedByAccount').and.returnValue(
+      Promise.resolve(AccountServiceFixture.credentialsKeyedByAccount),
+    );
+    spyOn(SubnetReader, 'listSubnets').and.returnValue(Promise.resolve([]));
+    spyOn(AccountService, 'getAvailabilityZonesForAccountAndRegion').and.returnValue(Promise.resolve(['a', 'b', 'c']));
+  });
 
   afterEach(AWSProviderSettings.resetToOriginal);
 
   describe('buildNewServerGroupCommand', function () {
-    it('initializes to default values, setting usePreferredZone flag to true', function () {
-      let command = null;
+    it('initializes to default values, setting usePreferredZone flag to true', async function () {
       AWSProviderSettings.defaults.iamRole = '{{application}}IAMRole';
-      this.awsServerGroupCommandBuilder
-        .buildNewServerGroupCommand({ name: 'appo', defaultCredentials: {}, defaultRegions: {} }, 'aws')
-        .then(function (result) {
-          command = result;
-        });
-
-      this.$scope.$digest();
+      const command = await this.awsServerGroupCommandBuilder.buildNewServerGroupCommand(
+        { name: 'appo', defaultCredentials: {}, defaultRegions: {} },
+        'aws',
+      );
 
       expect(command.viewState.usePreferredZones).toBe(true);
       expect(command.availabilityZones).toEqual(['a', 'b', 'c']);
       expect(command.iamRole).toBe('appoIAMRole');
     });
 
-    it('sets unlimitedCpuCredits to undefined if not modified by user', function () {
-      let command = null;
+    it('sets unlimitedCpuCredits to undefined if not modified by user', async function () {
       AWSProviderSettings.defaults.iamRole = '{{application}}IAMRole';
-      this.awsServerGroupCommandBuilder
-        .buildNewServerGroupCommand({ name: 'test-app', defaultCredentials: {}, defaultRegions: {} }, 'aws')
-        .then(function (result) {
-          command = result;
-        });
-
-      this.$scope.$digest();
+      const command = await this.awsServerGroupCommandBuilder.buildNewServerGroupCommand(
+        { name: 'test-app', defaultCredentials: {}, defaultRegions: {} },
+        'aws',
+      );
 
       expect(command.unlimitedCpuCredits).toBe(undefined);
     });
   });
 
   describe('buildServerGroupCommandFromExisting', function () {
-    it('sets usePreferredZones flag based on initial value', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(this.$q.when('custom'));
+    it('sets usePreferredZones flag based on initial value', async function () {
+      this.instanceTypeService.getCategoryForMultipleInstanceTypes.and.returnValue(Promise.resolve('custom'));
       const baseServerGroup = {
         account: 'prod',
         region: 'us-west-1',
@@ -78,37 +67,27 @@ describe('awsServerGroupCommandBuilder', function () {
         },
         launchTemplate: mockLaunchTemplate,
       };
-      let command = null;
-
-      this.awsServerGroupCommandBuilder
-        .buildServerGroupCommandFromExisting({ name: 'appo' }, baseServerGroup)
-        .then(function (result) {
-          command = result;
-        });
-
-      this.$scope.$digest();
+      let command = await this.awsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(
+        { name: 'appo' },
+        baseServerGroup,
+      );
 
       expect(command.viewState.usePreferredZones).toBe(true);
       expect(command.availabilityZones).toEqual(['g', 'h', 'i']);
 
       baseServerGroup.asg.availabilityZones = ['g'];
 
-      this.awsServerGroupCommandBuilder
-        .buildServerGroupCommandFromExisting({ name: 'appo' }, baseServerGroup)
-        .then(function (result) {
-          command = result;
-        });
-
-      this.$scope.$digest();
+      command = await this.awsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(
+        { name: 'appo' },
+        baseServerGroup,
+      );
 
       expect(command.viewState.usePreferredZones).toBe(false);
       expect(command.availabilityZones).toEqual(['g']);
     });
 
-    it('sets profile and instance type if available', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
-        this.$q.when('selectedProfile'),
-      );
+    it('sets profile and instance type if available', async function () {
+      this.instanceTypeService.getCategoryForMultipleInstanceTypes.and.returnValue(Promise.resolve('selectedProfile'));
 
       const baseServerGroup = {
         account: 'prod',
@@ -123,24 +102,17 @@ describe('awsServerGroupCommandBuilder', function () {
           securityGroups: [],
         },
       };
-      let command = null;
-
-      this.awsServerGroupCommandBuilder
-        .buildServerGroupCommandFromExisting({ name: 'appo' }, baseServerGroup)
-        .then(function (result) {
-          command = result;
-        });
-
-      this.$scope.$digest();
+      const command = await this.awsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(
+        { name: 'appo' },
+        baseServerGroup,
+      );
 
       expect(command.viewState.instanceProfile).toBe('selectedProfile');
       expect(command.instanceType).toBe('something-custom');
     });
 
-    it('copies suspended processes unless the mode is "editPipeline"', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
-        this.$q.when('selectedProfile'),
-      );
+    it('copies suspended processes unless the mode is "editPipeline"', async function () {
+      this.instanceTypeService.getCategoryForMultipleInstanceTypes.and.returnValue(Promise.resolve('selectedProfile'));
 
       const baseServerGroup = {
         account: 'prod',
@@ -156,29 +128,24 @@ describe('awsServerGroupCommandBuilder', function () {
           securityGroups: [],
         },
       };
-      let command = null;
-
-      this.awsServerGroupCommandBuilder
-        .buildServerGroupCommandFromExisting({ name: 'appo' }, baseServerGroup)
-        .then((result) => (command = result));
-
-      this.$scope.$digest();
+      let command = await this.awsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(
+        { name: 'appo' },
+        baseServerGroup,
+      );
 
       expect(command.suspendedProcesses).toEqual(['x', 'a']);
 
-      this.awsServerGroupCommandBuilder
-        .buildServerGroupCommandFromExisting({ name: 'appo' }, baseServerGroup, 'editPipeline')
-        .then((result) => (command = result));
-
-      this.$scope.$digest();
+      command = await this.awsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(
+        { name: 'appo' },
+        baseServerGroup,
+        'editPipeline',
+      );
 
       expect(command.suspendedProcesses).toEqual([]);
     });
 
-    it('copies tags not in the reserved list:', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
-        this.$q.when('selectedProfile'),
-      );
+    it('copies tags not in the reserved list:', async function () {
+      this.instanceTypeService.getCategoryForMultipleInstanceTypes.and.returnValue(Promise.resolve('selectedProfile'));
 
       const baseServerGroup = {
         account: 'prod',
@@ -207,21 +174,16 @@ describe('awsServerGroupCommandBuilder', function () {
           securityGroups: [],
         },
       };
-      let command = null;
-
-      this.awsServerGroupCommandBuilder
-        .buildServerGroupCommandFromExisting({ name: 'appo' }, baseServerGroup)
-        .then((result) => (command = result));
-
-      this.$scope.$digest();
+      const command = await this.awsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(
+        { name: 'appo' },
+        baseServerGroup,
+      );
 
       expect(command.tags).toEqual({ 'some-key': 'some-value' });
     });
 
-    it('sets unlimitedCpuCredits to false when building from source server group with standard credits', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
-        this.$q.when('selectedProfile'),
-      );
+    it('sets unlimitedCpuCredits to false when building from source server group with standard credits', async function () {
+      this.instanceTypeService.getCategoryForMultipleInstanceTypes.and.returnValue(Promise.resolve('selectedProfile'));
 
       const baseServerGroup = createMockAmazonServerGroupWithLt(
         createCustomMockLaunchTemplate('testLtCpuCredits', {
@@ -231,20 +193,16 @@ describe('awsServerGroupCommandBuilder', function () {
         }),
       );
 
-      let command = null;
-      this.awsServerGroupCommandBuilder
-        .buildServerGroupCommandFromExisting({ name: 'test' }, baseServerGroup)
-        .then((result) => (command = result));
-
-      this.$scope.$digest();
+      const command = await this.awsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(
+        { name: 'test' },
+        baseServerGroup,
+      );
 
       expect(command.unlimitedCpuCredits).toBe(false);
     });
 
-    it('sets unlimitedCpuCredits to true when building from source server group with unlimited credits', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
-        this.$q.when('selectedProfile'),
-      );
+    it('sets unlimitedCpuCredits to true when building from source server group with unlimited credits', async function () {
+      this.instanceTypeService.getCategoryForMultipleInstanceTypes.and.returnValue(Promise.resolve('selectedProfile'));
 
       const baseServerGroup = createMockAmazonServerGroupWithLt(
         createCustomMockLaunchTemplate('testLtCpuCredits', {
@@ -254,29 +212,23 @@ describe('awsServerGroupCommandBuilder', function () {
         }),
       );
 
-      let command = null;
-      this.awsServerGroupCommandBuilder
-        .buildServerGroupCommandFromExisting({ name: 'test' }, baseServerGroup)
-        .then((result) => (command = result));
-
-      this.$scope.$digest();
+      const command = await this.awsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(
+        { name: 'test' },
+        baseServerGroup,
+      );
 
       expect(command.unlimitedCpuCredits).toBe(true);
     });
 
-    it('sets unlimitedCpuCredits to undefined when building from source server group with cpu credits unset', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
-        this.$q.when('selectedProfile'),
-      );
+    it('sets unlimitedCpuCredits to undefined when building from source server group with cpu credits unset', async function () {
+      this.instanceTypeService.getCategoryForMultipleInstanceTypes.and.returnValue(Promise.resolve('selectedProfile'));
 
       const baseServerGroup = createMockAmazonServerGroupWithLt();
 
-      let command = null;
-      this.awsServerGroupCommandBuilder
-        .buildServerGroupCommandFromExisting({ name: 'test' }, baseServerGroup)
-        .then((result) => (command = result));
-
-      this.$scope.$digest();
+      const command = await this.awsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(
+        { name: 'test' },
+        baseServerGroup,
+      );
 
       expect(command.unlimitedCpuCredits).toBe(undefined);
     });

package/src/serverGroup/configure/serverGroupConfiguration.service.ts

@@ -1,4 +1,3 @@
-import { module } from 'angular';
 import {
   chain,
   clone,
@@ -15,11 +14,11 @@ import {
   some,
   xor,
 } from 'lodash';
-import { $q } from 'ngimport';
 
 import type {
   Application,
   CacheInitializerService,
+  DeckRuntimeServices,
   IAccountDetails,
   IDeploymentStrategy,
   IRegion,
@@ -31,20 +30,10 @@ import type {
   IServerGroupCommandResult,
   IServerGroupCommandViewState,
   ISubnet,
-  LoadBalancerReader,
   SecurityGroupReader,
   ServerGroupCommandRegistry,
 } from '@spinnaker/core';
-import {
-  AccountService,
-  CACHE_INITIALIZER_SERVICE,
-  LOAD_BALANCER_READ_SERVICE,
-  NameUtils,
-  SECURITY_GROUP_READER,
-  SERVER_GROUP_COMMAND_REGISTRY_PROVIDER,
-  setMatchingResourceSummary,
-  SubnetReader,
-} from '@spinnaker/core';
+import { AccountService, NameUtils, REST, setMatchingResourceSummary, SubnetReader } from '@spinnaker/core';
 
 import { AWSProviderSettings } from '../../aws.settings';
 import { AutoScalingProcessService } from '../details/scalingProcesses/AutoScalingProcessService';
@@ -54,8 +43,8 @@ import type {
   IKeyPair,
   IScalingProcess,
 } from '../../domain';
-import { AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE } from '../../instance/awsInstanceType.service';
-import type { IAmazonInstanceType } from '../../instance/awsInstanceType.service';
+import { AwsInstanceTypeService } from '../../instance/awsInstanceType.service';
+import type { IAmazonInstanceType, IAmazonInstanceTypesByRegion } from '../../instance/awsInstanceType.service';
 import { KeyPairsReader } from '../../keyPairs';
 
 export type IBlockDeviceMappingSource = 'source' | 'ami' | 'default';
@@ -81,7 +70,7 @@ export interface IAmazonServerGroupCommandBackingData extends IServerGroupComman
   keyPairs: IKeyPair[];
   targetGroups: string[];
   scalingProcesses: IScalingProcess[];
-  instanceTypesInfo: IAmazonInstanceType[];
+  instanceTypesInfo: IAmazonInstanceTypesByRegion;
 }
 
 export interface IAmazonServerGroupCommandViewState extends IServerGroupCommandViewState {
@@ -178,21 +167,30 @@ export class AwsServerGroupConfigurationService {
     'ClosestToNextInstanceHour',
     'Default',
   ];
+  private securityGroupReader: SecurityGroupReader;
+  private awsInstanceTypeService: AwsInstanceTypeService;
+  private cacheInitializer: CacheInitializerService;
 
-  public static $inject = [
-    'securityGroupReader',
-    'awsInstanceTypeService',
-    'cacheInitializer',
-    'loadBalancerReader',
-    'serverGroupCommandRegistry',
-  ];
   constructor(
-    private securityGroupReader: SecurityGroupReader,
-    private awsInstanceTypeService: any,
-    private cacheInitializer: CacheInitializerService,
-    private loadBalancerReader: LoadBalancerReader,
-    private serverGroupCommandRegistry: ServerGroupCommandRegistry,
-  ) {}
+    securityGroupReader: SecurityGroupReader,
+    awsInstanceTypeService: AwsInstanceTypeService,
+    cacheInitializer: CacheInitializerService,
+    private serverGroupCommandRegistry: Pick<ServerGroupCommandRegistry, 'getCommandOverrides'> = {
+      getCommandOverrides: () => [],
+    },
+  ) {
+    this.securityGroupReader = securityGroupReader;
+    this.awsInstanceTypeService = awsInstanceTypeService;
+    this.cacheInitializer = cacheInitializer;
+  }
+
+  private getSecurityGroupReader(): SecurityGroupReader {
+    return this.securityGroupReader;
+  }
+
+  private getCacheInitializer(): CacheInitializerService {
+    return this.cacheInitializer;
+  }
 
   public configureUpdateCommand(command: IAmazonServerGroupCommand): void {
     command.backingData = {
@@ -202,7 +200,7 @@ export class AwsServerGroupConfigurationService {
     } as IAmazonServerGroupCommandBackingData;
   }
 
-  public configureCommand(application: Application, cmd: IAmazonServerGroupCommand): PromiseLike<void> {
+  public configureCommand(application: Application, cmd: IAmazonServerGroupCommand): Promise<void> {
     this.applyOverrides('beforeConfiguration', cmd);
     // TODO: Instead of attaching these to the command itself, they could be static methods
     cmd.toggleSuspendedProcess = (command: IAmazonServerGroupCommand, process: string): void => {
@@ -260,21 +258,31 @@ export class AwsServerGroupConfigurationService {
         command.backingData.filtered.regions.some((region) => region.name === command.region && region.deprecated)
       );
     };
-
-    return $q
-      .all([
-        AccountService.getCredentialsKeyedByAccount('aws'),
-        this.securityGroupReader.getAllSecurityGroups(),
-        SubnetReader.listSubnets(),
-        AccountService.getPreferredZonesByAccount('aws'),
-        KeyPairsReader.listKeyPairs(),
-        this.awsInstanceTypeService.getAllTypesByRegion(),
-        $q.when(clone(this.enabledMetrics)),
-        $q.when(clone(this.healthCheckTypes)),
-        $q.when(clone(this.terminationPolicies)),
-      ])
-      .then(
-        ([
+    const securityGroupReader = this.getSecurityGroupReader();
+
+    return Promise.all([
+      AccountService.getCredentialsKeyedByAccount('aws'),
+      securityGroupReader.getAllSecurityGroups(),
+      SubnetReader.listSubnets(),
+      AccountService.getPreferredZonesByAccount('aws'),
+      KeyPairsReader.listKeyPairs(),
+      this.awsInstanceTypeService.getAllTypesByRegion(),
+      Promise.resolve(clone(this.enabledMetrics)),
+      Promise.resolve(clone(this.healthCheckTypes)),
+      Promise.resolve(clone(this.terminationPolicies)),
+    ]).then(
+      ([
+        credentialsKeyedByAccount,
+        securityGroups,
+        subnets,
+        preferredZones,
+        keyPairs,
+        instanceTypesInfo,
+        enabledMetrics,
+        healthCheckTypes,
+        terminationPolicies,
+      ]) => {
+        const backingData: Partial<IAmazonServerGroupCommandBackingData> = {
           credentialsKeyedByAccount,
           securityGroups,
           subnets,
@@ -284,45 +292,34 @@ export class AwsServerGroupConfigurationService {
           enabledMetrics,
           healthCheckTypes,
           terminationPolicies,
-        ]) => {
-          const backingData: Partial<IAmazonServerGroupCommandBackingData> = {
-            credentialsKeyedByAccount,
-            securityGroups,
-            subnets,
-            preferredZones,
-            keyPairs,
-            instanceTypesInfo,
-            enabledMetrics,
-            healthCheckTypes,
-            terminationPolicies,
-          };
-
-          let securityGroupReloader: PromiseLike<void> = $q.when();
-          backingData.accounts = keys(backingData.credentialsKeyedByAccount);
-          backingData.filtered = {} as IAmazonServerGroupCommandBackingDataFiltered;
-          backingData.scalingProcesses = AutoScalingProcessService.listProcesses();
-          backingData.appLoadBalancers = application.getDataSource('loadBalancers').data;
-          backingData.managedResources = application.getDataSource('managedResources')?.data?.resources;
-          cmd.backingData = backingData as IAmazonServerGroupCommandBackingData;
-          this.configureVpcId(cmd);
-          backingData.filtered.securityGroups = this.getRegionalSecurityGroups(cmd);
-          if (cmd.viewState.disableImageSelection) {
-            this.configureInstanceTypes(cmd);
-          }
+        };
+
+        let securityGroupReloader: Promise<void> = Promise.resolve();
+        backingData.accounts = keys(backingData.credentialsKeyedByAccount);
+        backingData.filtered = {} as IAmazonServerGroupCommandBackingDataFiltered;
+        backingData.scalingProcesses = AutoScalingProcessService.listProcesses();
+        backingData.appLoadBalancers = application.getDataSource('loadBalancers').data;
+        backingData.managedResources = application.getDataSource('managedResources')?.data?.resources;
+        cmd.backingData = backingData as IAmazonServerGroupCommandBackingData;
+        this.configureVpcId(cmd);
+        backingData.filtered.securityGroups = this.getRegionalSecurityGroups(cmd);
+        if (cmd.viewState.disableImageSelection) {
+          this.configureInstanceTypes(cmd);
+        }
 
-          if (cmd.securityGroups && cmd.securityGroups.length) {
-            const regionalSecurityGroupIds = map(this.getRegionalSecurityGroups(cmd), 'id');
-            if (intersection(cmd.securityGroups, regionalSecurityGroupIds).length < cmd.securityGroups.length) {
-              securityGroupReloader = this.refreshSecurityGroups(cmd, true);
-            }
+        if (cmd.securityGroups && cmd.securityGroups.length) {
+          const regionalSecurityGroupIds = map(this.getRegionalSecurityGroups(cmd), 'id');
+          if (intersection(cmd.securityGroups, regionalSecurityGroupIds).length < cmd.securityGroups.length) {
+            securityGroupReloader = this.refreshSecurityGroups(cmd, true);
           }
+        }
 
-          return securityGroupReloader.then(() => {
-            this.applyOverrides('afterConfiguration', cmd);
-            this.attachEventHandlers(cmd);
-          });
-        },
-      );
+        return securityGroupReloader.then(() => {
+          this.applyOverrides('afterConfiguration', cmd);
+          this.attachEventHandlers(cmd);
+        });
+      },
+    );
   }
 
   public applyOverrides(phase: string, command: IAmazonServerGroupCommand): void {
@@ -514,15 +511,19 @@ export class AwsServerGroupConfigurationService {
   public refreshSecurityGroups(
     command: IAmazonServerGroupCommand,
     skipCommandReconfiguration?: boolean,
-  ): PromiseLike<void> {
-    return this.cacheInitializer.refreshCache('securityGroups').then(() => {
-      return this.securityGroupReader.getAllSecurityGroups().then((securityGroups) => {
-        command.backingData.securityGroups = securityGroups;
-        if (!skipCommandReconfiguration) {
-          this.configureSecurityGroupOptions(command);
-        }
+  ): Promise<void> {
+    return this.getCacheInitializer()
+      .refreshCache('securityGroups')
+      .then(() => {
+        return this.getSecurityGroupReader()
+          .getAllSecurityGroups()
+          .then((securityGroups) => {
+            command.backingData.securityGroups = securityGroups;
+            if (!skipCommandReconfiguration) {
+              this.configureSecurityGroupOptions(command);
+            }
+          });
       });
-    });
   }
 
   private getLoadBalancerMap(command: IAmazonServerGroupCommand): IAmazonLoadBalancerSourceData[] {
@@ -613,12 +614,15 @@ export class AwsServerGroupConfigurationService {
   }
 
   public refreshLoadBalancers(command: IAmazonServerGroupCommand, skipCommandReconfiguration?: boolean) {
-    return this.loadBalancerReader.listLoadBalancers('aws').then((loadBalancers) => {
-      command.backingData.loadBalancers = loadBalancers;
-      if (!skipCommandReconfiguration) {
-        this.configureLoadBalancerOptions(command);
-      }
-    });
+    return REST('/loadBalancers')
+      .query({ provider: 'aws' })
+      .get()
+      .then((loadBalancers) => {
+        command.backingData.loadBalancers = loadBalancers;
+        if (!skipCommandReconfiguration) {
+          this.configureLoadBalancerOptions(command);
+        }
+      });
   }
 
   public configureVpcId(command: IAmazonServerGroupCommand): IAmazonServerGroupCommandResult {
@@ -737,11 +741,10 @@ export class AwsServerGroupConfigurationService {
   }
 }
 
-export const AWS_SERVER_GROUP_CONFIGURATION_SERVICE = 'spinnaker.amazon.serverGroup.configure.service';
-module(AWS_SERVER_GROUP_CONFIGURATION_SERVICE, [
-  SECURITY_GROUP_READER,
-  AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE,
-  LOAD_BALANCER_READ_SERVICE,
-  CACHE_INITIALIZER_SERVICE,
-  SERVER_GROUP_COMMAND_REGISTRY_PROVIDER,
-]).service('awsServerGroupConfigurationService', AwsServerGroupConfigurationService);
+export class AwsServerGroupConfigurationServiceDelegate extends AwsServerGroupConfigurationService {
+  public static readonly requiresDeckRuntimeServices = true;
+
+  constructor(_promiseService: unknown, runtimeServices: DeckRuntimeServices) {
+    super(runtimeServices.securityGroupReader, new AwsInstanceTypeService(), runtimeServices.cacheInitializer);
+  }
+}