@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/serverGroup/details/AmazonServerGroupActions.tsx

@@ -1,27 +1,31 @@
-import { filter, find, get, orderBy } from 'lodash';
+import { get } from 'lodash';
 import React from 'react';
 import { Dropdown, MenuItem, Tooltip } from 'react-bootstrap';
 
-import type { IOwnerOption, IServerGroupActionsProps, IServerGroupJob } from '@spinnaker/core';
+import type { IOwnerOption, IRouterInjectedProps, IServerGroupActionsProps, IServerGroupJob } from '@spinnaker/core';
 import {
   AddEntityTagLinks,
   ClusterTargetBuilder,
   ConfirmationModalService,
+  DeckRuntimeContext,
   ManagedMenuItem,
-  ModalInjector,
   Overridable,
-  ReactInjector,
   ServerGroupWarningMessageService,
   SETTINGS,
+  withRouter,
 } from '@spinnaker/core';
 
 import { AWSProviderSettings } from '../../aws.settings';
 import type { IAmazonServerGroupCommand } from '../configure';
 import { AmazonCloneServerGroupModal } from '../configure/wizard/AmazonCloneServerGroupModal';
 import type { IAmazonServerGroup, IAmazonServerGroupView } from '../../domain';
-import { AwsReactInjector } from '../../reactShims';
 import type { IAmazonResizeServerGroupModalProps } from './resize/AmazonResizeServerGroupModal';
 import { AmazonResizeServerGroupModal } from './resize/AmazonResizeServerGroupModal';
+import {
+  AmazonRollbackServerGroupModal,
+  isAmazonRollbackAvailable,
+  selectAmazonRollbackServerGroups,
+} from './rollback';
 
 export interface IAmazonServerGroupActionsProps extends IServerGroupActionsProps {
   serverGroup: IAmazonServerGroupView;
@@ -29,8 +33,11 @@ export interface IAmazonServerGroupActionsProps extends IServerGroupActionsProps
 
 @Overridable('AmazonServerGroupActions.resize')
 export class AmazonServerGroupActionsResize extends React.Component<IAmazonResizeServerGroupModalProps> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
   private resizeServerGroup = (): void => {
-    AmazonResizeServerGroupModal.show(this.props);
+    AmazonResizeServerGroupModal.show(this.props, this.context.services);
   };
 
   public render(): JSX.Element {
@@ -38,7 +45,12 @@ export class AmazonServerGroupActionsResize extends React.Component<IAmazonResiz
   }
 }
 
-export class AmazonServerGroupActions extends React.Component<IAmazonServerGroupActionsProps> {
+export class AmazonServerGroupActionsComponent extends React.Component<
+  IAmazonServerGroupActionsProps & IRouterInjectedProps
+> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
   private isEnableLocked(): boolean {
     if (this.props.serverGroup.isDisabled) {
       const resizeTasks = (this.props.serverGroup.runningTasks || []).filter((task) =>
@@ -53,22 +65,7 @@ export class AmazonServerGroupActions extends React.Component<IAmazonServerGroup
 
   private isRollbackEnabled(): boolean {
     const { app, serverGroup } = this.props;
-
-    if (!serverGroup.isDisabled) {
-      // enabled server groups are always a candidate for rollback
-      return true;
-    }
-
-    // if the server group selected for rollback is disabled, ensure that at least one enabled server group exists
-    return app
-      .getDataSource('serverGroups')
-      .data.some(
-        (g: IAmazonServerGroup) =>
-          g.cluster === serverGroup.cluster &&
-          g.region === serverGroup.region &&
-          g.account === serverGroup.account &&
-          !g.isDisabled,
-      );
+    return isAmazonRollbackAvailable(app.name, serverGroup, app.getDataSource('serverGroups').data);
   }
 
   private hasDisabledInstances(): boolean {
@@ -83,14 +80,14 @@ export class AmazonServerGroupActions extends React.Component<IAmazonServerGroup
       application: app,
       title: 'Destroying ' + serverGroup.name,
       onTaskComplete: () => {
-        if (ReactInjector.$state.includes('**.serverGroup', stateParams)) {
-          ReactInjector.$state.go('^');
+        if (this.props.stateService.includes('**.serverGroup', stateParams)) {
+          this.props.stateService.go('^');
         }
       },
     };
 
     const submitMethod = (params: IServerGroupJob) =>
-      ReactInjector.serverGroupWriter.destroyServerGroup(serverGroup, app, params);
+      this.context.services.serverGroupWriter.destroyServerGroup(serverGroup, app, params);
 
     const stateParams = {
       name: serverGroup.name,
@@ -128,7 +125,7 @@ export class AmazonServerGroupActions extends React.Component<IAmazonServerGroup
     };
 
     const submitMethod = (params: IServerGroupJob) => {
-      return ReactInjector.serverGroupWriter.disableServerGroup(serverGroup, app.name, params);
+      return this.context.services.serverGroupWriter.disableServerGroup(serverGroup, app.name, params);
     };
 
     const confirmationModalParams = {
@@ -167,9 +164,6 @@ export class AmazonServerGroupActions extends React.Component<IAmazonServerGroup
     };
 
     ConfirmationModalService.confirm(confirmationModalParams)
-      // Wait for the confirmation modal to go away first to avoid react/angular bootstrap fighting
-      // over the body.modal-open class
-      .then(() => new Promise((resolve) => setTimeout(resolve, 500)))
       .then(() => this.rollbackServerGroup())
       .catch((error) => {
         // don't show the enable modal if the user cancels with the header button
@@ -188,7 +182,7 @@ export class AmazonServerGroupActions extends React.Component<IAmazonServerGroup
     };
 
     const submitMethod = (params: IServerGroupJob) => {
-      return ReactInjector.serverGroupWriter.enableServerGroup(serverGroup, app, params);
+      return this.context.services.serverGroupWriter.enableServerGroup(serverGroup, app, params);
     };
 
     const confirmationModalParams = {
@@ -211,71 +205,25 @@ export class AmazonServerGroupActions extends React.Component<IAmazonServerGroup
   }
 
   private rollbackServerGroup = (): void => {
-    const { app } = this.props;
-
-    let serverGroup: IAmazonServerGroup = this.props.serverGroup;
-    let previousServerGroup: IAmazonServerGroup;
-    let allServerGroups = app
-      .getDataSource('serverGroups')
-      .data.filter(
-        (g: IAmazonServerGroup) =>
-          g.cluster === serverGroup.cluster && g.region === serverGroup.region && g.account === serverGroup.account,
-      );
-
-    if (serverGroup.isDisabled) {
-      // if the selected server group is disabled, it represents the server group that should be _rolled back to_
-      previousServerGroup = serverGroup;
-
-      /*
-       * Find an existing server group to rollback, prefer the largest enabled server group.
-       *
-       * isRollbackEnabled() ensures that at least one enabled server group exists.
-       */
-      serverGroup = orderBy(
-        allServerGroups.filter((g: IAmazonServerGroup) => g.name !== previousServerGroup.name && !g.isDisabled),
-        ['instanceCounts.total', 'createdTime'],
-        ['desc', 'desc'],
-      )[0] as IAmazonServerGroup;
-    }
-
-    // the set of all server groups should not include the server group selected for rollback
-    allServerGroups = allServerGroups.filter((g: IAmazonServerGroup) => g.name !== serverGroup.name);
+    const { app, serverGroup } = this.props;
+    const selection = selectAmazonRollbackServerGroups(
+      app.name,
+      serverGroup,
+      app.getDataSource('serverGroups').data as IAmazonServerGroup[],
+    );
 
-    if (allServerGroups.length === 1 && !previousServerGroup) {
-      // if there is only one other server group, default to it being the rollback target
-      previousServerGroup = allServerGroups[0];
+    if (selection) {
+      AmazonRollbackServerGroupModal.show({ application: app, ...selection }, this.context.services);
     }
-
-    ModalInjector.modalService.open({
-      templateUrl: ReactInjector.overrideRegistry.getTemplate(
-        'aws.rollback.modal',
-        require('./rollback/rollbackServerGroup.html'),
-      ),
-      controller: 'awsRollbackServerGroupCtrl as ctrl',
-      resolve: {
-        serverGroup: () => serverGroup,
-        previousServerGroup: () => previousServerGroup,
-        disabledServerGroups: () => {
-          const cluster = find(app.clusters, {
-            name: serverGroup.cluster,
-            account: serverGroup.account,
-            serverGroups: [],
-          });
-          return filter(cluster.serverGroups, { isDisabled: true, region: serverGroup.region });
-        },
-        allServerGroups: () => allServerGroups,
-        application: () => app,
-      },
-    });
   };
 
   private cloneServerGroup = (): void => {
     const { app, serverGroup } = this.props;
-    AwsReactInjector.awsServerGroupCommandBuilder
+    this.context.services.serverGroupCommandBuilder
       .buildServerGroupCommandFromExisting(app, serverGroup)
       .then((command: IAmazonServerGroupCommand) => {
         const title = `Clone ${serverGroup.name}`;
-        AmazonCloneServerGroupModal.show({ title, application: app, command });
+        AmazonCloneServerGroupModal.show({ title, application: app, command }, this.context.services);
       });
   };
 
@@ -341,3 +289,5 @@ export class AmazonServerGroupActions extends React.Component<IAmazonServerGroup
     );
   }
 }
+
+export const AmazonServerGroupActions = withRouter(AmazonServerGroupActionsComponent);

package/src/serverGroup/details/advancedSettings/EditAsgAdvancedSettingsModal.spec.tsx

@@ -0,0 +1,110 @@
+import { mount, shallow } from 'enzyme';
+import React from 'react';
+
+import { DeckRuntimeContext, FormikFormField, ReactModal, TaskMonitorModal } from '@spinnaker/core';
+
+import { EditAsgAdvancedSettingsModal } from './EditAsgAdvancedSettingsModal';
+
+describe('EditAsgAdvancedSettingsModal', () => {
+  const application = { name: 'deck', serverGroups: { refresh: jasmine.createSpy('refresh') } } as any;
+  const serverGroup = { name: 'deck-main-v001', account: 'test', region: 'us-east-1' } as any;
+  let buildUpdateServerGroupCommand: jasmine.Spy;
+  const modalProps = {
+    application,
+    serverGroup,
+    closeModal: jasmine.createSpy('closeModal'),
+    dismissModal: jasmine.createSpy('dismissModal'),
+  };
+
+  function mountModal(command: any) {
+    buildUpdateServerGroupCommand = jasmine.createSpy().and.returnValue(command);
+    const commandBuilder = { buildUpdateServerGroupCommand };
+    const runtime = {
+      services: { providerServiceDelegate: { getDelegate: jasmine.createSpy().and.returnValue(commandBuilder) } },
+    } as any;
+    return mount(
+      <DeckRuntimeContext.Provider value={runtime}>
+        <EditAsgAdvancedSettingsModal {...modalProps} />
+      </DeckRuntimeContext.Provider>,
+    ).find(EditAsgAdvancedSettingsModal);
+  }
+
+  it('builds one update command and preserves it across rerenders', () => {
+    const command = {
+      backingData: { enabledMetrics: [], healthCheckTypes: [], terminationPolicies: [] },
+    } as any;
+    const wrapper = mountModal(command);
+    const initialValues = wrapper.find(TaskMonitorModal).prop('initialValues');
+
+    wrapper.instance().forceUpdate();
+    wrapper.update();
+
+    expect(buildUpdateServerGroupCommand).toHaveBeenCalledTimes(1);
+    expect(wrapper.find(TaskMonitorModal).prop('initialValues')).toBe(initialValues);
+  });
+
+  it('uses the update command builder and exposes every advanced setting', () => {
+    const command = {
+      cooldown: 10,
+      enabledMetrics: ['GroupDesiredCapacity'],
+      healthCheckGracePeriod: 600,
+      healthCheckType: 'EC2',
+      terminationPolicies: ['Default'],
+      capacityRebalance: false,
+      backingData: {
+        enabledMetrics: ['GroupDesiredCapacity'],
+        healthCheckTypes: ['EC2', 'ELB'],
+        terminationPolicies: ['Default'],
+      },
+    } as any;
+    const wrapper = mountModal(command);
+    const taskModal = wrapper.find(TaskMonitorModal);
+
+    expect(taskModal.prop('initialValues')).toBe(command);
+    expect(taskModal.prop('mapValuesToTask')(command)).toEqual({ application, job: [command] });
+
+    const fields = shallow(<div>{taskModal.prop('render')({ values: command } as any)}</div>).find(FormikFormField);
+    expect(fields.map((field) => field.prop('name'))).toEqual([
+      'cooldown',
+      'enabledMetrics',
+      'healthCheckType',
+      'healthCheckGracePeriod',
+      'terminationPolicies',
+      'capacityRebalance',
+    ]);
+  });
+
+  it('requires finite non-negative cooldown and health check grace period values', () => {
+    const command = {
+      cooldown: 10,
+      healthCheckGracePeriod: 600,
+      backingData: { enabledMetrics: [], healthCheckTypes: [], terminationPolicies: [] },
+    } as any;
+    const wrapper = mountModal(command);
+    const taskModal = wrapper.find(TaskMonitorModal);
+    const fields = shallow(<div>{taskModal.prop('render')({ values: command } as any)}</div>).find(FormikFormField);
+
+    ['cooldown', 'healthCheckGracePeriod'].forEach((name) => {
+      const field = fields.filterWhere((candidate) => candidate.prop('name') === name);
+      const validate = field.prop('validate') as (value: unknown) => string | undefined;
+
+      expect(field.prop('required')).toBe(true);
+      [undefined, null, '', NaN, Infinity, -Infinity, -1].forEach((value) => expect(validate(value)).toBeDefined());
+      [0, 0.5, 1].forEach((value) => expect(validate(value)).toBeUndefined());
+    });
+  });
+
+  it('opens only after managed-resource verification succeeds', async () => {
+    const show = spyOn(ReactModal, 'show').and.returnValue(Promise.resolve() as any);
+    const runtimeServices = {} as any;
+
+    await EditAsgAdvancedSettingsModal.show({ application, serverGroup }, runtimeServices);
+
+    expect(show).toHaveBeenCalledWith(
+      EditAsgAdvancedSettingsModal,
+      { application, serverGroup },
+      { dialogClassName: 'modal-lg' },
+      runtimeServices,
+    );
+  });
+});

package/src/serverGroup/details/advancedSettings/EditAsgAdvancedSettingsModal.tsx

@@ -0,0 +1,117 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+
+import type { Application, DeckRuntimeServices, IModalComponentProps } from '@spinnaker/core';
+import {
+  CheckboxInput,
+  confirmNotManaged,
+  DeckRuntimeContext,
+  FormikFormField,
+  HelpField,
+  NumberInput,
+  ReactModal,
+  ReactSelectInput,
+  TaskMonitorModal,
+} from '@spinnaker/core';
+
+import type { AwsServerGroupCommandBuilder } from '../../configure/serverGroupCommandBuilder.service';
+import type { IAmazonServerGroupCommand } from '../../configure/serverGroupConfiguration.service';
+import type { IAmazonServerGroup } from '../../../domain';
+
+export interface IEditAsgAdvancedSettingsModalProps extends IModalComponentProps {
+  application: Application;
+  serverGroup: IAmazonServerGroup;
+}
+
+function validateRequiredNonNegativeNumber(value: unknown): string | undefined {
+  return typeof value !== 'number' || !Number.isFinite(value) || value < 0
+    ? 'Enter a finite non-negative number'
+    : undefined;
+}
+
+export class EditAsgAdvancedSettingsModal extends React.Component<IEditAsgAdvancedSettingsModalProps> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
+  private directCommand: Partial<IAmazonServerGroupCommand>;
+
+  public static show(props: IEditAsgAdvancedSettingsModalProps, runtimeServices: DeckRuntimeServices) {
+    return confirmNotManaged(props.serverGroup, props.application).then(
+      (notManaged) =>
+        notManaged &&
+        ReactModal.show(EditAsgAdvancedSettingsModal, props, { dialogClassName: 'modal-lg' }, runtimeServices),
+    );
+  }
+
+  private get command(): Partial<IAmazonServerGroupCommand> {
+    return (this.directCommand ||= this.context.services.providerServiceDelegate
+      .getDelegate<AwsServerGroupCommandBuilder>('aws', 'serverGroup.commandBuilder')
+      .buildUpdateServerGroupCommand(this.props.serverGroup));
+  }
+
+  private renderFields = (formik: FormikProps<IAmazonServerGroupCommand>) => {
+    const { backingData } = formik.values;
+    return (
+      <>
+        <FormikFormField
+          label="Cooldown"
+          name="cooldown"
+          help="Seconds"
+          input={(props) => <NumberInput {...props} min={0} />}
+          required={true}
+          validate={validateRequiredNonNegativeNumber}
+        />
+        <FormikFormField
+          label="Enabled Metrics"
+          name="enabledMetrics"
+          help={<HelpField id="aws.serverGroup.enabledMetrics" />}
+          input={(props) => <ReactSelectInput {...props} multi={true} stringOptions={backingData.enabledMetrics} />}
+        />
+        <FormikFormField
+          label="Health Check Type"
+          name="healthCheckType"
+          input={(props) => (
+            <ReactSelectInput {...props} clearable={false} stringOptions={backingData.healthCheckTypes} />
+          )}
+        />
+        <FormikFormField
+          label="Health Check Grace Period"
+          name="healthCheckGracePeriod"
+          help="Seconds"
+          input={(props) => <NumberInput {...props} min={0} />}
+          required={true}
+          validate={validateRequiredNonNegativeNumber}
+        />
+        <FormikFormField
+          label="Termination Policies"
+          name="terminationPolicies"
+          input={(props) => (
+            <ReactSelectInput {...props} multi={true} stringOptions={backingData.terminationPolicies} />
+          )}
+        />
+        <FormikFormField
+          label="Capacity Rebalance"
+          name="capacityRebalance"
+          help={<HelpField id="aws.serverGroup.capacityRebalance" />}
+          input={(props) => <CheckboxInput {...props} text="Enable capacity rebalance" />}
+        />
+      </>
+    );
+  };
+
+  public render() {
+    const { application, closeModal, dismissModal, serverGroup } = this.props;
+    return (
+      <TaskMonitorModal<IAmazonServerGroupCommand>
+        application={application}
+        closeModal={closeModal}
+        description={`Update Advanced Settings for ${serverGroup.name}`}
+        dismissModal={dismissModal}
+        initialValues={this.command as IAmazonServerGroupCommand}
+        mapValuesToTask={(command) => ({ application, job: [command] })}
+        render={this.renderFields}
+        title={`Edit Advanced Settings for ${serverGroup.name}`}
+      />
+    );
+  }
+}

package/src/serverGroup/details/advancedSettings/index.ts

@@ -0,0 +1 @@
+export * from './EditAsgAdvancedSettingsModal';

package/src/serverGroup/details/amazonServerGroupDetailsGetter.ts

@@ -3,12 +3,12 @@ import { Observable } from 'rxjs';
 
 import type { IServerGroupDetailsProps, ISubnet } from '@spinnaker/core';
 import { AccountService, ServerGroupReader, SubnetReader } from '@spinnaker/core';
-import type { IAmazonLoadBalancer, IAmazonServerGroup, IAmazonServerGroupView } from '../../domain';
-import { AwsReactInjector } from '../../reactShims';
 
+import { AwsServices } from '../../aws.services';
+import type { IAmazonLoadBalancer, IAmazonServerGroup, IAmazonServerGroupView } from '../../domain';
 import { AutoScalingProcessService } from './scalingProcesses/AutoScalingProcessService';
 
-function extractServerGroupSummary(props: IServerGroupDetailsProps): PromiseLike<IAmazonServerGroup> {
+function extractServerGroupSummary(props: IServerGroupDetailsProps): Promise<IAmazonServerGroup> {
   const { app, serverGroup } = props;
   return app.ready().then(() => {
     let summary: IAmazonServerGroup = app.serverGroups.data.find((toCheck: IAmazonServerGroup) => {
@@ -52,7 +52,7 @@ export function amazonServerGroupDetailsGetter(
         // it's possible the summary was not found because the clusters are still loading
         Object.assign(details, summary, { account: serverGroupInfo.accountId });
 
-        const serverGroup = AwsReactInjector.awsServerGroupTransformer.normalizeServerGroupDetails(details);
+        const serverGroup = AwsServices.awsServerGroupTransformer.normalizeServerGroupDetails(details);
 
         AccountService.getAccountDetails(serverGroup.account).then((accountDetails) => {
           serverGroup.accountDetails = accountDetails;

package/src/serverGroup/details/resize/AmazonResizeServerGroupModal.tsx

@@ -4,10 +4,17 @@ import { pickBy } from 'lodash';
 import React from 'react';
 import { Modal } from 'react-bootstrap';
 
-import type { Application, ICapacity, IModalComponentProps, IServerGroupJob } from '@spinnaker/core';
+import type {
+  Application,
+  DeckRuntimeServices,
+  ICapacity,
+  IModalComponentProps,
+  IServerGroupJob,
+} from '@spinnaker/core';
 import {
   CheckboxInput,
   confirmNotManaged,
+  DeckRuntimeContext,
   FormikFormField,
   HelpField,
   MinMaxDesiredChanges,
@@ -15,7 +22,6 @@ import {
   noop,
   NumberInput,
   PlatformHealthOverride,
-  ReactInjector,
   ReactModal,
   SpinFormik,
   TaskMonitor,
@@ -23,6 +29,7 @@ import {
   TaskReason,
   ValidationMessage,
 } from '@spinnaker/core';
+
 import { AwsModalFooter } from '../../../common';
 import type { IAmazonServerGroup } from '../../../domain';
 
@@ -57,6 +64,9 @@ export class AmazonResizeServerGroupModal extends React.Component<
   IAmazonResizeServerGroupModalProps,
   IAmazonResizeServerGroupModalState
 > {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
   public static defaultProps: Partial<IAmazonResizeServerGroupModalProps> = {
     closeModal: noop,
     dismissModal: noop,
@@ -64,11 +74,11 @@ export class AmazonResizeServerGroupModal extends React.Component<
 
   private formikRef = React.createRef<Formik<IAmazonResizeServerGroupValues>>();
 
-  public static show(props: IAmazonResizeServerGroupModalProps) {
+  public static show(props: IAmazonResizeServerGroupModalProps, runtimeServices: DeckRuntimeServices) {
     const modalProps = {};
     const { serverGroup, application } = props;
     return confirmNotManaged(serverGroup, application).then((notManaged) => {
-      notManaged && ReactModal.show(AmazonResizeServerGroupModal, props, modalProps);
+      notManaged && ReactModal.show(AmazonResizeServerGroupModal, props, modalProps, runtimeServices);
     });
   }
 
@@ -88,7 +98,7 @@ export class AmazonResizeServerGroupModal extends React.Component<
       taskMonitor: new TaskMonitor({
         application: props.application,
         title: 'Resizing your server group',
-        modalInstance: TaskMonitor.modalInstanceEmulation(() => this.props.dismissModal()),
+        onDismiss: () => this.props.dismissModal(),
         onTaskComplete: () => this.props.application.serverGroups.refresh(),
       }),
       platformHealthOnlyShowOverride: attributes.platformHealthOnlyShowOverride,
@@ -199,7 +209,7 @@ export class AmazonResizeServerGroupModal extends React.Component<
       };
     }
     this.state.taskMonitor.submit(() => {
-      return ReactInjector.serverGroupWriter.resizeServerGroup(serverGroup, application, command);
+      return this.context.services.serverGroupWriter.resizeServerGroup(serverGroup, application, command);
     });
   };