@spinnaker/amazon 0.0.0-2025.1-0

package/src/serverGroup/details/scalingPolicy/upsert/alarm/dimensionsEditor.less

@@ -0,0 +1,18 @@
+dimensions-editor {
+  h5 {
+    margin-bottom: 0;
+  }
+  display: block;
+  padding-left: 5px;
+
+  .dimensions-row {
+    margin-top: 5px;
+    margin-left: -20px;
+  }
+
+  .add-new {
+    margin-left: 0;
+    padding: 4px;
+    width: 100%;
+  }
+}

package/src/serverGroup/details/scalingPolicy/upsert/alarm/namespaces.ts

@@ -0,0 +1,31 @@
+export const NAMESPACES = [
+  'AWS/ApplicationELB',
+  'AWS/AutoScaling',
+  'AWS/AmazonMQ',
+  'AWS/Billing',
+  'AWS/CloudFront',
+  'AWS/CloudSearch',
+  'AWS/Events',
+  'AWS/DynamoDB',
+  'AWS/ECS',
+  'AWS/ElastiCache',
+  'AWS/EBS',
+  'AWS/EC2',
+  'AWS/ELB',
+  'AWS/ElasticMapReduce',
+  'AWS/ES',
+  'AWS/Kinesis',
+  'AWS/Lambda',
+  'AWS/ML',
+  'AWS/OpsWorks',
+  'AWS/Redshift',
+  'AWS/RDS',
+  'AWS/Route53',
+  'AWS/SNS',
+  'AWS/SQS',
+  'AWS/S3',
+  'AWS/SWF',
+  'AWS/StorageGateway',
+  'AWS/WAF',
+  'AWS/WorkSpaces',
+];

package/src/serverGroup/details/scalingPolicy/upsert/index.ts

@@ -0,0 +1,7 @@
+export * from './alarm/AlarmConfigurer';
+export * from './alarm/DimensionsEditor';
+export * from './alarm/MetricSelector';
+export * from './PolicyTypeSelectionModal';
+export * from './ScalingPolicyAdditionalSettings';
+export * from './step/StepPolicyAction';
+export { UpsertScalingPolicyModal as AmazonUpsertScalingPolicyModal } from './UpsertScalingPolicyModal';

package/src/serverGroup/details/scalingPolicy/upsert/simple/SimplePolicyAction.less

@@ -0,0 +1,9 @@
+.SimplePolicyAction {
+  .action-input {
+    width: 65px;
+  }
+
+  .adjustment-type-input {
+    width: 110px;
+  }
+}

package/src/serverGroup/details/scalingPolicy/upsert/simple/SimplePolicyAction.tsx

@@ -0,0 +1,70 @@
+import * as React from 'react';
+
+import { NumberInput, ReactSelectInput } from '@spinnaker/core';
+
+import './SimplePolicyAction.less';
+
+type Operator = 'Add' | 'Remove' | 'Set to';
+type AdjustmentTypeView = 'instances' | 'percent of group';
+
+export interface ISimplePolicyActionProps {
+  adjustmentType: AdjustmentTypeView;
+  adjustmentTypeChanged: (action: Operator, type: AdjustmentTypeView) => void;
+  operator: Operator;
+  scalingAdjustment: number;
+  updateScalingAdjustment: (adjustment: number) => void;
+}
+
+export const SimplePolicyAction = ({
+  adjustmentType,
+  adjustmentTypeChanged,
+  operator,
+  scalingAdjustment,
+  updateScalingAdjustment,
+}: ISimplePolicyActionProps) => {
+  const availableActions = ['Add', 'Remove', 'Set to'];
+
+  const adjustmentTypeOptions = operator === 'Set to' ? ['instances'] : ['instances', 'percent of group'];
+  const onActionChange = (val: Operator) => {
+    adjustmentTypeChanged(val, adjustmentType);
+  };
+
+  const [adjustmentTypeView, setAdjustmentTypeView] = React.useState<AdjustmentTypeView>(adjustmentType);
+  const onAdjustmentTypeChange = (type: AdjustmentTypeView) => {
+    setAdjustmentTypeView(type);
+    adjustmentTypeChanged(operator, type);
+  };
+
+  const [adjustment, setAdjustment] = React.useState<number>(scalingAdjustment);
+  const onScalingAdjustmentChange = (adj: number) => {
+    setAdjustment(adj);
+    updateScalingAdjustment(adj);
+  };
+
+  return (
+    <div className="SimplePolicyAction row">
+      <div className="col-md-10 col-md-offset-1 horizontal middle">
+        <ReactSelectInput
+          value={operator}
+          stringOptions={availableActions}
+          onChange={(e) => onActionChange(e.target.value)}
+          clearable={false}
+          inputClassName="action-input"
+        />
+        <NumberInput
+          value={adjustment}
+          min={1}
+          onChange={(e) => onScalingAdjustmentChange(Number.parseInt(e.target.value))}
+          inputClassName="action-input"
+        />
+        <ReactSelectInput
+          value={adjustmentTypeView}
+          stringOptions={adjustmentTypeOptions}
+          onChange={(e) => onAdjustmentTypeChange(e.target.value)}
+          clearable={false}
+          inputClassName="adjustment-type-input"
+        />
+      </div>
+    </div>
+  );
+};

package/src/serverGroup/details/scalingPolicy/upsert/step/StepPolicyAction.less

@@ -0,0 +1,18 @@
+.StepPolicyAction {
+  .step-policy-row {
+    padding: 5px 0;
+    border-bottom: 1px solid var(--color-seashell);
+
+    .action-input {
+      width: 65px !important;
+    }
+
+    .adjustment-type-input {
+      width: 110px;
+    }
+
+    .remove-step-action-icon {
+      margin-left: auto;
+    }
+  }
+}

package/src/serverGroup/details/scalingPolicy/upsert/step/StepPolicyAction.tsx

@@ -0,0 +1,163 @@
+import * as React from 'react';
+
+import { NumberInput, ReactSelectInput } from '@spinnaker/core';
+
+import type { IScalingPolicyAlarm, IStepAdjustment } from '../../../../../domain';
+
+import './StepPolicyAction.less';
+
+export type Operator = 'Add' | 'Remove' | 'Set to';
+export type AdjustmentTypeView = 'instances' | 'percent of group';
+
+export interface IStepPolicyActionProps {
+  adjustmentType: AdjustmentTypeView;
+  adjustmentTypeChanged: (action: Operator, type: AdjustmentTypeView) => void;
+  alarm: IScalingPolicyAlarm;
+  isMin: boolean;
+  operator: Operator;
+  step: { stepAdjustments: IStepAdjustment[] };
+  stepAdjustments?: IStepAdjustment[];
+  stepsChanged: (steps: IStepAdjustment[]) => void;
+}
+
+export const StepPolicyAction = ({
+  adjustmentType,
+  adjustmentTypeChanged,
+  alarm,
+  isMin,
+  operator,
+  step,
+  stepAdjustments,
+  stepsChanged,
+}: IStepPolicyActionProps) => {
+  const hasEqualTo = alarm?.comparisonOperator.includes('Equal');
+  const availableActions = ['Add', 'Remove', 'Set to'];
+
+  const adjustmentTypeOptions = operator === 'Set to' ? ['instances'] : ['instances', 'percent of group'];
+  const onActionChange = (val: Operator) => {
+    adjustmentTypeChanged(val, adjustmentType);
+  };
+
+  const onAdjustmentTypeChange = (type: AdjustmentTypeView) => {
+    adjustmentTypeChanged(operator, type);
+  };
+
+  const steps = step?.stepAdjustments || stepAdjustments;
+  const addStep = () => {
+    const newStep = { scalingAdjustment: 1 } as IStepAdjustment;
+    const newSteps = [...steps, newStep];
+    stepsChanged(newSteps);
+  };
+  const removeStep = (index: number) => {
+    const newSteps = steps.filter((_s, i) => i !== index);
+    stepsChanged(newSteps);
+  };
+  const updateStep = (updatedStep: IStepAdjustment, index: number) => {
+    const newSteps = [...steps];
+    newSteps[index] = updatedStep;
+    stepsChanged(newSteps);
+  };
+
+  return (
+    <div className="StepPolicyAction row">
+      {steps?.map((step: IStepAdjustment, index: number) => (
+        <div key={`step-adjustment-${index}`} className="step-policy-row col-md-10 col-md-offset-1 horizontal middle">
+          {Boolean(index) ? (
+            <span className="action-input sp-margin-xs-left">{operator}</span>
+          ) : (
+            <ReactSelectInput
+              value={operator}
+              stringOptions={availableActions}
+              onChange={(e) => onActionChange(e.target.value)}
+              clearable={false}
+              inputClassName="action-input sp-margin-xs-right"
+            />
+          )}
+          <NumberInput
+            value={step.scalingAdjustment}
+            min={1}
+            onChange={(e) => updateStep({ ...step, scalingAdjustment: Number.parseInt(e.target.value) }, index)}
+            inputClassName="action-input"
+          />
+          {Boolean(index) ? (
+            <span className="sp-margin-xs-left">{adjustmentType}</span>
+          ) : (
+            <ReactSelectInput
+              value={adjustmentType}
+              stringOptions={adjustmentTypeOptions}
+              onChange={(e) => onAdjustmentTypeChange(e.target.value)}
+              clearable={false}
+              inputClassName="adjustment-type-input sp-margin-xs-left"
+            />
+          )}
+          <span className="sp-margin-xs-xaxis">
+            {' '}
+            when <b>{alarm?.metricName}</b> is{' '}
+          </span>
+          {index === steps.length - 1 && (
+            <span>{` ${isMin ? 'less' : 'greater'} than${!Boolean(index) || hasEqualTo ? ' or equal to' : ''} ${
+              isMin ? step.metricIntervalUpperBound || '' : step.metricIntervalLowerBound || ''
+            } `}</span>
+          )}
+          {index < steps.length - 1 && (
+            <>
+              <span className="sp-margin-xs-xaxis">between</span>
+              {isMin ? (
+                <NumberInput
+                  value={step.metricIntervalLowerBound}
+                  max={step.metricIntervalUpperBound}
+                  step={0.1}
+                  onChange={(e) =>
+                    updateStep({ ...step, metricIntervalLowerBound: Number.parseFloat(e.target.value) }, index)
+                  }
+                  inputClassName="action-input"
+                />
+              ) : (
+                <span>{step.metricIntervalLowerBound}</span>
+              )}
+              <span className="sp-margin-xs-xaxis">and</span>
+              {isMin ? (
+                <span>{step.metricIntervalUpperBound}</span>
+              ) : (
+                <NumberInput
+                  value={step.metricIntervalUpperBound}
+                  min={step.metricIntervalLowerBound}
+                  step={0.1}
+                  onChange={(e) =>
+                    updateStep({ ...step, metricIntervalUpperBound: Number.parseFloat(e.target.value) }, index)
+                  }
+                  inputClassName="action-input"
+                />
+              )}
+            </>
+          )}
+          {Boolean(index) && (
+            <a
+              className="glyphicon glyphicon-trash clickable sp-margin-xs-xaxis remove-step-action-icon"
+              onClick={() => removeStep(index)}
+            />
+          )}
+        </div>
+      ))}
+      <div className="row sp-margin-s">
+        <div className="col-md-10 col-md-offset-1">
+          <button type="button" className="btn btn-block btn-sm add-new" onClick={addStep}>
+            <span className="glyphicon glyphicon-plus-sign"></span>
+            Add step
+          </button>
+        </div>
+      </div>
+      <div className="row sp-margin-s-xaxis">
+        <div className="col-md-10 col-md-offset-1">
+          <a
+            href="http://docs.aws.amazon.com/autoscaling/latest/userguide/as-scale-based-on-demand.html#as-scaling-steps"
+            target="_blank"
+          >
+            <i className="far fa-file-alt sp-margin-xs-right" />
+            Documentation
+          </a>
+        </div>
+      </div>
+    </div>
+  );
+};

package/src/serverGroup/details/scalingProcesses/AutoScalingProcessService.spec.ts

@@ -0,0 +1,94 @@
+import { AutoScalingProcessService } from './AutoScalingProcessService';
+import type { IAmazonAsg, IAmazonServerGroup } from '../../../domain';
+
+describe('AutoScalingProcessService', () => {
+  describe('normalizeScalingProcesses', () => {
+    it('returns an empty list if no asg or suspendedProcesses present on server group', function () {
+      expect(AutoScalingProcessService.normalizeScalingProcesses({} as IAmazonServerGroup)).toEqual([]);
+      expect(AutoScalingProcessService.normalizeScalingProcesses({ asg: {} } as IAmazonServerGroup)).toEqual([]);
+    });
+
+    it('returns all processes normalized if suspendedProcesses is empty', function () {
+      const asg = {
+        suspendedProcesses: [],
+      } as IAmazonAsg;
+      const normalized = AutoScalingProcessService.normalizeScalingProcesses({ asg: asg } as IAmazonServerGroup);
+      expect(normalized.length).toBe(8);
+      expect(normalized.filter((process) => process.enabled).length).toBe(8);
+      expect(normalized.map((process) => process.name)).toEqual([
+        'Launch',
+        'Terminate',
+        'AddToLoadBalancer',
+        'AlarmNotification',
+        'AZRebalance',
+        'HealthCheck',
+        'ReplaceUnhealthy',
+        'ScheduledActions',
+      ]);
+      expect(normalized.filter((process) => process.suspensionDate)).toEqual([]);
+    });
+
+    it('builds suspension date for suspended processes', function () {
+      const asg = {
+        suspendedProcesses: [
+          {
+            processName: 'Launch',
+            suspensionReason: 'User suspended at 2016-01-12T22:59:46Z',
+          },
+        ],
+      };
+      const normalized = AutoScalingProcessService.normalizeScalingProcesses({ asg: asg } as IAmazonServerGroup);
+      expect(normalized.length).toBe(8);
+      expect(normalized.filter((process) => process.enabled).length).toBe(7);
+      expect(normalized.map((process) => process.name)).toEqual([
+        'Launch',
+        'Terminate',
+        'AddToLoadBalancer',
+        'AlarmNotification',
+        'AZRebalance',
+        'HealthCheck',
+        'ReplaceUnhealthy',
+        'ScheduledActions',
+      ]);
+      expect(normalized.filter((process) => process.suspensionDate).length).toBe(1);
+      expect(normalized.filter((p) => p.suspensionDate).map((p) => p.suspensionDate)).toEqual([1452639586000]);
+    });
+  });
+
+  describe('getDisabledDate', function () {
+    it('returns null when server group is not disabled, regardless of suspended processes', function () {
+      const asg = {
+        suspendedProcesses: [
+          {
+            processName: 'AddToLoadBalancer',
+            suspensionReason: 'User suspended at 2016-01-12T22:59:46Z',
+          },
+        ],
+      };
+      expect(AutoScalingProcessService.getDisabledDate({ asg: asg } as IAmazonServerGroup)).toBeNull();
+    });
+
+    it('returns null when server group is disabled but suspended process for AddToLoadBalancer not present', function () {
+      const asg = {
+        suspendedProcesses: [],
+      } as IAmazonAsg;
+      expect(
+        AutoScalingProcessService.getDisabledDate({ isDisabled: true, asg: asg } as IAmazonServerGroup),
+      ).toBeNull();
+    });
+
+    it('returns suspension date when server group is disabled and AddToLoadBalancer suspended', function () {
+      const asg = {
+        suspendedProcesses: [
+          {
+            processName: 'AddToLoadBalancer',
+            suspensionReason: 'User suspended at 2016-01-12T22:59:46Z',
+          },
+        ],
+      };
+      expect(AutoScalingProcessService.getDisabledDate({ isDisabled: true, asg: asg } as IAmazonServerGroup)).toEqual(
+        1452639586000,
+      );
+    });
+  });
+});

package/src/serverGroup/details/scalingProcesses/AutoScalingProcessService.ts

@@ -0,0 +1,76 @@
+import type { IAmazonServerGroup, IScalingProcess } from '../../../domain';
+
+export class AutoScalingProcessService {
+  public static getDisabledDate(serverGroup: IAmazonServerGroup): number {
+    if (serverGroup.isDisabled) {
+      const processes = this.normalizeScalingProcesses(serverGroup);
+      const disabledProcess = processes.find((process) => process.name === 'AddToLoadBalancer' && !process.enabled);
+      if (disabledProcess) {
+        return disabledProcess.suspensionDate;
+      }
+    }
+    return null;
+  }
+
+  public static normalizeScalingProcesses(serverGroup: IAmazonServerGroup): IScalingProcess[] {
+    if (!serverGroup.asg || !serverGroup.asg.suspendedProcesses) {
+      return [];
+    }
+    const disabled = serverGroup.asg.suspendedProcesses;
+    const allProcesses = this.listProcesses();
+    return allProcesses.map((process) => {
+      const disabledProcess = disabled.find((p) => p.processName === process.name);
+      const scalingProcess: IScalingProcess = {
+        name: process.name,
+        enabled: !disabledProcess,
+        description: process.description,
+      };
+      if (disabledProcess) {
+        const suspensionDate = disabledProcess.suspensionReason.replace('User suspended at ', '');
+        scalingProcess.suspensionDate = new Date(suspensionDate).getTime();
+      }
+      return scalingProcess;
+    });
+  }
+
+  public static listProcesses(): IScalingProcess[] {
+    return [
+      {
+        name: 'Launch',
+        description:
+          'Controls if new instances should be launched into the ASG. If this is disabled, scale-up ' +
+          'events will not produce new instances.',
+      },
+      {
+        name: 'Terminate',
+        description: 'Controls if instances should be terminated during a scale-down event.',
+      },
+      {
+        name: 'AddToLoadBalancer',
+        description: 'Controls if new instances should be added to the ASG’s ELB.',
+      },
+      {
+        name: 'AlarmNotification',
+        description: 'This disables autoscaling.',
+      },
+      {
+        name: 'AZRebalance',
+        description:
+          'Controls whether AWS should attempt to maintain an even distribution of instances across all ' +
+          'healthy Availability Zones configured for the ASG.',
+      },
+      {
+        name: 'HealthCheck',
+        description: 'If disabled, the instance’s health will no longer be reported to the autoscaling processor.',
+      },
+      {
+        name: 'ReplaceUnhealthy',
+        description: 'Controls whether instances should be replaced if they failed the health check.',
+      },
+      {
+        name: 'ScheduledActions',
+        description: 'Controls whether scheduled actions should be executed.',
+      },
+    ];
+  }
+}

package/src/serverGroup/details/scalingProcesses/modifyScalingProcesses.controller.js

@@ -0,0 +1,95 @@
+'use strict';
+
+import * as angular from 'angular';
+import _ from 'lodash';
+
+import { TaskExecutor, TaskMonitor } from '@spinnaker/core';
+
+export const AMAZON_SERVERGROUP_DETAILS_SCALINGPROCESSES_MODIFYSCALINGPROCESSES_CONTROLLER =
+  'spinnaker.amazon.serverGroup.details.autoscaling.process.controller';
+export const name = AMAZON_SERVERGROUP_DETAILS_SCALINGPROCESSES_MODIFYSCALINGPROCESSES_CONTROLLER; // for backwards compatibility
+angular
+  .module(AMAZON_SERVERGROUP_DETAILS_SCALINGPROCESSES_MODIFYSCALINGPROCESSES_CONTROLLER, [])
+  .controller('ModifyScalingProcessesCtrl', [
+    '$scope',
+    '$uibModalInstance',
+    'application',
+    'serverGroup',
+    'processes',
+    function ($scope, $uibModalInstance, application, serverGroup, processes) {
+      $scope.command = angular.copy(processes);
+      $scope.serverGroup = serverGroup;
+      $scope.verification = {};
+
+      this.isValid = function () {
+        if (!$scope.verification.verified) {
+          return false;
+        }
+        return this.isDirty();
+      };
+
+      const currentlyEnabled = _.chain($scope.command).filter({ enabled: true }).map('name').value();
+      const currentlySuspended = _.chain($scope.command).filter({ enabled: false }).map('name').value();
+
+      this.isDirty = function () {
+        const enabledSelections = _.chain($scope.command).filter({ enabled: true }).map('name').value();
+        const suspendedSelections = _.chain($scope.command).filter({ enabled: false }).map('name').value();
+        const toEnable = _.intersection(currentlySuspended, enabledSelections);
+        const toSuspend = _.intersection(currentlyEnabled, suspendedSelections);
+
+        return !!(toEnable.length || toSuspend.length);
+      };
+
+      $scope.taskMonitor = new TaskMonitor({
+        application: application,
+        title: 'Update Auto Scaling Processes for ' + serverGroup.name,
+        modalInstance: $uibModalInstance,
+        onTaskComplete: () => application.serverGroups.refresh(),
+      });
+
+      this.submit = function () {
+        const enabledSelections = _.chain($scope.command).filter({ enabled: true }).map('name').value();
+        const suspendedSelections = _.chain($scope.command).filter({ enabled: false }).map('name').value();
+        const toEnable = _.intersection(currentlySuspended, enabledSelections);
+        const toSuspend = _.intersection(currentlyEnabled, suspendedSelections);
+
+        const job = [];
+        if (toEnable.length) {
+          job.push({
+            type: 'modifyScalingProcess',
+            action: 'resume',
+            processes: toEnable,
+            asgName: serverGroup.name,
+            regions: [serverGroup.region],
+            credentials: serverGroup.account,
+            cloudProvider: 'aws',
+            reason: $scope.command.reason,
+          });
+        }
+        if (toSuspend.length) {
+          job.push({
+            type: 'modifyScalingProcess',
+            action: 'suspend',
+            processes: toSuspend,
+            asgName: serverGroup.name,
+            regions: [serverGroup.region],
+            credentials: serverGroup.account,
+            cloudProvider: 'aws',
+            reason: $scope.command.reason,
+          });
+        }
+
+        const submitMethod = function () {
+          return TaskExecutor.executeTask({
+            job: job,
+            application: application,
+            description: 'Update Auto Scaling Processes for ' + serverGroup.name,
+          });
+        };
+
+        $scope.taskMonitor.submit(submitMethod);
+      };
+
+      this.cancel = $uibModalInstance.dismiss;
+    },
+  ]);