@spinnaker/ecs 0.0.0-main-2

package/src/serverGroup/details/resize/resizeServerGroup.controller.js

@@ -0,0 +1,85 @@
+'use strict';
+
+import * as angular from 'angular';
+
+import { SERVER_GROUP_WRITER, TaskMonitor } from '@spinnaker/core';
+
+import { ECS_RESIZE_CAPACITY_COMPONENT } from './resizeCapacity.component';
+
+export const ECS_SERVERGROUP_DETAILS_RESIZE_RESIZESERVERGROUP_CONTROLLER =
+  'spinnaker.ecs.serverGroup.details.resize.controller';
+export const name = ECS_SERVERGROUP_DETAILS_RESIZE_RESIZESERVERGROUP_CONTROLLER; // for backwards compatibility
+angular
+  .module(ECS_SERVERGROUP_DETAILS_RESIZE_RESIZESERVERGROUP_CONTROLLER, [
+    SERVER_GROUP_WRITER,
+    ECS_RESIZE_CAPACITY_COMPONENT,
+  ])
+  .controller('ecsResizeServerGroupCtrl', [
+    '$scope',
+    '$uibModalInstance',
+    'serverGroupWriter',
+    'application',
+    'serverGroup',
+    function ($scope, $uibModalInstance, serverGroupWriter, application, serverGroup) {
+      $scope.serverGroup = serverGroup;
+      $scope.currentSize = {
+        min: serverGroup.capacity.min,
+        max: serverGroup.capacity.max,
+        desired: serverGroup.capacity.desired,
+        newSize: null,
+      };
+
+      $scope.verification = {};
+
+      $scope.command = angular.copy($scope.currentSize);
+      $scope.command.advancedMode = serverGroup.capacity.min !== serverGroup.capacity.max;
+
+      if (application && application.attributes) {
+        if (application.attributes.platformHealthOnlyShowOverride && application.attributes.platformHealthOnly) {
+          $scope.command.interestingHealthProviderNames = ['Ecs'];
+        }
+
+        $scope.command.platformHealthOnlyShowOverride = application.attributes.platformHealthOnlyShowOverride;
+      }
+
+      this.isValid = function () {
+        const command = $scope.command;
+        if (!$scope.verification.verified) {
+          return false;
+        }
+        return command.advancedMode
+          ? command.min <= command.max && command.desired >= command.min && command.desired <= command.max
+          : command.newSize !== null;
+      };
+
+      $scope.taskMonitor = new TaskMonitor({
+        application: application,
+        title: 'Resizing ' + serverGroup.name,
+        modalInstance: $uibModalInstance,
+      });
+
+      this.resize = function () {
+        if (!this.isValid()) {
+          return;
+        }
+        let capacity = { min: $scope.command.min, max: $scope.command.max, desired: $scope.command.desired };
+        if (!$scope.command.advancedMode) {
+          capacity = { min: $scope.command.newSize, max: $scope.command.newSize, desired: $scope.command.newSize };
+        }
+
+        const submitMethod = function () {
+          return serverGroupWriter.resizeServerGroup(serverGroup, application, {
+            capacity: capacity,
+            interestingHealthProviderNames: $scope.command.interestingHealthProviderNames,
+            reason: $scope.command.reason,
+          });
+        };
+
+        $scope.taskMonitor.submit(submitMethod);
+      };
+
+      this.cancel = function () {
+        $uibModalInstance.dismiss();
+      };
+    },
+  ]);

package/src/serverGroup/details/resize/resizeServerGroup.html

@@ -0,0 +1,28 @@
+<div modal-page class="confirmation-modal">
+  <task-monitor monitor="taskMonitor"></task-monitor>
+  <form role="form">
+    <modal-close dismiss="$dismiss()"></modal-close>
+    <div class="modal-header">
+      <h4 class="modal-title">Resize {{serverGroup.name}}</h4>
+    </div>
+    <div class="modal-body confirmation-modal">
+      <div class="form-horizontal">
+        <ecs-resize-capacity command="command" current-size="currentSize"></ecs-resize-capacity>
+      </div>
+      <div class="row" ng-if="command.platformHealthOnlyShowOverride">
+        <div class="col-sm-10 col-sm-offset-1">
+          <platform-health-override command="command" platform-health-type="'Ecs'" show-help-details="true">
+          </platform-health-override>
+        </div>
+      </div>
+      <task-reason command="command"></task-reason>
+    </div>
+    <ecs-footer
+      action="ctrl.resize()"
+      cancel="ctrl.cancel()"
+      is-valid="ctrl.isValid()"
+      account="serverGroup.account"
+      verification="verification"
+    ></ecs-footer>
+  </form>
+</div>

package/src/serverGroup/details/rollback/rollbackServerGroup.controller.js

@@ -0,0 +1,97 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { SERVER_GROUP_WRITER, TaskMonitor } from '@spinnaker/core';
+
+export const ECS_SERVERGROUP_DETAILS_ROLLBACK_ROLLBACKSERVERGROUP_CONTROLLER =
+  'spinnaker.ecs.serverGroup.details.rollback.controller';
+export const name = ECS_SERVERGROUP_DETAILS_ROLLBACK_ROLLBACKSERVERGROUP_CONTROLLER; // for backwards compatibility
+module(ECS_SERVERGROUP_DETAILS_ROLLBACK_ROLLBACKSERVERGROUP_CONTROLLER, [SERVER_GROUP_WRITER]).controller(
+  'ecsRollbackServerGroupCtrl',
+  [
+    '$scope',
+    '$uibModalInstance',
+    'serverGroupWriter',
+    'application',
+    'serverGroup',
+    'disabledServerGroups',
+    'allServerGroups',
+    function (
+      $scope,
+      $uibModalInstance,
+      serverGroupWriter,
+      application,
+      serverGroup,
+      disabledServerGroups,
+      allServerGroups,
+    ) {
+      $scope.serverGroup = serverGroup;
+      $scope.disabledServerGroups = disabledServerGroups.sort((a, b) => b.name.localeCompare(a.name));
+      $scope.allServerGroups = allServerGroups.sort((a, b) => b.name.localeCompare(a.name));
+      $scope.verification = {};
+
+      $scope.command = {
+        rollbackType: 'EXPLICIT',
+        rollbackContext: {
+          rollbackServerGroupName: serverGroup.name,
+        },
+      };
+
+      if (application && application.attributes) {
+        if (application.attributes.platformHealthOnlyShowOverride && application.attributes.platformHealthOnly) {
+          $scope.command.interestingHealthProviderNames = ['Ecs'];
+        }
+
+        $scope.command.platformHealthOnlyShowOverride = application.attributes.platformHealthOnlyShowOverride;
+      }
+
+      this.isValid = function () {
+        const command = $scope.command;
+        if (!$scope.verification.verified) {
+          return false;
+        }
+
+        return command.rollbackContext.restoreServerGroupName !== undefined;
+      };
+
+      $scope.taskMonitor = new TaskMonitor({
+        application: application,
+        title: 'Rollback ' + serverGroup.name,
+        modalInstance: $uibModalInstance,
+      });
+
+      this.rollback = function () {
+        if (!this.isValid()) {
+          return;
+        }
+
+        const submitMethod = function () {
+          return serverGroupWriter.rollbackServerGroup(serverGroup, application, $scope.command);
+        };
+
+        $scope.taskMonitor.submit(submitMethod);
+      };
+
+      this.cancel = function () {
+        $uibModalInstance.dismiss();
+      };
+
+      this.label = function (serverGroup) {
+        if (!serverGroup) {
+          return '';
+        }
+
+        if (!serverGroup.buildInfo || !serverGroup.buildInfo.jenkins || !serverGroup.buildInfo.jenkins.number) {
+          return serverGroup.name;
+        }
+
+        return serverGroup.name + ' (build #' + serverGroup.buildInfo.jenkins.number + ')';
+      };
+
+      this.group = function (serverGroup) {
+        return serverGroup.isDisabled ? 'Disabled Server Groups' : 'Enabled Server Groups';
+      };
+    },
+  ],
+);

package/src/serverGroup/details/rollback/rollbackServerGroup.html

@@ -0,0 +1,67 @@
+<div modal-page class="confirmation-modal">
+  <task-monitor monitor="taskMonitor"></task-monitor>
+  <form role="form">
+    <modal-close dismiss="$dismiss()"></modal-close>
+    <div class="modal-header">
+      <h4 class="modal-title">Rollback {{serverGroup.name}}</h4>
+    </div>
+    <div class="modal-body confirmation-modal">
+      <div class="row">
+        <div class="col-sm-3 sm-label-right">Restore to</div>
+        <div class="col-sm-6">
+          <ui-select ng-model="command.rollbackContext.restoreServerGroupName" class="form-control input-sm">
+            <ui-select-match placeholder="Select...">{{ctrl.label($select.selected)}}</ui-select-match>
+            <ui-select-choices group-by="ctrl.group" repeat="serverGroup.name as serverGroup in allServerGroups">
+              <span ng-bind-html="ctrl.label(serverGroup)"></span>
+            </ui-select-choices>
+          </ui-select>
+        </div>
+      </div>
+
+      <div class="row" ng-if="command.platformHealthOnlyShowOverride">
+        <div class="col-sm-10 col-sm-offset-1">
+          <platform-health-override
+            command="command"
+            platform-health-type="'Ecs'"
+            show-help-details="true"
+            field-columns="12"
+          >
+          </platform-health-override>
+        </div>
+      </div>
+
+      <task-reason command="command"></task-reason>
+
+      <div class="row">
+        <div class="col-sm-4 sm-label-right">Rollback Operations</div>
+      </div>
+      <div class="row">
+        <div class="col-sm-11 col-sm-offset-1">
+          <ol>
+            <li>Enable <em>{{ command.rollbackContext.restoreServerGroupName || 'previous server group' }}</em></li>
+            <li>
+              Resize <em>{{ command.rollbackContext.restoreServerGroupName || 'previous server group' }}</em> to [
+              <strong>min</strong>: {{serverGroup.capacity.desired}}, <strong>max</strong>: {{ serverGroup.capacity.max
+              }}, <strong>desired</strong>: {{ serverGroup.capacity.desired }} ]<br />(minimum capacity pinned at
+              {{serverGroup.capacity.desired}} to prevent autoscaling down during rollback)
+            </li>
+            <li>Disable {{ serverGroup.name }}</li>
+            <li>
+              Restore minimum capacity of
+              <em>{{ command.rollbackContext.restoreServerGroupName || 'previous server group' }}</em> [
+              <strong>min</strong>: {{ serverGroup.capacity.min }} ]
+            </li>
+          </ol>
+          <p>This rollback will affect server groups in {{ serverGroup.account }} ({{ serverGroup.region }}).</p>
+        </div>
+      </div>
+    </div>
+    <ecs-footer
+      action="ctrl.rollback()"
+      cancel="ctrl.cancel()"
+      is-valid="ctrl.isValid()"
+      account="serverGroup.account"
+      verification="verification"
+    ></ecs-footer>
+  </form>
+</div>

package/src/serverGroup/details/serverGroupDetails.ecs.controller.js

@@ -0,0 +1,366 @@
+'use strict';
+
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import * as angular from 'angular';
+import { chain, filter, find, has, isEmpty } from 'lodash';
+
+import {
+  AccountService,
+  ConfirmationModalService,
+  FirewallLabels,
+  OVERRIDE_REGISTRY,
+  SERVER_GROUP_WRITER,
+  ServerGroupReader,
+  ServerGroupWarningMessageService,
+  SubnetReader,
+} from '@spinnaker/core';
+
+import { ECS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE } from '../configure/serverGroupCommandBuilder.service';
+import { ECS_SERVERGROUP_DETAILS_RESIZE_RESIZESERVERGROUP_CONTROLLER } from './resize/resizeServerGroup.controller';
+import { ECS_SERVERGROUP_DETAILS_ROLLBACK_ROLLBACKSERVERGROUP_CONTROLLER } from './rollback/rollbackServerGroup.controller';
+import { ECS_SERVER_GROUP_TRANSFORMER } from '../serverGroup.transformer';
+
+export const ECS_SERVERGROUP_DETAILS_SERVERGROUPDETAILS_ECS_CONTROLLER = 'spinnaker.ecs.serverGroup.details.controller';
+export const name = ECS_SERVERGROUP_DETAILS_SERVERGROUPDETAILS_ECS_CONTROLLER; // for backwards compatibility
+angular
+  .module(ECS_SERVERGROUP_DETAILS_SERVERGROUPDETAILS_ECS_CONTROLLER, [
+    UIROUTER_ANGULARJS,
+    ECS_SERVER_GROUP_TRANSFORMER,
+    OVERRIDE_REGISTRY,
+    SERVER_GROUP_WRITER,
+    ECS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE,
+    ECS_SERVERGROUP_DETAILS_RESIZE_RESIZESERVERGROUP_CONTROLLER,
+    ECS_SERVERGROUP_DETAILS_ROLLBACK_ROLLBACKSERVERGROUP_CONTROLLER,
+  ])
+  .controller('ecsServerGroupDetailsCtrl', [
+    '$scope',
+    '$state',
+    'app',
+    'serverGroup',
+    'ecsServerGroupCommandBuilder',
+    '$uibModal',
+    'serverGroupWriter',
+    'ecsServerGroupTransformer',
+    'overrideRegistry',
+    function (
+      $scope,
+      $state,
+      app,
+      serverGroup,
+      ecsServerGroupCommandBuilder,
+      $uibModal,
+      serverGroupWriter,
+      ecsServerGroupTransformer,
+      overrideRegistry,
+    ) {
+      this.state = {
+        loading: true,
+      };
+
+      this.firewallsLabel = FirewallLabels.get('Firewalls');
+
+      this.application = app;
+
+      const extractServerGroupSummary = () => {
+        return app.ready().then(() => {
+          let summary = find(app.serverGroups.data, (toCheck) => {
+            return (
+              toCheck.name === serverGroup.name &&
+              toCheck.account === serverGroup.accountId &&
+              toCheck.region === serverGroup.region
+            );
+          });
+          if (!summary) {
+            app.loadBalancers.data.some((loadBalancer) => {
+              if (loadBalancer.account === serverGroup.accountId && loadBalancer.region === serverGroup.region) {
+                return loadBalancer.serverGroups.some((possibleServerGroup) => {
+                  if (possibleServerGroup.name === serverGroup.name) {
+                    summary = possibleServerGroup;
+                    return true;
+                  }
+                });
+              }
+            });
+          }
+          return summary;
+        });
+      };
+
+      const autoClose = () => {
+        if ($scope.$$destroyed) {
+          return;
+        }
+        $state.go('^', { allowModalToStayOpen: true }, { location: 'replace' });
+      };
+
+      const cancelLoader = () => {
+        this.state.loading = false;
+      };
+
+      const retrieveServerGroup = () => {
+        return extractServerGroupSummary()
+          .then((summary) => {
+            return ServerGroupReader.getServerGroup(
+              app.name,
+              serverGroup.accountId,
+              serverGroup.region,
+              serverGroup.name,
+            ).then((details) => {
+              cancelLoader();
+
+              // it's possible the summary was not found because the clusters are still loading
+              angular.extend(details, summary, { account: serverGroup.accountId });
+
+              this.serverGroup = ecsServerGroupTransformer.normalizeServerGroupDetails(details);
+              this.applyAccountDetails(this.serverGroup);
+
+              if (!isEmpty(this.serverGroup)) {
+                this.image = details.image ? details.image : undefined;
+
+                const vpc = this.serverGroup.asg ? this.serverGroup.asg.vpczoneIdentifier : '';
+
+                if (vpc !== '') {
+                  const subnetId = vpc.split(',')[0];
+                  SubnetReader.listSubnets().then((subnets) => {
+                    const subnet = chain(subnets).find({ id: subnetId }).value();
+                    this.serverGroup.subnetType = subnet.purpose;
+                  });
+                }
+
+                if (details.image && details.image.description) {
+                  const tags = details.image.description.split(', ');
+                  tags.forEach((tag) => {
+                    const keyVal = tag.split('=');
+                    if (keyVal.length === 2 && keyVal[0] === 'ancestor_name') {
+                      details.image.baseImage = keyVal[1];
+                    }
+                  });
+                }
+
+                if (details.image && details.image.tags) {
+                  const baseAmiVersionTag = details.image.tags.find((tag) => tag.key === 'base_ami_version');
+                  if (baseAmiVersionTag) {
+                    details.baseAmiVersion = baseAmiVersionTag.value;
+                  }
+                }
+
+                this.scalingPolicies = this.serverGroup.scalingPolicies;
+                // TODO - figure out whether we need the commented out block below, or not.  IF we do, then we need to make it stop crashing
+
+                if (has(this.serverGroup, 'buildInfo.jenkins')) {
+                  this.changeConfig.buildInfo = {
+                    jenkins: this.serverGroup.buildInfo.jenkins,
+                  };
+                }
+
+                /*this.scalingPoliciesDisabled = this.scalingPolicies.length && this.autoScalingProcesses
+                    .filter(p => !p.enabled)
+                    .some(p => ['Launch','Terminate','AlarmNotification'].includes(p.name));
+                this.scheduledActionsDisabled = this.serverGroup.scheduledActions.length && this.autoScalingProcesses
+                    .filter(p => !p.enabled)
+                    .some(p => ['Launch','Terminate','ScheduledAction'].includes(p.name));
+                configureEntityTagTargets();
+
+                this.changeConfig = {
+                  metadata: get(this.serverGroup.entityTags, 'creationMetadata')
+                };
+                */
+              } else {
+                autoClose();
+              }
+            });
+          })
+          .catch(autoClose);
+      };
+
+      retrieveServerGroup().then(() => {
+        // If the user navigates away from the view before the initial retrieveServerGroup call completes,
+        // do not bother subscribing to the refresh
+        if (!$scope.$$destroyed) {
+          app.serverGroups.onRefresh($scope, retrieveServerGroup);
+        }
+      });
+
+      this.destroyServerGroup = () => {
+        const serverGroup = this.serverGroup;
+
+        const taskMonitor = {
+          application: app,
+          title: 'Destroying ' + serverGroup.name,
+          onTaskComplete: () => {
+            if ($state.includes('**.serverGroup', stateParams)) {
+              $state.go('^');
+            }
+          },
+        };
+
+        const submitMethod = (params) => serverGroupWriter.destroyServerGroup(serverGroup, app, params);
+
+        const stateParams = {
+          name: serverGroup.name,
+          accountId: serverGroup.account,
+          region: serverGroup.region,
+        };
+
+        const confirmationModalParams = {
+          header: 'Really destroy ' + serverGroup.name + '?',
+          buttonText: 'Destroy ' + serverGroup.name,
+          account: serverGroup.account,
+          taskMonitorConfig: taskMonitor,
+          submitMethod: submitMethod,
+          askForReason: true,
+          platformHealthOnlyShowOverride: app.attributes.platformHealthOnlyShowOverride,
+          platformHealthType: 'Ecs',
+        };
+
+        ServerGroupWarningMessageService.addDestroyWarningMessage(app, serverGroup, confirmationModalParams);
+
+        if (app.attributes.platformHealthOnlyShowOverride && app.attributes.platformHealthOnly) {
+          confirmationModalParams.interestingHealthProviderNames = ['Ecs'];
+        }
+
+        ConfirmationModalService.confirm(confirmationModalParams);
+      };
+
+      this.disableServerGroup = () => {
+        const serverGroup = this.serverGroup;
+
+        const taskMonitor = {
+          application: app,
+          title: 'Disabling ' + serverGroup.name,
+        };
+
+        const submitMethod = (params) => {
+          return serverGroupWriter.disableServerGroup(serverGroup, app, params);
+        };
+
+        const confirmationModalParams = {
+          header: 'Really disable ' + serverGroup.name + '?',
+          buttonText: 'Disable ' + serverGroup.name,
+          account: serverGroup.account,
+          taskMonitorConfig: taskMonitor,
+          platformHealthOnlyShowOverride: app.attributes.platformHealthOnlyShowOverride,
+          platformHealthType: 'Ecs',
+          submitMethod: submitMethod,
+          askForReason: true,
+        };
+
+        ServerGroupWarningMessageService.addDisableWarningMessage(app, serverGroup, confirmationModalParams);
+
+        if (app.attributes.platformHealthOnlyShowOverride && app.attributes.platformHealthOnly) {
+          confirmationModalParams.interestingHealthProviderNames = ['Ecs'];
+        }
+
+        ConfirmationModalService.confirm(confirmationModalParams);
+      };
+
+      this.enableServerGroup = () => {
+        const serverGroup = this.serverGroup;
+
+        const taskMonitor = {
+          application: app,
+          title: 'Enabling ' + serverGroup.name,
+        };
+
+        const submitMethod = (params) => {
+          return serverGroupWriter.enableServerGroup(serverGroup, app, params);
+        };
+
+        const confirmationModalParams = {
+          header: 'Really enable ' + serverGroup.name + '?',
+          buttonText: 'Enable ' + serverGroup.name,
+          account: serverGroup.account,
+          taskMonitorConfig: taskMonitor,
+          platformHealthOnlyShowOverride: app.attributes.platformHealthOnlyShowOverride,
+          platformHealthType: 'Ecs',
+          submitMethod: submitMethod,
+          askForReason: true,
+        };
+
+        if (app.attributes.platformHealthOnlyShowOverride && app.attributes.platformHealthOnly) {
+          confirmationModalParams.interestingHealthProviderNames = ['Ecs'];
+        }
+
+        ConfirmationModalService.confirm(confirmationModalParams);
+      };
+
+      this.rollbackServerGroup = () => {
+        $uibModal.open({
+          templateUrl: overrideRegistry.getTemplate(
+            'ecs.rollback.modal',
+            require('./rollback/rollbackServerGroup.html'),
+          ),
+          windowClass: 'modal-z-index',
+          controller: 'ecsRollbackServerGroupCtrl as ctrl',
+          resolve: {
+            serverGroup: () => this.serverGroup,
+            disabledServerGroups: () => {
+              const cluster = find(app.clusters, { name: this.serverGroup.cluster, account: this.serverGroup.account });
+              return filter(cluster.serverGroups, { isDisabled: true, region: this.serverGroup.region });
+            },
+            allServerGroups: () =>
+              app
+                .getDataSource('serverGroups')
+                .data.filter(
+                  (g) =>
+                    g.cluster === this.serverGroup.cluster &&
+                    g.region === this.serverGroup.region &&
+                    g.account === this.serverGroup.account &&
+                    g.name !== this.serverGroup.name,
+                ),
+            application: () => app,
+          },
+        });
+      };
+
+      this.resizeServerGroup = () => {
+        $uibModal.open({
+          templateUrl: overrideRegistry.getTemplate('ecs.resize.modal', require('./resize/resizeServerGroup.html')),
+          controller: 'ecsResizeServerGroupCtrl as ctrl',
+          windowClass: 'modal-z-index',
+          resolve: {
+            serverGroup: () => this.serverGroup,
+            application: () => app,
+          },
+        });
+      };
+
+      this.cloneServerGroup = (serverGroup) => {
+        $uibModal.open({
+          templateUrl: require('../configure/wizard/serverGroupWizard.html'),
+          controller: 'ecsCloneServerGroupCtrl as ctrl',
+          size: 'lg',
+          windowClass: 'modal-z-index',
+          resolve: {
+            title: () => 'Clone ' + serverGroup.name,
+            application: () => app,
+            serverGroupCommand: () =>
+              ecsServerGroupCommandBuilder.buildServerGroupCommandFromExisting(app, serverGroup),
+          },
+        });
+      };
+
+      this.buildJenkinsLink = () => {
+        if (has(this, 'serverGroup.buildInfo.buildInfoUrl')) {
+          return this.serverGroup.buildInfo.buildInfoUrl;
+        } else if (has(this, 'serverGroup.buildInfo.jenkins')) {
+          const jenkins = this.serverGroup.buildInfo.jenkins;
+          return jenkins.host + 'job/' + jenkins.name + '/' + jenkins.number;
+        }
+        return null;
+      };
+
+      this.truncateCommitHash = () => {
+        if (this.serverGroup && this.serverGroup.buildInfo && this.serverGroup.buildInfo.commit) {
+          return this.serverGroup.buildInfo.commit.substring(0, 8);
+        }
+        return null;
+      };
+
+      this.applyAccountDetails = (serverGroup) => {
+        return AccountService.getAccountDetails(serverGroup.account).then((details) => {
+          serverGroup.accountDetails = details;
+        });
+      };
+    },
+  ]);