@spinnaker/ecs 2026.2.2 → 2026.3.0

package/src/pipeline/stages/shrinkCluster/ecsShrinkClusterStage.js

@@ -1,73 +1,19 @@
-'use strict';
-
-import { module } from 'angular';
-
-import { AccountService, Registry } from '@spinnaker/core';
-
-export const ECS_PIPELINE_STAGES_SHRINKCLUSTER_ECSSHRINKCLUSTERSTAGE =
-  'spinnaker.ecs.pipeline.stage.ecs.shrinkClusterStage';
-export const name = ECS_PIPELINE_STAGES_SHRINKCLUSTER_ECSSHRINKCLUSTERSTAGE; // for backwards compatibility
-module(ECS_PIPELINE_STAGES_SHRINKCLUSTER_ECSSHRINKCLUSTERSTAGE, [])
-  .config(function () {
-    Registry.pipeline.registerStage({
-      provides: 'shrinkCluster',
-      cloudProvider: 'ecs',
-      templateUrl: require('./shrinkClusterStage.html'),
-      accountExtractor: (stage) => [stage.context.credentials],
-      configAccountExtractor: (stage) => [stage.credentials],
-      validators: [
-        { type: 'requiredField', fieldName: 'cluster' },
-        { type: 'requiredField', fieldName: 'shrinkToSize', fieldLabel: 'shrink to [X] Server Groups' },
-        { type: 'requiredField', fieldName: 'regions' },
-        { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
-      ],
-    });
-  })
-  .controller('ecsShrinkClusterStageCtrl', [
-    '$scope',
-    function ($scope) {
-      const ctrl = this;
-
-      const stage = $scope.stage;
-
-      $scope.state = {
-        accounts: false,
-        regionsLoaded: false,
-      };
-
-      AccountService.listAccounts('ecs').then(function (accounts) {
-        $scope.accounts = accounts;
-        $scope.state.accounts = true;
-      });
-
-      stage.regions = stage.regions || [];
-      stage.cloudProvider = 'ecs';
-
-      if (!stage.credentials && $scope.application.defaultCredentials.ecs) {
-        stage.credentials = $scope.application.defaultCredentials.ecs;
-      }
-      if (!stage.regions.length && $scope.application.defaultRegions.ecs) {
-        stage.regions.push($scope.application.defaultRegions.ecs);
-      }
-
-      if (stage.shrinkToSize === undefined) {
-        stage.shrinkToSize = 1;
-      }
-
-      if (stage.allowDeleteActive === undefined) {
-        stage.allowDeleteActive = false;
-      }
-
-      ctrl.pluralize = function (str, val) {
-        if (val === 1) {
-          return str;
-        }
-        return str + 's';
-      };
-
-      if (stage.retainLargerOverNewer === undefined) {
-        stage.retainLargerOverNewer = 'false';
-      }
-      stage.retainLargerOverNewer = stage.retainLargerOverNewer.toString();
-    },
-  ]);
+import { Registry } from '@spinnaker/core';
+
+import { EcsShrinkClusterStageConfig } from '../common/EcsStageConfigs';
+
+export function registerEcsShrinkClusterStage() {
+  Registry.pipeline.registerStage({
+    provides: 'shrinkCluster',
+    cloudProvider: 'ecs',
+    component: EcsShrinkClusterStageConfig,
+    accountExtractor: (stage) => [stage.context.credentials],
+    configAccountExtractor: (stage) => [stage.credentials],
+    validators: [
+      { type: 'requiredField', fieldName: 'cluster' },
+      { type: 'requiredField', fieldName: 'shrinkToSize', fieldLabel: 'shrink to [X] Server Groups' },
+      { type: 'requiredField', fieldName: 'regions' },
+      { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+    ],
+  });
+}

package/src/placementStrategy/placementStrategy.service.ts

@@ -1,5 +1,3 @@
-import { module } from 'angular';
-
 import type { IPlacementStrategy } from './IPlacementStrategy';
 
 export class PlacementStrategyService {
@@ -57,7 +55,3 @@ export class PlacementStrategyService {
     return [{ type: 'spread', field: 'instanceId' }];
   }
 }
-
-export const PLACEMENT_STRATEGY_SERVICE = 'spinnaker.ecs.placementStrategyService.service';
-
-module(PLACEMENT_STRATEGY_SERVICE, []).service('placementStrategyService', PlacementStrategyService);

package/src/secrets/secret.read.service.ts

@@ -1,14 +1,8 @@
-import { module } from 'angular';
-
 import { REST } from '@spinnaker/core';
 import type { ISecretDescriptor } from './ISecret';
 
 export class SecretReader {
-  public listSecrets(): PromiseLike<ISecretDescriptor[]> {
+  public listSecrets(): Promise<ISecretDescriptor[]> {
     return REST('/ecs/secrets').get();
   }
 }
-
-export const ECS_SECRET_READ_SERVICE = 'spinnaker.ecs.secret.read.service';
-
-module(ECS_SECRET_READ_SERVICE, []).service('secretReader', SecretReader);

package/src/securityGroup/details/EcsSecurityGroupDetails.spec.tsx

@@ -0,0 +1,245 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+
+import { IPRangeRules } from '@spinnaker/amazon';
+import { CollapsibleSection } from '@spinnaker/core';
+
+import { EcsSecurityGroupDetailsComponent as EcsSecurityGroupDetails } from './EcsSecurityGroupDetails';
+
+const tick = () => new Promise((resolve) => setTimeout(resolve));
+
+describe('EcsSecurityGroupDetails', () => {
+  const resolvedSecurityGroup = {
+    accountId: 'test-account',
+    name: 'web-sg',
+    provider: 'ecs',
+    region: 'eu-west-1',
+    vpcId: 'vpc-1',
+  };
+
+  function app(isStandalone = false) {
+    return {
+      isStandalone,
+      getDataSource: () => ({
+        ready: () => Promise.resolve(),
+        onRefresh: () => jasmine.createSpy('unsubscribe'),
+      }),
+    } as any;
+  }
+
+  it('replaces missing details through the injected state service', () => {
+    const stateService = { go: jasmine.createSpy('go') };
+    const component = new EcsSecurityGroupDetails({
+      app: app(),
+      resolvedSecurityGroup,
+      router: {},
+      stateParams: {},
+      stateService,
+    } as any);
+
+    (component as any).showNotFound();
+
+    expect(stateService.go).toHaveBeenCalledWith('^', { allowModalToStayOpen: true }, { location: 'replace' });
+  });
+
+  function securityGroup(name = 'web-sg') {
+    return {
+      accountId: 'test-account',
+      accountName: 'test-account',
+      description: 'Web ingress',
+      id: `id-${name}`,
+      ipRangeRules: [
+        {
+          protocol: 'tcp',
+          range: { ip: '10.0.0.0', cidr: '/24' },
+          portRanges: [{ startPort: 80, endPort: 80 }],
+        },
+      ],
+      name,
+      region: 'eu-west-1',
+      securityGroupRules: [
+        {
+          protocol: 'tcp',
+          portRanges: [{ startPort: 443, endPort: 443 }],
+          securityGroup: {
+            accountName: 'shared-account',
+            id: 'sg-source',
+            name: 'source-sg',
+            region: 'eu-west-1',
+            vpcId: 'vpc-1',
+          },
+        },
+      ],
+      vpcId: 'vpc-1',
+    };
+  }
+
+  it('loads full details and renders descriptions, VPC names, and Amazon rule models with ECS links', async () => {
+    const details = securityGroup();
+    const securityGroupReader = {
+      getApplicationSecurityGroup: jasmine.createSpy('getApplicationSecurityGroup').and.returnValue({}),
+      getSecurityGroupDetails: jasmine.createSpy('getSecurityGroupDetails').and.returnValue(Promise.resolve(details)),
+    };
+    const vpcReader = {
+      getVpcName: jasmine.createSpy('getVpcName').and.returnValue(Promise.resolve('Production VPC')),
+    };
+    const wrapper = shallow(
+      <EcsSecurityGroupDetails
+        app={app()}
+        resolvedSecurityGroup={resolvedSecurityGroup}
+        securityGroupReader={securityGroupReader as any}
+        vpcReader={vpcReader}
+      />,
+    );
+
+    await tick();
+    wrapper.update();
+
+    expect(securityGroupReader.getSecurityGroupDetails).toHaveBeenCalledWith(
+      jasmine.anything(),
+      'test-account',
+      'ecs',
+      'eu-west-1',
+      'vpc-1',
+      'web-sg',
+    );
+    expect(vpcReader.getVpcName).toHaveBeenCalledWith('vpc-1');
+    const detailsSection = shallow(<div>{wrapper.find(CollapsibleSection).first().prop('children')}</div>);
+    expect(detailsSection.text()).toContain('Web ingress');
+    expect(detailsSection.text()).toContain('Production VPC');
+    expect(wrapper.find(IPRangeRules).prop('ipRules')).toEqual([
+      {
+        address: '10.0.0.0/24',
+        rules: [{ description: '', endPort: 80, protocol: 'tcp', startPort: 80 }],
+      },
+    ]);
+
+    const referencedRules = shallow(<div>{wrapper.find(CollapsibleSection).last().prop('children')}</div>);
+    expect(referencedRules.text()).toContain('tcp: 443');
+    const securityGroupLink = referencedRules.find('UISref');
+    expect(shallow(<div>{securityGroupLink.prop('children')}</div>).text()).toContain('source-sg (sg-source)');
+    expect(securityGroupLink.prop('params')).toEqual(jasmine.objectContaining({ provider: 'ecs', name: 'source-sg' }));
+  });
+
+  it('renders explicit empty states when no IP or referenced security-group rules exist', async () => {
+    const details = { ...securityGroup(), ipRangeRules: [], securityGroupRules: [] };
+    const securityGroupReader = {
+      getApplicationSecurityGroup: () => ({}),
+      getSecurityGroupDetails: () => Promise.resolve(details),
+    };
+    const wrapper = shallow(
+      <EcsSecurityGroupDetails
+        app={app()}
+        resolvedSecurityGroup={resolvedSecurityGroup}
+        securityGroupReader={securityGroupReader as any}
+        vpcReader={{ getVpcName: () => Promise.resolve(null) }}
+      />,
+    );
+
+    await tick();
+    wrapper.update();
+
+    expect(wrapper.find(IPRangeRules).prop('ipRules')).toEqual([]);
+    expect(wrapper.find('[data-test-id="ecs-ip-rules-empty"]').text()).toBe('None');
+    expect(wrapper.find('[data-test-id="ecs-security-group-rules-empty"]').text()).toBe('None');
+  });
+
+  it('shows the standalone not-found state for empty and failed detail loads', async () => {
+    const emptyReader = {
+      getSecurityGroupDetails: () => Promise.resolve({}),
+    };
+    const failedReader = {
+      getSecurityGroupDetails: () => Promise.reject(new Error('not found')),
+    };
+    const emptyWrapper = shallow(
+      <EcsSecurityGroupDetails
+        app={app(true)}
+        resolvedSecurityGroup={resolvedSecurityGroup}
+        securityGroupReader={emptyReader as any}
+      />,
+    );
+    const failedWrapper = shallow(
+      <EcsSecurityGroupDetails
+        app={app(true)}
+        resolvedSecurityGroup={resolvedSecurityGroup}
+        securityGroupReader={failedReader as any}
+      />,
+    );
+
+    await tick();
+    emptyWrapper.update();
+    failedWrapper.update();
+
+    expect(emptyWrapper.text()).toContain('Could not find');
+    expect(emptyWrapper.text()).toContain('web-sg');
+    expect(failedWrapper.text()).toContain('Could not find');
+    expect(failedWrapper.text()).toContain('web-sg');
+  });
+
+  it('ignores stale detail and VPC responses after coordinates change', async () => {
+    let resolveFirstDetails: (details: any) => void;
+    let resolveFirstVpc: (name: string) => void;
+    const firstDetails = new Promise<any>((resolve) => (resolveFirstDetails = resolve));
+    const firstVpc = new Promise<string>((resolve) => (resolveFirstVpc = resolve));
+    const securityGroupReader = {
+      getApplicationSecurityGroup: () => ({}),
+      getSecurityGroupDetails: jasmine
+        .createSpy('getSecurityGroupDetails')
+        .and.callFake((_app: any, _account: string, _provider: string, _region: string, _vpcId: string, name: string) =>
+          name === 'web-sg' ? firstDetails : Promise.resolve({ ...securityGroup('api-sg'), vpcId: 'vpc-2' }),
+        ),
+    };
+    const vpcReader = {
+      getVpcName: jasmine
+        .createSpy('getVpcName')
+        .and.callFake((vpcId: string) => (vpcId === 'vpc-1' ? firstVpc : Promise.resolve('API VPC'))),
+    };
+    const wrapper = shallow(
+      <EcsSecurityGroupDetails
+        app={app()}
+        resolvedSecurityGroup={resolvedSecurityGroup}
+        securityGroupReader={securityGroupReader as any}
+        vpcReader={vpcReader}
+      />,
+    );
+
+    await tick();
+    resolveFirstDetails(securityGroup());
+    await tick();
+    wrapper.setProps({
+      resolvedSecurityGroup: { ...resolvedSecurityGroup, name: 'api-sg', vpcId: 'vpc-2' },
+    });
+    await tick();
+    wrapper.update();
+    expect(wrapper.text()).toContain('api-sg');
+    expect(shallow(<div>{wrapper.find(CollapsibleSection).first().prop('children')}</div>).text()).toContain('API VPC');
+
+    resolveFirstVpc('Stale VPC');
+    await tick();
+    wrapper.update();
+
+    expect(wrapper.text()).toContain('api-sg');
+    expect(wrapper.text()).not.toContain('Stale VPC');
+  });
+
+  it('does not update state when a detail request resolves after unmount', async () => {
+    let resolveDetails: (details: any) => void;
+    const securityGroupReader = {
+      getSecurityGroupDetails: () => new Promise<any>((resolve) => (resolveDetails = resolve)),
+    };
+    const component = new EcsSecurityGroupDetails({
+      app: app(),
+      resolvedSecurityGroup,
+      securityGroupReader: securityGroupReader as any,
+    });
+    spyOn(component, 'setState');
+
+    (component as any).loadSecurityGroup();
+    (component.setState as jasmine.Spy).calls.reset();
+    component.componentWillUnmount();
+    resolveDetails(securityGroup());
+    await tick();
+
+    expect(component.setState).not.toHaveBeenCalled();
+  });
+});

package/src/securityGroup/details/EcsSecurityGroupDetails.tsx

@@ -0,0 +1,285 @@
+import { UISref } from '@uirouter/react';
+import { isEmpty } from 'lodash';
+import React from 'react';
+
+import { buildIpRulesModel, buildSecurityGroupRulesModel, IPRangeRules, VpcReader } from '@spinnaker/amazon';
+import type {
+  Application,
+  IRouterInjectedProps,
+  ISecurityGroup,
+  ISecurityGroupDetail,
+  SecurityGroupReader,
+} from '@spinnaker/core';
+import {
+  AccountTag,
+  CloudProviderLogo,
+  CollapsibleSection,
+  DeckRuntimeContext,
+  FirewallLabels,
+  RecentHistoryService,
+  Spinner,
+  withRouter,
+} from '@spinnaker/core';
+
+interface IEcsResolvedSecurityGroup {
+  accountId: string;
+  name: string;
+  provider?: string;
+  region: string;
+  vpcId?: string;
+}
+
+interface IEcsSecurityGroupDetailsProps {
+  app: Application;
+  autoClose?: () => void;
+  resolvedSecurityGroup: IEcsResolvedSecurityGroup;
+  securityGroupReader?: SecurityGroupReader;
+  vpcReader?: Pick<typeof VpcReader, 'getVpcName'>;
+}
+
+interface IEcsSecurityGroupDetailsState {
+  loading: boolean;
+  notFound?: boolean;
+  securityGroup?: ISecurityGroupDetail & ISecurityGroup & Record<string, any>;
+}
+
+export class EcsSecurityGroupDetailsComponent extends React.Component<
+  IEcsSecurityGroupDetailsProps & IRouterInjectedProps,
+  IEcsSecurityGroupDetailsState
+> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
+  public state: IEcsSecurityGroupDetailsState = { loading: true };
+
+  private isUnmounted = false;
+  private loadRequestId = 0;
+  private unsubscribeFromRefresh: () => void;
+
+  public componentDidMount(): void {
+    const dataSource = this.props.app.getDataSource?.('securityGroups');
+    if (!dataSource) {
+      this.loadSecurityGroup();
+      return;
+    }
+
+    dataSource.ready().then(() => {
+      if (this.isUnmounted) {
+        return;
+      }
+      this.loadSecurityGroup();
+      this.unsubscribeFromRefresh = dataSource.onRefresh(this.loadSecurityGroup);
+    });
+  }
+
+  public componentDidUpdate(prevProps: IEcsSecurityGroupDetailsProps): void {
+    if (this.getCoordinatesKey(prevProps) !== this.getCoordinatesKey(this.props)) {
+      this.loadSecurityGroup();
+    }
+  }
+
+  public componentWillUnmount(): void {
+    this.isUnmounted = true;
+    this.unsubscribeFromRefresh?.();
+  }
+
+  private getCoordinatesKey(props: IEcsSecurityGroupDetailsProps): string {
+    const { accountId, name, region, vpcId } = props.resolvedSecurityGroup;
+    return [accountId, region, vpcId || '', name].join(':');
+  }
+
+  private getSecurityGroupReader(): SecurityGroupReader {
+    return this.props.securityGroupReader || this.context.services.securityGroupReader;
+  }
+
+  private getVpcReader(): Pick<typeof VpcReader, 'getVpcName'> {
+    return this.props.vpcReader || VpcReader;
+  }
+
+  private showNotFound = (): void => {
+    if (this.isUnmounted) {
+      return;
+    }
+    if (this.props.autoClose) {
+      this.props.autoClose();
+      return;
+    }
+    if (this.props.app.isStandalone) {
+      RecentHistoryService.removeLastItem('securityGroups');
+      this.setState({ loading: false, notFound: true, securityGroup: undefined });
+      return;
+    }
+    this.props.stateService.go('^', { allowModalToStayOpen: true }, { location: 'replace' });
+  };
+
+  private loadSecurityGroup = (): void => {
+    const { app, resolvedSecurityGroup } = this.props;
+    const requestId = ++this.loadRequestId;
+    this.setState({ loading: true, notFound: false, securityGroup: undefined });
+
+    this.getSecurityGroupReader()
+      .getSecurityGroupDetails(
+        app,
+        resolvedSecurityGroup.accountId,
+        'ecs',
+        resolvedSecurityGroup.region,
+        resolvedSecurityGroup.vpcId || '',
+        resolvedSecurityGroup.name,
+      )
+      .then((details: ISecurityGroupDetail & ISecurityGroup & Record<string, any>) => {
+        if (this.isUnmounted || requestId !== this.loadRequestId) {
+          return;
+        }
+        if (!details || isEmpty(details)) {
+          this.showNotFound();
+          return;
+        }
+
+        Promise.resolve(this.getVpcReader().getVpcName(details.vpcId)).then(
+          (vpcName) => {
+            if (this.isUnmounted || requestId !== this.loadRequestId) {
+              return;
+            }
+            const applicationSecurityGroup = this.getSecurityGroupReader().getApplicationSecurityGroup?.(
+              app,
+              resolvedSecurityGroup.accountId,
+              resolvedSecurityGroup.region,
+              resolvedSecurityGroup.name,
+            );
+            this.setState({
+              loading: false,
+              securityGroup: {
+                ...(applicationSecurityGroup || {}),
+                ...details,
+                accountId: details.accountId || resolvedSecurityGroup.accountId,
+                name: details.name || resolvedSecurityGroup.name,
+                region: details.region || resolvedSecurityGroup.region,
+                vpcId: details.vpcId || resolvedSecurityGroup.vpcId,
+                vpcName,
+              },
+            });
+          },
+          () => {
+            if (!this.isUnmounted && requestId === this.loadRequestId) {
+              this.showNotFound();
+            }
+          },
+        );
+      })
+      .catch(() => {
+        if (!this.isUnmounted && requestId === this.loadRequestId) {
+          this.showNotFound();
+        }
+      });
+  };
+
+  private closeDetails = (): void => {
+    this.props.stateService.go('^');
+  };
+
+  public render(): JSX.Element {
+    const { app, resolvedSecurityGroup } = this.props;
+    const { loading, notFound, securityGroup } = this.state;
+
+    if (notFound) {
+      return (
+        <div className="text-center">
+          <h3>
+            Could not find {FirewallLabels.get('firewall')} {resolvedSecurityGroup.name}.
+          </h3>
+          <UISref to="home.infrastructure">
+            <a>Back to search results</a>
+          </UISref>
+        </div>
+      );
+    }
+
+    const ipRules = securityGroup ? buildIpRulesModel(securityGroup) : [];
+    const securityGroupRules = securityGroup ? buildSecurityGroupRulesModel(securityGroup) : [];
+
+    return (
+      <div className="details-panel">
+        <div className="header">
+          {!app.isStandalone && (
+            <div className="close-button">
+              <a className="btn btn-link" onClick={this.closeDetails}>
+                <span className="glyphicon glyphicon-remove" />
+              </a>
+            </div>
+          )}
+          {loading && (
+            <div className="horizontal center middle">
+              <Spinner size="small" />
+            </div>
+          )}
+          {!loading && securityGroup && (
+            <div className="header-text horizontal middle">
+              <CloudProviderLogo provider="ecs" height="36px" width="36px" />
+              <h3>{securityGroup.name || '(not found)'}</h3>
+            </div>
+          )}
+        </div>
+        {!loading && securityGroup && (
+          <div className="content">
+            <CollapsibleSection heading={`${FirewallLabels.get('Firewall')} Details`} defaultExpanded={true}>
+              <dl className="dl-horizontal dl-medium">
+                <dt>ID</dt>
+                <dd>{securityGroup.id}</dd>
+                <dt>Account</dt>
+                <dd>
+                  <AccountTag account={securityGroup.accountName || securityGroup.accountId} />
+                </dd>
+                <dt>Region</dt>
+                <dd>{securityGroup.region}</dd>
+                <dt>VPC</dt>
+                <dd>{securityGroup.vpcName || securityGroup.vpcId}</dd>
+                <dt>Description</dt>
+                <dd>{securityGroup.description}</dd>
+              </dl>
+            </CollapsibleSection>
+            <IPRangeRules ipRules={ipRules} />
+            {!ipRules.length && <div data-test-id="ecs-ip-rules-empty">None</div>}
+            <CollapsibleSection
+              heading={`${FirewallLabels.get('Firewall')} Rules (${securityGroupRules.length})`}
+              defaultExpanded={securityGroupRules.length > 0}
+            >
+              {!securityGroupRules.length && <div data-test-id="ecs-security-group-rules-empty">None</div>}
+              {securityGroupRules.map((rule) => (
+                <dl className="dl-horizontal dl-medium" key={rule.securityGroup.id || rule.securityGroup.name}>
+                  <dt>{FirewallLabels.get('Firewall')}</dt>
+                  <dd>
+                    <UISref
+                      to="^.firewallDetails"
+                      params={{
+                        accountId: rule.securityGroup.accountName || rule.securityGroup.accountId,
+                        name: rule.securityGroup.name,
+                        provider: 'ecs',
+                        region: rule.securityGroup.region,
+                        vpcId: rule.securityGroup.vpcId,
+                      }}
+                    >
+                      <a>
+                        {rule.securityGroup.accountName !== securityGroup.accountName && (
+                          <AccountTag account={rule.securityGroup.accountName || rule.securityGroup.accountId} />
+                        )}{' '}
+                        {rule.securityGroup.name} ({rule.securityGroup.id})
+                      </a>
+                    </UISref>
+                  </dd>
+                  <dt>Port Ranges</dt>
+                  {rule.rules.map((portRange) => (
+                    <dd key={`${portRange.protocol}-${portRange.startPort}-${portRange.endPort}`}>
+                      {portRange.protocol}: {portRange.startPort} &rarr; {portRange.endPort}
+                    </dd>
+                  ))}
+                </dl>
+              ))}
+            </CollapsibleSection>
+          </div>
+        )}
+      </div>
+    );
+  }
+}
+
+export const EcsSecurityGroupDetails = withRouter(EcsSecurityGroupDetailsComponent);

package/src/securityGroup/securityGroup.reader.ts

@@ -1,5 +1,3 @@
-import { module } from 'angular';
-
 import type { ISecurityGroup, ISecurityGroupsByAccount } from '@spinnaker/core';
 
 export class EcsSecurityGroupReader {
@@ -11,6 +9,3 @@ export class EcsSecurityGroupReader {
     return indexedSecurityGroups[container.account][container.region][securityGroupId];
   }
 }
-
-export const ECS_SECURITY_GROUP_READER = 'spinnaker.ecs.securityGroup.reader';
-module(ECS_SECURITY_GROUP_READER, []).service('ecsSecurityGroupReader', EcsSecurityGroupReader);

package/src/securityGroup/securityGroup.transformer.js

@@ -1,13 +1,5 @@
-'use strict';
-
-import { module } from 'angular';
-
-export const ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER = 'spinnaker.ecs.securityGroup.transformer';
-export const name = ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER; // for backwards compatibility
-module(ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER, []).factory('ecsSecurityGroupTransformer', function () {
-  function normalizeSecurityGroup() {}
-
-  return {
-    normalizeSecurityGroup: normalizeSecurityGroup,
-  };
-});
+export class EcsSecurityGroupTransformer {
+  normalizeSecurityGroup(securityGroup) {
+    return Promise.resolve(securityGroup);
+  }
+}