@spinnaker/amazon 0.11.0 → 0.12.2

package/src/loadBalancer/details/LoadBalancerActions.tsx

@@ -13,6 +13,7 @@ import {
   SETTINGS,
 } from '@spinnaker/core';
 
+import { AWSProviderSettings } from '../../aws.settings';
 import { LoadBalancerTypes } from '../configure/LoadBalancerTypes';
 import type { IAmazonLoadBalancer, IAmazonLoadBalancerDeleteCommand } from '../../domain';
 import type { ILoadBalancerFromStateParams } from './loadBalancerDetails.controller';
@@ -114,7 +115,7 @@ export class LoadBalancerActions extends React.Component<ILoadBalancerActionsPro
 
     return (
       <div style={{ display: 'inline-block' }}>
-        {SETTINGS.awsAdHocInfraWritesEnabled && (
+        {AWSProviderSettings.adHocInfraWritesEnabled && (
           <Dropdown className="dropdown" id="load-balancer-actions-dropdown">
             <Dropdown.Toggle className="btn btn-sm btn-primary dropdown-toggle">
               <span>Load Balancer Actions</span>

package/src/loadBalancer/details/loadBalancerDetails.controller.spec.ts

@@ -1,7 +1,9 @@
-import { IControllerService, IRootScopeService, mock } from 'angular';
-import { StateService } from '@uirouter/core';
+import type { StateService } from '@uirouter/core';
+import type { IControllerService, IRootScopeService } from 'angular';
+import { mock } from 'angular';
 
-import { ApplicationModelBuilder, ISubnet } from '@spinnaker/core';
+import type { ISubnet } from '@spinnaker/core';
+import { ApplicationModelBuilder } from '@spinnaker/core';
 
 import { AWS_LOAD_BALANCER_DETAILS_CTRL, AwsLoadBalancerDetailsController } from './loadBalancerDetails.controller';
 

package/src/search/{searchResultFormatter.js → searchResultFormatter.ts}

@@ -1,18 +1,19 @@
-'use strict';
-
 import { module } from 'angular';
 
+import type { ISecurityGroupSearchResult } from '@spinnaker/core';
+import type { ISearchResultFormatter } from '@spinnaker/core';
+
 import { VpcReader } from '../vpc/VpcReader';
 
 export const AMAZON_SEARCH_SEARCHRESULTFORMATTER = 'spinnaker.amazon.search.searchResultFormatter';
 export const name = AMAZON_SEARCH_SEARCHRESULTFORMATTER; // for backwards compatibility
 module(AMAZON_SEARCH_SEARCHRESULTFORMATTER, []).factory('awsSearchResultFormatter', function () {
   return {
-    securityGroups: function (entry) {
+    securityGroups: function (entry: ISecurityGroupSearchResult) {
       return VpcReader.getVpcName(entry.vpcId).then(function (vpcName) {
         const region = vpcName ? entry.region + ' - ' + vpcName.toLowerCase() : entry.region;
         return entry.name + ' (' + region + ')';
       });
-    },
+    } as ISearchResultFormatter,
   };
 });

package/src/securityGroup/details/securityGroupDetail.controller.js

@@ -17,6 +17,7 @@ import {
   SETTINGS,
 } from '@spinnaker/core';
 
+import { AWSProviderSettings } from '../../aws.settings';
 import { AMAZON_SECURITYGROUP_CLONE_CLONESECURITYGROUP_CONTROLLER } from '../clone/cloneSecurityGroup.controller';
 import { VpcReader } from '../../vpc/VpcReader';
 
@@ -46,7 +47,7 @@ angular
       // needed for standalone instances
       $scope.detailsTemplateUrl = CloudProviderRegistry.getValue('aws', 'securityGroup.detailsTemplateUrl');
 
-      $scope.isDisabled = !SETTINGS.awsAdHocInfraWritesEnabled;
+      $scope.isDisabled = !AWSProviderSettings.adHocInfraWritesEnabled;
 
       $scope.state = {
         loading: true,

package/src/serverGroup/configure/AmazonImageSelectInput.spec.tsx

@@ -1,13 +1,16 @@
-import React from 'react';
-import { mockHttpClient } from 'core/api/mock/jasmine';
 import { mock } from 'angular';
-import { ShallowWrapper, ReactWrapper, shallow, mount } from 'enzyme';
+import type { ReactWrapper, ShallowWrapper } from 'enzyme';
+import { mount, shallow } from 'enzyme';
+import React from 'react';
 
-import { IAmazonImage } from '../../image';
-import { Application } from 'core/application';
-import { REACT_MODULE } from 'core/reactShims';
+import { Application } from '@spinnaker/core';
+import { REACT_MODULE } from '@spinnaker/core';
 
-import { AmazonImageSelectInput, IAmazonImageSelectorProps, IAmazonImageSelectorState } from './AmazonImageSelectInput';
+import type { IAmazonImageSelectorProps, IAmazonImageSelectorState } from './AmazonImageSelectInput';
+import { AmazonImageSelectInput } from './AmazonImageSelectInput';
+// eslint-disable-next-line @spinnaker/import-from-npm-not-relative
+import { mockHttpClient } from '../../../../core/src/api/mock/jasmine';
+import type { IAmazonImage } from '../../image';
 const application = new Application('testapp', null, []);
 const region = 'us-region-1';
 const credentials = 'prodaccount';

package/src/serverGroup/configure/serverGroupCommandBuilder.aws.service.spec.js

@@ -3,16 +3,24 @@
 import { AccountService, SubnetReader } from '@spinnaker/core';
 
 import { AWSProviderSettings } from '../../aws.settings';
+import {
+  createCustomMockLaunchTemplate,
+  mockLaunchTemplate,
+  mockLaunchTemplateData,
+  mockServerGroup,
+} from '@spinnaker/mocks';
 
 describe('Service: awsServerGroup', function () {
   beforeEach(window.module(require('./serverGroupCommandBuilder.service').name));
 
+  let instanceTypeService;
   beforeEach(
     window.inject(function (awsServerGroupCommandBuilder, _instanceTypeService_, _$q_, $rootScope) {
       this.service = awsServerGroupCommandBuilder;
       this.$q = _$q_;
       this.$scope = $rootScope;
-      spyOn(_instanceTypeService_, 'getCategoryForInstanceType').and.returnValue(_$q_.when('custom'));
+      instanceTypeService = _instanceTypeService_;
+      spyOn(instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(_$q_.when('custom'));
     }),
   );
 
@@ -30,6 +38,7 @@ describe('Service: awsServerGroup', function () {
           min: 1,
           max: 1,
         },
+        instanceType: 'm5.large',
       };
 
       AWSProviderSettings.defaults = {
@@ -77,6 +86,73 @@ describe('Service: awsServerGroup', function () {
       this.$scope.$digest();
       expect(command.viewState.usePreferredZones).toBe(false);
     });
+
+    describe('extracts instanceProfile from pipeline cluster correctly', function () {
+      const cluster = {
+        account: 'prod',
+        availabilityZones: {
+          'us-west-1': ['d', 'g'],
+        },
+        capacity: {
+          min: 1,
+          max: 1,
+        },
+        instanceType: 'm5.large',
+      };
+
+      const clusters = [
+        {
+          desc: 'single instance type',
+          cluster: {
+            ...cluster,
+            instanceType: 'r5.large',
+          },
+          expected: {
+            instanceTypes: ['r5.large'],
+            useSimpleInstanceTypeSelector: true,
+          },
+        },
+        {
+          desc: 'multiple instance types',
+          cluster: {
+            ...cluster,
+            spotAllocationStrategy: 'capacity-optimized',
+            launchTemplateOverridesForInstanceType: [
+              {
+                instanceType: 't3.nano',
+                weightedCapacity: '2',
+              },
+              {
+                instanceType: 't3.micro',
+                weightedCapacity: '4',
+              },
+            ],
+          },
+          expected: {
+            instanceTypes: ['t3.nano', 't3.micro'],
+            useSimpleInstanceTypeSelector: false,
+          },
+        },
+      ];
+
+      clusters.forEach((test) => {
+        it(`cluster with ${test.desc}`, function () {
+          let actualCommand = null;
+          this.service.buildServerGroupCommandFromPipeline({}, test.cluster).then(function (result) {
+            actualCommand = result;
+          });
+          this.$scope.$digest();
+
+          expect(instanceTypeService.getCategoryForMultipleInstanceTypes).toHaveBeenCalledWith(
+            'aws',
+            test.expected.instanceTypes,
+          );
+          expect(actualCommand.viewState.useSimpleInstanceTypeSelector).toBe(
+            test.expected.useSimpleInstanceTypeSelector,
+          );
+        });
+      });
+    });
   });
 
   describe('buildServerGroupCommandFromExisting', function () {
@@ -97,6 +173,7 @@ describe('Service: awsServerGroup', function () {
             { processName: 'AddToLoadBalancer' },
           ],
         },
+        launchTemplate: mockLaunchTemplate,
       };
       var command = null;
       this.service.buildServerGroupCommandFromExisting({}, serverGroup).then(function (result) {
@@ -114,6 +191,7 @@ describe('Service: awsServerGroup', function () {
           vpczoneIdentifier: '',
           suspendedProcesses: [],
         },
+        launchTemplate: mockLaunchTemplate,
       };
       var command = null;
       this.service.buildServerGroupCommandFromExisting({}, serverGroup, 'editPipeline').then(function (result) {
@@ -125,5 +203,228 @@ describe('Service: awsServerGroup', function () {
       expect(command.viewState.useSimpleCapacity).toBe(false);
       expect(command.useSourceCapacity).toBe(true);
     });
+
+    describe('extracts properties from server group correctly', function () {
+      const sgCommon = {
+        ...mockServerGroup,
+        asg: {
+          autoScalingGroupName: 'myasg-test-v000',
+          availabilityZones: [],
+          vpczoneIdentifier: '',
+          suspendedProcesses: [],
+          enabledMetrics: [],
+        },
+      };
+
+      const testLt = createCustomMockLaunchTemplate('test-lt', {
+        ...mockLaunchTemplateData,
+        instanceMarketOptions: {
+          spotOptions: {
+            maxPrice: '0.50',
+          },
+        },
+        networkInterfaces: [
+          {
+            deviceIndex: 0,
+            groups: ['my-sg'],
+            ipv6AddressCount: 1,
+            ipv6Addresses: [],
+            privateIpAddresses: [],
+          },
+        ],
+        keyName: 'test',
+        kernelId: 'kernal-abc',
+        ramDiskId: 'ramDisk-123',
+        userData: 'thisisfakeuserdata',
+        instanceType: 'm5.large',
+      });
+
+      const serverGroupsWithoutMip = [
+        {
+          desc: 'launchConfig',
+          sg: {
+            ...sgCommon,
+            launchConfig: {
+              instanceType: 'r5.large',
+              securityGroups: [],
+            },
+          },
+          expected: {
+            instanceType: 'r5.large',
+            launchTemplateOverridesForInstanceType: undefined,
+            instanceTypesParam: ['r5.large'],
+            useSimpleInstanceTypeSelector: true,
+          },
+        },
+        {
+          desc: 'launchTemplate',
+          sg: {
+            ...sgCommon,
+            launchTemplate: testLt,
+          },
+          expected: {
+            instanceType: 'm5.large',
+            launchTemplateOverridesForInstanceType: undefined,
+            instanceTypesParam: ['m5.large'],
+            useSimpleInstanceTypeSelector: true,
+            spotPrice: '0.50',
+            associateIPv6Address: true,
+            securityGroups: ['my-sg'],
+          },
+        },
+      ];
+
+      const mipCommon = {
+        instancesDistribution: {
+          onDemandAllocationStrategy: 'prioritized',
+          onDemandBaseCapacity: 1,
+          onDemandPercentageAboveBaseCapacity: 50,
+          spotAllocationStrategy: 'capacity-optimized',
+        },
+      };
+
+      const serverGroupsWithMip = [
+        {
+          desc: 'mixedInstancesPolicy without overrides',
+          sg: {
+            ...sgCommon,
+            mixedInstancesPolicy: {
+              instancesDistribution: {
+                onDemandAllocationStrategy: 'prioritized',
+                onDemandBaseCapacity: 1,
+                onDemandPercentageAboveBaseCapacity: 50,
+                spotAllocationStrategy: 'capacity-optimized',
+                spotMaxPrice: '1.5',
+              },
+              allowedInstanceTypes: ['m5.large'],
+              launchTemplates: [testLt],
+            },
+          },
+          expected: {
+            instanceType: 'm5.large',
+            launchTemplateOverridesForInstanceType: undefined,
+            instanceTypesParam: ['m5.large'],
+            useSimpleInstanceTypeSelector: false,
+            spotPrice: '1.5',
+            associateIPv6Address: true,
+            securityGroups: ['my-sg'],
+          },
+        },
+        {
+          desc: 'mixedInstancesPolicy with overrides and no priority',
+          sg: {
+            ...sgCommon,
+            mixedInstancesPolicy: {
+              ...mipCommon,
+              launchTemplates: [mockLaunchTemplate],
+              allowedInstanceTypes: ['t3.nano', 'm5.large'],
+              launchTemplateOverridesForInstanceType: [
+                { instanceType: 't3.nano', weightedCapacity: '2' },
+                { instanceType: 'm5.large', weightedCapacity: '4' },
+              ],
+            },
+          },
+          expected: {
+            instanceType: undefined,
+            launchTemplateOverridesForInstanceType: [
+              { instanceType: 't3.nano', priority: 1, weightedCapacity: '2' },
+              { instanceType: 'm5.large', priority: 2, weightedCapacity: '4' },
+            ],
+            instanceTypesParam: ['t3.nano', 'm5.large'],
+            useSimpleInstanceTypeSelector: false,
+          },
+        },
+        {
+          desc: 'mixedInstancesPolicy with overrides and all instance types have priority',
+          sg: {
+            ...sgCommon,
+            mixedInstancesPolicy: {
+              ...mipCommon,
+              launchTemplates: [mockLaunchTemplate],
+              allowedInstanceTypes: ['t3.nano', 'm5.large'],
+              launchTemplateOverridesForInstanceType: [
+                { instanceType: 't3.nano', weightedCapacity: '2', priority: 2 },
+                { instanceType: 'm5.large', weightedCapacity: '4', priority: 1 },
+              ],
+            },
+          },
+          expected: {
+            instanceType: undefined,
+            launchTemplateOverridesForInstanceType: [
+              ,
+              { instanceType: 'm5.large', weightedCapacity: '4', priority: 1 },
+              { instanceType: 't3.nano', weightedCapacity: '2', priority: 2 },
+            ],
+            instanceTypesParam: ['t3.nano', 'm5.large'],
+            useSimpleInstanceTypeSelector: false,
+          },
+        },
+        {
+          desc: 'mixedInstancesPolicy with overrides and some instance types have priority',
+          sg: {
+            ...sgCommon,
+            mixedInstancesPolicy: {
+              ...mipCommon,
+              launchTemplates: [mockLaunchTemplate],
+              allowedInstanceTypes: ['t3.nano', 't3.micro', 't2.nano', 't2.micro'],
+              launchTemplateOverridesForInstanceType: [
+                { instanceType: 't3.nano' },
+                { instanceType: 't3.micro', priority: 2 },
+                { instanceType: 't2.nano' },
+                { instanceType: 't2.micro', priority: 1 },
+              ],
+            },
+          },
+          expected: {
+            instanceType: undefined,
+            launchTemplateOverridesForInstanceType: [
+              { instanceType: 't2.micro', priority: 1 },
+              { instanceType: 't3.micro', priority: 2 },
+              { instanceType: 't3.nano', priority: 3 },
+              { instanceType: 't2.nano', priority: 4 },
+            ],
+            instanceTypesParam: ['t3.nano', 't3.micro', 't2.nano', 't2.micro'],
+            useSimpleInstanceTypeSelector: false,
+          },
+        },
+      ];
+
+      [...serverGroupsWithoutMip, ...serverGroupsWithMip].forEach((test) => {
+        it(`extracts instanceProfile, instanceType and useSimpleInstanceTypeSelector from server group with ${test.desc} correctly`, function () {
+          let actualCommand = null;
+          this.service.buildServerGroupCommandFromExisting({}, test.sg, 'clone').then(function (result) {
+            actualCommand = result;
+          });
+          this.$scope.$digest();
+
+          expect(instanceTypeService.getCategoryForMultipleInstanceTypes).toHaveBeenCalledWith(
+            'aws',
+            test.expected.instanceTypesParam,
+          );
+          expect(actualCommand.instanceType).toBe(test.expected.instanceType);
+          expect(actualCommand.viewState.useSimpleInstanceTypeSelector).toBe(
+            test.expected.useSimpleInstanceTypeSelector,
+          );
+          test.expected.spotPrice && expect(actualCommand.spotPrice).toBe(test.expected.spotPrice);
+        });
+      });
+
+      serverGroupsWithMip.forEach((test) => {
+        it(`extracts launchTemplateOverridesForInstanceType and sets explicit priority correctly for server group with ${test.desc}`, function () {
+          let actualCommand = null;
+          this.service.buildServerGroupCommandFromExisting({}, test.sg, 'clone').then(function (result) {
+            actualCommand = result;
+          });
+          this.$scope.$digest();
+
+          expect(
+            _.isEqual(
+              actualCommand.launchTemplateOverridesForInstanceType,
+              test.expected.launchTemplateOverridesForInstanceType,
+            ).toBeTruthy,
+          );
+        });
+      });
+    });
   });
 });

package/src/serverGroup/configure/serverGroupCommandBuilder.service.js

@@ -86,6 +86,7 @@ angular
               copySourceCustomBlockDeviceMappings: false, // default to using block device mappings from current instance type
               viewState: {
                 instanceProfile: 'custom',
+                useSimpleInstanceTypeSelector: true,
                 useAllImageSelection: false,
                 useSimpleCapacity: true,
                 usePreferredZones: true,
@@ -130,10 +131,15 @@ angular
       function buildServerGroupCommandFromPipeline(application, originalCluster) {
         const pipelineCluster = _.cloneDeep(originalCluster);
         const region = Object.keys(pipelineCluster.availabilityZones)[0];
-        const instanceTypeCategoryLoader = instanceTypeService.getCategoryForInstanceType(
+
+        let instanceTypes = pipelineCluster.launchTemplateOverridesForInstanceType
+          ? pipelineCluster.launchTemplateOverridesForInstanceType.map((o) => o.instanceType)
+          : [pipelineCluster.instanceType];
+        const instanceTypeCategoryLoader = instanceTypeService.getCategoryForMultipleInstanceTypes(
           'aws',
-          pipelineCluster.instanceType,
+          instanceTypes,
         );
+
         const commandOptions = { account: pipelineCluster.account, region: region };
         const asyncLoader = $q.all([
           buildNewServerGroupCommand(application, commandOptions),
@@ -156,6 +162,7 @@ angular
             templatingEnabled: true,
             existingPipelineCluster: true,
             dirty: {},
+            useSimpleInstanceTypeSelector: isSimpleModeEnabled(pipelineCluster),
           };
 
           const viewOverrides = {
@@ -213,15 +220,23 @@ angular
       function buildServerGroupCommandFromExisting(application, serverGroup, mode = 'clone') {
         const preferredZonesLoader = AccountService.getPreferredZonesByAccount('aws');
         const subnetsLoader = SubnetReader.listSubnets();
-
         const serverGroupName = NameUtils.parseServerGroupName(serverGroup.asg.autoScalingGroupName);
 
-        const instanceType = serverGroup.launchConfig
-          ? serverGroup.launchConfig.instanceType
-          : serverGroup.launchTemplate
-          ? serverGroup.launchTemplate.launchTemplateData.instanceType
-          : null;
-        const instanceTypeCategoryLoader = instanceTypeService.getCategoryForInstanceType('aws', instanceType);
+        let instanceTypes;
+        if (serverGroup.mixedInstancesPolicy) {
+          const ltOverrides = _.get(serverGroup, 'mixedInstancesPolicy.launchTemplateOverridesForInstanceType');
+          instanceTypes = ltOverrides
+            ? ltOverrides.map((o) => o.instanceType)
+            : [_.get(serverGroup, 'mixedInstancesPolicy.launchTemplates[0].launchTemplateData.instanceType')]; // note: single launch template case is currently the only supported case for mixed instances policy
+        } else if (serverGroup.launchTemplate) {
+          instanceTypes = [_.get(serverGroup, 'launchTemplate.launchTemplateData.instanceType')];
+        } else if (serverGroup.launchConfig) {
+          instanceTypes = [_.get(serverGroup, 'launchConfig.instanceType')];
+        }
+        const instanceTypeCategoryLoader = instanceTypeService.getCategoryForMultipleInstanceTypes(
+          'aws',
+          instanceTypes,
+        );
 
         return $q
           .all([preferredZonesLoader, subnetsLoader, instanceTypeCategoryLoader])
@@ -333,7 +348,8 @@ angular
                 keyPair: serverGroup.launchConfig.keyName,
                 associatePublicIpAddress: serverGroup.launchConfig.associatePublicIpAddress,
                 ramdiskId: serverGroup.launchConfig.ramdiskId,
-                instanceMonitoring: serverGroup.launchConfig.instanceMonitoring.enabled,
+                instanceMonitoring:
+                  serverGroup.launchConfig.instanceMonitoring && serverGroup.launchConfig.instanceMonitoring.enabled,
                 ebsOptimized: serverGroup.launchConfig.ebsOptimized,
                 spotPrice: serverGroup.launchConfig.spotPrice,
               });
@@ -341,18 +357,47 @@ angular
                 command.base64UserData = serverGroup.launchConfig.userData;
               }
               command.viewState.imageId = serverGroup.launchConfig.imageId;
+              command.viewState.useSimpleInstanceTypeSelector = true;
             }
 
-            if (serverGroup.launchTemplate) {
-              const { launchTemplateData } = serverGroup.launchTemplate;
-              const maxPrice =
-                launchTemplateData.instanceMarketOptions &&
-                launchTemplateData.instanceMarketOptions.spotOptions &&
-                launchTemplateData.instanceMarketOptions.spotOptions.maxPrice;
-              const { ipv6AddressCount } =
-                launchTemplateData.networkInterfaces &&
-                launchTemplateData.networkInterfaces.length &&
-                launchTemplateData.networkInterfaces[0];
+            if (serverGroup.launchTemplate || serverGroup.mixedInstancesPolicy) {
+              let launchTemplateData, spotMaxPrice;
+              if (serverGroup.launchTemplate) {
+                launchTemplateData = serverGroup.launchTemplate.launchTemplateData;
+                spotMaxPrice = _.get(launchTemplateData, 'instanceMarketOptions.spotOptions.maxPrice');
+
+                command.instanceType = launchTemplateData.instanceType;
+                command.viewState.useSimpleInstanceTypeSelector = true;
+              }
+
+              if (serverGroup.mixedInstancesPolicy) {
+                const mip = serverGroup.mixedInstancesPolicy;
+                launchTemplateData = _.get(mip, 'launchTemplates[0].launchTemplateData'); // note: single launch template case is currently the only supported case for mixed instances policy
+                spotMaxPrice = _.get(mip, 'instancesDistribution.spotMaxPrice');
+
+                command.securityGroups = launchTemplateData.networkInterfaces
+                  ? (launchTemplateData.networkInterfaces.find((ni) => ni.deviceIndex === 0) || {}).groups
+                  : _.get(launchTemplateData, 'securityGroups');
+                command.onDemandAllocationStrategy = mip.instancesDistribution.onDemandAllocationStrategy;
+                command.onDemandBaseCapacity = mip.instancesDistribution.onDemandBaseCapacity;
+                command.onDemandPercentageAboveBaseCapacity =
+                  mip.instancesDistribution.onDemandPercentageAboveBaseCapacity;
+                command.spotAllocationStrategy = mip.instancesDistribution.spotAllocationStrategy;
+                command.spotInstancePools = mip.instancesDistribution.spotInstancePools;
+
+                // 'launchTemplateOverridesForInstanceType' is used for multiple instance types case, 'instanceType' is used for all other cases.
+                if (mip.launchTemplateOverridesForInstanceType) {
+                  command.launchTemplateOverridesForInstanceType = getInstanceTypesWithPriority(
+                    mip.launchTemplateOverridesForInstanceType,
+                  );
+                } else {
+                  command.instanceType = launchTemplateData.instanceType;
+                }
+
+                command.viewState.useSimpleInstanceTypeSelector = isSimpleModeEnabled(command);
+              }
+
+              const ipv6AddressCount = _.get(launchTemplateData, 'networkInterfaces[0]');
 
               const asgSettings = AWSProviderSettings.serverGroups;
               const isTestEnv = serverGroup.accountDetails && serverGroup.accountDetails.environment === 'test';
@@ -360,16 +405,15 @@ angular
                 asgSettings && asgSettings.enableIPv6 && asgSettings.setIPv6InTest && isTestEnv;
 
               angular.extend(command, {
-                instanceType: launchTemplateData.instanceType,
                 iamRole: launchTemplateData.iamInstanceProfile.name,
                 keyPair: launchTemplateData.keyName,
                 associateIPv6Address: shouldAutoEnableIPv6 || Boolean(ipv6AddressCount),
                 ramdiskId: launchTemplateData.ramdiskId,
-                instanceMonitoring: launchTemplateData.monitoring.enabled,
+                instanceMonitoring: launchTemplateData.monitoring && launchTemplateData.monitoring.enabled,
                 ebsOptimized: launchTemplateData.ebsOptimized,
-                spotPrice: maxPrice || undefined,
+                spotPrice: spotMaxPrice || undefined,
                 requireIMDSv2: Boolean(
-                  launchTemplateData.metadataOptions && launchTemplateData.metadataOptions.httpTokens === 'required',
+                  launchTemplateData.metadataOptions && launchTemplateData.metadataOptions.httpsTokens === 'required',
                 ),
                 unlimitedCpuCredits: launchTemplateData.creditSpecification
                   ? launchTemplateData.creditSpecification.cpuCredits === 'unlimited'
@@ -402,6 +446,34 @@ angular
           });
       }
 
+      // Since Deck allows changing priority of instance types via drag handle, fill priority field explicitly if empty
+      function getInstanceTypesWithPriority(instanceTypeOverrides) {
+        let explicitPriority = 1;
+        return _.sortBy(instanceTypeOverrides, ['priority']).map((override) => {
+          const { instanceType, weightedCapacity } = override;
+          let priority;
+          if (override.priority) {
+            priority = override.priority;
+            explicitPriority = override.priority + 1;
+          } else {
+            priority = explicitPriority++;
+          }
+          return { instanceType, weightedCapacity, priority };
+        });
+      }
+
+      function isSimpleModeEnabled(command) {
+        const isAdvancedModeEnabledInCommand =
+          command.onDemandAllocationStrategy ||
+          command.onDemandBaseCapacity ||
+          command.onDemandPercentageAboveBaseCapacity ||
+          command.spotAllocationStrategy ||
+          command.spotInstancePools ||
+          (command.launchTemplateOverridesForInstanceType && command.launchTemplateOverridesForInstanceType.length > 0);
+
+        return !isAdvancedModeEnabledInCommand;
+      }
+
       return {
         buildNewServerGroupCommand: buildNewServerGroupCommand,
         buildServerGroupCommandFromExisting: buildServerGroupCommandFromExisting,