@spinnaker/amazon 0.11.1 → 0.12.3

package/src/instance/awsInstanceType.service.spec.js

@@ -134,80 +134,46 @@ describe('Service: InstanceType', function () {
     });
   });
 
-  describe('isBurstingSupported', function () {
-    it('identifies burstable performance instance types correctly', function () {
-      const types = ['t2.small', 't3.nano', 't3a.medium', 't4g.large', 'm5.small', 'r5.4xlarge'];
-      const service = this.awsInstanceTypeService;
-
-      let supportedInstanceTypes = [];
-      for (it of types) {
-        const actualResult = service.isBurstingSupported(it);
-        if (actualResult) {
-          supportedInstanceTypes.push(it);
-        }
-      }
-
-      expect(supportedInstanceTypes).toEqual(['t2.small', 't3.nano', 't3a.medium', 't4g.large']);
+  describe('isBurstingSupportedForAllTypes', function () {
+    const testInputs = [
+      { types: ['t2.small', 't3.nano', 't3a.medium', 't4g.large'], result: true },
+      { types: ['m5.large'], result: false },
+      { types: ['t2.small', 't3.nano', 't3a.medium', 't4g.large', 'm5.small'], result: false },
+      { types: ['t2.small', 'r5.large'], result: false },
+      { types: ['invalid'], result: false },
+      { types: [], result: false },
+      { types: null, result: false },
+    ];
+
+    testInputs.forEach((testInput) => {
+      it(`identifies if bursting is supported for all instance types passed correctly for ${testInput.types}`, function () {
+        const actualResult = this.awsInstanceTypeService.isBurstingSupportedForAllTypes(testInput.types);
+        expect(actualResult).toEqual(testInput.result);
+      });
     });
   });
 
-  describe('isInstanceTypeInCategory', function () {
-    it('identifies instance types in category correctly', function () {
-      const input = [
-        { type: 'm5.large', cat: 'general' },
-        { type: 't2.small', cat: 'general' },
-        { type: 't2.medium', cat: 'general' },
-        { type: 'r5.large', cat: 'memory' },
-        { type: 'r5.xlarge', cat: 'memory' },
-        { type: 't2.nano', cat: 'micro' },
-        { type: 't2.micro', cat: 'micro' },
-        { type: 't2.small', cat: 'micro' },
-        { type: 't3.nano', cat: 'micro' },
-        { type: 't3.micro', cat: 'micro' },
-        { type: 't3.small', cat: 'micro' },
-        { type: 'm3.small', cat: 'custom' },
-        { type: 'a1.medium', cat: 'custom' },
-      ];
-      let service = this.awsInstanceTypeService;
-
-      for (let test of input) {
-        expect(service.isInstanceTypeInCategory(test.type, test.cat)).toBeTrue();
-      }
-    });
-
-    it('returns false for instance types NOT in category', function () {
-      const input = [
-        { type: 't2.nano', cat: 'general' },
-        { type: 't3.nano', cat: 'general' },
-        { type: 't2.micro', cat: 'general' },
-        { type: 't3.micro', cat: 'general' },
-        { type: 't2.medium', cat: 'micro' },
-        { type: 't3.medium', cat: 'micro' },
-      ];
-      let service = this.awsInstanceTypeService;
-
-      for (let test of input) {
-        expect(service.isInstanceTypeInCategory(test.type, test.cat)).toBeFalse();
-      }
-    });
-
-    it('returns undefined for instance families NOT in category or invalid input', function () {
-      const input = [
-        { type: 'm5.large', cat: 'memory' },
-        { type: 't2.small', cat: 'memory' },
-        { type: 't3.something', cat: 'memory' },
-        { type: 'r5.xlarge', cat: 'micro' },
-        { type: 'm5.large', cat: 'invalid' },
-        { type: 't2.invalid', cat: 'memory' },
-        { type: 't3.invalid', cat: 'memory' },
-        { type: 'invalid', cat: 'micro' },
-        { type: 'invalid', cat: 'invalid' },
-      ];
-      let service = this.awsInstanceTypeService;
-
-      for (let test of input) {
-        expect(service.isInstanceTypeInCategory(test.type, test.cat)).toBeFalsy();
-      }
+  describe('getInstanceTypesInCategory', function () {
+    const testInputs = [
+      { types: ['m5.large'], cat: 'general', result: ['m5.large'] },
+      { types: ['t2.small', 't2.medium'], cat: 'general', result: ['t2.small', 't2.medium'] },
+      { types: ['r5.large', 'r5.xlarge'], cat: 'memory', result: ['r5.large', 'r5.xlarge'] },
+      { types: ['t2.nano', 't2.micro', 't2.small'], cat: 'micro', result: ['t2.nano', 't2.micro', 't2.small'] },
+      { types: ['t3.nano', 't3.micro', 't3.small'], cat: 'micro', result: ['t3.nano', 't3.micro', 't3.small'] },
+      { types: ['m3.small', 'a1.medium'], cat: 'custom', result: ['m3.small', 'a1.medium'] },
+      { types: ['t3.nano', 'm3.large', 'r5.large'], cat: 'micro', result: ['t3.nano'] },
+      { types: ['m5.small', 'r5.large'], cat: 'memory', result: ['r5.large'] },
+      { types: ['invalid'], cat: 'micro', result: [] },
+      { types: ['invalid'], cat: 'invalid', result: [] },
+      { types: ['t2.invalid'], cat: 'micro', result: [] },
+      { types: ['m5.small', 'a1.medium'], cat: 'general', result: [] },
+    ];
+
+    testInputs.forEach((testInput) => {
+      it(`identifies instance types in category correctly for ${testInput.types}`, function () {
+        const actual = this.awsInstanceTypeService.getInstanceTypesInCategory(testInput.types, testInput.cat);
+        expect(actual).toEqual(testInput.result);
+      });
     });
   });
 });

package/src/instance/awsInstanceType.service.ts

@@ -0,0 +1,191 @@
+import type { IQService } from 'angular';
+import { module } from 'angular';
+import _ from 'lodash';
+
+import type {
+  IInstanceType,
+  IInstanceTypeCategory,
+  IInstanceTypesByRegion,
+  IPreferredInstanceType,
+} from '@spinnaker/core';
+import { REST } from '@spinnaker/core';
+
+import { categories, defaultCategories } from './awsInstanceTypes';
+
+export interface IAmazonPreferredInstanceType extends IPreferredInstanceType {
+  cpuCreditsPerHour?: number;
+}
+
+export interface IAmazonInstanceTypeCategory extends IInstanceTypeCategory {
+  showCpuCredits?: boolean;
+  descriptionListOverride?: string[];
+}
+
+export const AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE = 'spinnaker.amazon.instanceType.service';
+export const name = AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE; // for backwards compatibility
+
+module(AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE, []).factory('awsInstanceTypeService', [
+  '$q',
+  function ($q: IQService) {
+    function getCategories() {
+      return $q.when(categories);
+    }
+
+    const getAllTypesByRegion = function getAllTypesByRegion(): PromiseLike<IInstanceTypesByRegion> {
+      return REST('/instanceTypes')
+        .get()
+        .then(function (types) {
+          return _.chain(types)
+            .map(function (type: IInstanceType) {
+              return {
+                region: type.region,
+                account: type.account,
+                name: type.name,
+                key: [type.region, type.account, type.name].join(':'),
+              };
+            })
+            .uniqBy('key')
+            .groupBy('region')
+            .value();
+        });
+    };
+
+    const instanceClassOrder = ['xlarge', 'large', 'medium', 'small', 'micro', 'nano'];
+
+    function sortTypesByFamilyAndSize(o1: string, o2: string) {
+      const type1 = o1.split('.');
+      const type2 = o2.split('.');
+
+      const [family1, class1 = ''] = type1;
+      const [family2, class2 = ''] = type2;
+
+      if (family1 !== family2) {
+        if (family1 > family2) {
+          return 1;
+        } else if (family1 < family2) {
+          return -1;
+        }
+        return 0;
+      }
+
+      const t1Idx = instanceClassOrder.findIndex((el) => class1.endsWith(el));
+      const t2Idx = instanceClassOrder.findIndex((el) => class2.endsWith(el));
+
+      if (t1Idx === -1 || t2Idx === -1) {
+        return 0;
+      }
+
+      if (t1Idx === 0 && t2Idx === 0) {
+        const size1 = parseInt(class1.replace('xlarge', '')) || 0;
+        const size2 = parseInt(class2.replace('xlarge', '')) || 0;
+
+        if (size2 < size1) {
+          return 1;
+        } else if (size2 > size1) {
+          return -1;
+        }
+        return 0;
+      }
+
+      if (t1Idx > t2Idx) {
+        return -1;
+      } else if (t1Idx < t2Idx) {
+        return 1;
+      }
+      return 0;
+    }
+
+    function getAvailableTypesForRegions(availableInstanceTypes: IInstanceTypesByRegion, selectedRegions: string[]) {
+      selectedRegions = selectedRegions || [];
+      let availableTypes: string[] = [];
+
+      // prime the list of available types
+      if (selectedRegions && selectedRegions.length) {
+        availableTypes = _.map(availableInstanceTypes[selectedRegions[0]], 'name');
+      }
+
+      // this will perform an unnecessary intersection with the first region, which is fine
+      selectedRegions.forEach(function (selectedRegion) {
+        if (availableInstanceTypes[selectedRegion]) {
+          availableTypes = _.intersection(availableTypes, _.map(availableInstanceTypes[selectedRegion], 'name'));
+        }
+      });
+
+      return availableTypes.sort(sortTypesByFamilyAndSize);
+    }
+
+    const families: { [key: string]: string[] } = {
+      paravirtual: ['c1', 'c3', 'hi1', 'hs1', 'm1', 'm2', 'm3', 't1'],
+      hvm: ['c3', 'c4', 'd2', 'i2', 'g2', 'm3', 'm4', 'm5', 'p2', 'r3', 'r4', 'r5', 't2', 'x1'],
+      vpcOnly: ['c4', 'm4', 'm5', 'r4', 'r5', 't2', 'x1'],
+      ebsOptimized: ['c4', 'd2', 'f1', 'g3', 'i3', 'm4', 'm5', 'p2', 'r4', 'r5', 'x1'],
+      burstablePerf: ['t2', 't3', 't3a', 't4g'],
+    };
+
+    function filterInstanceTypes(instanceTypes: string[], virtualizationType: string, vpcOnly: boolean): string[] {
+      return instanceTypes.filter((instanceType: string) => {
+        if (virtualizationType === '*') {
+          // show all instance types
+          return true;
+        }
+        const [family] = instanceType.split('.');
+        if (!vpcOnly && families.vpcOnly.includes(family)) {
+          return false;
+        }
+        if (!families.paravirtual.includes(family) && virtualizationType === 'hvm') {
+          return true;
+        }
+        return families[virtualizationType].includes(family);
+      });
+    }
+
+    function isEbsOptimized(instanceType: string) {
+      if (!instanceType) {
+        return false;
+      }
+      const family = _.split(instanceType, '.', 1)[0];
+      return families.ebsOptimized.includes(family);
+    }
+
+    function isBurstingSupportedForAllTypes(instanceTypes: string[]): boolean {
+      if (!instanceTypes || !instanceTypes.length) {
+        return false;
+      }
+      // for multiple instance types case, all instance types must support bursting in order to prevent incompatible configuration.
+      return instanceTypes.every((instanceType) => isBurstingSupported(instanceType));
+    }
+
+    function isBurstingSupported(instanceType: string): boolean {
+      if (!instanceType) {
+        return false;
+      }
+      const family = _.split(instanceType, '.', 1)[0];
+      return families.burstablePerf.includes(family);
+    }
+
+    function getInstanceTypesInCategory(instanceTypesToFilter: string[], category: string): string[] {
+      if (!instanceTypesToFilter || !instanceTypesToFilter.length || !category) {
+        return [];
+      }
+
+      if (category === 'custom') {
+        return instanceTypesToFilter;
+      }
+
+      const instanceTypesInCategory: string[] = _.flatten(
+        _.find(defaultCategories, { type: category })?.families.map((f) => f.instanceTypes.map((it) => it.name)),
+      );
+      return _.intersection(instanceTypesToFilter, instanceTypesInCategory);
+    }
+
+    return {
+      getCategories,
+      getAvailableTypesForRegions,
+      getAllTypesByRegion,
+      filterInstanceTypes,
+      isEbsOptimized,
+      isBurstingSupportedForAllTypes,
+      getInstanceTypesInCategory,
+    };
+  },
+]);

package/src/instance/awsInstanceTypes.ts

@@ -0,0 +1,311 @@
+import type { IInstanceTypeCategory, IInstanceTypeFamily, IPreferredInstanceType } from '@spinnaker/core';
+
+import { AWSProviderSettings } from '../aws.settings';
+
+interface IAwsInstanceTypeFamily extends IInstanceTypeFamily {
+  instanceTypes: IAwsPreferredInstanceType[];
+}
+
+interface IAwsPreferredInstanceType extends IPreferredInstanceType {
+  cpuCreditsPerHour?: number;
+}
+
+interface IAwsInstanceTypeCategory extends IInstanceTypeCategory {
+  showCpuCredits?: boolean;
+  descriptionListOverride?: string[];
+}
+
+const m5: IAwsInstanceTypeFamily = {
+  type: 'm5',
+  description:
+    'm5 instances provide a balance of compute, memory, and network resources. They are a good choice for most applications.',
+  instanceTypes: [
+    {
+      name: 'm5.large',
+      label: 'Large',
+      cpu: 2,
+      memory: 8,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+    },
+    {
+      name: 'm5.xlarge',
+      label: 'XLarge',
+      cpu: 4,
+      memory: 16,
+      storage: { type: 'EBS' },
+      costFactor: 3,
+    },
+    {
+      name: 'm5.2xlarge',
+      label: '2XLarge',
+      cpu: 8,
+      memory: 32,
+      storage: { type: 'EBS' },
+      costFactor: 4,
+    },
+  ],
+};
+
+const t2gp: IAwsInstanceTypeFamily = {
+  type: 't2',
+  description:
+    't2 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+  instanceTypes: [
+    {
+      name: 't2.small',
+      label: 'Small',
+      cpu: 1,
+      memory: 2,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 12,
+    },
+    {
+      name: 't2.medium',
+      label: 'Medium',
+      cpu: 2,
+      memory: 4,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 24,
+    },
+    {
+      name: 't2.large',
+      label: 'Large',
+      cpu: 2,
+      memory: 8,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+      cpuCreditsPerHour: 36,
+    },
+    {
+      name: 't2.xlarge',
+      label: 'XLarge',
+      cpu: 4,
+      memory: 16,
+      storage: { type: 'EBS' },
+      costFactor: 3,
+      cpuCreditsPerHour: 54,
+    },
+    {
+      name: 't2.2xlarge',
+      label: '2XLarge',
+      cpu: 8,
+      memory: 32,
+      storage: { type: 'EBS' },
+      costFactor: 4,
+      cpuCreditsPerHour: 81,
+    },
+  ],
+};
+
+const t3gp: IAwsInstanceTypeFamily = {
+  type: 't3',
+  description:
+    't3 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+  instanceTypes: [
+    {
+      name: 't3.small',
+      label: 'Small',
+      cpu: 2,
+      memory: 2,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 24,
+    },
+    {
+      name: 't3.medium',
+      label: 'Medium',
+      cpu: 2,
+      memory: 4,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 24,
+    },
+    {
+      name: 't3.large',
+      label: 'Large',
+      cpu: 2,
+      memory: 8,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+      cpuCreditsPerHour: 36,
+    },
+    {
+      name: 't3.xlarge',
+      label: 'XLarge',
+      cpu: 4,
+      memory: 16,
+      storage: { type: 'EBS' },
+      costFactor: 3,
+      cpuCreditsPerHour: 96,
+    },
+    {
+      name: 't3.2xlarge',
+      label: '2XLarge',
+      cpu: 8,
+      memory: 32,
+      storage: { type: 'EBS' },
+      costFactor: 4,
+      cpuCreditsPerHour: 192,
+    },
+  ],
+};
+
+const t2: IAwsInstanceTypeFamily = {
+  type: 't2',
+  description:
+    't2 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+  instanceTypes: [
+    {
+      name: 't2.nano',
+      label: 'Nano',
+      cpu: 1,
+      memory: 0.5,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 3,
+    },
+    {
+      name: 't2.micro',
+      label: 'Micro',
+      cpu: 1,
+      memory: 1,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 6,
+    },
+    {
+      name: 't2.small',
+      label: 'Small',
+      cpu: 1,
+      memory: 2,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 12,
+    },
+  ],
+};
+
+const t3: IAwsInstanceTypeFamily = {
+  type: 't3',
+  description:
+    't3 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+  instanceTypes: [
+    {
+      name: 't3.nano',
+      label: 'Nano',
+      cpu: 2,
+      memory: 0.5,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 6,
+    },
+    {
+      name: 't3.micro',
+      label: 'Micro',
+      cpu: 2,
+      memory: 1,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 12,
+    },
+    {
+      name: 't3.small',
+      label: 'Small',
+      cpu: 2,
+      memory: 2,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+      cpuCreditsPerHour: 24,
+    },
+  ],
+};
+
+const r5: IAwsInstanceTypeFamily = {
+  type: 'r5',
+  description:
+    'r5 instances are optimized for memory-intensive applications and have the lowest cost per GiB of RAM among Amazon EC2 instance types.',
+  instanceTypes: [
+    {
+      name: 'r5.large',
+      label: 'Large',
+      cpu: 2,
+      memory: 16,
+      storage: { type: 'EBS' },
+      costFactor: 1,
+    },
+    {
+      name: 'r5.xlarge',
+      label: 'XLarge',
+      cpu: 4,
+      memory: 32,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+    },
+    {
+      name: 'r5.2xlarge',
+      label: '2XLarge',
+      cpu: 8,
+      memory: 64,
+      storage: { type: 'EBS' },
+      costFactor: 2,
+    },
+    {
+      name: 'r5.4xlarge',
+      label: '4XLarge',
+      cpu: 16,
+      memory: 128,
+      storage: { type: 'EBS' },
+      costFactor: 3,
+    },
+  ],
+};
+
+export const defaultCategories: IAwsInstanceTypeCategory[] = [
+  {
+    type: 'general',
+    label: 'General Purpose',
+    families: [m5, t2gp, t3gp],
+    icon: 'hdd',
+    showCpuCredits: true,
+    descriptionListOverride: [
+      m5.description,
+      't2/t3 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+    ],
+  },
+  {
+    type: 'memory',
+    label: 'High Memory',
+    families: [r5],
+    icon: 'hdd',
+  },
+  {
+    type: 'micro',
+    label: 'Micro Utility',
+    families: [t2, t3],
+    icon: 'hdd',
+    showCpuCredits: true,
+    descriptionListOverride: [
+      't2/t3 instances are a good choice for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+    ],
+  },
+  {
+    type: 'custom',
+    label: 'Custom Type',
+    families: [],
+    icon: 'asterisk',
+  },
+];
+
+const excludeCategories = AWSProviderSettings.instanceTypes?.exclude?.categories ?? [];
+const excludeFamilies = AWSProviderSettings.instanceTypes?.exclude?.families ?? [];
+
+export const categories = defaultCategories
+  .filter(({ type }) => !excludeCategories.includes(type))
+  .map((category) =>
+    Object.assign({}, category, {
+      families: category.families.filter(({ type }) => !excludeFamilies.includes(type)),
+    }),
+  );

package/src/instance/details/CostFactor.tsx

@@ -0,0 +1,29 @@
+import React from 'react';
+
+export interface ICostFactorProps {
+  min: number;
+  max?: number;
+}
+
+export const CostFactor = ({ min, max }: ICostFactorProps) => {
+  const MAX_DOLLARS = 4;
+  const minDollars = (
+    <>
+      <span className="cost">{'$'.repeat(min)}</span>
+      {'$'.repeat(MAX_DOLLARS - min)}
+    </>
+  );
+  const maxDollars = (
+    <>
+      <span className="cost">{'$'.repeat(Math.min(MAX_DOLLARS, max))}</span>
+      {'$'.repeat(MAX_DOLLARS - Math.min(MAX_DOLLARS, max))}
+    </>
+  );
+
+  return (
+    <span className={'cost-factor'}>
+      {minDollars}
+      {max ? ` - ${maxDollars}` : ''}
+    </span>
+  );
+};

package/src/instance/details/InstanceInformation.spec.tsx

@@ -1,5 +1,6 @@
-import React from 'react';
 import { shallow } from 'enzyme';
+import React from 'react';
+
 import { mockInstance } from '@spinnaker/mocks';
 
 import { InstanceInformation } from './InstanceInformation';