@spinnaker/ecs 2026.2.2 → 2026.3.0

package/src/serverGroup/details/EcsServerGroupActions.spec.tsx

@@ -0,0 +1,244 @@
+import { mount as enzymeMount } from 'enzyme';
+import React from 'react';
+import { Dropdown, Tooltip } from 'react-bootstrap';
+
+import { AWSProviderSettings } from '@spinnaker/amazon';
+import {
+  AddEntityTagLinks,
+  ConfirmationModalService,
+  DeckRuntimeContext,
+  ManagedMenuItem,
+  SETTINGS,
+  ServerGroupWarningMessageService,
+} from '@spinnaker/core';
+
+import { EcsServerGroupActionsComponent as EcsServerGroupActions } from './EcsServerGroupActions';
+import { EcsResizeServerGroupModal } from './resize/EcsResizeServerGroupModal';
+import { EcsRollbackServerGroupModal } from './rollback/EcsRollbackServerGroupModal';
+
+describe('<EcsServerGroupActions />', () => {
+  const originalAdHocInfraWritesEnabled = AWSProviderSettings.adHocInfraWritesEnabled;
+  let runtimeServices: any;
+  const RuntimeWrapper = ({ children }: React.PropsWithChildren<{}>) => (
+    <DeckRuntimeContext.Provider value={{ services: runtimeServices } as any}>{children}</DeckRuntimeContext.Provider>
+  );
+  const shallow = (component: React.ReactElement) => enzymeMount(component, { wrappingComponent: RuntimeWrapper });
+
+  const buildServerGroup = (overrides: any = {}) => ({
+    account: 'test-account',
+    capacity: { desired: 2, max: 4, min: 1 },
+    cloudProvider: 'ecs',
+    cluster: 'test-app-main',
+    isDisabled: false,
+    moniker: { app: 'test-app', cluster: 'test-app-main' },
+    name: 'test-app-main-v002',
+    region: 'us-east-1',
+    runningTasks: [],
+    ...overrides,
+  });
+
+  const buildApp = (overrides: any = {}) => {
+    const serverGroups = overrides.serverGroups || [];
+    return {
+      attributes: {},
+      getDataSource: (key: string) => (key === 'serverGroups' ? { data: serverGroups } : undefined),
+      name: 'test-app',
+      serverGroups: { data: serverGroups, refresh: jasmine.createSpy('refresh') },
+      ...overrides,
+    } as any;
+  };
+
+  const action = (wrapper: any, label: string) =>
+    wrapper.find(ManagedMenuItem).filterWhere((item: any) => item.prop('children') === label);
+
+  beforeEach(() => {
+    AWSProviderSettings.adHocInfraWritesEnabled = true;
+    runtimeServices = {
+      serverGroupWriter: {
+        destroyServerGroup: () => Promise.resolve(),
+        disableServerGroup: () => Promise.resolve(),
+        enableServerGroup: () => Promise.resolve(),
+      },
+    };
+  });
+
+  afterEach(() => {
+    AWSProviderSettings.adHocInfraWritesEnabled = originalAdHocInfraWritesEnabled;
+    SETTINGS.resetToOriginal();
+  });
+
+  it('shows rollback, resize, disable, and destroy for an enabled server group', () => {
+    const serverGroup = buildServerGroup();
+    const wrapper = shallow(
+      <EcsServerGroupActions app={buildApp({ serverGroups: [serverGroup] })} serverGroup={serverGroup} />,
+    );
+
+    expect(action(wrapper, 'Rollback').length).toBe(1);
+    expect(action(wrapper, 'Resize').length).toBe(1);
+    expect(action(wrapper, 'Disable').length).toBe(1);
+    expect(action(wrapper, 'Enable').length).toBe(0);
+    expect(action(wrapper, 'Destroy').length).toBe(1);
+  });
+
+  it('shows resize, enable, and destroy for a disabled server group', () => {
+    const serverGroup = buildServerGroup({ isDisabled: true });
+    const wrapper = shallow(
+      <EcsServerGroupActions app={buildApp({ serverGroups: [serverGroup] })} serverGroup={serverGroup} />,
+    );
+
+    expect(action(wrapper, 'Rollback').length).toBe(0);
+    expect(action(wrapper, 'Resize').length).toBe(1);
+    expect(action(wrapper, 'Disable').length).toBe(0);
+    expect(action(wrapper, 'Enable').length).toBe(1);
+    expect(action(wrapper, 'Destroy').length).toBe(1);
+  });
+
+  it('locks enable while a resize task is running', () => {
+    const serverGroup = buildServerGroup({
+      isDisabled: true,
+      runningTasks: [{ execution: { stages: [{ type: 'resizeServerGroup' }] } }],
+    });
+    const wrapper = shallow(<EcsServerGroupActions app={buildApp()} serverGroup={serverGroup} />);
+
+    expect(action(wrapper, 'Enable').length).toBe(0);
+    expect(wrapper.find('li.disabled').length).toBe(1);
+    expect(wrapper.find(Tooltip).prop('value')).toContain('Cannot enable');
+  });
+
+  it('hides all actions when AWS ad-hoc infrastructure writes are disabled', () => {
+    const app = buildApp();
+    const serverGroup = buildServerGroup();
+    expect(shallow(<EcsServerGroupActions app={app} serverGroup={serverGroup} />).find(Dropdown).length).toBe(1);
+
+    AWSProviderSettings.adHocInfraWritesEnabled = false;
+
+    const wrapper = shallow(<EcsServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    expect(wrapper.find(Dropdown).length).toBe(0);
+  });
+
+  it('protects every write action with the managed-resource interstitial', () => {
+    const app = buildApp();
+    const serverGroup = buildServerGroup({ isManaged: true });
+    const wrapper = shallow(<EcsServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    expect(wrapper.find(ManagedMenuItem).length).toBe(4);
+    wrapper.find(ManagedMenuItem).forEach((item) => {
+      expect(item.prop('resource')).toBe(serverGroup);
+      expect(item.prop('application')).toBe(app);
+    });
+  });
+
+  it('opens the completed rollback modal with the enriched server group', () => {
+    const app = buildApp();
+    const serverGroup = buildServerGroup();
+    const show = spyOn(EcsRollbackServerGroupModal, 'show').and.returnValue(Promise.resolve({} as any));
+    const wrapper = shallow(<EcsServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    action(wrapper, 'Rollback').prop('onClick')();
+
+    expect(show).toHaveBeenCalledOnceWith({ application: app, serverGroup }, runtimeServices);
+  });
+
+  it('opens the completed resize modal with the enriched server group', () => {
+    const app = buildApp();
+    const serverGroup = buildServerGroup();
+    const show = spyOn(EcsResizeServerGroupModal, 'show').and.returnValue(Promise.resolve({} as any));
+    const wrapper = shallow(<EcsServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    action(wrapper, 'Resize').prop('onClick')();
+
+    expect(show).toHaveBeenCalledOnceWith({ application: app, serverGroup }, runtimeServices);
+  });
+
+  ['Disable', 'Enable', 'Destroy'].forEach((label) => {
+    it(`confirms ${label.toLowerCase()} with reason and account verification and preserves the exact writer contract`, () => {
+      const app = buildApp();
+      const serverGroup = buildServerGroup({ isDisabled: label === 'Enable' });
+      const writerMethod = `${label.toLowerCase()}ServerGroup`;
+      const writer = runtimeServices.serverGroupWriter as any;
+      const write = spyOn(writer, writerMethod).and.returnValue(Promise.resolve());
+      const confirm = spyOn(ConfirmationModalService, 'confirm').and.returnValue(Promise.resolve());
+      const stateService = {
+        go: jasmine.createSpy('go'),
+        includes: jasmine.createSpy('includes').and.returnValue(true),
+      };
+      spyOn(ServerGroupWarningMessageService, 'addDisableWarningMessage');
+      spyOn(ServerGroupWarningMessageService, 'addDestroyWarningMessage');
+      const wrapper = shallow(
+        <EcsServerGroupActions
+          app={app}
+          router={{} as any}
+          serverGroup={serverGroup}
+          stateParams={{}}
+          stateService={stateService as any}
+        />,
+      );
+
+      action(wrapper, label).prop('onClick')();
+
+      const params = confirm.calls.mostRecent().args[0] as any;
+      expect(params.account).toBe('test-account');
+      expect(params.askForReason).toBe(true);
+      const command = { interestingHealthProviderNames: ['Ecs'], reason: 'because it is safe' };
+      params.submitMethod(command);
+      expect(write).toHaveBeenCalledOnceWith(serverGroup, label === 'Disable' ? app.name : app, command);
+      if (label === 'Destroy') {
+        params.taskMonitorConfig.onTaskComplete();
+        expect(stateService.go).toHaveBeenCalledWith('^');
+      }
+    });
+  });
+
+  it('preselects ECS health only when the application requests platform-only health', () => {
+    const app = buildApp({ attributes: { platformHealthOnly: true, platformHealthOnlyShowOverride: true } });
+    const confirm = spyOn(ConfirmationModalService, 'confirm').and.returnValue(Promise.resolve());
+    spyOn(ServerGroupWarningMessageService, 'addDisableWarningMessage');
+    const wrapper = shallow(<EcsServerGroupActions app={app} serverGroup={buildServerGroup()} />);
+
+    action(wrapper, 'Disable').prop('onClick')();
+
+    expect((confirm.calls.mostRecent().args[0] as any).interestingHealthProviderNames).toEqual(['Ecs']);
+  });
+
+  it('adds entity tag links using the enriched ECS coordinates and refreshes after updates', () => {
+    SETTINGS.feature.entityTags = true;
+    const app = buildApp();
+    const serverGroup = buildServerGroup();
+    const wrapper = shallow(<EcsServerGroupActions app={app} serverGroup={serverGroup} />);
+    const links = wrapper.find(AddEntityTagLinks);
+
+    expect(links.prop('component')).toBe(serverGroup);
+    expect(links.prop('application')).toBe(app);
+    expect(links.prop('entityType')).toBe('serverGroup');
+    expect(links.prop('ownerOptions')).toEqual([
+      jasmine.objectContaining({ type: 'serverGroup', owner: serverGroup }),
+      jasmine.objectContaining({
+        type: 'cluster',
+        owner: { account: 'test-account', cloudProvider: 'ecs', name: 'test-app-main', region: 'us-east-1' },
+      }),
+      jasmine.objectContaining({
+        type: 'cluster',
+        owner: { account: 'test-account', cloudProvider: 'ecs', name: 'test-app-main', region: '*' },
+      }),
+    ]);
+
+    links.prop('onUpdate')();
+    expect(app.serverGroups.refresh).toHaveBeenCalled();
+  });
+
+  it('omits entity tag links when the feature is disabled', () => {
+    const app = buildApp();
+    const serverGroup = buildServerGroup();
+    SETTINGS.feature.entityTags = true;
+    expect(shallow(<EcsServerGroupActions app={app} serverGroup={serverGroup} />).find(AddEntityTagLinks).length).toBe(
+      1,
+    );
+
+    SETTINGS.feature.entityTags = false;
+
+    const wrapper = shallow(<EcsServerGroupActions app={app} serverGroup={serverGroup} />);
+
+    expect(wrapper.find(AddEntityTagLinks).length).toBe(0);
+  });
+});

package/src/serverGroup/details/EcsServerGroupActions.tsx

@@ -0,0 +1,152 @@
+import React from 'react';
+import { Dropdown, Tooltip } from 'react-bootstrap';
+
+import { AWSProviderSettings } from '@spinnaker/amazon';
+import type { IOwnerOption, IRouterInjectedProps, IServerGroupActionsProps, IServerGroupJob } from '@spinnaker/core';
+import {
+  AddEntityTagLinks,
+  ClusterTargetBuilder,
+  ConfirmationModalService,
+  ManagedMenuItem,
+  ServerGroupWarningMessageService,
+  SETTINGS,
+  useDeckRuntimeServices,
+  withRouter,
+} from '@spinnaker/core';
+
+import { EcsResizeServerGroupModal } from './resize/EcsResizeServerGroupModal';
+import { EcsRollbackServerGroupModal } from './rollback/EcsRollbackServerGroupModal';
+
+type ConfirmedAction = 'destroy' | 'disable' | 'enable';
+
+const actionLabels: Record<ConfirmedAction, { present: string; progressive: string }> = {
+  destroy: { present: 'Destroy', progressive: 'Destroying' },
+  disable: { present: 'Disable', progressive: 'Disabling' },
+  enable: { present: 'Enable', progressive: 'Enabling' },
+};
+
+export function EcsServerGroupActionsComponent({
+  app,
+  serverGroup,
+  stateService,
+}: IServerGroupActionsProps & IRouterInjectedProps) {
+  const runtimeServices = useDeckRuntimeServices();
+  const { serverGroupWriter } = runtimeServices;
+  if (!AWSProviderSettings.adHocInfraWritesEnabled) {
+    return null;
+  }
+
+  const showEntityTags = SETTINGS.feature && SETTINGS.feature.entityTags;
+  const entityTagTargets: IOwnerOption[] = ClusterTargetBuilder.buildClusterTargets(serverGroup);
+  const enableLocked =
+    serverGroup.isDisabled &&
+    (serverGroup.runningTasks || []).some((task: any) =>
+      (task.execution?.stages || []).some((stage: any) => stage.type === 'resizeServerGroup'),
+    );
+
+  const confirmAction = (action: ConfirmedAction): void => {
+    const label = actionLabels[action];
+    const stateParams = { name: serverGroup.name, accountId: serverGroup.account, region: serverGroup.region };
+    const confirmationModalParams = {
+      header: `Really ${action} ${serverGroup.name}?`,
+      buttonText: `${label.present} ${serverGroup.name}`,
+      account: serverGroup.account,
+      taskMonitorConfig: {
+        application: app,
+        title: `${label.progressive} ${serverGroup.name}`,
+        ...(action === 'destroy'
+          ? {
+              onTaskComplete: () => {
+                if (stateService.includes('**.serverGroup', stateParams)) {
+                  stateService.go('^');
+                }
+              },
+            }
+          : {}),
+      },
+      platformHealthOnlyShowOverride: app.attributes.platformHealthOnlyShowOverride,
+      platformHealthType: 'Ecs',
+      interestingHealthProviderNames:
+        app.attributes.platformHealthOnlyShowOverride && app.attributes.platformHealthOnly ? ['Ecs'] : undefined,
+      submitMethod: (params: IServerGroupJob) => {
+        if (action === 'destroy') {
+          return serverGroupWriter.destroyServerGroup(serverGroup, app, params);
+        }
+        if (action === 'disable') {
+          return serverGroupWriter.disableServerGroup(serverGroup, app.name, params);
+        }
+        return serverGroupWriter.enableServerGroup(serverGroup, app, params);
+      },
+      askForReason: true,
+    };
+
+    if (action === 'destroy') {
+      ServerGroupWarningMessageService.addDestroyWarningMessage(app, serverGroup, confirmationModalParams);
+    } else if (action === 'disable') {
+      ServerGroupWarningMessageService.addDisableWarningMessage(app, serverGroup, confirmationModalParams);
+    }
+
+    ConfirmationModalService.confirm(confirmationModalParams);
+  };
+
+  return (
+    <Dropdown className="dropdown" id="server-group-actions-dropdown">
+      <Dropdown.Toggle className="btn btn-sm btn-primary dropdown-toggle">Server Group Actions</Dropdown.Toggle>
+      <Dropdown.Menu className="dropdown-menu">
+        {!serverGroup.isDisabled && (
+          <ManagedMenuItem
+            resource={serverGroup}
+            application={app}
+            onClick={() => EcsRollbackServerGroupModal.show({ application: app, serverGroup }, runtimeServices)}
+          >
+            Rollback
+          </ManagedMenuItem>
+        )}
+        <ManagedMenuItem
+          resource={serverGroup}
+          application={app}
+          onClick={() => EcsResizeServerGroupModal.show({ application: app, serverGroup }, runtimeServices)}
+        >
+          Resize
+        </ManagedMenuItem>
+        {!serverGroup.isDisabled && (
+          <ManagedMenuItem resource={serverGroup} application={app} onClick={() => confirmAction('disable')}>
+            Disable
+          </ManagedMenuItem>
+        )}
+        {serverGroup.isDisabled && !enableLocked && (
+          <ManagedMenuItem resource={serverGroup} application={app} onClick={() => confirmAction('enable')}>
+            Enable
+          </ManagedMenuItem>
+        )}
+        {enableLocked && (
+          <li className="disabled">
+            <Tooltip
+              id="ecs-enable-locked-tooltip"
+              value="Cannot enable this server group until resize operation completes"
+              placement="left"
+            >
+              <a>
+                <span className="small glyphicon glyphicon-lock" /> Enable
+              </a>
+            </Tooltip>
+          </li>
+        )}
+        <ManagedMenuItem resource={serverGroup} application={app} onClick={() => confirmAction('destroy')}>
+          Destroy
+        </ManagedMenuItem>
+        {showEntityTags && (
+          <AddEntityTagLinks
+            component={serverGroup}
+            application={app}
+            entityType="serverGroup"
+            ownerOptions={entityTagTargets}
+            onUpdate={() => app.serverGroups.refresh()}
+          />
+        )}
+      </Dropdown.Menu>
+    </Dropdown>
+  );
+}
+
+export const EcsServerGroupActions = withRouter(EcsServerGroupActionsComponent);

package/src/serverGroup/details/ecsServerGroupDetailsGetter.spec.ts

@@ -0,0 +1,110 @@
+import { ServerGroupReader } from '@spinnaker/core';
+
+import { ecsServerGroupDetailsGetter } from './ecsServerGroupDetailsGetter';
+import { EcsServerGroupTransformer } from '../serverGroup.transformer';
+
+function deferred<T>() {
+  let resolve: (value: T) => void;
+  let reject: (error: any) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve: resolve!, reject: reject! };
+}
+
+describe('ecsServerGroupDetailsGetter', () => {
+  const serverGroup = { accountId: 'test', name: 'fnord-main-v001', region: 'us-east-1' } as any;
+
+  it('merges the application summary over full details and normalizes the result', (done) => {
+    const summary = {
+      account: 'test',
+      name: 'fnord-main-v001',
+      region: 'us-east-1',
+      instanceCounts: { total: 2, up: 2 },
+      isDisabled: true,
+    };
+    const app = {
+      name: 'fnord',
+      ready: () => Promise.resolve(),
+      serverGroups: { data: [summary] },
+      loadBalancers: { data: [] },
+    } as any;
+    const details = {
+      name: 'fnord-main-v001',
+      isDisabled: false,
+      taskDefinition: { taskName: 'fnord:1' },
+      scalingPolicies: [],
+    };
+    spyOn(ServerGroupReader, 'getServerGroup').and.returnValue(Promise.resolve(details) as any);
+    const normalize = spyOn(
+      EcsServerGroupTransformer.prototype,
+      'normalizeServerGroupDetails',
+    ).and.callFake((value: any) => ({ ...value, normalized: true }));
+    const autoClose = jasmine.createSpy('autoClose');
+
+    ecsServerGroupDetailsGetter({ app, serverGroup } as any, autoClose).subscribe({
+      next: (result: any) => {
+        expect(normalize).toHaveBeenCalledOnceWith(
+          jasmine.objectContaining({
+            account: 'test',
+            instanceCounts: summary.instanceCounts,
+            isDisabled: true,
+            taskDefinition: details.taskDefinition,
+          }),
+        );
+        expect(result.normalized).toBe(true);
+        expect(autoClose).not.toHaveBeenCalled();
+      },
+      error: done.fail,
+      complete: done,
+    });
+  });
+
+  it('uses a matching load balancer server group summary when the application summary is unavailable', (done) => {
+    const loadBalancerSummary = {
+      account: 'test',
+      name: 'fnord-main-v001',
+      region: 'us-east-1',
+      instanceCounts: { total: 1, up: 1 },
+    };
+    const app = {
+      name: 'fnord',
+      ready: () => Promise.resolve(),
+      serverGroups: { data: [] },
+      loadBalancers: { data: [{ account: 'test', region: 'us-east-1', serverGroups: [loadBalancerSummary] }] },
+    } as any;
+    spyOn(ServerGroupReader, 'getServerGroup').and.returnValue(
+      Promise.resolve({ name: 'fnord-main-v001', scalingPolicies: [] }) as any,
+    );
+
+    ecsServerGroupDetailsGetter({ app, serverGroup } as any, done.fail).subscribe({
+      next: (result: any) => expect(result.instanceCounts).toBe(loadBalancerSummary.instanceCounts),
+      error: done.fail,
+      complete: done,
+    });
+  });
+
+  it('does not emit or auto-close after the details subscription is cancelled', async () => {
+    const request = deferred<any>();
+    const app = {
+      name: 'fnord',
+      ready: () => Promise.resolve(),
+      serverGroups: { data: [] },
+      loadBalancers: { data: [] },
+    } as any;
+    spyOn(ServerGroupReader, 'getServerGroup').and.returnValue(request.promise as any);
+    const autoClose = jasmine.createSpy('autoClose');
+    const next = jasmine.createSpy('next');
+    const subscription = ecsServerGroupDetailsGetter({ app, serverGroup } as any, autoClose).subscribe(next);
+
+    await Promise.resolve();
+    subscription.unsubscribe();
+    request.reject(new Error('not found'));
+    await request.promise.catch(() => undefined);
+    await Promise.resolve();
+
+    expect(next).not.toHaveBeenCalled();
+    expect(autoClose).not.toHaveBeenCalled();
+  });
+});

package/src/serverGroup/details/ecsServerGroupDetailsGetter.ts

@@ -0,0 +1,73 @@
+import { isEmpty } from 'lodash';
+import { Observable } from 'rxjs';
+
+import type { IServerGroup, IServerGroupDetailsProps } from '@spinnaker/core';
+import { ServerGroupReader } from '@spinnaker/core';
+
+import { EcsServerGroupTransformer } from '../serverGroup.transformer';
+
+export function ecsServerGroupDetailsGetter(
+  props: IServerGroupDetailsProps,
+  autoClose: () => void,
+): Observable<IServerGroup> {
+  const { app, serverGroup: serverGroupInfo } = props;
+  return new Observable<IServerGroup>((observer) => {
+    let cancelled = false;
+    let summary: IServerGroup;
+
+    app
+      .ready()
+      .then(() => {
+        if (cancelled) {
+          return null;
+        }
+
+        summary = app.serverGroups.data.find(
+          (candidate: IServerGroup) =>
+            candidate.name === serverGroupInfo.name &&
+            candidate.account === serverGroupInfo.accountId &&
+            candidate.region === serverGroupInfo.region,
+        );
+        if (!summary) {
+          const loadBalancer = app.loadBalancers.data.find(
+            (candidate: any) =>
+              candidate.account === serverGroupInfo.accountId && candidate.region === serverGroupInfo.region,
+          );
+          summary = loadBalancer?.serverGroups.find(
+            (candidate: IServerGroup) => candidate.name === serverGroupInfo.name,
+          );
+        }
+
+        return ServerGroupReader.getServerGroup(
+          app.name,
+          serverGroupInfo.accountId,
+          serverGroupInfo.region,
+          serverGroupInfo.name,
+        );
+      })
+      .then((serverGroup: IServerGroup) => {
+        if (cancelled || serverGroup === null) {
+          return;
+        }
+        if (isEmpty(serverGroup)) {
+          autoClose();
+          observer.complete();
+          return;
+        }
+
+        const merged = { ...serverGroup, ...summary, account: serverGroupInfo.accountId } as IServerGroup;
+        observer.next(new EcsServerGroupTransformer().normalizeServerGroupDetails(merged as any) as IServerGroup);
+        observer.complete();
+      })
+      .catch(() => {
+        if (!cancelled) {
+          autoClose();
+          observer.complete();
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  });
+}