@spinnaker/amazon 0.0.0-main-2

package/src/serverGroup/details/AmazonServerGroupActions.tsx

@@ -0,0 +1,343 @@
+import { filter, find, get, orderBy } from 'lodash';
+import React from 'react';
+import { Dropdown, MenuItem, Tooltip } from 'react-bootstrap';
+
+import type { IOwnerOption, IServerGroupActionsProps, IServerGroupJob } from '@spinnaker/core';
+import {
+  AddEntityTagLinks,
+  ClusterTargetBuilder,
+  ConfirmationModalService,
+  ManagedMenuItem,
+  ModalInjector,
+  Overridable,
+  ReactInjector,
+  ServerGroupWarningMessageService,
+  SETTINGS,
+} from '@spinnaker/core';
+
+import { AWSProviderSettings } from '../../aws.settings';
+import type { IAmazonServerGroupCommand } from '../configure';
+import { AmazonCloneServerGroupModal } from '../configure/wizard/AmazonCloneServerGroupModal';
+import type { IAmazonServerGroup, IAmazonServerGroupView } from '../../domain';
+import { AwsReactInjector } from '../../reactShims';
+import type { IAmazonResizeServerGroupModalProps } from './resize/AmazonResizeServerGroupModal';
+import { AmazonResizeServerGroupModal } from './resize/AmazonResizeServerGroupModal';
+
+export interface IAmazonServerGroupActionsProps extends IServerGroupActionsProps {
+  serverGroup: IAmazonServerGroupView;
+}
+
+@Overridable('AmazonServerGroupActions.resize')
+export class AmazonServerGroupActionsResize extends React.Component<IAmazonResizeServerGroupModalProps> {
+  private resizeServerGroup = (): void => {
+    AmazonResizeServerGroupModal.show(this.props);
+  };
+
+  public render(): JSX.Element {
+    return <MenuItem onClick={this.resizeServerGroup}>Resize</MenuItem>;
+  }
+}
+
+export class AmazonServerGroupActions extends React.Component<IAmazonServerGroupActionsProps> {
+  private isEnableLocked(): boolean {
+    if (this.props.serverGroup.isDisabled) {
+      const resizeTasks = (this.props.serverGroup.runningTasks || []).filter((task) =>
+        get(task, 'execution.stages', []).some((stage) => stage.type === 'resizeServerGroup'),
+      );
+      if (resizeTasks.length) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private isRollbackEnabled(): boolean {
+    const { app, serverGroup } = this.props;
+
+    if (!serverGroup.isDisabled) {
+      // enabled server groups are always a candidate for rollback
+      return true;
+    }
+
+    // if the server group selected for rollback is disabled, ensure that at least one enabled server group exists
+    return app
+      .getDataSource('serverGroups')
+      .data.some(
+        (g: IAmazonServerGroup) =>
+          g.cluster === serverGroup.cluster &&
+          g.region === serverGroup.region &&
+          g.account === serverGroup.account &&
+          !g.isDisabled,
+      );
+  }
+
+  private hasDisabledInstances(): boolean {
+    // server group may have disabled instances (out of service) but NOT itself be disabled
+    return this.props.serverGroup.isDisabled || get(this.props.serverGroup, 'instanceCounts.outOfService', 0) > 0;
+  }
+
+  private destroyServerGroup = (): void => {
+    const { app, serverGroup } = this.props;
+
+    const taskMonitor = {
+      application: app,
+      title: 'Destroying ' + serverGroup.name,
+      onTaskComplete: () => {
+        if (ReactInjector.$state.includes('**.serverGroup', stateParams)) {
+          ReactInjector.$state.go('^');
+        }
+      },
+    };
+
+    const submitMethod = (params: IServerGroupJob) =>
+      ReactInjector.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,
+      interestingHealthProviderNames: undefined as string[],
+      submitMethod,
+      askForReason: true,
+      platformHealthOnlyShowOverride: app.attributes.platformHealthOnlyShowOverride,
+      platformHealthType: 'Amazon',
+    };
+
+    ServerGroupWarningMessageService.addDestroyWarningMessage(app, serverGroup, confirmationModalParams);
+
+    if (app.attributes.platformHealthOnlyShowOverride && app.attributes.platformHealthOnly) {
+      confirmationModalParams.interestingHealthProviderNames = ['Amazon'];
+    }
+
+    ConfirmationModalService.confirm(confirmationModalParams);
+  };
+
+  private disableServerGroup = (): void => {
+    const { app, serverGroup } = this.props;
+
+    const taskMonitor = {
+      application: app,
+      title: 'Disabling ' + serverGroup.name,
+    };
+
+    const submitMethod = (params: IServerGroupJob) => {
+      return ReactInjector.serverGroupWriter.disableServerGroup(serverGroup, app.name, params);
+    };
+
+    const confirmationModalParams = {
+      header: 'Really disable ' + serverGroup.name + '?',
+      buttonText: 'Disable ' + serverGroup.name,
+      account: serverGroup.account,
+      interestingHealthProviderNames: undefined as string[],
+      taskMonitorConfig: taskMonitor,
+      platformHealthOnlyShowOverride: app.attributes.platformHealthOnlyShowOverride,
+      platformHealthType: 'Amazon',
+      submitMethod,
+      askForReason: true,
+    };
+
+    ServerGroupWarningMessageService.addDisableWarningMessage(app, serverGroup, confirmationModalParams);
+
+    if (app.attributes.platformHealthOnlyShowOverride && app.attributes.platformHealthOnly) {
+      confirmationModalParams.interestingHealthProviderNames = ['Amazon'];
+    }
+
+    ConfirmationModalService.confirm(confirmationModalParams);
+  };
+
+  private enableServerGroup = (): void => {
+    if (!this.isRollbackEnabled()) {
+      this.showEnableServerGroupModal();
+      return;
+    }
+
+    const confirmationModalParams = {
+      header: 'Rolling back?',
+      body: `Spinnaker provides an orchestrated rollback feature to carefully restore a different version of this
+             server group. Do you want to use the orchestrated rollback?`,
+      buttonText: `Yes, take me to the rollback settings modal`,
+      cancelButtonText: 'No, I just want to enable the server group',
+    };
+
+    ConfirmationModalService.confirm(confirmationModalParams)
+      // Wait for the confirmation modal to go away first to avoid react/angular bootstrap fighting
+      // over the body.modal-open class
+      .then(() => new Promise((resolve) => setTimeout(resolve, 500)))
+      .then(() => this.rollbackServerGroup())
+      .catch((error) => {
+        // don't show the enable modal if the user cancels with the header button
+        if (error?.source === 'footer') {
+          this.showEnableServerGroupModal();
+        }
+      });
+  };
+
+  private showEnableServerGroupModal(): void {
+    const { app, serverGroup } = this.props;
+
+    const taskMonitor = {
+      application: app,
+      title: 'Enabling ' + serverGroup.name,
+    };
+
+    const submitMethod = (params: IServerGroupJob) => {
+      return ReactInjector.serverGroupWriter.enableServerGroup(serverGroup, app, params);
+    };
+
+    const confirmationModalParams = {
+      header: 'Really enable ' + serverGroup.name + '?',
+      buttonText: 'Enable ' + serverGroup.name,
+      account: serverGroup.account,
+      interestingHealthProviderNames: undefined as string[],
+      taskMonitorConfig: taskMonitor,
+      platformHealthOnlyShowOverride: app.attributes.platformHealthOnlyShowOverride,
+      platformHealthType: 'Amazon',
+      submitMethod,
+      askForReason: true,
+    };
+
+    if (app.attributes.platformHealthOnlyShowOverride && app.attributes.platformHealthOnly) {
+      confirmationModalParams.interestingHealthProviderNames = ['Amazon'];
+    }
+
+    ConfirmationModalService.confirm(confirmationModalParams);
+  }
+
+  private rollbackServerGroup = (): void => {
+    const { app } = this.props;
+
+    let serverGroup: IAmazonServerGroup = this.props.serverGroup;
+    let previousServerGroup: IAmazonServerGroup;
+    let allServerGroups = app
+      .getDataSource('serverGroups')
+      .data.filter(
+        (g: IAmazonServerGroup) =>
+          g.cluster === serverGroup.cluster && g.region === serverGroup.region && g.account === serverGroup.account,
+      );
+
+    if (serverGroup.isDisabled) {
+      // if the selected server group is disabled, it represents the server group that should be _rolled back to_
+      previousServerGroup = serverGroup;
+
+      /*
+       * Find an existing server group to rollback, prefer the largest enabled server group.
+       *
+       * isRollbackEnabled() ensures that at least one enabled server group exists.
+       */
+      serverGroup = orderBy(
+        allServerGroups.filter((g: IAmazonServerGroup) => g.name !== previousServerGroup.name && !g.isDisabled),
+        ['instanceCounts.total', 'createdTime'],
+        ['desc', 'desc'],
+      )[0] as IAmazonServerGroup;
+    }
+
+    // the set of all server groups should not include the server group selected for rollback
+    allServerGroups = allServerGroups.filter((g: IAmazonServerGroup) => g.name !== serverGroup.name);
+
+    if (allServerGroups.length === 1 && !previousServerGroup) {
+      // if there is only one other server group, default to it being the rollback target
+      previousServerGroup = allServerGroups[0];
+    }
+
+    ModalInjector.modalService.open({
+      templateUrl: ReactInjector.overrideRegistry.getTemplate(
+        'aws.rollback.modal',
+        require('./rollback/rollbackServerGroup.html'),
+      ),
+      controller: 'awsRollbackServerGroupCtrl as ctrl',
+      resolve: {
+        serverGroup: () => serverGroup,
+        previousServerGroup: () => previousServerGroup,
+        disabledServerGroups: () => {
+          const cluster = find(app.clusters, {
+            name: serverGroup.cluster,
+            account: serverGroup.account,
+            serverGroups: [],
+          });
+          return filter(cluster.serverGroups, { isDisabled: true, region: serverGroup.region });
+        },
+        allServerGroups: () => allServerGroups,
+        application: () => app,
+      },
+    });
+  };
+
+  private cloneServerGroup = (): void => {
+    const { app, serverGroup } = this.props;
+    AwsReactInjector.awsServerGroupCommandBuilder
+      .buildServerGroupCommandFromExisting(app, serverGroup)
+      .then((command: IAmazonServerGroupCommand) => {
+        const title = `Clone ${serverGroup.name}`;
+        AmazonCloneServerGroupModal.show({ title, application: app, command });
+      });
+  };
+
+  public render(): JSX.Element {
+    const { app, serverGroup } = this.props;
+
+    const showEntityTags = SETTINGS.feature && SETTINGS.feature.entityTags;
+    const entityTagTargets: IOwnerOption[] = ClusterTargetBuilder.buildClusterTargets(serverGroup);
+
+    return (
+      <>
+        {AWSProviderSettings.adHocInfraWritesEnabled && (
+          <Dropdown className="dropdown" id="server-group-actions-dropdown">
+            <Dropdown.Toggle className="btn btn-sm btn-primary dropdown-toggle">Server Group Actions</Dropdown.Toggle>
+            <Dropdown.Menu className="dropdown-menu">
+              {this.isRollbackEnabled() && (
+                <ManagedMenuItem resource={serverGroup} application={app} onClick={this.rollbackServerGroup}>
+                  Rollback
+                </ManagedMenuItem>
+              )}
+              {this.isRollbackEnabled() && <li role="presentation" className="divider" />}
+              <AmazonServerGroupActionsResize application={app} serverGroup={serverGroup} />
+              {!serverGroup.isDisabled && (
+                <ManagedMenuItem resource={serverGroup} application={app} onClick={this.disableServerGroup}>
+                  Disable
+                </ManagedMenuItem>
+              )}
+              {this.hasDisabledInstances() && !this.isEnableLocked() && (
+                <ManagedMenuItem resource={serverGroup} application={app} onClick={this.enableServerGroup}>
+                  Enable
+                </ManagedMenuItem>
+              )}
+              {this.isEnableLocked() && (
+                <li className="disabled">
+                  <Tooltip value="Cannot enable this server group until resize operation completes" placement="left">
+                    <a>
+                      <span className="small glyphicon glyphicon-lock" /> Enable
+                    </a>
+                  </Tooltip>
+                </li>
+              )}
+              <ManagedMenuItem resource={serverGroup} application={app} onClick={this.destroyServerGroup}>
+                Destroy
+              </ManagedMenuItem>
+              <li>
+                <a className="clickable" onClick={this.cloneServerGroup}>
+                  Clone
+                </a>
+              </li>
+              {showEntityTags && (
+                <AddEntityTagLinks
+                  component={serverGroup}
+                  application={app}
+                  entityType="serverGroup"
+                  ownerOptions={entityTagTargets}
+                  onUpdate={() => app.serverGroups.refresh()}
+                />
+              )}
+            </Dropdown.Menu>
+          </Dropdown>
+        )}
+      </>
+    );
+  }
+}

package/src/serverGroup/details/advancedSettings/editAsgAdvancedSettings.modal.controller.js

@@ -0,0 +1,47 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { TaskExecutor, TaskMonitor } from '@spinnaker/core';
+import { AMAZON_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE } from '../../configure/serverGroupCommandBuilder.service';
+
+export const AMAZON_SERVERGROUP_DETAILS_ADVANCEDSETTINGS_EDITASGADVANCEDSETTINGS_MODAL_CONTROLLER =
+  'spinnaker.amazon.serverGroup.editAsgAdvancedSettings.modal.controller';
+export const name = AMAZON_SERVERGROUP_DETAILS_ADVANCEDSETTINGS_EDITASGADVANCEDSETTINGS_MODAL_CONTROLLER; // for backwards compatibility
+module(AMAZON_SERVERGROUP_DETAILS_ADVANCEDSETTINGS_EDITASGADVANCEDSETTINGS_MODAL_CONTROLLER, [
+  AMAZON_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE,
+]).controller('EditAsgAdvancedSettingsCtrl', [
+  '$scope',
+  '$uibModalInstance',
+  'application',
+  'serverGroup',
+  'awsServerGroupCommandBuilder',
+  function ($scope, $uibModalInstance, application, serverGroup, awsServerGroupCommandBuilder) {
+    $scope.command = awsServerGroupCommandBuilder.buildUpdateServerGroupCommand(serverGroup);
+
+    $scope.serverGroup = serverGroup;
+
+    $scope.taskMonitor = new TaskMonitor({
+      application: application,
+      title: 'Update Advanced Settings for ' + serverGroup.name,
+      modalInstance: $uibModalInstance,
+      onTaskComplete: () => application.serverGroups.refresh(),
+    });
+
+    this.submit = () => {
+      const job = [$scope.command];
+
+      const submitMethod = function () {
+        return TaskExecutor.executeTask({
+          job: job,
+          application: application,
+          description: 'Update Advanced Settings for ' + serverGroup.name,
+        });
+      };
+
+      $scope.taskMonitor.submit(submitMethod);
+    };
+
+    this.cancel = $uibModalInstance.dismiss;
+  },
+]);

package/src/serverGroup/details/advancedSettings/editAsgAdvancedSettings.modal.html

@@ -0,0 +1,79 @@
+<div modal-page>
+  <task-monitor monitor="taskMonitor"></task-monitor>
+  <form role="form" name="form">
+    <modal-close dismiss="$dismiss()"></modal-close>
+    <div class="modal-header">
+      <h4 class="modal-title">Edit Advanced Settings for {{serverGroup.name}}</h4>
+    </div>
+    <div class="modal-body container-fluid form-horizontal">
+      <div class="form-group">
+        <div class="col-md-5 sm-label-right"><b>Cooldown</b></div>
+        <div class="col-md-2">
+          <input type="number" required class="form-control input-sm" ng-model="command.cooldown" />
+        </div>
+        &nbsp;seconds
+      </div>
+      <div class="form-group">
+        <div class="col-md-5 sm-label-right">
+          <b>Enabled Metrics</b>
+          <help-field key="aws.serverGroup.enabledMetrics"></help-field>
+        </div>
+        <div class="col-md-6">
+          <ui-select multiple ng-model="command.enabledMetrics" class="form-control input-sm">
+            <ui-select-match>{{$item}}</ui-select-match>
+            <ui-select-choices
+              repeat="enabledMetric in command.backingData.enabledMetrics | filter: $select.search | orderBy: 'toString()'"
+            >
+              <span ng-bind-html="enabledMetric | highlight: $select.search"></span>
+            </ui-select-choices>
+          </ui-select>
+        </div>
+      </div>
+      <div class="form-group">
+        <div class="col-md-5 sm-label-right"><b>Health Check Type</b></div>
+        <div class="col-md-6">
+          <ui-select ng-model="command.healthCheckType" class="form-control input-sm">
+            <ui-select-match placeholder="Select...">{{$select.selected}}</ui-select-match>
+            <ui-select-choices
+              repeat="healthCheckType in command.backingData.healthCheckTypes | filter: $select.search"
+            >
+              <span ng-bind-html="healthCheckType | highlight: $select.search"></span>
+            </ui-select-choices>
+          </ui-select>
+        </div>
+      </div>
+      <div class="form-group">
+        <div class="col-md-5 sm-label-right"><b>Health Check Grace Period</b></div>
+        <div class="col-md-2">
+          <input type="text" required class="form-control input-sm" ng-model="command.healthCheckGracePeriod" />
+        </div>
+        &nbsp;seconds
+      </div>
+      <div class="form-group">
+        <div class="col-md-5 sm-label-right"><b>Termination Policies</b></div>
+        <div class="col-md-6">
+          <ui-select multiple ng-model="command.terminationPolicies" class="form-control input-sm">
+            <ui-select-match>{{$item}}</ui-select-match>
+            <ui-select-choices
+              repeat="terminationPolicy in command.backingData.terminationPolicies | filter: $select.search | orderBy: 'toString()'"
+            >
+              <span ng-bind-html="terminationPolicy | highlight: $select.search"></span>
+            </ui-select-choices>
+          </ui-select>
+        </div>
+      </div>
+      <div class="form-group">
+        <div class="col-md-5 sm-label-right">
+          <b>Capacity Rebalance</b><help-field key="aws.serverGroup.capacityRebalance" />
+        </div>
+        <div class="col-md-6">
+          <input type="checkbox" ng-model="command.capacityRebalance" /> Enable capacity rebalance
+        </div>
+      </div>
+    </div>
+    <div class="modal-footer">
+      <button class="btn btn-default" ng-click="ctrl.cancel()">Cancel</button>
+      <button type="submit" class="btn btn-primary" ng-disabled="form.$invalid" ng-click="ctrl.submit()">Submit</button>
+    </div>
+  </form>
+</div>

package/src/serverGroup/details/amazonServerGroupDetailsGetter.ts

@@ -0,0 +1,83 @@
+import { isEmpty } from 'lodash';
+import { Observable } from 'rxjs';
+
+import type { IServerGroupDetailsProps, ISubnet } from '@spinnaker/core';
+import { AccountService, ServerGroupReader, SubnetReader } from '@spinnaker/core';
+import type { IAmazonLoadBalancer, IAmazonServerGroup, IAmazonServerGroupView } from '../../domain';
+import { AwsReactInjector } from '../../reactShims';
+
+import { AutoScalingProcessService } from './scalingProcesses/AutoScalingProcessService';
+
+function extractServerGroupSummary(props: IServerGroupDetailsProps): PromiseLike<IAmazonServerGroup> {
+  const { app, serverGroup } = props;
+  return app.ready().then(() => {
+    let summary: IAmazonServerGroup = app.serverGroups.data.find((toCheck: IAmazonServerGroup) => {
+      return (
+        toCheck.name === serverGroup.name &&
+        toCheck.account === serverGroup.accountId &&
+        toCheck.region === serverGroup.region
+      );
+    });
+    if (!summary) {
+      app.loadBalancers.data.some((loadBalancer: IAmazonLoadBalancer) => {
+        if (loadBalancer.account === serverGroup.accountId && loadBalancer.region === serverGroup.region) {
+          return loadBalancer.serverGroups.some((possibleServerGroup) => {
+            if (possibleServerGroup.name === serverGroup.name) {
+              summary = possibleServerGroup;
+              return true;
+            }
+            return false;
+          });
+        }
+        return false;
+      });
+    }
+    return summary;
+  });
+}
+
+export function amazonServerGroupDetailsGetter(
+  props: IServerGroupDetailsProps,
+  autoClose: () => void,
+): Observable<IAmazonServerGroup> {
+  const { app, serverGroup: serverGroupInfo } = props;
+  return new Observable<IAmazonServerGroupView>((observer) => {
+    extractServerGroupSummary(props).then((summary) => {
+      ServerGroupReader.getServerGroup(
+        app.name,
+        serverGroupInfo.accountId,
+        serverGroupInfo.region,
+        serverGroupInfo.name,
+      ).then((details: IAmazonServerGroup) => {
+        // it's possible the summary was not found because the clusters are still loading
+        Object.assign(details, summary, { account: serverGroupInfo.accountId });
+
+        const serverGroup = AwsReactInjector.awsServerGroupTransformer.normalizeServerGroupDetails(details);
+
+        AccountService.getAccountDetails(serverGroup.account).then((accountDetails) => {
+          serverGroup.accountDetails = accountDetails;
+          observer.next(serverGroup);
+        });
+
+        if (!isEmpty(serverGroup)) {
+          const vpc = serverGroup.asg ? serverGroup.asg.vpczoneIdentifier : '';
+
+          if (vpc !== '') {
+            const subnetId = vpc.split(',')[0];
+            SubnetReader.listSubnets().then((subnets: ISubnet[]) => {
+              const subnet = subnets.find((s) => s.id === subnetId);
+              serverGroup.subnetType = subnet.purpose;
+              observer.next(serverGroup);
+            });
+          }
+
+          serverGroup.disabledDate = AutoScalingProcessService.getDisabledDate(serverGroup);
+
+          observer.next(serverGroup);
+        } else {
+          autoClose();
+        }
+      }, autoClose);
+    }, autoClose);
+  });
+}