@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/instance/awsInstanceType.service.ts

@@ -1,5 +1,3 @@
-import type { IQService } from 'angular';
-import { module } from 'angular';
 import _ from 'lodash';
 
 import type {
@@ -69,185 +67,175 @@ export interface IAmazonInstanceTypesByRegion extends IInstanceTypesByRegion {
   [region: string]: IAmazonInstanceType[];
 }
 
-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<IAmazonInstanceTypesByRegion> {
-      return REST('/instanceTypes')
-        .get()
-        .then(function (types) {
-          return _.chain(types)
-            .map(function (type: IAmazonInstanceType) {
-              return {
-                ...type,
-                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;
-      }
+export class AwsInstanceTypeService {
+  private instanceClassOrder = ['xlarge', 'large', 'medium', 'small', 'micro', 'nano'];
+  private families: { [key: string]: string[] } = {
+    ec2ClassicSupported: ['m1', 'm3', 't1', 'c1', 'c3', 'cc2', 'cr1', 'm2', 'r3', 'd2', 'hs1', 'i2', 'g2'],
+    ebsOptimized: ['c4', 'd2', 'f1', 'g3', 'i3', 'm4', 'm5', 'p2', 'r4', 'r5', 'x1'],
+    burstablePerf: ['t2', 't3', 't3a', 't4g'],
+  };
+
+  public getCategories(): Promise<IAmazonInstanceTypeCategory[]> {
+    return Promise.resolve(categories);
+  }
+
+  public getAllTypesByRegion(): Promise<IAmazonInstanceTypesByRegion> {
+    return REST('/instanceTypes')
+      .get()
+      .then(function (types) {
+        return _.chain(types)
+          .map(function (type: IAmazonInstanceType) {
+            return {
+              ...type,
+              key: [type.region, type.account, type.name].join(':'),
+            };
+          })
+          .uniqBy('key')
+          .groupBy('region')
+          .value();
+      });
+  }
 
-      if (t1Idx === 0 && t2Idx === 0) {
-        const size1 = parseInt(class1.replace('xlarge', '')) || 0;
-        const size2 = parseInt(class2.replace('xlarge', '')) || 0;
+  private sortTypesByFamilyAndSize(o1: string, o2: string) {
+    const type1 = o1.split('.');
+    const type2 = o2.split('.');
 
-        if (size2 < size1) {
-          return 1;
-        } else if (size2 > size1) {
-          return -1;
-        }
-        return 0;
-      }
+    const [family1, class1 = ''] = type1;
+    const [family2, class2 = ''] = type2;
 
-      if (t1Idx > t2Idx) {
-        return -1;
-      } else if (t1Idx < t2Idx) {
+    if (family1 !== family2) {
+      if (family1 > family2) {
         return 1;
+      } else if (family1 < family2) {
+        return -1;
       }
       return 0;
     }
 
-    function getAvailableTypesForRegions(
-      availableInstanceTypes: IAmazonInstanceTypesByRegion,
-      selectedRegions: string[],
-    ): IAmazonInstanceType[] {
-      selectedRegions = selectedRegions || [];
-      let availableTypes: IAmazonInstanceType[] = [];
+    const t1Idx = this.instanceClassOrder.findIndex((el) => class1.endsWith(el));
+    const t2Idx = this.instanceClassOrder.findIndex((el) => class2.endsWith(el));
 
-      // prime the list of available types
-      if (selectedRegions && selectedRegions.length) {
-        availableTypes = availableInstanceTypes[selectedRegions[0]] || [];
-      }
+    if (t1Idx === -1 || t2Idx === -1) {
+      return 0;
+    }
 
-      // this will perform an unnecessary intersection with the first region, which is fine
-      selectedRegions.forEach(function (selectedRegion) {
-        if (availableInstanceTypes[selectedRegion]) {
-          availableTypes = _.intersectionBy(availableTypes, availableInstanceTypes[selectedRegion], 'name');
-        }
-      });
+    if (t1Idx === 0 && t2Idx === 0) {
+      const size1 = parseInt(class1.replace('xlarge', '')) || 0;
+      const size2 = parseInt(class2.replace('xlarge', '')) || 0;
 
-      return availableTypes?.sort((a, b) => sortTypesByFamilyAndSize(a.name, b.name));
+      if (size2 < size1) {
+        return 1;
+      } else if (size2 > size1) {
+        return -1;
+      }
+      return 0;
     }
 
-    const families: { [key: string]: string[] } = {
-      ec2ClassicSupported: ['m1', 'm3', 't1', 'c1', 'c3', 'cc2', 'cr1', 'm2', 'r3', 'd2', 'hs1', 'i2', 'g2'], // https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-classic-platform.html#ec2-classic-instance-types
-      ebsOptimized: ['c4', 'd2', 'f1', 'g3', 'i3', 'm4', 'm5', 'p2', 'r4', 'r5', 'x1'],
-      burstablePerf: ['t2', 't3', 't3a', 't4g'],
-    };
-
-    function filterInstanceTypes(
-      instanceTypes: IAmazonInstanceType[],
-      virtualizationType: string,
-      vpcConfigured: boolean,
-      architecture: string,
-    ): IAmazonInstanceType[] {
-      return _.filter(instanceTypes, function (i) {
-        if (virtualizationType === '*' && architecture === '*') {
-          // show all instance types
-          return true;
-        }
-
-        if (!vpcConfigured && !families.ec2ClassicSupported.includes(i.name.split('.')[0])) {
-          return false;
-        }
-
-        if (
-          virtualizationType &&
-          i.supportedVirtualizationTypes &&
-          !i.supportedVirtualizationTypes.includes(virtualizationType)
-        ) {
-          return false;
-        }
-
-        if (architecture && i.supportedArchitectures && !i.supportedArchitectures.includes(architecture)) {
-          return false;
-        }
+    if (t1Idx > t2Idx) {
+      return -1;
+    } else if (t1Idx < t2Idx) {
+      return 1;
+    }
+    return 0;
+  }
+
+  public getAvailableTypesForRegions(
+    availableInstanceTypes: IAmazonInstanceTypesByRegion,
+    selectedRegions: string[],
+  ): IAmazonInstanceType[] {
+    selectedRegions = selectedRegions || [];
+    let availableTypes: IAmazonInstanceType[] = [];
+
+    // prime the list of available types
+    if (selectedRegions && selectedRegions.length) {
+      availableTypes = availableInstanceTypes[selectedRegions[0]] || [];
+    }
 
+    // this will perform an unnecessary intersection with the first region, which is fine
+    selectedRegions.forEach(function (selectedRegion) {
+      if (availableInstanceTypes[selectedRegion]) {
+        availableTypes = _.intersectionBy(availableTypes, availableInstanceTypes[selectedRegion], 'name');
+      }
+    });
+
+    return availableTypes?.sort((a, b) => this.sortTypesByFamilyAndSize(a.name, b.name));
+  }
+
+  public filterInstanceTypes(
+    instanceTypes: IAmazonInstanceType[],
+    virtualizationType: string,
+    vpcConfigured: boolean,
+    architecture: string,
+  ): IAmazonInstanceType[] {
+    // The casing of virtualizationType/architecture can differ between the AMI attributes we
+    // compare against (e.g. 'HVM', 'ARM64') and the supportedVirtualizationTypes/supportedArchitectures
+    // reported for instance types (e.g. 'hvm', 'X86_64'), depending on the account/provider. Compare
+    // both case-insensitively to avoid filtering out every instance type due to a casing mismatch.
+    const includesIgnoreCase = (values: string[], value: string) =>
+      values.some((v) => v.toLowerCase() === value.toLowerCase());
+
+    return _.filter(instanceTypes, (i) => {
+      if (virtualizationType === '*' && architecture === '*') {
+        // show all instance types
         return true;
-      });
-    }
+      }
 
-    function isEbsOptimized(instanceType: string) {
-      if (!instanceType) {
+      if (!vpcConfigured && !this.families.ec2ClassicSupported.includes(i.name.split('.')[0])) {
         return false;
       }
-      const family = _.split(instanceType, '.', 1)[0];
-      return families.ebsOptimized.includes(family);
-    }
 
-    function isBurstingSupportedForAllTypes(instanceTypes: string[]): boolean {
-      if (!instanceTypes || !instanceTypes.length) {
+      if (
+        virtualizationType &&
+        i.supportedVirtualizationTypes &&
+        !includesIgnoreCase(i.supportedVirtualizationTypes, virtualizationType)
+      ) {
         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) {
+      if (architecture && i.supportedArchitectures && !includesIgnoreCase(i.supportedArchitectures, architecture)) {
         return false;
       }
-      const family = _.split(instanceType, '.', 1)[0];
-      return families.burstablePerf.includes(family);
+
+      return true;
+    });
+  }
+
+  public isEbsOptimized(instanceType: string) {
+    if (!instanceType) {
+      return false;
     }
+    const family = _.split(instanceType, '.', 1)[0];
+    return this.families.ebsOptimized.includes(family);
+  }
 
-    function getInstanceTypesInCategory(instanceTypesToFilter: string[], category: string): string[] {
-      if (!instanceTypesToFilter || !instanceTypesToFilter.length || !category) {
-        return [];
-      }
+  public 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) => this.isBurstingSupported(instanceType));
+  }
 
-      if (category === 'custom') {
-        return instanceTypesToFilter;
-      }
+  public isBurstingSupported(instanceType: string): boolean {
+    if (!instanceType) {
+      return false;
+    }
+    const family = _.split(instanceType, '.', 1)[0];
+    return this.families.burstablePerf.includes(family);
+  }
+
+  public getInstanceTypesInCategory(instanceTypesToFilter: string[], category: string): string[] {
+    if (!instanceTypesToFilter || !instanceTypesToFilter.length || !category) {
+      return [];
+    }
 
-      const instanceTypesInCategory: string[] = _.flatten(
-        _.find(defaultCategories, { type: category })?.families.map((f) => f.instanceTypes.map((it) => it.name)),
-      );
-      return _.intersection(instanceTypesToFilter, instanceTypesInCategory);
+    if (category === 'custom') {
+      return instanceTypesToFilter;
     }
 
-    return {
-      getCategories,
-      getAvailableTypesForRegions,
-      getAllTypesByRegion,
-      filterInstanceTypes,
-      isEbsOptimized,
-      isBurstingSupportedForAllTypes,
-      getInstanceTypesInCategory,
-    };
-  },
-]);
+    const instanceTypesInCategory: string[] = _.flatten(
+      _.find(defaultCategories, { type: category })?.families.map((f) => f.instanceTypes.map((it) => it.name)),
+    );
+    return _.intersection(instanceTypesToFilter, instanceTypesInCategory);
+  }
+}

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

@@ -0,0 +1,79 @@
+import { ConfirmationModalService } from '@spinnaker/core';
+
+import { AWSProviderSettings } from '../../aws.settings';
+
+import {
+  AmazonInstanceActionsComponent,
+  AmazonInstanceDetailsComponent as AmazonInstanceDetails,
+} from './AmazonInstanceDetails';
+
+describe('AmazonInstanceDetails', () => {
+  let adHocInfraWritesEnabled: boolean;
+  let stateService: any;
+
+  beforeEach(() => {
+    adHocInfraWritesEnabled = AWSProviderSettings.adHocInfraWritesEnabled;
+    AWSProviderSettings.adHocInfraWritesEnabled = true;
+    stateService = { go: jasmine.createSpy('go'), includes: jasmine.createSpy('includes').and.returnValue(true) };
+  });
+
+  afterEach(() => (AWSProviderSettings.adHocInfraWritesEnabled = adHocInfraWritesEnabled));
+
+  it('closes details when required data sources fail before instance loading', () => {
+    const readyFailure = new Error('server groups failed');
+    const rejectedReadiness = {
+      then: (_onFulfilled: () => void, onRejected?: (error: Error) => void) => {
+        if (onRejected) {
+          onRejected(readyFailure);
+        }
+        return rejectedReadiness;
+      },
+      catch: (onRejected: (error: Error) => void) => {
+        onRejected(readyFailure);
+        return rejectedReadiness;
+      },
+    };
+    const app = {
+      isStandalone: false,
+      serverGroups: {
+        ready: jasmine.createSpy('serverGroups.ready').and.returnValue(Promise.resolve()),
+        onRefresh: jasmine.createSpy('onRefresh'),
+      },
+      loadBalancers: {
+        ready: jasmine.createSpy('loadBalancers.ready').and.returnValue(Promise.resolve()),
+      },
+    } as any;
+    spyOn(Promise, 'all').and.returnValue(rejectedReadiness as any);
+
+    const component = new AmazonInstanceDetails({
+      app,
+      $stateParams: { account: 'test', instanceId: 'i-123', provider: 'aws', region: 'us-east-1' },
+      router: {},
+      stateParams: {},
+      stateService,
+    } as any);
+
+    component.componentDidMount();
+
+    expect(stateService.go).toHaveBeenCalledWith('^', { allowModalToStayOpen: true }, { location: 'replace' });
+    expect(app.serverGroups.onRefresh).not.toHaveBeenCalled();
+  });
+
+  it('closes terminated instance details through the injected state service', () => {
+    const confirmation = spyOn(ConfirmationModalService, 'confirm');
+    const instance = { account: 'test', health: [], instanceId: 'i-123', placement: {} } as any;
+    const actions = AmazonInstanceActionsComponent({
+      app: { attributes: {} } as any,
+      instance,
+      router: {} as any,
+      stateParams: {},
+      stateService,
+    }).props.actions;
+
+    actions.find(({ label }: any) => label === 'Terminate').triggerAction();
+    confirmation.calls.mostRecent().args[0].taskMonitorConfig.onTaskComplete();
+
+    expect(stateService.includes).toHaveBeenCalledWith('**.instanceDetails', { instanceId: 'i-123' });
+    expect(stateService.go).toHaveBeenCalledWith('^');
+  });
+});