@spinnaker/amazon 0.0.0-main-2

package/src/validation/ApplicationNameValidator.ts

@@ -0,0 +1,84 @@
+import type { IApplicationNameValidator } from '@spinnaker/core';
+import { ApplicationNameValidator, FirewallLabels } from '@spinnaker/core';
+import { AWSProviderSettings } from '../aws.settings';
+
+class AmazonApplicationNameValidator implements IApplicationNameValidator {
+  private validateSpecialCharacters(name: string, errors: string[]): void {
+    const pattern = /^[a-zA-Z_0-9.]*$/g;
+    if (!pattern.test(name)) {
+      errors.push('Only dot(.) and underscore(_) special characters are allowed.');
+    }
+  }
+
+  private validateClassicLock(warnings: string[]): void {
+    const lockoutDate = AWSProviderSettings.classicLaunchLockout;
+    if (lockoutDate && lockoutDate < new Date().getTime()) {
+      warnings.push(
+        `New applications deployed to AWS are restricted to VPC; you cannot create server groups,
+          load balancers, or ${FirewallLabels.get('firewalls')} in EC2 Classic.`,
+      );
+    }
+  }
+
+  private validateLoadBalancerCharacters(name: string, warnings: string[]) {
+    if (name.includes('.') || name.includes('_')) {
+      warnings.push(`If the application's name contains an underscore(_) or dot(.),
+            you will not be able to create a load balancer,
+            preventing it from being used as a front end service.
+            Any hostname constructed with this application name may have issues.`);
+    }
+  }
+
+  private validateLength(name: string, warnings: string[], errors: string[]) {
+    if (name.length > 250) {
+      errors.push('The maximum length for an application in Amazon is 250 characters.');
+      return;
+    }
+    if (name.length > 240) {
+      if (name.length >= 248) {
+        warnings.push(
+          `You will not be able to include a stack or detail field for clusters or ${FirewallLabels.get('firewalls')}.`,
+        );
+      } else {
+        const remaining = 248 - name.length;
+        warnings.push(`If you plan to include a stack or detail field for clusters, you will only
+            have ~${remaining} characters to do so.`);
+      }
+    }
+    if (name.length > 20) {
+      if (name.length > 32) {
+        warnings.push(`You will not be able to create an Amazon load balancer for this application if the
+            application's name is longer than 32 characters (currently: ${name.length} characters)`);
+      } else {
+        if (name.length >= 30) {
+          warnings.push(`If you plan to create load balancers for this application, be aware that the character limit
+              for load balancer names is 32 (currently: ${name.length} characters). With separators ("-"), you will not
+              be able to add a stack and detail field to any load balancer.`);
+        } else {
+          const remaining = 30 - name.length;
+          warnings.push(`If you plan to create load balancers for this application, be aware that the character limit
+              for load balancer names is 32. You will only have ~${remaining} characters to add a stack or detail
+              field to any load balancer.`);
+        }
+      }
+    }
+  }
+
+  public validate(name = '') {
+    const warnings: string[] = [];
+    const errors: string[] = [];
+
+    if (name.length) {
+      this.validateClassicLock(warnings);
+      this.validateSpecialCharacters(name, errors);
+      this.validateLoadBalancerCharacters(name, warnings);
+      this.validateLength(name, warnings, errors);
+    }
+
+    return {
+      warnings,
+      errors,
+    };
+  }
+}
+ApplicationNameValidator.registerValidator('aws', new AmazonApplicationNameValidator());

package/src/vpc/VpcReader.spec.ts

@@ -0,0 +1,45 @@
+// eslint-disable-next-line @spinnaker/import-from-npm-not-relative
+import { mockHttpClient } from '../../../core/src/api/mock/jasmine';
+import { VpcReader } from '../vpc/VpcReader';
+
+describe('VpcReader', function () {
+  afterEach(function () {
+    VpcReader.resetCache();
+  });
+
+  it('adds label to vpc, including (deprecated) if deprecated field is true', async function () {
+    const http = mockHttpClient({ autoFlush: true });
+    http.expectGET('/networks/aws').respond(200, [
+      { name: 'vpc1', id: 'vpc-1', deprecated: true },
+      { name: 'vpc2', id: 'vpc-2', deprecated: false },
+      { name: 'vpc3', id: 'vpc-3' },
+    ]);
+
+    const vpcs = await VpcReader.listVpcs();
+
+    expect(vpcs[0].label).toBe('vpc1 (deprecated)');
+    expect(vpcs[0].deprecated).toBe(true);
+    expect(vpcs[1].label).toBe('vpc2');
+    expect(vpcs[1].deprecated).toBe(false);
+    expect(vpcs[2].label).toBe('vpc3');
+    expect(vpcs[2].deprecated).toBe(false);
+  });
+
+  it('retrieves vpc name - not label - from id', async function () {
+    const http = mockHttpClient({ autoFlush: true });
+    http.expectGET('/networks/aws').respond(200, [
+      { name: 'vpc1', id: 'vpc-1', deprecated: true },
+      { name: 'vpc2', id: 'vpc-2', deprecated: false },
+      { name: 'vpc3', id: 'vpc-3' },
+    ]);
+
+    const vpc1 = await VpcReader.getVpcName('vpc-1');
+    expect(vpc1).toBe('vpc1');
+
+    const vpc2 = await VpcReader.getVpcName('vpc-2');
+    expect(vpc2).toBe('vpc2');
+
+    const vpc4 = await VpcReader.getVpcName('vpc-4');
+    expect(vpc4).toBe(null);
+  });
+});

package/src/vpc/VpcReader.ts

@@ -0,0 +1,36 @@
+import type { IVpc } from '@spinnaker/core';
+import { NetworkReader } from '@spinnaker/core';
+
+export class VpcReader {
+  private static cache: PromiseLike<IVpc[]>;
+
+  public static listVpcs(): PromiseLike<IVpc[]> {
+    if (this.cache) {
+      return this.cache;
+    }
+    this.cache = NetworkReader.listNetworksByProvider('aws').then((vpcs: IVpc[]) => {
+      return vpcs.map((vpc) => {
+        vpc.label = vpc.name;
+        vpc.deprecated = !!vpc.deprecated;
+        if (vpc.deprecated) {
+          vpc.label += ' (deprecated)';
+        }
+        return vpc;
+      });
+    });
+    return this.cache;
+  }
+
+  public static resetCache() {
+    this.cache = null;
+  }
+
+  public static getVpcName(id: string) {
+    return this.listVpcs().then((vpcs) => {
+      const match = vpcs.find((test) => {
+        return test.id === id;
+      });
+      return match ? match.name : null;
+    });
+  }
+}

package/src/vpc/VpcTag.spec.tsx

@@ -0,0 +1,37 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { VpcTag } from './VpcTag';
+import { VpcReader } from '../vpc/VpcReader';
+
+const tick = () => new Promise((resolve) => setTimeout(resolve));
+
+describe('VpcTag', function () {
+  describe('vpc tag rendering - no VPC provided', function () {
+    it('displays default message when no vpcId supplied', function () {
+      const component = mount(<VpcTag vpcId={undefined} />);
+      expect(component.text()).toBe('None (EC2 Classic)');
+    });
+
+    it('displays default message when null vpcId supplied', function () {
+      const component = mount(<VpcTag vpcId={null} />);
+      expect(component.text()).toBe('None (EC2 Classic)');
+    });
+  });
+
+  describe('vpc tag rendering - VPC provided', function () {
+    it('displays vpc name when found', async function () {
+      spyOn(VpcReader, 'getVpcName').and.returnValue(Promise.resolve('Main VPC'));
+      const component = mount(<VpcTag vpcId="vpc-1" />);
+      await tick();
+      expect(component.text()).toBe('Main VPC (vpc-1)');
+    });
+
+    it('displays vpc id when not found', async function () {
+      spyOn(VpcReader, 'getVpcName').and.returnValue(Promise.resolve(null));
+      const component = mount(<VpcTag vpcId="vpc-2" />);
+      await tick();
+      expect(component.text()).toBe('(vpc-2)');
+    });
+  });
+});

package/src/vpc/VpcTag.tsx

@@ -0,0 +1,24 @@
+import React from 'react';
+import { useData } from '@spinnaker/core';
+import { VpcReader } from './VpcReader';
+
+export interface IVpcTagProps {
+  vpcId: string;
+}
+
+const defaultLabel = 'None (EC2 Classic)';
+
+export function VpcTag(props: IVpcTagProps) {
+  const { vpcId } = props;
+  const fetchVpcLabel = useData(
+    async () => {
+      const name = await VpcReader.getVpcName(props.vpcId);
+      return name ? `${name} (${props.vpcId})` : `(${props.vpcId})`;
+    },
+    defaultLabel,
+    [vpcId],
+  );
+
+  const label = vpcId ? fetchVpcLabel.result : defaultLabel;
+  return <span className="vpc-tag">{label}</span>;
+}

package/src/vpc/index.ts

@@ -0,0 +1 @@
+export * from './VpcReader';

package/src/vpc/vpc.module.ts

@@ -0,0 +1,9 @@
+import { module } from 'angular';
+import { react2angular } from 'react2angular';
+
+import { withErrorBoundary } from '@spinnaker/core';
+
+import { VpcTag } from './VpcTag';
+
+export const VPC_MODULE = 'spinnaker.amazon.vpc';
+module(VPC_MODULE, []).component('vpcTag', react2angular(withErrorBoundary(VpcTag, 'vpcTag'), ['vpcId']));