@spinnaker/amazon 0.13.3 → 0.13.4

package/dist/serverGroup/configure/serverGroupConfiguration.service.d.ts

@@ -4,6 +4,7 @@ import type { IAmazonInstanceType } from '../../instance/awsInstanceType.service
 export declare type IBlockDeviceMappingSource = 'source' | 'ami' | 'default';
 export interface IAmazonServerGroupCommandDirty extends IServerGroupCommandDirty {
     targetGroups?: string[];
+    launchTemplateOverridesForInstanceType?: IAmazonInstanceTypeOverride[];
 }
 export interface IAmazonServerGroupCommandResult extends IServerGroupCommandResult {
     dirty: IAmazonServerGroupCommandDirty;

package/dist/serverGroup/configure/wizard/instanceType/InstanceTypeWarning.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { IAmazonServerGroupCommandDirty } from '../../serverGroupConfiguration.service';
+export declare function InstanceTypeWarning(props: {
+    dirty: IAmazonServerGroupCommandDirty;
+    clearWarnings: () => void;
+}): JSX.Element;

package/dist/serverGroup/configure/wizard/instanceType/advancedMode/AdvancedModeSelector.d.ts

@@ -6,6 +6,7 @@ export interface IAdvancedModeSelectorProps {
     formik: FormikProps<IAmazonServerGroupCommand>;
     instanceTypeDetails: IAmazonInstanceTypeCategory[];
     setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
+    clearWarnings: () => void;
 }
 /**
  * Note: Launch templates support is expected to be enabled if this component is rendered.

package/dist/serverGroup/configure/wizard/instanceType/advancedMode/InstanceTypeTable.d.ts

@@ -2,6 +2,7 @@
 import type { IAmazonInstanceTypeCategory } from '../../../../../instance/awsInstanceType.service';
 import type { IAmazonInstanceType } from '../../../../../instance/awsInstanceType.service';
 import type { IAmazonInstanceTypeOverride } from '../../../serverGroupConfiguration.service';
+import type { IAmazonServerGroupCommandViewState } from '../../../serverGroupConfiguration.service';
 import './advancedMode.less';
 export interface IInstanceTypeTableProps {
     currentProfile: string;
@@ -11,5 +12,7 @@ export interface IInstanceTypeTableProps {
     availableInstanceTypesList: IAmazonInstanceType[];
     handleInstanceTypesChange: (instanceTypes: IAmazonInstanceTypeOverride[]) => void;
     setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
+    viewState: IAmazonServerGroupCommandViewState;
+    clearWarnings: () => void;
 }
 export declare function InstanceTypeTable(props: IInstanceTypeTableProps): JSX.Element;

package/dist/serverGroup/configure/wizard/instanceType/simpleMode/SimpleModeSelector.d.ts

@@ -4,5 +4,6 @@ export interface ISimpleModeSelectorProps {
     command: IAmazonServerGroupCommand;
     setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
     setFieldValue: (field: keyof IAmazonServerGroupCommand, value: any, shouldValidate?: boolean) => void;
+    clearWarnings: () => void;
 }
 export declare function SimpleModeSelector(props: ISimpleModeSelectorProps): JSX.Element;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@spinnaker/amazon",
   "license": "Apache-2.0",
-  "version": "0.13.3",
+  "version": "0.13.4",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
@@ -13,7 +13,7 @@
     "lib": "npm run build"
   },
   "dependencies": {
-    "@spinnaker/core": "^0.22.2",
+    "@spinnaker/core": "^0.23.0",
     "@uirouter/angularjs": "1.0.26",
     "@uirouter/core": "6.0.8",
     "@uirouter/react": "1.0.7",
@@ -55,5 +55,5 @@
     "shx": "0.3.3",
     "typescript": "4.3.5"
   },
-  "gitHead": "587b5a7a5fe2121cd93bed86e5e83795ee401be0"
+  "gitHead": "4d61e53884040e8cae45d29b398c88e3814c6aca"
 }

package/src/pipeline/stages/rollbackCluster/rollbackClusterStage.html

@@ -28,5 +28,16 @@
       />
       percent of instances are healthy.
     </div>
+    <div class="col-sm-10 col-sm-offset-2">
+      Rollback Timeout is
+      <input
+        type="number"
+        min="0"
+        max="100"
+        ng-model="stage.rollbackTimeout"
+        class="form-control input-sm inline-number"
+      />
+      minutes.
+    </div>
   </div>
 </div>

package/src/serverGroup/AvailabilityZoneSelector.tsx

@@ -27,23 +27,22 @@ export class AvailabilityZoneSelector extends React.Component<
       usePreferredZones: props.usePreferredZones || !props.selectedZones || props.selectedZones.length === 0,
     };
 
-    this.setDefaultZones(props);
+    this.setDefaultZones(this.state.usePreferredZones, props);
   }
 
   public componentWillReceiveProps(nextProps: IAvailabilityZoneSelectorProps): void {
     if (nextProps.region !== this.props.region || nextProps.credentials !== this.props.credentials) {
-      this.setDefaultZones(nextProps);
+      this.setDefaultZones(this.state.usePreferredZones, nextProps);
     }
   }
 
-  private setDefaultZones(props: IAvailabilityZoneSelectorProps) {
-    const { credentials, onChange, region } = props;
-    const { usePreferredZones } = this.state;
+  private setDefaultZones(usePreferredZones: boolean, props: IAvailabilityZoneSelectorProps) {
+    const { credentials, region } = props;
 
     AccountService.getAvailabilityZonesForAccountAndRegion('aws', credentials, region).then((preferredZones) => {
       this.setState({ defaultZones: preferredZones });
       if (usePreferredZones && preferredZones) {
-        onChange(preferredZones.slice());
+        props.onChange(preferredZones.slice());
       }
     });
   }
@@ -53,7 +52,7 @@ export class AvailabilityZoneSelector extends React.Component<
     this.setState({ usePreferredZones });
 
     if (usePreferredZones) {
-      this.setDefaultZones(this.props);
+      this.setDefaultZones(usePreferredZones, this.props);
     }
   };
 

package/src/serverGroup/configure/serverGroupConfiguration.service.ts

@@ -3,6 +3,7 @@ import {
   chain,
   clone,
   cloneDeep,
+  difference,
   extend,
   find,
   flatten,
@@ -61,6 +62,7 @@ export type IBlockDeviceMappingSource = 'source' | 'ami' | 'default';
 
 export interface IAmazonServerGroupCommandDirty extends IServerGroupCommandDirty {
   targetGroups?: string[];
+  launchTemplateOverridesForInstanceType?: IAmazonInstanceTypeOverride[];
 }
 
 export interface IAmazonServerGroupCommandResult extends IServerGroupCommandResult {
@@ -376,11 +378,13 @@ export class AwsServerGroupConfigurationService {
 
   public configureInstanceTypes(command: IAmazonServerGroupCommand): IServerGroupCommandResult {
     const result: IAmazonServerGroupCommandResult = { dirty: {} };
+
     if (command.region && (command.virtualizationType || command.viewState.disableImageSelection)) {
       let filteredTypesInfo: IAmazonInstanceType[] = this.awsInstanceTypeService.getAvailableTypesForRegions(
         command.backingData.instanceTypesInfo,
         [command.region],
       );
+
       if (command.virtualizationType || command.amiArchitecture) {
         filteredTypesInfo = this.awsInstanceTypeService.filterInstanceTypes(
           filteredTypesInfo,
@@ -389,18 +393,35 @@ export class AwsServerGroupConfigurationService {
           command.amiArchitecture,
         );
       }
-
       const filteredTypes: string[] = map(filteredTypesInfo, 'name');
+
+      // handle incompatibility for single instance type case
       if (command.instanceType && !filteredTypes.includes(command.instanceType)) {
         result.dirty.instanceType = command.instanceType;
         command.instanceType = null;
       }
+
+      // handle incompatibility for multiple instance types case
+      const multipleInstanceTypes: string[] = map(command.launchTemplateOverridesForInstanceType, 'instanceType');
+      const validInstanceTypes: string[] = intersection(multipleInstanceTypes, filteredTypes);
+      const invalidInstanceTypes: string[] = difference(multipleInstanceTypes, validInstanceTypes);
+
+      if (command.launchTemplateOverridesForInstanceType && invalidInstanceTypes.length > 0) {
+        result.dirty.launchTemplateOverridesForInstanceType = command.launchTemplateOverridesForInstanceType.filter(
+          (it) => invalidInstanceTypes.includes(it.instanceType),
+        );
+        command.launchTemplateOverridesForInstanceType = command.launchTemplateOverridesForInstanceType.filter((it) =>
+          validInstanceTypes.includes(it.instanceType),
+        );
+      }
+
       command.backingData.filtered.instanceTypes = filteredTypes;
       command.backingData.filtered.instanceTypesInfo = filteredTypesInfo;
     } else {
       command.backingData.filtered.instanceTypes = [];
       command.backingData.filtered.instanceTypesInfo = [];
     }
+
     extend(command.viewState.dirty, result.dirty);
     return result;
   }
@@ -613,6 +634,7 @@ export class AwsServerGroupConfigurationService {
       });
       command.vpcId = subnet ? subnet.vpcId : null;
     }
+
     extend(result.dirty, this.configureInstanceTypes(command).dirty);
     return result;
   }

package/src/serverGroup/configure/wizard/instanceType/InstanceTypeSelector.tsx

@@ -16,51 +16,83 @@ export interface IInstanceTypeSelectorProps {
 
 export function InstanceTypeSelector(props: IInstanceTypeSelectorProps) {
   const { instanceTypeDetails } = props;
-  const { values: command, setFieldValue } = props.formik;
+  const { values, setFieldValue } = props.formik;
   const isLaunchTemplatesEnabled = AWSProviderSettings.serverGroups?.enableLaunchTemplates;
 
-  const useSimpleMode = command.viewState.useSimpleInstanceTypeSelector;
-  const [unlimitedCpuCredits, setUnlimitedCpuCredits] = useState(command.unlimitedCpuCredits);
+  const useSimpleMode = values.viewState.useSimpleInstanceTypeSelector;
+  const [unlimitedCpuCredits, setUnlimitedCpuCredits] = useState(values.unlimitedCpuCredits);
 
   useEffect(() => {
-    if (command.unlimitedCpuCredits !== unlimitedCpuCredits) {
+    if (values.unlimitedCpuCredits !== unlimitedCpuCredits) {
       setFieldValue('unlimitedCpuCredits', unlimitedCpuCredits);
     }
   }, [unlimitedCpuCredits]);
 
+  const clearWarnings = () => {
+    const { formik } = props;
+
+    // clear for both keys to support consistency between simple and advanced modes
+    formik.values.viewState.dirty['instanceType'] = null;
+    formik.values.viewState.dirty['launchTemplateOverridesForInstanceType'] = null;
+
+    formik.validateForm();
+  };
+
   const handleModeChange = (useSimpleModeNew: boolean) => {
     if (useSimpleMode !== useSimpleModeNew) {
       setFieldValue('viewState', {
-        ...command.viewState,
+        ...values.viewState,
         useSimpleInstanceTypeSelector: useSimpleModeNew,
       });
 
       // update selected instance type(s) if mode changed.
       // Simple mode uses command.instanceType to track selected type. Advanced mode uses command.launchTemplateOverridesForInstanceType to track selected types.
-      const multipleInstanceTypesInProps = command.launchTemplateOverridesForInstanceType;
-      const singleInstanceTypeInProps = command.instanceType;
-
-      const toSimple = useSimpleModeNew && multipleInstanceTypesInProps?.length;
-      const toAdvanced = !useSimpleModeNew && singleInstanceTypeInProps;
-      if (toSimple) {
-        const highestPriorityNum = Math.min(...multipleInstanceTypesInProps.map((it) => it.priority));
-        const instanceTypeWithHighestPriority = multipleInstanceTypesInProps.find(
-          (it) => it.priority === highestPriorityNum,
-        ).instanceType;
-
-        setFieldValue('instanceType', instanceTypeWithHighestPriority);
-        setFieldValue('launchTemplateOverridesForInstanceType', []);
-        command.instanceTypeChanged(command);
-      } else if (toAdvanced) {
-        const instanceTypes: IAmazonInstanceTypeOverride[] = [
-          {
-            instanceType: singleInstanceTypeInProps,
-            priority: 1,
-          },
-        ];
-        setFieldValue('instanceType', undefined);
-        setFieldValue('launchTemplateOverridesForInstanceType', instanceTypes);
-        command.launchTemplateOverridesChanged(command);
+      if (useSimpleModeNew) {
+        const multipleInstanceTypesInProps = values.launchTemplateOverridesForInstanceType;
+        const dirtyMultipleInstanceTypesInProps = values.viewState.dirty.launchTemplateOverridesForInstanceType;
+
+        if (multipleInstanceTypesInProps?.length) {
+          const instanceTypeWithHighestPriority = multipleInstanceTypesInProps.reduce((prev, current) => {
+            return prev.priority < current.priority ? prev : current;
+          }).instanceType;
+          setFieldValue('instanceType', instanceTypeWithHighestPriority);
+          setFieldValue('launchTemplateOverridesForInstanceType', []);
+          values.instanceTypeChanged(values);
+        }
+
+        if (dirtyMultipleInstanceTypesInProps?.length) {
+          const instanceTypeWithHighestPriorityDirty = dirtyMultipleInstanceTypesInProps.reduce((prev, current) => {
+            return prev.priority < current.priority ? prev : current;
+          }).instanceType;
+          setFieldValue('viewState.dirty.instanceType', instanceTypeWithHighestPriorityDirty);
+          setFieldValue('viewState.dirty.launchTemplateOverridesForInstanceType', []);
+        }
+      } else if (!useSimpleModeNew) {
+        const singleInstanceTypeInProps = values.instanceType;
+        const dirtySingleInstanceTypeInProps = values.viewState.dirty.instanceType;
+
+        if (singleInstanceTypeInProps) {
+          const instanceTypes: IAmazonInstanceTypeOverride[] = [
+            {
+              instanceType: singleInstanceTypeInProps,
+              priority: 1,
+            },
+          ];
+          setFieldValue('instanceType', undefined);
+          setFieldValue('launchTemplateOverridesForInstanceType', instanceTypes);
+          values.launchTemplateOverridesChanged(values);
+        }
+
+        if (dirtySingleInstanceTypeInProps) {
+          const dirtyInstanceTypes: IAmazonInstanceTypeOverride[] = [
+            {
+              instanceType: dirtySingleInstanceTypeInProps,
+              priority: 1,
+            },
+          ];
+          setFieldValue('viewState.dirty.instanceType', undefined);
+          setFieldValue('viewState.dirty.launchTemplateOverridesForInstanceType', dirtyInstanceTypes);
+        }
       }
     }
   };
@@ -86,6 +118,7 @@ export function InstanceTypeSelector(props: IInstanceTypeSelectorProps) {
           formik={props.formik}
           instanceTypeDetails={instanceTypeDetails}
           setUnlimitedCpuCredits={setUnlimitedCpuCredits}
+          clearWarnings={clearWarnings}
         />
       </div>
     );
@@ -124,9 +157,10 @@ export function InstanceTypeSelector(props: IInstanceTypeSelectorProps) {
         )}
       </div>
       <SimpleModeSelector
-        command={command}
+        command={values}
         setUnlimitedCpuCredits={setUnlimitedCpuCredits}
         setFieldValue={setFieldValue}
+        clearWarnings={clearWarnings}
       />
     </div>
   );

package/src/serverGroup/configure/wizard/instanceType/InstanceTypeWarning.tsx

@@ -0,0 +1,44 @@
+import React from 'react';
+
+import type { IAmazonServerGroupCommandDirty } from '../../serverGroupConfiguration.service';
+
+export function InstanceTypeWarning(props: { dirty: IAmazonServerGroupCommandDirty; clearWarnings: () => void }) {
+  if (
+    props.dirty.instanceType ||
+    (props.dirty.launchTemplateOverridesForInstanceType &&
+      props.dirty.launchTemplateOverridesForInstanceType.length > 0)
+  ) {
+    return (
+      <div className="col-md-12">
+        <div className="alert alert-warning">
+          <p>
+            <i className="fa fa-exclamation-triangle" />
+            {props.dirty.instanceType &&
+              'The following instance type was found incompatible with the selected image/region and was removed:'}
+            {props.dirty.launchTemplateOverridesForInstanceType &&
+              props.dirty.launchTemplateOverridesForInstanceType.length > 0 &&
+              'The following instance type(s) were found incompatible with the selected image/region and were removed:'}
+          </p>
+          <ul>
+            {props.dirty.instanceType && <li key={props.dirty.instanceType}>{props.dirty.instanceType}</li>}
+            {props.dirty.launchTemplateOverridesForInstanceType &&
+              props.dirty.launchTemplateOverridesForInstanceType.length > 0 &&
+              props.dirty.launchTemplateOverridesForInstanceType.map((it) => (
+                <li key={it.instanceType}>
+                  {it.instanceType}
+                  {it.weightedCapacity ? ' with weight ' + it.weightedCapacity : ''}
+                </li>
+              ))}
+          </ul>
+          <p className="text-right">
+            <a className="btn btn-sm btn-default dirty-flag-dismiss clickable" onClick={() => props.clearWarnings()}>
+              Okay
+            </a>
+          </p>
+        </div>
+      </div>
+    );
+  } else {
+    return null;
+  }
+}

package/src/serverGroup/configure/wizard/instanceType/advancedMode/AdvancedModeSelector.tsx

@@ -15,6 +15,7 @@ export interface IAdvancedModeSelectorProps {
   formik: FormikProps<IAmazonServerGroupCommand>;
   instanceTypeDetails: IAmazonInstanceTypeCategory[];
   setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
+  clearWarnings: () => void;
 }
 
 /**
@@ -93,6 +94,8 @@ export function AdvancedModeSelector(props: IAdvancedModeSelectorProps) {
         }
         handleInstanceTypesChange={handleInstanceTypesChange}
         setUnlimitedCpuCredits={setUnlimitedCpuCredits}
+        viewState={command.viewState}
+        clearWarnings={props.clearWarnings}
       />
     </div>
   );

package/src/serverGroup/configure/wizard/instanceType/advancedMode/AmazonInstanceTypeInfoRenderer.tsx

@@ -4,50 +4,50 @@ import React from 'react';
 import type { IAmazonInstanceType } from '../../../../../instance/awsInstanceType.service';
 
 export function AmazonInstanceTypeInfoRenderer(props: { instanceType: IAmazonInstanceType }) {
-  const spotSupport = props.instanceType.supportedUsageClasses.includes('spot') ? '| SPOT supported' : '';
-  const CpuMem = `${props.instanceType.defaultVCpus} vCPU | ${props.instanceType.memoryInGiB} Gib Memory ${spotSupport}`;
-  const instanceStorageInfo = props.instanceType.instanceStorageSupported && (
+  const spotSupport = props.instanceType?.supportedUsageClasses?.includes('spot') ? '| SPOT supported' : '';
+  const CpuMem = `${props.instanceType?.defaultVCpus} vCPU | ${props.instanceType?.memoryInGiB} Gib Memory ${spotSupport}`;
+  const instanceStorageInfo = props.instanceType?.instanceStorageSupported && (
     <span>
       <br />
       <span className={`select-option-label-attributes`}>
-        {`Instance Storage: ${_.toUpper(props.instanceType.instanceStorageInfo.storageTypes)} | ${
-          props.instanceType.instanceStorageInfo.totalSizeInGB
+        {`Instance Storage: ${_.toUpper(props.instanceType?.instanceStorageInfo?.storageTypes)} | ${
+          props.instanceType?.instanceStorageInfo?.totalSizeInGB
         } Gib total size`}
       </span>
     </span>
   );
-  const ebsInfo = props.instanceType.ebsInfo && (
+  const ebsInfo = props.instanceType?.ebsInfo && (
     <span>
       <br />
       <span className={`select-option-label-attributes`}>
-        {`EBS: optimization ${props.instanceType.ebsInfo.ebsOptimizedSupport} | NVMe ${props.instanceType.ebsInfo.nvmeSupport} | Encryption ${props.instanceType.ebsInfo.encryptionSupport}`}
+        {`EBS: optimization ${props.instanceType?.ebsInfo?.ebsOptimizedSupport} | NVMe ${props.instanceType?.ebsInfo?.nvmeSupport} | Encryption ${props.instanceType?.ebsInfo?.encryptionSupport}`}
       </span>
     </span>
   );
-  const gpuInfo = props.instanceType.gpuInfo && (
+  const gpuInfo = props.instanceType?.gpuInfo && (
     <span>
       <br />
       <span className={`select-option-label-attributes`}>
-        {`GPU: ${props.instanceType.gpuInfo.totalGpuMemoryInMiB} MiB total memory`}
-        {props.instanceType.gpuInfo.gpus.map(
+        {`GPU: ${props.instanceType?.gpuInfo?.totalGpuMemoryInMiB} MiB total memory`}
+        {props.instanceType?.gpuInfo?.gpus.map(
           (g) => ` | ${g.count} ${g.manufacturer} ${g.name} GPUs, size: ${g.gpuSizeInMiB} MiB`,
         )}
       </span>
     </span>
   );
-  const generationInfo = typeof props.instanceType.currentGeneration !== 'undefined' &&
-    props.instanceType.currentGeneration !== null && (
+  const generationInfo = typeof props.instanceType?.currentGeneration !== 'undefined' &&
+    props.instanceType?.currentGeneration !== null && (
       <span>
         <br />
         <span className={`select-option-label-attributes`}>
-          {props.instanceType.currentGeneration ? 'Current Generation' : 'Previous Generation'}
+          {props.instanceType?.currentGeneration ? 'Current Generation' : 'Previous Generation'}
         </span>
       </span>
     );
 
   return (
     <span>
-      <span className={`select-option-label`}>{props.instanceType.name}</span>
+      <span className={`select-option-label`}>{props.instanceType?.name}</span>
       <br />
       <span className={`select-option-label-attributes`}>{CpuMem}</span>
       {instanceStorageInfo}

package/src/serverGroup/configure/wizard/instanceType/advancedMode/InstanceTypeTable.tsx

@@ -6,10 +6,12 @@ import { CpuCreditsToggle } from '../CpuCreditsToggle';
 import { InstanceTypeTableBody } from './InstanceTypeTableBody';
 import { Header, Heading } from './InstanceTypeTableParts';
 import { Footer } from './InstanceTypeTableParts';
+import { InstanceTypeWarning } from '../InstanceTypeWarning';
 import { AWSProviderSettings } from '../../../../../aws.settings';
 import type { IAmazonInstanceTypeCategory } from '../../../../../instance/awsInstanceType.service';
 import type { IAmazonInstanceType } from '../../../../../instance/awsInstanceType.service';
 import type { IAmazonInstanceTypeOverride } from '../../../serverGroupConfiguration.service';
+import type { IAmazonServerGroupCommandViewState } from '../../../serverGroupConfiguration.service';
 
 import './advancedMode.less';
 
@@ -21,6 +23,8 @@ export interface IInstanceTypeTableProps {
   availableInstanceTypesList: IAmazonInstanceType[];
   handleInstanceTypesChange: (instanceTypes: IAmazonInstanceTypeOverride[]) => void;
   setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
+  viewState: IAmazonServerGroupCommandViewState;
+  clearWarnings: () => void;
 }
 
 export function InstanceTypeTable(props: IInstanceTypeTableProps) {
@@ -96,6 +100,7 @@ export function InstanceTypeTable(props: IInstanceTypeTableProps) {
           profileLabel={label}
           profileDescriptionArr={descriptionListOverride ? descriptionListOverride : families.map((f) => f.description)}
         />
+        <InstanceTypeWarning dirty={props.viewState.dirty} clearWarnings={props.clearWarnings} />
         {isCpuCreditsEnabled && cpuCreditsToggle}
         <table className="table table-hover">
           <Header isCustom={isCustom} showCpuCredits={showCpuCredits} />
@@ -115,6 +120,7 @@ export function InstanceTypeTable(props: IInstanceTypeTableProps) {
     return (
       <div className={'row sub-section'}>
         <Heading isCustom={isCustom} />
+        <InstanceTypeWarning dirty={props.viewState.dirty} clearWarnings={props.clearWarnings} />
         {isCpuCreditsEnabled && cpuCreditsToggle}
         <table className="table table-hover">
           <Header isCustom={isCustom} />

package/src/serverGroup/configure/wizard/instanceType/simpleMode/SimpleModeSelector.tsx

@@ -3,6 +3,7 @@ import React from 'react';
 import { NgReact } from '@spinnaker/core';
 
 import { CpuCreditsToggle } from '../CpuCreditsToggle';
+import { InstanceTypeWarning } from '../InstanceTypeWarning';
 import { AWSProviderSettings } from '../../../../../aws.settings';
 import type { IAmazonServerGroupCommand } from '../../../serverGroupConfiguration.service';
 
@@ -10,6 +11,7 @@ export interface ISimpleModeSelectorProps {
   command: IAmazonServerGroupCommand;
   setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
   setFieldValue: (field: keyof IAmazonServerGroupCommand, value: any, shouldValidate?: boolean) => void;
+  clearWarnings: () => void;
 }
 
 export function SimpleModeSelector(props: ISimpleModeSelectorProps) {
@@ -41,6 +43,7 @@ export function SimpleModeSelector(props: ISimpleModeSelectorProps) {
           onTypeChanged={instanceTypeChanged}
           onProfileChanged={instanceProfileChanged}
         />
+        <InstanceTypeWarning dirty={command.viewState.dirty} clearWarnings={props.clearWarnings} />
         <div style={{ padding: '0 15px' }}>
           {command.viewState.instanceProfile && command.viewState.instanceProfile !== 'custom' && (
             <InstanceTypeSelector command={command} onTypeChanged={instanceTypeChanged} />

package/src/serverGroup/configure/wizard/pages/ServerGroupBasicSettings.tsx

@@ -98,6 +98,9 @@ export class ServerGroupBasicSettings
         setFieldValue('associateIPv6Address', false);
       }
     }
+
+    // an image change might clear the single or multiple instance types previously selected with the image, validate the form to surface related errors.
+    this.props.formik.validateForm();
   };
 
   private accountUpdated = (account: string): void => {

package/src/serverGroup/configure/wizard/pages/ServerGroupInstanceType.tsx

@@ -31,12 +31,22 @@ export class ServerGroupInstanceType
     const errors: FormikErrors<IAmazonServerGroupCommand> = {};
 
     if (values.viewState.useSimpleInstanceTypeSelector) {
-      if (!values.instanceType) {
+      // For the clone scenario, when values.instanceType is cleared for various reasons (see serverGroupConfiguration.service.ts),
+      // the previously selected instance type might be cleared/ unselected to fail-fast and this might look like unexpected behavior. But, there is always a reason when this happens.
+      // The error handling below adds transparency around what changed and why.
+      if (values.viewState.dirty.instanceType) {
+        errors.instanceType = 'You must confirm removed instance type and pick a compatible instance type.';
+      } else if (!values.instanceType) {
         errors.instanceType = 'Instance Type required.';
       }
     } else {
-      const advancedModeErrors = this.validateAdvancedModeFields(values, errors);
-      Object.assign(errors, { ...advancedModeErrors });
+      const prevInstanceTypes = values.viewState.dirty.launchTemplateOverridesForInstanceType;
+      if (prevInstanceTypes && prevInstanceTypes.length > 0) {
+        errors.instanceType = 'You must confirm removed instance types and/or pick more instance types.';
+      } else {
+        const advancedModeErrors = this.validateAdvancedModeFields(values, errors);
+        Object.assign(errors, { ...advancedModeErrors });
+      }
     }
 
     return errors;

package/src/serverGroup/details/sections/LaunchConfigDetailsSection.tsx

@@ -58,8 +58,12 @@ export class LaunchConfigDetailsSection extends React.Component<
             <dt>IAM Profile</dt>
             <dd>{launchConfig.iamInstanceProfile}</dd>
 
-            <dt>Instance Monitoring</dt>
-            <dd>{launchConfig.instanceMonitoring.enabled ? 'enabled' : 'disabled'}</dd>
+            {launchConfig.instanceMonitoring && (
+              <>
+                <dt>Instance Monitoring</dt>
+                <dd>{launchConfig.instanceMonitoring.enabled ? 'enabled' : 'disabled'}</dd>
+              </>
+            )}
 
             {launchConfig.spotPrice && <dt>Spot Price</dt>}
             {launchConfig.spotPrice && <dd>{launchConfig.spotPrice}</dd>}

package/src/serverGroup/serverGroup.transformer.ts

@@ -96,6 +96,10 @@ export class AwsServerGroupTransformer {
     deployConfig.targetGroups = base.targetGroups || [];
     deployConfig.account = deployConfig.credentials;
     deployConfig.subnetType = deployConfig.subnetType || '';
+    deployConfig.instanceType =
+      deployConfig.instanceType ||
+      (deployConfig.launchTemplateOverridesForInstanceType &&
+        deployConfig.launchTemplateOverridesForInstanceType[0].instanceType); // populate instanceType for backwards compatibility
 
     if (base.viewState.mode !== 'clone') {
       delete deployConfig.source;