@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/pipeline/stages/disableAsg/AwsDisableAsgStageConfig.tsx

@@ -0,0 +1,103 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  PlatformHealthOverride,
+  Registry,
+  StageConfigField,
+  StageConstants,
+  TargetSelect,
+} from '@spinnaker/core';
+
+export function AwsDisableAsgStageConfig(props: IStageConfigProps) {
+  const { application, pipeline, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'aws') {
+      changes.cloudProvider = 'aws';
+    }
+    if (!stage.credentials && application.defaultCredentials?.aws) {
+      changes.credentials = application.defaultCredentials.aws;
+    }
+    if (!stage.target) {
+      changes.target = StageConstants.TARGET_LIST[0].val;
+    }
+    if (
+      stage.isNew &&
+      application.attributes.platformHealthOnlyShowOverride &&
+      application.attributes.platformHealthOnly &&
+      stage.interestingHealthProviderNames === undefined
+    ) {
+      changes.interestingHealthProviderNames = ['Amazon'];
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('aws').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={stage}
+          onComponentUpdate={stageFieldUpdated}
+        />
+      )}
+      <StageConfigField label="Target">
+        <TargetSelect
+          model={{ target: stage.target }}
+          onChange={(target: string) => updateStageField({ target })}
+          options={StageConstants.TARGET_LIST}
+        />
+      </StageConfigField>
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <StageConfigField label="Task Completion">
+          <PlatformHealthOverride
+            interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+            onChange={(interestingHealthProviderNames) => updateStageField({ interestingHealthProviderNames })}
+            platformHealthType="Amazon"
+          />
+        </StageConfigField>
+      )}
+    </div>
+  );
+}
+
+export const awsDisableAsgStage = {
+  key: 'disableServerGroup',
+  provides: 'disableServerGroup',
+  alias: 'disableAsg',
+  cloudProvider: 'aws',
+  component: AwsDisableAsgStageConfig,
+  validators: [
+    {
+      type: 'targetImpedance',
+      message:
+        'This pipeline will attempt to disable a server group without deploying a new version into the same cluster.',
+    },
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+};
+
+export function registerAwsDisableAsgStage() {
+  Registry.pipeline.registerStage(awsDisableAsgStage);
+}
+
+registerAwsDisableAsgStage();

package/src/pipeline/stages/disableCluster/AwsDisableClusterStageConfig.tsx

@@ -0,0 +1,119 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  PlatformHealthOverride,
+  Registry,
+  StageConfigField,
+} from '@spinnaker/core';
+
+function pluralize(str: string, val: number): string {
+  return val === 1 ? str : `${str}s`;
+}
+
+export function AwsDisableClusterStageConfig(props: IStageConfigProps) {
+  const { application, pipeline, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'aws') {
+      changes.cloudProvider = 'aws';
+    }
+    if (!stage.credentials && application.defaultCredentials?.aws) {
+      changes.credentials = application.defaultCredentials.aws;
+    }
+    if (stage.remainingEnabledServerGroups === undefined) {
+      changes.remainingEnabledServerGroups = 1;
+    }
+    if (stage.preferLargerOverNewer === undefined) {
+      changes.preferLargerOverNewer = 'false';
+    }
+    if (
+      stage.isNew &&
+      application.attributes.platformHealthOnlyShowOverride &&
+      application.attributes.platformHealthOnly &&
+      stage.interestingHealthProviderNames === undefined
+    ) {
+      changes.interestingHealthProviderNames = ['Amazon'];
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('aws').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={stage}
+          onComponentUpdate={stageFieldUpdated}
+        />
+      )}
+      <StageConfigField label="Disable Options">
+        <div className="form-inline">
+          Keep the{' '}
+          <input
+            className="form-control input-sm"
+            min={0}
+            onChange={(event) => updateStageField({ remainingEnabledServerGroups: Number(event.target.value) })}
+            required
+            style={{ width: 50 }}
+            type="number"
+            value={stage.remainingEnabledServerGroups ?? ''}
+          />{' '}
+          <select
+            className="form-control input-sm"
+            onChange={(event) => updateStageField({ preferLargerOverNewer: event.target.value })}
+            style={{ width: 100 }}
+            value={stage.preferLargerOverNewer ?? 'false'}
+          >
+            <option value="true">largest</option>
+            <option value="false">newest</option>
+          </select>{' '}
+          {pluralize('server group', stage.remainingEnabledServerGroups)} enabled.
+        </div>
+      </StageConfigField>
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <StageConfigField label="Task Completion">
+          <PlatformHealthOverride
+            interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+            onChange={(interestingHealthProviderNames) => updateStageField({ interestingHealthProviderNames })}
+            platformHealthType="Amazon"
+          />
+        </StageConfigField>
+      )}
+    </div>
+  );
+}
+
+export const awsDisableClusterStage = {
+  key: 'disableCluster',
+  provides: 'disableCluster',
+  cloudProvider: 'aws',
+  component: AwsDisableClusterStageConfig,
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'remainingEnabledServerGroups', fieldLabel: 'Keep [X] enabled Server Groups' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+};
+
+export function registerAwsDisableClusterStage() {
+  Registry.pipeline.registerStage(awsDisableClusterStage);
+}
+
+registerAwsDisableClusterStage();

package/src/pipeline/stages/enableAsg/AwsEnableAsgStageConfig.tsx

@@ -0,0 +1,98 @@
+import React, { useEffect, useState } from 'react';
+
+import type { IAccount, IStageConfigProps } from '@spinnaker/core';
+import {
+  AccountRegionClusterSelector,
+  AccountService,
+  PlatformHealthOverride,
+  Registry,
+  StageConfigField,
+  StageConstants,
+  TargetSelect,
+} from '@spinnaker/core';
+
+export function AwsEnableAsgStageConfig(props: IStageConfigProps) {
+  const { application, pipeline, stage, stageFieldUpdated, updateStageField } = props;
+  const [accounts, setAccounts] = useState<IAccount[]>([]);
+
+  useEffect(() => {
+    const changes: Record<string, any> = {};
+    if (stage.cloudProvider !== 'aws') {
+      changes.cloudProvider = 'aws';
+    }
+    if (!stage.credentials && application.defaultCredentials?.aws) {
+      changes.credentials = application.defaultCredentials.aws;
+    }
+    if (!stage.target) {
+      changes.target = StageConstants.TARGET_LIST[0].val;
+    }
+    if (
+      stage.isNew &&
+      application.attributes.platformHealthOnlyShowOverride &&
+      application.attributes.platformHealthOnly &&
+      stage.interestingHealthProviderNames === undefined
+    ) {
+      changes.interestingHealthProviderNames = ['Amazon'];
+    }
+    if (Object.keys(changes).length) {
+      updateStageField(changes);
+    }
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+    AccountService.listAccounts('aws').then((loadedAccounts) => active && setAccounts(loadedAccounts));
+    return () => {
+      active = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline.strategy && (
+        <AccountRegionClusterSelector
+          accounts={accounts}
+          application={application}
+          component={stage}
+          onComponentUpdate={stageFieldUpdated}
+        />
+      )}
+      <StageConfigField label="Target">
+        <TargetSelect
+          model={{ target: stage.target }}
+          onChange={(target: string) => updateStageField({ target })}
+          options={StageConstants.TARGET_LIST}
+        />
+      </StageConfigField>
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <StageConfigField label="Task Completion">
+          <PlatformHealthOverride
+            interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+            onChange={(interestingHealthProviderNames) => updateStageField({ interestingHealthProviderNames })}
+            platformHealthType="Amazon"
+          />
+        </StageConfigField>
+      )}
+    </div>
+  );
+}
+
+export const awsEnableAsgStage = {
+  key: 'enableServerGroup',
+  provides: 'enableServerGroup',
+  alias: 'enableAsg',
+  cloudProvider: 'aws',
+  component: AwsEnableAsgStageConfig,
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'target' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+  ],
+};
+
+export function registerAwsEnableAsgStage() {
+  Registry.pipeline.registerStage(awsEnableAsgStage);
+}
+
+registerAwsEnableAsgStage();

package/src/pipeline/stages/findAmi/awsFindAmiStage.js

@@ -1,79 +1,22 @@
-'use strict';
-
-import * as angular from 'angular';
-
-import { AccountService, Registry } from '@spinnaker/core';
-
-export const AMAZON_PIPELINE_STAGES_FINDAMI_AWSFINDAMISTAGE = 'spinnaker.amazon.pipeline.stage.findAmiStage';
-export const name = AMAZON_PIPELINE_STAGES_FINDAMI_AWSFINDAMISTAGE; // for backwards compatibility
-angular
-  .module(AMAZON_PIPELINE_STAGES_FINDAMI_AWSFINDAMISTAGE, [])
-  .config(function () {
-    Registry.pipeline.registerStage({
-      provides: 'findImage',
-      alias: 'findAmi',
-      cloudProvider: 'aws',
-      templateUrl: require('./findAmiStage.html'),
-      validators: [
-        { type: 'requiredField', fieldName: 'cluster' },
-        { type: 'requiredField', fieldName: 'selectionStrategy', fieldLabel: 'Server Group Selection' },
-        { type: 'requiredField', fieldName: 'regions' },
-        { type: 'requiredField', fieldName: 'credentials' },
-      ],
-    });
-  })
-  .controller('awsFindAmiStageCtrl', [
-    '$scope',
-    function ($scope) {
-      const stage = $scope.stage;
-
-      $scope.state = {
-        accounts: false,
-        regionsLoaded: false,
-      };
-
-      AccountService.listAccounts('aws').then(function (accounts) {
-        $scope.accounts = accounts;
-        $scope.state.accounts = true;
-      });
-
-      $scope.selectionStrategies = [
-        {
-          label: 'Largest',
-          val: 'LARGEST',
-          description: 'When multiple server groups exist, prefer the server group with the most instances',
-        },
-        {
-          label: 'Newest',
-          val: 'NEWEST',
-          description: 'When multiple server groups exist, prefer the newest',
-        },
-        {
-          label: 'Oldest',
-          val: 'OLDEST',
-          description: 'When multiple server groups exist, prefer the oldest',
-        },
-        {
-          label: 'Fail',
-          val: 'FAIL',
-          description: 'When multiple server groups exist, fail',
-        },
-      ];
-
-      stage.regions = stage.regions || [];
-      stage.cloudProvider = 'aws';
-      stage.selectionStrategy = stage.selectionStrategy || $scope.selectionStrategies[0].val;
-
-      if (angular.isUndefined(stage.onlyEnabled)) {
-        stage.onlyEnabled = true;
-      }
-      if (!stage.credentials && $scope.application.defaultCredentials.aws) {
-        stage.credentials = $scope.application.defaultCredentials.aws;
-      }
-      if (!stage.regions.length && $scope.application.defaultRegions.aws) {
-        stage.regions.push($scope.application.defaultRegions.aws);
-      }
-
-      $scope.$watch('stage.credentials', $scope.accountUpdated);
-    },
-  ]);
+import { Registry } from '@spinnaker/core';
+
+import { AmazonStageConfig } from '../AmazonStageConfig';
+
+export const awsFindAmiStage = {
+  provides: 'findImage',
+  alias: 'findAmi',
+  cloudProvider: 'aws',
+  component: AmazonStageConfig,
+  validators: [
+    { type: 'requiredField', fieldName: 'cluster' },
+    { type: 'requiredField', fieldName: 'selectionStrategy', fieldLabel: 'Server Group Selection' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'credentials' },
+  ],
+};
+
+export function registerAwsFindAmiStage() {
+  Registry.pipeline.registerStage(awsFindAmiStage);
+}
+
+registerAwsFindAmiStage();

package/src/pipeline/stages/findImageFromTags/AwsFindImageFromTagsStageConfig.spec.tsx

@@ -0,0 +1,122 @@
+import { mount, shallow } from 'enzyme';
+import React from 'react';
+
+import { BakeryReader, ChecklistInput, MapEditor } from '@spinnaker/core';
+
+import { AmazonStageConfig } from '../AmazonStageConfig';
+import { AwsFindImageFromTagsStageConfig } from './AwsFindImageFromTagsStageConfig';
+import { awsFindImageFromTagsStage } from './awsFindImageFromTagsStage';
+
+describe('AWS Find Image from Tags stage', () => {
+  function renderEditor(stage: any) {
+    const updateStageField = jasmine.createSpy('updateStageField');
+    const wrapper = shallow(
+      <AwsFindImageFromTagsStageConfig
+        application={{ defaultRegions: { aws: 'eu-west-1' } } as any}
+        pipeline={{} as any}
+        stage={stage}
+        updateStageField={updateStageField}
+      />,
+    );
+    return { updateStageField, wrapper };
+  }
+
+  it('registers a dedicated stage editor', () => {
+    expect(awsFindImageFromTagsStage.component).not.toBe(AmazonStageConfig);
+  });
+
+  it('renders explicit persisted values without changing them on mount', () => {
+    spyOn(BakeryReader, 'getRegions').and.returnValue(Promise.resolve([]) as any);
+    const tags = { Environment: 'production', EmptyValue: '' };
+    const updateStageField = jasmine.createSpy('updateStageField');
+    const wrapper = mount(
+      <AwsFindImageFromTagsStageConfig
+        application={{ defaultRegions: { aws: 'eu-west-1' } } as any}
+        pipeline={{} as any}
+        stage={{ cloudProvider: '', packageName: 'payments', regions: [], tags }}
+        updateStageField={updateStageField}
+      />,
+    );
+
+    expect(wrapper.find('input[name="packageName"]').prop('value')).toBe('payments');
+    expect(wrapper.find(ChecklistInput).prop('value')).toEqual([]);
+    expect(wrapper.find(MapEditor).prop('model')).toBe(tags);
+    expect(wrapper.find(MapEditor).prop('allowEmpty')).toBe(true);
+    expect(updateStageField).not.toHaveBeenCalled();
+    wrapper.unmount();
+  });
+
+  it('defaults only undefined stage fields on mount', () => {
+    spyOn(BakeryReader, 'getRegions').and.returnValue(Promise.resolve([]) as any);
+    const updateStageField = jasmine.createSpy('updateStageField');
+
+    const wrapper = mount(
+      <AwsFindImageFromTagsStageConfig
+        application={{ defaultRegions: { aws: 'eu-west-1' } } as any}
+        pipeline={{} as any}
+        stage={{ cloudProvider: undefined, regions: undefined, tags: undefined }}
+        updateStageField={updateStageField}
+      />,
+    );
+
+    expect(updateStageField).toHaveBeenCalledOnceWith({ cloudProvider: 'aws', regions: ['eu-west-1'], tags: {} });
+    wrapper.unmount();
+  });
+
+  it('loads AWS regions while retaining persisted selections as options', async () => {
+    spyOn(BakeryReader, 'getRegions').and.returnValue(Promise.resolve(['eu-west-1', 'us-east-1']) as any);
+    const updateStageField = jasmine.createSpy('updateStageField');
+    const wrapper = mount(
+      <AwsFindImageFromTagsStageConfig
+        application={{} as any}
+        pipeline={{} as any}
+        stage={{ cloudProvider: 'aws', packageName: 'payments', regions: ['persisted-region'], tags: {} }}
+        updateStageField={updateStageField}
+      />,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+    wrapper.update();
+
+    expect(BakeryReader.getRegions).toHaveBeenCalledWith('aws');
+    expect(wrapper.find(ChecklistInput).prop('stringOptions')).toEqual(['persisted-region', 'eu-west-1', 'us-east-1']);
+    expect(updateStageField).not.toHaveBeenCalled();
+    wrapper.unmount();
+  });
+
+  it('updates the package through the stage config callback', () => {
+    const { updateStageField, wrapper } = renderEditor({ packageName: 'payments', regions: [], tags: {} });
+
+    wrapper.find('input[name="packageName"]').simulate('change', { target: { value: 'transfers' } });
+
+    expect(updateStageField).toHaveBeenCalledWith({ packageName: 'transfers' });
+  });
+
+  it('updates regions through the stage config callback', () => {
+    const { updateStageField, wrapper } = renderEditor({ packageName: 'payments', regions: [], tags: {} });
+
+    wrapper.find(ChecklistInput).prop('onChange')({ target: { value: ['eu-west-1', 'us-east-1'] } } as any);
+
+    expect(updateStageField).toHaveBeenCalledWith({ regions: ['eu-west-1', 'us-east-1'] });
+  });
+
+  it('persists map-valued tag additions, edits, and removals through the stage config callback', () => {
+    const { updateStageField, wrapper } = renderEditor({
+      packageName: 'payments',
+      regions: [],
+      tags: { Environment: 'production' },
+    });
+    const onChange = wrapper.find(MapEditor).prop('onChange');
+
+    onChange({ Environment: 'production', Team: '' }, false);
+    onChange({ Environment: 'staging' }, false);
+    onChange({}, false);
+
+    expect(updateStageField.calls.allArgs()).toEqual([
+      [{ tags: { Environment: 'production', Team: '' } }],
+      [{ tags: { Environment: 'staging' } }],
+      [{ tags: {} }],
+    ]);
+  });
+});

package/src/pipeline/stages/findImageFromTags/AwsFindImageFromTagsStageConfig.tsx

@@ -0,0 +1,71 @@
+import React from 'react';
+
+import type { IStageConfigProps } from '@spinnaker/core';
+import { BakeryReader, ChecklistInput, MapEditor, StageConfigField } from '@spinnaker/core';
+
+export function AwsFindImageFromTagsStageConfig({ application, pipeline, stage, updateStageField }: IStageConfigProps) {
+  const [regions, setRegions] = React.useState<string[]>([]);
+  const regionOptions = [...(stage.regions ?? []), ...regions].filter(
+    (region, index, allRegions) => region && allRegions.indexOf(region) === index,
+  );
+
+  React.useEffect(() => {
+    const defaults: { cloudProvider?: string; regions?: string[]; tags?: Record<string, string> } = {};
+    if (stage.cloudProvider === undefined) {
+      defaults.cloudProvider = 'aws';
+    }
+    if (stage.regions === undefined) {
+      defaults.regions = application.defaultRegions?.aws ? [application.defaultRegions.aws] : [];
+    }
+    if (stage.tags === undefined) {
+      defaults.tags = {};
+    }
+    if (Object.keys(defaults).length > 0) {
+      updateStageField(defaults);
+    }
+  }, []);
+
+  React.useEffect(() => {
+    let mounted = true;
+    BakeryReader.getRegions('aws').then((loadedRegions) => {
+      if (mounted) {
+        setRegions(loadedRegions);
+      }
+    });
+    return () => {
+      mounted = false;
+    };
+  }, []);
+
+  return (
+    <div className="form-horizontal">
+      <StageConfigField label="Package">
+        <input
+          className="form-control input-sm"
+          name="packageName"
+          onChange={(event) => updateStageField({ packageName: event.target.value })}
+          type="text"
+          value={stage.packageName ?? ''}
+        />
+      </StageConfigField>
+      <StageConfigField label="Regions">
+        <ChecklistInput
+          inline={true}
+          name="regions"
+          onChange={(event: React.ChangeEvent<HTMLInputElement>) => updateStageField({ regions: event.target.value })}
+          showSelectAll={true}
+          stringOptions={regionOptions}
+          value={stage.regions ?? []}
+        />
+      </StageConfigField>
+      <StageConfigField label="Tags">
+        <MapEditor
+          allowEmpty={true}
+          model={stage.tags ?? {}}
+          onChange={(tags) => updateStageField({ tags })}
+          pipeline={pipeline}
+        />
+      </StageConfigField>
+    </div>
+  );
+}

package/src/pipeline/stages/findImageFromTags/awsFindImageFromTagsStage.js

@@ -1,36 +1,21 @@
-'use strict';
+import { Registry } from '@spinnaker/core';
 
-import { module } from 'angular';
+import { AwsFindImageFromTagsStageConfig } from './AwsFindImageFromTagsStageConfig';
 
-import { BakeryReader, Registry } from '@spinnaker/core';
+export const awsFindImageFromTagsStage = {
+  key: 'findImageFromTags',
+  provides: 'findImageFromTags',
+  cloudProvider: 'aws',
+  component: AwsFindImageFromTagsStageConfig,
+  validators: [
+    { type: 'requiredField', fieldName: 'packageName' },
+    { type: 'requiredField', fieldName: 'regions' },
+    { type: 'requiredField', fieldName: 'tags' },
+  ],
+};
 
-export const AMAZON_PIPELINE_STAGES_FINDIMAGEFROMTAGS_AWSFINDIMAGEFROMTAGSSTAGE =
-  'spinnaker.amazon.pipeline.stage.findImageFromTagsStage';
-export const name = AMAZON_PIPELINE_STAGES_FINDIMAGEFROMTAGS_AWSFINDIMAGEFROMTAGSSTAGE; // for backwards compatibility
-module(AMAZON_PIPELINE_STAGES_FINDIMAGEFROMTAGS_AWSFINDIMAGEFROMTAGSSTAGE, [])
-  .config(function () {
-    Registry.pipeline.registerStage({
-      provides: 'findImageFromTags',
-      cloudProvider: 'aws',
-      templateUrl: require('./findImageFromTagsStage.html'),
-      executionDetailsUrl: require('./findImageFromTagsExecutionDetails.html'),
-      executionConfigSections: ['findImageConfig', 'taskStatus'],
-      validators: [
-        { type: 'requiredField', fieldName: 'packageName' },
-        { type: 'requiredField', fieldName: 'regions' },
-        { type: 'requiredField', fieldName: 'tags' },
-      ],
-    });
-  })
-  .controller('awsFindImageFromTagsStageCtrl', [
-    '$scope',
-    function ($scope) {
-      $scope.stage.tags = $scope.stage.tags || {};
-      $scope.stage.regions = $scope.stage.regions || [];
-      $scope.stage.cloudProvider = $scope.stage.cloudProvider || 'aws';
+export function registerAwsFindImageFromTagsStage() {
+  Registry.pipeline.registerStage(awsFindImageFromTagsStage);
+}
 
-      BakeryReader.getRegions('aws').then(function (regions) {
-        $scope.regions = regions;
-      });
-    },
-  ]);
+registerAwsFindImageFromTagsStage();