@spinnaker/titus 0.0.0-main-2

package/src/pipeline/stages/cloneServerGroup/cloneServerGroupExecutionDetails.controller.js

@@ -0,0 +1,66 @@
+'use strict';
+
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import { module } from 'angular';
+import _ from 'lodash';
+
+import { ClusterState, UrlBuilder } from '@spinnaker/core';
+
+export const TITUS_PIPELINE_STAGES_CLONESERVERGROUP_CLONESERVERGROUPEXECUTIONDETAILS_CONTROLLER =
+  'spinnaker.titus.pipeline.stage.cloneServerGroup.executionDetails.controller';
+export const name = TITUS_PIPELINE_STAGES_CLONESERVERGROUP_CLONESERVERGROUPEXECUTIONDETAILS_CONTROLLER; // for backwards compatibility
+module(TITUS_PIPELINE_STAGES_CLONESERVERGROUP_CLONESERVERGROUPEXECUTIONDETAILS_CONTROLLER, [
+  UIROUTER_ANGULARJS,
+]).controller('titusCloneServerGroupExecutionDetailsCtrl', [
+  '$scope',
+  '$stateParams',
+  'executionDetailsSectionService',
+  function ($scope, $stateParams, executionDetailsSectionService) {
+    $scope.configSections = ['cloneServerGroupConfig', 'taskStatus'];
+
+    const initialized = () => {
+      const resultObjects = context['kato.tasks'][0].resultObjects;
+      $scope.detailsSection = $stateParams.details;
+
+      const context = $scope.stage.context || {};
+      const results = [];
+
+      function addDeployedArtifacts(key) {
+        const deployedArtifacts = _.find(resultObjects, key);
+        if (deployedArtifacts) {
+          _.forEach(deployedArtifacts[key], (serverGroupNameAndRegion) => {
+            if (serverGroupNameAndRegion.includes(':')) {
+              const [region, serverGroupName] = serverGroupNameAndRegion.split(':');
+              const result = {
+                type: 'serverGroups',
+                application: context.application,
+                serverGroup: serverGroupName,
+                account: context.credentials,
+                region: region,
+                provider: 'titus',
+                project: $stateParams.project,
+              };
+              result.href = UrlBuilder.buildFromMetadata(result);
+              results.push(result);
+            }
+          });
+        }
+      }
+
+      if (context && context['kato.tasks'] && context['kato.tasks'].length) {
+        if (resultObjects && resultObjects.length) {
+          addDeployedArtifacts('serverGroupNames');
+        }
+      }
+      $scope.deployed = results;
+    };
+
+    this.overrideFiltersForUrl = (r) => ClusterState.filterService.overrideFiltersForUrl(r);
+
+    const initialize = () => executionDetailsSectionService.synchronizeSection($scope.configSections, initialized);
+
+    initialize();
+
+    $scope.$on('$stateChangeSuccess', initialize);
+  },
+]);

package/src/pipeline/stages/cloneServerGroup/cloneServerGroupExecutionDetails.html

@@ -0,0 +1,46 @@
+<div ng-controller="titusCloneServerGroupExecutionDetailsCtrl">
+  <execution-details-section-nav sections="configSections"></execution-details-section-nav>
+  <div class="step-section-details" ng-if="detailsSection === 'cloneServerGroupConfig'">
+    <div class="row">
+      <div class="col-md-9">
+        <dl class="dl-narrow dl-horizontal">
+          <dt>Account</dt>
+          <dd><account-tag account="stage.context.credentials"></account-tag></dd>
+          <dt>Region</dt>
+          <dd>{{stage.context.region}}</dd>
+          <dt>Cluster</dt>
+          <dd>{{stage.context.targetCluster}}</dd>
+          <dt>Server Group</dt>
+          <dd>{{stage.context.source.serverGroupName}}</dd>
+          <dt ng-if="!stage.context.useSourceCapacity && stage.context.capacity">Capacity</dt>
+          <dd ng-if="!stage.context.useSourceCapacity && stage.context.capacity">
+            Min: {{stage.context.capacity.min}} / Desired: {{stage.context.capacity.desired}} / Max:
+            {{stage.context.capacity.max}}
+          </dd>
+        </dl>
+      </div>
+    </div>
+    <stage-failure-message stage="stage" message="stage.failureMessage"></stage-failure-message>
+
+    <div class="row" ng-if="deployed.length">
+      <div class="col-md-12">
+        <div class="well alert alert-info">
+          <strong>Deployed:</strong>
+          <a
+            ng-repeat="serverGroup in deployed"
+            ng-click="$event.stopPropagation(); deployDetailsCtrl.overrideFiltersForUrl(serverGroup);"
+            ng-href="{{serverGroup.href}}"
+          >
+            {{serverGroup.serverGroup}}
+          </a>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <div class="step-section-details" ng-if="detailsSection === 'taskStatus'">
+    <div class="row">
+      <execution-step-details item="stage"></execution-step-details>
+    </div>
+  </div>
+</div>

package/src/pipeline/stages/cloneServerGroup/cloneServerGroupStage.html

@@ -0,0 +1,106 @@
+<div ng-controller="titusCloneServerGroupStageCtrl as cloneServerGroupStageCtrl">
+  <div ng-if="!pipeline.strategy">
+    <div ng-if="viewState.loading">
+      <h4 class="text-center">
+        <span us-spinner="{radius:20, width:6, length: 12}"></span>
+      </h4>
+    </div>
+    <div ng-if="!viewState.loading">
+      <account-region-cluster-selector
+        application="application"
+        component="stage"
+        accounts="accounts"
+        single-region="true"
+        cluster-field="targetCluster"
+      >
+      </account-region-cluster-selector>
+    </div>
+  </div>
+  <stage-config-field label="Target">
+    <target-select model="stage" options="cloneServerGroupStageCtrl.cloneTargets"></target-select>
+  </stage-config-field>
+  <div>
+    <div class="form-group">
+      <div class="col-md-3 sm-label-right">Capacity</div>
+      <div class="col-md-9 radio">
+        <label>
+          <input
+            type="radio"
+            ng-model="stage.useSourceCapacity"
+            ng-value="true"
+            ng-click="cloneServerGroupStageCtrl.removeCapacity()"
+            id="useSourceCapacityTrue"
+          />
+          Copy the capacity from the current server group
+          <help-field key="serverGroupCapacity.useSourceCapacityTrue"></help-field>
+        </label>
+      </div>
+      <div class="col-md-9 col-md-offset-3 radio">
+        <label>
+          <input type="radio" ng-model="stage.useSourceCapacity" ng-value="false" id="useSourceCapacityFalse" />
+          Let me specify the capacity
+          <help-field key="serverGroupCapacity.useSourceCapacityFalse"></help-field>
+        </label>
+      </div>
+    </div>
+    <div class="form-group">
+      <div class="col-md-2 col-md-offset-3">Min</div>
+      <div class="col-md-2">Max</div>
+      <div class="col-md-2">Desired</div>
+    </div>
+    <div class="form-group">
+      <div class="col-md-2 col-md-offset-3">
+        <input
+          type="number"
+          ng-disabled="stage.useSourceCapacity"
+          class="form-control input-sm"
+          ng-model="stage.capacity.min"
+          min="0"
+          max="{{stage.capacity.max}}"
+          required
+        />
+      </div>
+      <div class="col-md-2">
+        <input
+          type="number"
+          ng-disabled="stage.useSourceCapacity"
+          class="form-control input-sm"
+          ng-model="stage.capacity.max"
+          min="{{stage.capacity.min}}"
+          required
+        />
+      </div>
+      <div class="col-md-2">
+        <input
+          type="number"
+          ng-disabled="stage.useSourceCapacity"
+          class="form-control input-sm"
+          ng-model="stage.capacity.desired"
+          min="{{stage.capacity.min}}"
+          max="{{stage.capacity.max}}"
+          required
+        />
+      </div>
+    </div>
+  </div>
+  <stage-config-field label="Traffic" help-key="titus.serverGroup.traffic">
+    <div class="checkbox">
+      <label>
+        <input
+          type="checkbox"
+          ng-click="cloneServerGroupStageCtrl.toggleSuspendedProcess('AddToLoadBalancer')"
+          ng-checked="!cloneServerGroupStageCtrl.processIsSuspended('AddToLoadBalancer')"
+        />
+        Send client requests to new instances
+      </label>
+    </div>
+  </stage-config-field>
+  <stage-platform-health-override application="application" stage="stage" platform-health-type="'Titus'">
+  </stage-platform-health-override>
+  <deployment-strategy-selector
+    label-columns="3"
+    field-columns="6"
+    command="stage"
+    on-field-change="cloneServerGroupStageCtrl.onRedBlackFieldChange"
+  ></deployment-strategy-selector>
+</div>

package/src/pipeline/stages/cloneServerGroup/cloneServerGroupStepLabel.html

@@ -0,0 +1 @@
+<span class="task-label"> Clone Server Group: {{step.context.source.serverGroupName}} ({{step.context.region}}) </span>

package/src/pipeline/stages/cloneServerGroup/titusCloneServerGroupStage.js

@@ -0,0 +1,104 @@
+'use strict';
+
+import { module } from 'angular';
+import _ from 'lodash';
+
+import { AccountService, NameUtils, Registry, StageConstants } from '@spinnaker/core';
+import { TITUS_PIPELINE_STAGES_CLONESERVERGROUP_CLONESERVERGROUPEXECUTIONDETAILS_CONTROLLER } from './cloneServerGroupExecutionDetails.controller';
+
+export const TITUS_PIPELINE_STAGES_CLONESERVERGROUP_TITUSCLONESERVERGROUPSTAGE =
+  'spinnaker.titus.pipeline.stage.cloneServerGroupStage';
+export const name = TITUS_PIPELINE_STAGES_CLONESERVERGROUP_TITUSCLONESERVERGROUPSTAGE; // for backwards compatibility
+module(TITUS_PIPELINE_STAGES_CLONESERVERGROUP_TITUSCLONESERVERGROUPSTAGE, [
+  TITUS_PIPELINE_STAGES_CLONESERVERGROUP_CLONESERVERGROUPEXECUTIONDETAILS_CONTROLLER,
+])
+  .config(function () {
+    Registry.pipeline.registerStage({
+      provides: 'cloneServerGroup',
+      cloudProvider: 'titus',
+      templateUrl: require('./cloneServerGroupStage.html'),
+      executionDetailsUrl: require('./cloneServerGroupExecutionDetails.html'),
+      executionStepLabelUrl: require('./cloneServerGroupStepLabel.html'),
+      validators: [
+        { type: 'requiredField', fieldName: 'targetCluster', fieldLabel: 'cluster' },
+        { type: 'requiredField', fieldName: 'target' },
+        { type: 'requiredField', fieldName: 'region' },
+        { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+      ],
+    });
+  })
+  .controller('titusCloneServerGroupStageCtrl', [
+    '$scope',
+    function ($scope) {
+      const stage = $scope.stage;
+
+      $scope.viewState = {
+        accountsLoaded: false,
+      };
+
+      AccountService.listAccounts('titus').then((accounts) => {
+        $scope.accounts = accounts;
+        $scope.viewState.accountsLoaded = true;
+      });
+
+      this.cloneTargets = StageConstants.TARGET_LIST;
+      stage.target = stage.target || this.cloneTargets[0].val;
+      stage.application = $scope.application.name;
+      stage.cloudProvider = 'titus';
+      stage.cloudProviderType = 'titus';
+      stage.viewState = {
+        mode: 'editPipeline',
+      };
+
+      if (
+        stage.isNew &&
+        $scope.application.attributes.platformHealthOnlyShowOverride &&
+        $scope.application.attributes.platformHealthOnly
+      ) {
+        stage.interestingHealthProviderNames = ['Titus'];
+      }
+
+      if (!stage.credentials && $scope.application.defaultCredentials.titus) {
+        stage.credentials = $scope.application.defaultCredentials.titus;
+      }
+
+      this.targetClusterUpdated = () => {
+        if (stage.targetCluster) {
+          const clusterName = NameUtils.parseServerGroupName(stage.targetCluster);
+          stage.stack = clusterName.stack;
+          stage.freeFormDetails = clusterName.freeFormDetails;
+        } else {
+          stage.stack = '';
+          stage.freeFormDetails = '';
+        }
+      };
+
+      $scope.$watch('stage.targetCluster', this.targetClusterUpdated);
+
+      this.removeCapacity = () => {
+        delete stage.capacity;
+      };
+
+      if (!_.has(stage, 'useSourceCapacity')) {
+        stage.useSourceCapacity = true;
+      }
+
+      this.toggleSuspendedProcess = (process) => {
+        stage.suspendedProcesses = stage.suspendedProcesses || [];
+        const processIndex = stage.suspendedProcesses.indexOf(process);
+        if (processIndex === -1) {
+          stage.suspendedProcesses.push(process);
+        } else {
+          stage.suspendedProcesses.splice(processIndex, 1);
+        }
+      };
+
+      this.processIsSuspended = (process) => {
+        return stage.suspendedProcesses && stage.suspendedProcesses.includes(process);
+      };
+
+      this.onRedBlackFieldChange = (key, value) => {
+        _.set(stage, key, value);
+      };
+    },
+  ]);

package/src/pipeline/stages/destroyAsg/destroyAsgStage.html

@@ -0,0 +1,9 @@
+<div ng-controller="titusDestroyAsgStageCtrl as destroyAsgStageCtrl" class="form-horizontal">
+  <div ng-if="!pipeline.strategy">
+    <account-region-cluster-selector application="application" component="stage" accounts="accounts">
+    </account-region-cluster-selector>
+  </div>
+  <stage-config-field label="Target">
+    <target-select model="stage" options="targets"></target-select>
+  </stage-config-field>
+</div>

package/src/pipeline/stages/destroyAsg/destroyAsgStepLabel.html

@@ -0,0 +1 @@
+<span class="task-label"> Destroy Server Group: {{step.context.serverGroupName}} ({{step.context.region}}) </span>

package/src/pipeline/stages/destroyAsg/titusDestroyAsgStage.js

@@ -0,0 +1,65 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { AccountService, Registry, StageConstants } from '@spinnaker/core';
+
+export const TITUS_PIPELINE_STAGES_DESTROYASG_TITUSDESTROYASGSTAGE = 'spinnaker.titus.pipeline.stage.destroyAsgStage';
+export const name = TITUS_PIPELINE_STAGES_DESTROYASG_TITUSDESTROYASGSTAGE; // for backwards compatibility
+module(TITUS_PIPELINE_STAGES_DESTROYASG_TITUSDESTROYASGSTAGE, [])
+  .config(function () {
+    Registry.pipeline.registerStage({
+      provides: 'destroyServerGroup',
+      alias: 'destroyAsg',
+      cloudProvider: 'titus',
+      templateUrl: require('./destroyAsgStage.html'),
+      executionStepLabelUrl: require('./destroyAsgStepLabel.html'),
+      accountExtractor: (stage) => [stage.context.credentials],
+      configAccountExtractor: (stage) => [stage.credentials],
+      validators: [
+        {
+          type: 'targetImpedance',
+          message:
+            'This pipeline will attempt to destroy 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' },
+      ],
+    });
+  })
+  .controller('titusDestroyAsgStageCtrl', [
+    '$scope',
+    function ($scope) {
+      const stage = $scope.stage;
+
+      $scope.state = {
+        accounts: false,
+        regionsLoaded: false,
+      };
+
+      AccountService.listAccounts('titus').then(function (accounts) {
+        $scope.accounts = accounts;
+        $scope.state.accounts = true;
+      });
+
+      $scope.regions = ['us-east-1', 'us-west-1', 'eu-west-1', 'us-west-2'];
+
+      $scope.targets = StageConstants.TARGET_LIST;
+
+      stage.regions = stage.regions || [];
+      stage.cloudProvider = 'titus';
+
+      if (!stage.credentials && $scope.application.defaultCredentials.titus) {
+        stage.credentials = $scope.application.defaultCredentials.titus;
+      }
+      if (!stage.regions.length && $scope.application.defaultRegions.titus) {
+        stage.regions.push($scope.application.defaultRegions.titus);
+      }
+
+      if (!stage.target) {
+        stage.target = $scope.targets[0].val;
+      }
+    },
+  ]);

package/src/pipeline/stages/disableAsg/disableAsgStage.html

@@ -0,0 +1,11 @@
+<div ng-controller="titusDisableAsgStageCtrl as disableAsgStageCtrl" class="form-horizontal">
+  <div ng-if="!pipeline.strategy">
+    <account-region-cluster-selector application="application" component="stage" accounts="accounts">
+    </account-region-cluster-selector>
+  </div>
+  <stage-config-field label="Target">
+    <target-select model="stage" options="targets"></target-select>
+  </stage-config-field>
+  <stage-platform-health-override application="application" stage="stage" platform-health-type="'Titus'">
+  </stage-platform-health-override>
+</div>

package/src/pipeline/stages/disableAsg/disableAsgStepLabel.html

@@ -0,0 +1 @@
+<span class="task-label"> Disable Server Group: {{step.context.serverGroupName}} ({{step.context.region}}) </span>

package/src/pipeline/stages/disableAsg/titusDisableAsgStage.js

@@ -0,0 +1,69 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { AccountService, Registry, StageConstants } from '@spinnaker/core';
+
+export const TITUS_PIPELINE_STAGES_DISABLEASG_TITUSDISABLEASGSTAGE = 'spinnaker.titus.pipeline.stage.disableAsgStage';
+export const name = TITUS_PIPELINE_STAGES_DISABLEASG_TITUSDISABLEASGSTAGE; // for backwards compatibility
+module(TITUS_PIPELINE_STAGES_DISABLEASG_TITUSDISABLEASGSTAGE, [])
+  .config(function () {
+    Registry.pipeline.registerStage({
+      provides: 'disableServerGroup',
+      alias: 'disableAsg',
+      cloudProvider: 'titus',
+      templateUrl: require('./disableAsgStage.html'),
+      executionStepLabelUrl: require('./disableAsgStepLabel.html'),
+      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' },
+      ],
+    });
+  })
+  .controller('titusDisableAsgStageCtrl', [
+    '$scope',
+    function ($scope) {
+      const stage = $scope.stage;
+
+      $scope.state = {
+        accounts: false,
+        regionsLoaded: false,
+      };
+
+      AccountService.listAccounts('titus').then(function (accounts) {
+        $scope.accounts = accounts;
+        $scope.state.accounts = true;
+      });
+
+      $scope.targets = StageConstants.TARGET_LIST;
+
+      stage.regions = stage.regions || [];
+      stage.cloudProvider = 'titus';
+
+      if (
+        stage.isNew &&
+        $scope.application.attributes.platformHealthOnlyShowOverride &&
+        $scope.application.attributes.platformHealthOnly
+      ) {
+        stage.interestingHealthProviderNames = ['Titus'];
+      }
+
+      if (!stage.credentials && $scope.application.defaultCredentials.titus) {
+        stage.credentials = $scope.application.defaultCredentials.titus;
+      }
+      if (!stage.regions.length && $scope.application.defaultRegions.titus) {
+        stage.regions.push($scope.application.defaultRegions.titus);
+      }
+
+      if (!stage.target) {
+        stage.target = $scope.targets[0].val;
+      }
+    },
+  ]);

package/src/pipeline/stages/disableCluster/disableClusterStage.html

@@ -0,0 +1,26 @@
+<div ng-controller="titusDisableClusterStageCtrl as disableClusterStageCtrl" class="form-horizontal">
+  <div ng-if="!pipeline.strategy">
+    <account-region-cluster-selector application="application" component="stage" accounts="accounts">
+    </account-region-cluster-selector>
+  </div>
+  <stage-config-field label="Disable Options">
+    <div class="form-inline">
+      Keep the
+      <input
+        type="number"
+        min="0"
+        required
+        ng-model="stage.remainingEnabledServerGroups"
+        class="form-control input-sm"
+        style="width: 50px"
+      />
+      <select class="form-control input-sm" ng-model="stage.preferLargerOverNewer" style="width: 100px">
+        <option value="true">largest</option>
+        <option value="false">newest</option>
+      </select>
+      {{disableClusterStageCtrl.pluralize('server group', stage.remainingEnabledServerGroups)}} enabled.
+    </div>
+  </stage-config-field>
+  <stage-platform-health-override application="application" stage="stage" platform-health-type="'Titus'">
+  </stage-platform-health-override>
+</div>

package/src/pipeline/stages/disableCluster/titusDisableClusterStage.js

@@ -0,0 +1,85 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { AccountService, Registry } from '@spinnaker/core';
+
+export const TITUS_PIPELINE_STAGES_DISABLECLUSTER_TITUSDISABLECLUSTERSTAGE =
+  'spinnaker.titus.pipeline.stage.disableClusterStage';
+export const name = TITUS_PIPELINE_STAGES_DISABLECLUSTER_TITUSDISABLECLUSTERSTAGE; // for backwards compatibility
+module(TITUS_PIPELINE_STAGES_DISABLECLUSTER_TITUSDISABLECLUSTERSTAGE, [])
+  .config(function () {
+    Registry.pipeline.registerStage({
+      provides: 'disableCluster',
+      cloudProvider: 'titus',
+      templateUrl: require('./disableClusterStage.html'),
+      executionConfigSections: ['disableClusterConfig', 'taskStatus'],
+      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' },
+      ],
+    });
+  })
+  .controller('titusDisableClusterStageCtrl', [
+    '$scope',
+    function ($scope) {
+      const ctrl = this;
+
+      const stage = $scope.stage;
+
+      $scope.state = {
+        accounts: false,
+        regionsLoaded: false,
+      };
+
+      AccountService.listAccounts('titus').then(function (accounts) {
+        $scope.accounts = accounts;
+        $scope.state.accounts = true;
+      });
+
+      ctrl.reset = () => {
+        ctrl.accountUpdated();
+        ctrl.resetSelectedCluster();
+      };
+
+      stage.regions = stage.regions || [];
+      stage.cloudProvider = 'titus';
+
+      if (
+        stage.isNew &&
+        $scope.application.attributes.platformHealthOnlyShowOverride &&
+        $scope.application.attributes.platformHealthOnly
+      ) {
+        stage.interestingHealthProviderNames = ['Titus'];
+      }
+
+      if (!stage.credentials && $scope.application.defaultCredentials.titus) {
+        stage.credentials = $scope.application.defaultCredentials.titus;
+      }
+      if (!stage.regions.length && $scope.application.defaultRegions.titus) {
+        stage.regions.push($scope.application.defaultRegions.titus);
+      }
+
+      if (stage.remainingEnabledServerGroups === undefined) {
+        stage.remainingEnabledServerGroups = 1;
+      }
+
+      ctrl.pluralize = function (str, val) {
+        if (val === 1) {
+          return str;
+        }
+        return str + 's';
+      };
+
+      if (stage.preferLargerOverNewer === undefined) {
+        stage.preferLargerOverNewer = 'false';
+      }
+      stage.preferLargerOverNewer = stage.preferLargerOverNewer.toString();
+    },
+  ]);

package/src/pipeline/stages/enableAsg/enableAsgStage.html

@@ -0,0 +1,11 @@
+<div ng-controller="titusEnableAsgStageCtrl as enableAsgStageCtrl" class="form-horizontal">
+  <div ng-if="!pipeline.strategy">
+    <account-region-cluster-selector application="application" component="stage" accounts="accounts">
+    </account-region-cluster-selector>
+  </div>
+  <stage-config-field label="Target">
+    <target-select model="stage" options="targets"></target-select>
+  </stage-config-field>
+  <stage-platform-health-override application="application" stage="stage" platform-health-type="'Titus'">
+  </stage-platform-health-override>
+</div>

package/src/pipeline/stages/enableAsg/enableAsgStepLabel.html

@@ -0,0 +1 @@
+<span class="task-label"> Enable Server Group: {{step.context.serverGroupName}} ({{step.context.region}}) </span>