@spinnaker/amazon 0.0.0-main-2

package/src/domain/IAmazonLoadBalancerSourceData.ts

@@ -0,0 +1,188 @@
+import type { ILoadBalancerSourceData } from '@spinnaker/core';
+
+import type { IListenerAction, NLBListenerProtocol } from './IAmazonLoadBalancer';
+
+import type { IListenerRule } from './IAmazonLoadBalancer';
+
+export interface IAmazonContainerServerGroupSourceData {
+  detachedInstances: string[];
+  isDisabled: boolean;
+  name: string;
+  region: string;
+}
+
+export interface IAmazonLoadBalancerServerGroupSourceData extends IAmazonContainerServerGroupSourceData {
+  instances: IAmazonLoadBalancerInstanceSourceData[];
+}
+
+export interface IAmazonTargetGroupServerGroupSourceData extends IAmazonContainerServerGroupSourceData {
+  instances: IAmazonTargetGroupInstanceSourceData[];
+}
+
+export interface IAmazonInstanceHealthSourceData {
+  type: string;
+  state: 'InService' | 'OutOfService' | 'Unknown';
+  reasonCode: 'ELB' | 'Instance' | 'N/A';
+  description: string;
+}
+
+export interface IAmazonTargetHealthSourceData {
+  description: string;
+  reason: string;
+  state: 'initial' | 'healthy' | 'unhealthy' | 'unused' | 'draining';
+}
+
+export interface IClassicListenerSourceData {
+  instancePort: number;
+  instanceProtocol: string;
+  loadBalancerPort: number;
+  protocol: string;
+}
+
+export interface IAmazonLoadBalancerSourceData extends ILoadBalancerSourceData {
+  account: string;
+  availabilityZones: string[];
+  cloudProvider: string;
+  createdTime: number;
+  dnsname: string;
+  loadBalancerName: string;
+  loadBalancerType?: string;
+  name: string;
+  region: string;
+  scheme: 'internal' | 'internet-facing';
+  securityGroups: string[];
+  serverGroups: IAmazonLoadBalancerServerGroupSourceData[];
+  subnets: string[];
+  type: string;
+  vpcId: string;
+  // Some of the backend in clouddriver returns a vpcid (lowecase) only,
+  // and was cached with some of that. Until caches roll off and we are
+  // sure clouddriver is cleaed up, leave this dirtiness in here
+  vpcid?: string;
+}
+
+export interface IAmazonLoadBalancerInstanceSourceData {
+  id: string;
+  zone: string;
+  health: IAmazonInstanceHealthSourceData;
+}
+
+export interface IAmazonTargetGroupInstanceSourceData {
+  id: string;
+  zone: string;
+  health: IAmazonTargetHealthSourceData;
+}
+
+export interface IAmazonTargetGroupSourceData {
+  account: string;
+  attributes: {
+    'deregistration_delay.timeout_seconds': number;
+    'stickiness.enabled': boolean;
+    'stickiness.lb_cookie.duration_seconds': number;
+    'stickiness.type': 'lb_cookie';
+    'lambda.multi_value_headers.enabled': boolean;
+  };
+  cloudProvider: string;
+  healthCheckIntervalSeconds: number;
+  healthCheckPath: string;
+  healthCheckPort: string;
+  healthCheckProtocol: string;
+  healthCheckTimeoutSeconds: number;
+  healthyThresholdCount: number;
+  instances: string[];
+  loadBalancerNames: string[];
+  matcher: {
+    httpCode: string;
+  };
+  name: string;
+  port: number;
+  protocol: string;
+  region: string;
+  serverGroups: IAmazonTargetGroupServerGroupSourceData[];
+  targetGroupArn: string;
+  targetGroupName: string;
+  targetType: string;
+  type: string;
+  unhealthyThresholdCount: number;
+  vpcId: string;
+}
+
+export interface IApplicationLoadBalancerCertificateSourceData {
+  certificateArn: string;
+}
+
+export interface IApplicationLoadBalancerListenerSourceData {
+  certificates?: IApplicationLoadBalancerCertificateSourceData[];
+  defaultActions: IListenerAction[];
+  listenerArn: string;
+  loadBalancerName: string;
+  port: number;
+  protocol: 'HTTP' | 'HTTPS';
+  rules: IListenerRule[];
+  sslPolicy?: string;
+}
+
+export interface IApplicationLoadBalancerSourceData extends IAmazonLoadBalancerSourceData {
+  ipAddressType: 'ipv4' | 'dualstack';
+  listeners: IApplicationLoadBalancerListenerSourceData[];
+  loadBalancerArn: string;
+  loadBalancerType: 'application';
+  state: {
+    code: 'active' | 'provisioning' | 'failed';
+    reason?: string;
+  };
+  targetGroups: IAmazonTargetGroupSourceData[];
+}
+
+export interface INetworkLoadBalancerListenerSourceData {
+  certificates?: IApplicationLoadBalancerCertificateSourceData[];
+  defaultActions: Array<{
+    targetGroupName: string;
+    type: 'forward';
+  }>;
+  listenerArn: string;
+  loadBalancerName: string;
+  port: number;
+  protocol: NLBListenerProtocol;
+  rules: IListenerRule[];
+  sslPolicy?: string;
+}
+
+export interface INetworkLoadBalancerSourceData extends IAmazonLoadBalancerSourceData {
+  ipAddressType: 'ipv4' | 'dualstack';
+  listeners: INetworkLoadBalancerListenerSourceData[];
+  loadBalancerArn: string;
+  loadBalancerType: 'network';
+  state: {
+    code: 'active' | 'provisioning' | 'failed';
+    reason?: string;
+  };
+  targetGroups: IAmazonTargetGroupSourceData[];
+}
+
+export interface IClassicLoadBalancerSourceData extends IAmazonLoadBalancerSourceData {
+  healthCheck: {
+    healthyThreshold: number;
+    interval: number;
+    target: string;
+    timeout: number;
+    unhealthyThreshold: number;
+  };
+  instances: string[];
+  listenerDescriptions: Array<{ listener: IClassicListenerSourceData; policyNames: string[] }>;
+  policies: {
+    appCookieStickinessPolicies: Array<{
+      CookieName: string;
+      PolicyName: string;
+    }>;
+    lbcookieStickinessPolicies: Array<{
+      CookieExpirationPeriod: string;
+      PolicyName: string;
+    }>;
+    otherPolicies: any[];
+  };
+  sourceSecurityGroup: {
+    groupName: string;
+    ownerAlias: string;
+  };
+}

package/src/domain/IAmazonScalingPolicy.ts

@@ -0,0 +1,26 @@
+import type { IScalingPolicy, IScalingPolicyAlarm, IStepAdjustment } from './IScalingPolicy';
+import type { ITargetTrackingConfiguration } from './ITargetTrackingPolicy';
+
+export interface IScalingAdjustmentView extends IStepAdjustment {
+  operator: string;
+  absAdjustment: number;
+}
+
+export interface IScalingPolicyAlarmView extends IScalingPolicyAlarm {
+  name?: string;
+  description?: string;
+  disableEditingDimensions?: boolean;
+  comparator?: '<' | '>' | '≤' | '≥';
+}
+
+export interface IScalingPolicyView extends IScalingPolicy, IScalingAdjustmentView {
+  alarms: IScalingPolicyAlarmView[];
+  stepAdjustments: IStepAdjustmentView[];
+  operator: string;
+  targetTrackingConfiguration?: ITargetTrackingConfiguration;
+}
+
+export interface IStepAdjustmentView extends IScalingAdjustmentView, IStepAdjustment {
+  metricIntervalLowerBound: number;
+  metricIntervalUpperBound: number;
+}

package/src/domain/IAmazonSecurityGroup.ts

@@ -0,0 +1,4 @@
+export interface IAmazonSecurityGroup {
+  groupId: string;
+  groupName: string;
+}

package/src/domain/IAmazonServerGroup.ts

@@ -0,0 +1,74 @@
+import type { IAccountDetails, IAsg, IServerGroup } from '@spinnaker/core';
+
+import type { IAmazonLaunchTemplate } from './IAmazonLaunchTemplate';
+import type { IScalingPolicyView } from './IAmazonScalingPolicy';
+import type { IScalingPolicy } from './IScalingPolicy';
+import type { ISuspendedProcess } from './IScalingProcess';
+
+export interface IAmazonAsgTag {
+  key: string;
+  value: string;
+  propagateAtLaunch: boolean;
+  resourceId: string;
+  resourceType: string;
+}
+
+export interface IAmazonAsg extends IAsg {
+  availabilityZones: string[];
+  autoScalingGroupName: string;
+  defaultCooldown: number;
+  healthCheckType: string;
+  healthCheckGracePeriod: number;
+  loadBalancerNames: string[];
+  terminationPolicies: string[];
+  enabledMetrics: Array<{ metric: string }>;
+  vpczoneIdentifier?: string;
+  suspendedProcesses?: ISuspendedProcess[];
+  capacityRebalance?: boolean;
+  tags: IAmazonAsgTag[];
+}
+
+export interface IAmazonServerGroup extends IServerGroup {
+  image?: any;
+  scalingPolicies?: IScalingPolicy[];
+  targetGroups?: string[];
+  asg: IAmazonAsg;
+  awsAccount?: string;
+  launchTemplate?: IAmazonLaunchTemplate;
+  mixedInstancesPolicy?: IAmazonMixedInstancesPolicy;
+}
+
+export interface IScheduledAction {
+  recurrence: number;
+  minSize: number;
+  maxSize: number;
+  desiredCapacity: number;
+}
+
+export interface IAmazonMixedInstancesPolicy {
+  allowedInstanceTypes: string[];
+  instancesDistribution: IAmazonInstancesDistribution;
+  launchTemplates: IAmazonLaunchTemplate[];
+  launchTemplateOverridesForInstanceType: IAmazonLaunchTemplateOverrides[];
+}
+
+export interface IAmazonInstancesDistribution {
+  onDemandAllocationStrategy: string;
+  onDemandBaseCapacity: number;
+  onDemandPercentageAboveBaseCapacity: number;
+  spotAllocationStrategy: string;
+  spotInstancePools?: number;
+  spotMaxPrice: string;
+}
+
+export interface IAmazonLaunchTemplateOverrides {
+  instanceType: string;
+  weightedCapacity?: string;
+  priority?: number;
+}
+
+export interface IAmazonServerGroupView extends IAmazonServerGroup {
+  accountDetails?: IAccountDetails;
+  scalingPolicies: IScalingPolicyView[];
+  scheduledActions?: IScheduledAction[];
+}

package/src/domain/IKeyPair.ts

@@ -0,0 +1,6 @@
+export interface IKeyPair {
+  account: string;
+  region: string;
+  keyName: string;
+  keyFingerprint: string;
+}

package/src/domain/IScalingPolicy.ts

@@ -0,0 +1,85 @@
+import type { IMetricAlarmDimension } from '@spinnaker/core';
+
+export interface IScalingPolicyAlarm {
+  alarmName?: string;
+  alarmArn?: string;
+  alarmActionArns?: string[];
+  metricName: string;
+  namespace: string;
+  statistic: AlarmStatisticType;
+  dimensions: IMetricAlarmDimension[];
+  period: number;
+  threshold: number;
+  comparisonOperator: AlarmComparisonOperator;
+  okactions?: string[];
+  insufficientDataActions?: string[];
+  alarmActions?: string[];
+  evaluationPeriods?: number;
+  alarmDescription?: string;
+  unit?: StandardUnitType;
+}
+
+export type ScalingPolicyAdjustmentType = 'ChangeInCapacity' | 'ExactCapacity' | 'PercentChangeInCapacity';
+
+export type MetricAggregationType = 'Minimum' | 'Maximum' | 'Average';
+
+export type AlarmComparisonOperator =
+  | 'GreaterThanOrEqualToThreshold'
+  | 'GreaterThanThreshold'
+  | 'LessThanThreshold'
+  | 'LessThanOrEqualToThreshold';
+
+export type AlarmStatisticType = 'SampleCount' | 'Average' | 'Sum' | 'Minimum' | 'Maximum';
+
+export type StandardUnitType =
+  | 'Seconds'
+  | 'Microseconds'
+  | 'Milliseconds'
+  | 'Bytes'
+  | 'Kilobytes'
+  | 'Megabytes'
+  | 'Gigabytes'
+  | 'Terabytes'
+  | 'Bits'
+  | 'Kilobits'
+  | 'Megabits'
+  | 'Gigabits'
+  | 'Terabits'
+  | 'Percent'
+  | 'Count'
+  | 'BytesSecond'
+  | 'KilobytesSecond'
+  | 'MegabytesSecond'
+  | 'GigabytesSecond'
+  | 'TerabytesSecond'
+  | 'BitsSecond'
+  | 'KilobitsSecond'
+  | 'MegabitsSecond'
+  | 'GigabitsSecond'
+  | 'TerabitsSecond'
+  | 'CountSecond'
+  | 'None';
+
+export interface IStepAdjustment {
+  metricIntervalLowerBound?: number;
+  metricIntervalUpperBound?: number;
+  scalingAdjustment?: number;
+}
+
+export interface IScalingPolicy {
+  policyARN?: string;
+  policyName?: string;
+  policyType?: string;
+  id?: string;
+  adjustmentType?: ScalingPolicyAdjustmentType;
+  alarms: IScalingPolicyAlarm[];
+
+  stepAdjustments?: IStepAdjustment[]; // step
+  metricAggregationType?: MetricAggregationType; // step
+  estimatedInstanceWarmup?: number; // step
+
+  minAdjustmentStep?: number; // simple
+  cooldown?: number; // simple
+  minAdjustmentMagnitude?: number; // simple
+  scalingAdjustment?: number; // simple
+}

package/src/domain/IScalingProcess.ts

@@ -0,0 +1,11 @@
+export interface IScalingProcess {
+  name: string;
+  enabled?: boolean;
+  description: string;
+  suspensionDate?: number;
+}
+
+export interface ISuspendedProcess {
+  processName: string;
+  suspensionReason: string;
+}

package/src/domain/ITargetTrackingPolicy.ts

@@ -0,0 +1,31 @@
+import type { AlarmStatisticType, IScalingPolicy } from './IScalingPolicy';
+
+export interface ITargetTrackingPolicy extends IScalingPolicy {
+  autoScalingGroupName?: string;
+  targetTrackingConfiguration: ITargetTrackingConfiguration;
+}
+
+export interface ITargetTrackingConfiguration {
+  customizedMetricSpecification?: ICustomizedMetricSpecification;
+  predefinedMetricSpecification?: IPredefinedMetricSpecification;
+  disableScaleIn?: boolean;
+  targetValue: number;
+}
+
+export interface ICustomizedMetricSpecification {
+  metricName: string;
+  namespace: string;
+  dimensions: any[];
+  statistic: AlarmStatisticType;
+}
+
+export interface IPredefinedMetricSpecification {
+  predefinedMetricType: PredefinedMetricType;
+  resourceLabel?: string;
+}
+
+export type PredefinedMetricType =
+  | 'ASGAverageCPUUtilization'
+  | 'ASGAverageNetworkIn'
+  | 'ASGAverageNetworkOut'
+  | 'ALBRequestCountPerTarget';

package/src/domain/index.ts

@@ -0,0 +1,15 @@
+export * from './IAmazonBlockDeviceMapping';
+export * from './IAmazonCertificate';
+export * from './IAmazonInstance';
+export * from './IAmazonLaunchTemplate';
+export * from './IAmazonLoadBalancer';
+export * from './IAmazonFunction';
+export * from './IAmazonLoadBalancerSourceData';
+export * from './IAmazonFunctionSourceData';
+export * from './IAmazonHealth';
+export * from './IAmazonScalingPolicy';
+export * from './IAmazonServerGroup';
+export * from './IKeyPair';
+export * from './IScalingPolicy';
+export * from './IScalingProcess';
+export * from './ITargetTrackingPolicy';

package/src/function/CreateLambdaFunction.tsx

@@ -0,0 +1,228 @@
+import { cloneDeep } from 'lodash';
+import React from 'react';
+
+import type { IFunctionModalProps } from '@spinnaker/core';
+import { FunctionWriter, noop, ReactInjector, ReactModal, TaskMonitor, WizardModal, WizardPage } from '@spinnaker/core';
+
+import { ExecutionRole } from './configure/ExecutionRole';
+import { FunctionBasicInformation } from './configure/FunctionBasicInformation';
+import { FunctionDebugAndErrorHandling } from './configure/FunctionDebugAndErrorHandling';
+import { FunctionEnvironmentVariables } from './configure/FunctionEnvironmentVariables';
+import { FunctionSettings } from './configure/FunctionSettings';
+import { FunctionTags } from './configure/FunctionTags';
+import { Network } from './configure/Network';
+import type { IAmazonFunction, IAmazonFunctionUpsertCommand } from '../domain';
+import { AwsFunctionTransformer } from './function.transformer';
+
+export interface IAmazonCreateFunctionProps extends IFunctionModalProps {
+  functionDef: IAmazonFunction;
+}
+export interface IAmazonCreateFunctionState {
+  isNew: boolean;
+  functionCommand: IAmazonFunctionUpsertCommand;
+  taskMonitor: TaskMonitor;
+}
+
+export class CreateLambdaFunction extends React.Component<IAmazonCreateFunctionProps, IAmazonCreateFunctionState> {
+  public static defaultProps: Partial<IAmazonCreateFunctionProps> = {
+    closeModal: noop,
+    dismissModal: noop,
+  };
+
+  constructor(props: IAmazonCreateFunctionProps) {
+    super(props);
+    const functionTransformer = new AwsFunctionTransformer();
+    const funcCommand = props.functionDef
+      ? functionTransformer.convertFunctionForEditing(props.functionDef)
+      : functionTransformer.constructNewAwsFunctionTemplate(props.app);
+    this.state = {
+      isNew: !props.functionDef,
+      functionCommand: funcCommand,
+      taskMonitor: null,
+    };
+  }
+
+  private _isUnmounted = false;
+  private refreshUnsubscribe: () => void;
+
+  public static show(props: IAmazonCreateFunctionProps): Promise<IAmazonFunctionUpsertCommand> {
+    const modalProps = { dialogClassName: 'wizard-modal modal-lg' };
+    return ReactModal.show(CreateLambdaFunction, props, modalProps);
+  }
+
+  public componentWillUnmount(): void {
+    this._isUnmounted = true;
+    if (this.refreshUnsubscribe) {
+      this.refreshUnsubscribe();
+    }
+  }
+
+  protected onApplicationRefresh(values: IAmazonFunctionUpsertCommand): void {
+    if (this._isUnmounted) {
+      return;
+    }
+
+    this.refreshUnsubscribe = undefined;
+    this.props.dismissModal();
+    this.setState({ taskMonitor: undefined });
+    const newStateParams = {
+      name: values.name,
+      accountId: values.credentials,
+      region: values.region,
+      vpcId: values.vpcId,
+      provider: 'aws',
+    };
+
+    if (!ReactInjector.$state.includes('**.functionDetails')) {
+      ReactInjector.$state.go('.functionDetails', newStateParams);
+    } else {
+      ReactInjector.$state.go('^.functionDetails', newStateParams);
+    }
+  }
+
+  private onTaskComplete(values: IAmazonFunctionUpsertCommand): void {
+    this.props.app.functions.refresh();
+    this.refreshUnsubscribe = this.props.app.functions.onNextRefresh(null, () => this.onApplicationRefresh(values));
+  }
+
+  private checkForS3Update(functionCommandFormatted: IAmazonFunctionUpsertCommand, descriptor: string): void {
+    const { isNew } = this.state;
+    if (!isNew && (functionCommandFormatted.s3bucket || functionCommandFormatted.s3key)) {
+      functionCommandFormatted.operation = 'updateLambdaFunctionCode';
+      const { app } = this.props;
+      FunctionWriter.upsertFunction(functionCommandFormatted, app, descriptor);
+    }
+    this.onTaskComplete(functionCommandFormatted);
+  }
+
+  private submit = (values: IAmazonFunctionUpsertCommand): void => {
+    const { app } = this.props;
+    const { isNew } = this.state;
+    const functionCommandFormatted = cloneDeep(values);
+
+    const descriptor = isNew ? 'Create' : 'Update';
+
+    const taskMonitor = new TaskMonitor({
+      application: app,
+      title: `${isNew ? 'Creating' : 'Updating'} your function`,
+      modalInstance: TaskMonitor.modalInstanceEmulation(() => this.props.dismissModal()),
+      onTaskComplete: () => {
+        this.checkForS3Update(functionCommandFormatted, descriptor);
+      },
+    });
+
+    taskMonitor.submit(() => {
+      functionCommandFormatted.type = 'lambdaFunction';
+      if (!isNew) {
+        functionCommandFormatted.operation = 'updateLambdaFunctionConfiguration';
+      } else {
+        functionCommandFormatted.operation = 'createLambdaFunction';
+      }
+      return FunctionWriter.upsertFunction(functionCommandFormatted, app, descriptor);
+    });
+    this.setState({ taskMonitor });
+  };
+
+  public render() {
+    const { app, dismissModal, forPipelineConfig, functionDef } = this.props;
+    const { isNew, functionCommand, taskMonitor } = this.state;
+
+    let heading = forPipelineConfig ? 'Configure Existing Function' : 'Create New Function';
+    if (!isNew) {
+      heading = `Edit ${functionCommand.functionName}: ${functionCommand.region}: ${functionCommand.credentials}`;
+    }
+
+    return (
+      <WizardModal<IAmazonFunctionUpsertCommand>
+        heading={heading}
+        initialValues={functionCommand}
+        taskMonitor={taskMonitor}
+        dismissModal={dismissModal}
+        closeModal={this.submit}
+        submitButtonLabel={forPipelineConfig ? (isNew ? 'Add' : 'Done') : isNew ? 'Create' : 'Update'}
+        render={({ formik, nextIdx, wizard }) => {
+          return (
+            <>
+              <WizardPage
+                label="Basic information"
+                wizard={wizard}
+                order={nextIdx()}
+                render={({ innerRef }) => (
+                  <FunctionBasicInformation
+                    ref={innerRef}
+                    app={app}
+                    formik={formik}
+                    isNew={isNew}
+                    functionDef={functionDef}
+                  />
+                )}
+              />
+              <WizardPage
+                label="Execution Role"
+                wizard={wizard}
+                order={nextIdx()}
+                render={({ innerRef }) => {
+                  return <ExecutionRole ref={innerRef} formik={formik} isNew={isNew} functionDef={functionDef} />;
+                }}
+              />
+              <WizardPage
+                label="Environment"
+                wizard={wizard}
+                order={nextIdx()}
+                render={({ innerRef }) => {
+                  return (
+                    <FunctionEnvironmentVariables
+                      ref={innerRef}
+                      formik={formik}
+                      isNew={isNew}
+                      functionDef={functionDef}
+                    />
+                  );
+                }}
+              />
+              <WizardPage
+                label="Tags"
+                wizard={wizard}
+                order={nextIdx()}
+                render={({ innerRef }) => {
+                  return <FunctionTags ref={innerRef} formik={formik} isNew={isNew} functionDef={functionDef} />;
+                }}
+              />
+              <WizardPage
+                label="Settings"
+                wizard={wizard}
+                order={nextIdx()}
+                render={({ innerRef }) => {
+                  return <FunctionSettings ref={innerRef} formik={formik} isNew={isNew} functionDef={functionDef} />;
+                }}
+              />
+              <WizardPage
+                label="Network"
+                wizard={wizard}
+                order={nextIdx()}
+                render={({ innerRef }) => {
+                  return <Network ref={innerRef} app={app} formik={formik} isNew={isNew} />;
+                }}
+              />
+              <WizardPage
+                label="Debugging and Error Handling"
+                wizard={wizard}
+                order={nextIdx()}
+                render={({ innerRef }) => {
+                  return (
+                    <FunctionDebugAndErrorHandling
+                      ref={innerRef}
+                      formik={formik}
+                      isNew={isNew}
+                      functionDef={functionDef}
+                    />
+                  );
+                }}
+              />
+            </>
+          );
+        }}
+      />
+    );
+  }
+}