@spinnaker/amazon 0.11.1 → 0.12.3

package/dist/instance/awsInstanceType.service.d.ts

@@ -1,2 +1,10 @@
-export const AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE: "spinnaker.amazon.instanceType.service";
-export const name: "spinnaker.amazon.instanceType.service";
+import type { IInstanceTypeCategory, IPreferredInstanceType } from '@spinnaker/core';
+export interface IAmazonPreferredInstanceType extends IPreferredInstanceType {
+    cpuCreditsPerHour?: number;
+}
+export interface IAmazonInstanceTypeCategory extends IInstanceTypeCategory {
+    showCpuCredits?: boolean;
+    descriptionListOverride?: string[];
+}
+export declare const AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE = "spinnaker.amazon.instanceType.service";
+export declare const name = "spinnaker.amazon.instanceType.service";

package/dist/instance/awsInstanceTypes.d.ts

@@ -0,0 +1,10 @@
+import type { IInstanceTypeCategory, IInstanceTypeFamily } from '@spinnaker/core';
+interface IAwsInstanceTypeCategory extends IInstanceTypeCategory {
+    showCpuCredits?: boolean;
+    descriptionListOverride?: string[];
+}
+export declare const defaultCategories: IAwsInstanceTypeCategory[];
+export declare const categories: (IAwsInstanceTypeCategory & {
+    families: IInstanceTypeFamily[];
+})[];
+export {};

package/dist/instance/details/CostFactor.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export interface ICostFactorProps {
+    min: number;
+    max?: number;
+}
+export declare const CostFactor: ({ min, max }: ICostFactorProps) => JSX.Element;

package/dist/reactShims/aws.react.injector.d.ts

@@ -3,11 +3,12 @@ import IInjectorService = angular.auto.IInjectorService;
 import type { FunctionReader } from '@spinnaker/core';
 import { ReactInject } from '@spinnaker/core';
 import type { EvaluateCloudFormationChangeSetExecutionService } from '../pipeline/stages/deployCloudFormation/evaluateCloudFormationChangeSetExecution.service';
+import type { AwsServerGroupCommandBuilder } from '../serverGroup/configure/serverGroupCommandBuilder.service';
 import type { AwsServerGroupConfigurationService } from '../serverGroup/configure/serverGroupConfiguration.service';
 import type { AwsServerGroupTransformer } from '../serverGroup/serverGroup.transformer';
 export declare class AwsReactInject extends ReactInject {
     get awsInstanceTypeService(): any;
-    get awsServerGroupCommandBuilder(): any;
+    get awsServerGroupCommandBuilder(): AwsServerGroupCommandBuilder;
     get awsServerGroupConfigurationService(): AwsServerGroupConfigurationService;
     get awsServerGroupTransformer(): AwsServerGroupTransformer;
     get functionReader(): FunctionReader;

package/dist/search/searchResultFormatter.d.ts

@@ -1,2 +1,2 @@
-export const AMAZON_SEARCH_SEARCHRESULTFORMATTER: "spinnaker.amazon.search.searchResultFormatter";
-export const name: "spinnaker.amazon.search.searchResultFormatter";
+export declare const AMAZON_SEARCH_SEARCHRESULTFORMATTER = "spinnaker.amazon.search.searchResultFormatter";
+export declare const name = "spinnaker.amazon.search.searchResultFormatter";

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

@@ -1,2 +1,17 @@
-export const AMAZON_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE: "spinnaker.amazon.serverGroupCommandBuilder.service";
-export const name: "spinnaker.amazon.serverGroupCommandBuilder.service";
+import type { Application } from '@spinnaker/core';
+import type { IAmazonServerGroup, IAmazonServerGroupView } from '../../domain';
+import type { IAmazonServerGroupCommand, IAmazonServerGroupDeployConfiguration } from './serverGroupConfiguration.service';
+export declare const AMAZON_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE = "spinnaker.amazon.serverGroupCommandBuilder.service";
+export declare const name = "spinnaker.amazon.serverGroupCommandBuilder.service";
+export interface AwsServerGroupCommandBuilder {
+    buildNewServerGroupCommand(application: Application, defaults?: {
+        account?: string;
+        region?: string;
+        subnet?: string;
+        mode?: string;
+    }): PromiseLike<Partial<IAmazonServerGroupCommand>>;
+    buildServerGroupCommandFromExisting(application: Application, serverGroup: IAmazonServerGroupView, mode?: string): PromiseLike<Partial<IAmazonServerGroupCommand>>;
+    buildNewServerGroupCommandForPipeline(): PromiseLike<Partial<IAmazonServerGroupCommand>>;
+    buildServerGroupCommandFromPipeline(application: Application, originalCluster: IAmazonServerGroupDeployConfiguration): PromiseLike<Partial<IAmazonServerGroupCommand>>;
+    buildUpdateServerGroupCommand(serverGroup: IAmazonServerGroup): Partial<IAmazonServerGroupCommand>;
+}

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

@@ -19,14 +19,39 @@ export interface IAmazonServerGroupCommandBackingData extends IServerGroupComman
     scalingProcesses: IScalingProcess[];
 }
 export interface IAmazonServerGroupCommandViewState extends IServerGroupCommandViewState {
+    isNew: boolean;
     dirty: IAmazonServerGroupCommandDirty;
     spelTargetGroups: string[];
     spelLoadBalancers: string[];
+    useSimpleInstanceTypeSelector: boolean;
+}
+export interface IAmazonInstanceTypeOverride {
+    instanceType: string;
+    weightedCapacity?: string;
+    priority?: number;
+}
+/**
+ * We model server group commands in two subtly different ways.
+ * It's unclear what the intention is, but we should converge on a single model eventually.
+ *
+ * This model is stored in a Aws Deploy Stage under `clusters[]`.
+ * It is also sent across the wire during a deploy task from infrastructure view
+ * (i.e., "clone server group", "create server group")
+ */
+export interface IAmazonServerGroupDeployConfiguration extends IAmazonServerGroupCommand_Internal {
+    account: string;
+    availabilityZones: {
+        [region: string]: string[];
+    };
+}
+interface IAmazonServerGroupCommand_Internal extends IAmazonServerGroupCommand {
+    availabilityZones: any;
 }
 export interface IAmazonServerGroupCommand extends IServerGroupCommand {
     associateIPv6Address?: boolean;
     associatePublicIpAddress: boolean;
     backingData: IAmazonServerGroupCommandBackingData;
+    base64UserData: string;
     copySourceCustomBlockDeviceMappings: boolean;
     ebsOptimized: boolean;
     healthCheckGracePeriod: number;
@@ -41,11 +66,24 @@ export interface IAmazonServerGroupCommand extends IServerGroupCommand {
     setLaunchTemplate?: boolean;
     unlimitedCpuCredits?: boolean;
     capacityRebalance?: boolean;
+    ramdiskId?: string;
     viewState: IAmazonServerGroupCommandViewState;
+    source: {
+        account: string;
+        region: string;
+        asgName: string;
+    };
+    onDemandAllocationStrategy?: string;
+    onDemandBaseCapacity?: number;
+    onDemandPercentageAboveBaseCapacity?: number;
+    spotAllocationStrategy?: string;
+    spotInstancePools?: number;
+    launchTemplateOverridesForInstanceType?: IAmazonInstanceTypeOverride[];
     getBlockDeviceMappingsSource: (command: IServerGroupCommand) => IBlockDeviceMappingSource;
     selectBlockDeviceMappingsSource: (command: IServerGroupCommand, selection: string) => void;
     usePreferredZonesChanged: (command: IServerGroupCommand) => IAmazonServerGroupCommandResult;
     regionIsDeprecated: (command: IServerGroupCommand) => boolean;
+    launchTemplateOverridesChanged: (command: IServerGroupCommand) => void;
 }
 export declare class AwsServerGroupConfigurationService {
     private securityGroupReader;
@@ -80,3 +118,4 @@ export declare class AwsServerGroupConfigurationService {
     attachEventHandlers(cmd: IAmazonServerGroupCommand): void;
 }
 export declare const AWS_SERVER_GROUP_CONFIGURATION_SERVICE = "spinnaker.amazon.serverGroup.configure.service";
+export {};

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

@@ -1,9 +1,8 @@
 /// <reference types="react" />
-import type { IAmazonServerGroupCommand } from '../../serverGroupConfiguration.service';
 export interface ICpuCreditsToggleProps {
-    command: IAmazonServerGroupCommand;
-    newInstanceType?: string;
-    newProfileType?: string;
+    unlimitedCpuCredits?: boolean;
+    selectedInstanceTypes: string[];
+    currentProfile: string;
     setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
 }
 export declare function CpuCreditsToggle(props: ICpuCreditsToggleProps): JSX.Element;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { FormikProps } from 'formik/dist/types';
+import type { IInstanceTypeCategory } from '@spinnaker/core';
+import type { IAmazonServerGroupCommand } from '../../serverGroupConfiguration.service';
+export interface IInstanceTypeSelectorProps {
+    formik: FormikProps<IAmazonServerGroupCommand>;
+    instanceTypeDetails: IInstanceTypeCategory[];
+}
+export declare function InstanceTypeSelector(props: IInstanceTypeSelectorProps): JSX.Element;

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { FormikProps } from 'formik/dist/types';
+import type { IAmazonInstanceTypeCategory } from '../../../../../instance/awsInstanceType.service';
+import type { IAmazonServerGroupCommand } from '../../../serverGroupConfiguration.service';
+export interface IAdvancedModeSelectorProps {
+    formik: FormikProps<IAmazonServerGroupCommand>;
+    instanceTypeDetails: IAmazonInstanceTypeCategory[];
+    setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
+}
+/**
+ * Note: Launch templates support is expected to be enabled if this component is rendered.
+ */
+export declare function AdvancedModeSelector(props: IAdvancedModeSelectorProps): JSX.Element;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { IAmazonInstanceTypeCategory } from '../../../../../instance/awsInstanceType.service';
+import './advancedMode.less';
+export interface IInstanceProfileSelectorProps {
+    currentProfile: string;
+    handleProfileChange: (profile: string) => void;
+    instanceProfileList: IAmazonInstanceTypeCategory[];
+}
+export declare function InstanceProfileSelector(props: IInstanceProfileSelectorProps): JSX.Element;

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { IAmazonPreferredInstanceType } from '../../../../../instance/awsInstanceType.service';
+import type { IAmazonInstanceTypeOverride } from '../../../serverGroupConfiguration.service';
+export interface IRowProps {
+    isCustom: boolean;
+    selectedType?: IAmazonInstanceTypeOverride;
+    instanceTypeDetails?: IAmazonPreferredInstanceType;
+    removeInstanceType?: (typeToRemove: string) => void;
+    addOrUpdateInstanceType: (instanceType: string, weight: string) => void;
+}
+export declare function InstanceTypeRow(props: IRowProps): JSX.Element;

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

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import type { IAmazonInstanceTypeCategory } from '../../../../../instance/awsInstanceType.service';
+import type { IAmazonInstanceTypeOverride } from '../../../serverGroupConfiguration.service';
+import './advancedMode.less';
+export interface IInstanceTypeTableProps {
+    currentProfile: string;
+    selectedInstanceTypesMap: Map<string, IAmazonInstanceTypeOverride>;
+    unlimitedCpuCreditsInCmd: boolean;
+    profileDetails: IAmazonInstanceTypeCategory;
+    availableInstanceTypesList: string[];
+    handleInstanceTypesChange: (instanceTypes: IAmazonInstanceTypeOverride[]) => void;
+    setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
+}
+export declare function InstanceTypeTable(props: IInstanceTypeTableProps): JSX.Element;

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { SortEnd } from 'react-sortable-hoc';
+import type { IInstanceTypeFamily } from '@spinnaker/core';
+import type { IAmazonInstanceTypeOverride } from '../../../serverGroupConfiguration.service';
+export declare function InstanceTypeTableBody(props: {
+    isCustom: boolean;
+    profileFamiliesDetails?: IInstanceTypeFamily[];
+    selectedInstanceTypesMap: Map<string, IAmazonInstanceTypeOverride>;
+    addOrUpdateInstanceType: (instanceType: string, weight: string) => void;
+    removeInstanceType: (instanceType: string) => void;
+    handleSortEnd: (sortEnd: SortEnd) => void;
+}): JSX.Element;

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

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+export declare function Heading(props: {
+    isCustom: boolean;
+    profileLabel?: string;
+    profileDescriptionArr?: string[];
+}): JSX.Element;
+export declare function Header(props: {
+    isCustom: boolean;
+    showCpuCredits?: boolean;
+}): JSX.Element;
+export declare function Footer(props: {
+    isCustom: boolean;
+    availableInstanceTypesList: string[];
+    addOrUpdateInstanceType: (type: string, weight: string) => void;
+}): JSX.Element;

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

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { FormikProps } from 'formik';
+import type { IAmazonServerGroupCommand } from '../../../serverGroupConfiguration.service';
+import './InstancesDistribution.less';
+export interface IInstancesDistributionProps {
+    formik: FormikProps<IAmazonServerGroupCommand>;
+}
+export declare function InstancesDistribution(props: IInstancesDistributionProps): JSX.Element;

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

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { IAmazonServerGroupCommand } from '../../../serverGroupConfiguration.service';
+export interface ISimpleModeSelectorProps {
+    command: IAmazonServerGroupCommand;
+    setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
+    setFieldValue: (field: keyof IAmazonServerGroupCommand, value: any, shouldValidate?: boolean) => void;
+}
+export declare function SimpleModeSelector(props: ISimpleModeSelectorProps): JSX.Element;

package/dist/serverGroup/configure/wizard/pages/ServerGroupInstanceType.d.ts

@@ -1,19 +1,22 @@
 import type { FormikErrors, FormikProps } from 'formik';
 import React from 'react';
 import type { IWizardPageComponent } from '@spinnaker/core';
+import type { IAmazonInstanceTypeCategory } from '../../../../instance/awsInstanceType.service';
 import type { IAmazonServerGroupCommand } from '../../serverGroupConfiguration.service';
 export interface IServerGroupInstanceTypeProps {
     formik: FormikProps<IAmazonServerGroupCommand>;
 }
 export interface IServerGroupInstanceTypeState {
-    newInstanceType?: string;
-    newProfileType?: string;
+    instanceTypeDetails: IAmazonInstanceTypeCategory[];
 }
 export declare class ServerGroupInstanceType extends React.Component<IServerGroupInstanceTypeProps, IServerGroupInstanceTypeState> implements IWizardPageComponent<IAmazonServerGroupCommand> {
-    constructor(props: IServerGroupInstanceTypeProps);
+    state: IServerGroupInstanceTypeState;
+    private props$;
+    private destroy$;
     validate(values: IAmazonServerGroupCommand): FormikErrors<IAmazonServerGroupCommand>;
-    private instanceProfileChanged;
-    private instanceTypeChanged;
-    private setUnlimitedCpuCredits;
+    private validateAdvancedModeFields;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
     render(): JSX.Element;
 }

package/dist/serverGroup/serverGroup.transformer.d.ts

@@ -1,3 +1,4 @@
+import type { IAmazonServerGroupCommand, IAmazonServerGroupDeployConfiguration } from './configure';
 import type { IAmazonServerGroup, IAmazonServerGroupView, IScalingPolicy, IScalingPolicyView, ITargetTrackingPolicy } from '../domain';
 export declare class AwsServerGroupTransformer {
     private addComparator;
@@ -6,7 +7,7 @@ export declare class AwsServerGroupTransformer {
     normalizeServerGroupDetails(serverGroup: IAmazonServerGroup): IAmazonServerGroupView;
     normalizeServerGroup(serverGroup: IAmazonServerGroup): PromiseLike<IAmazonServerGroup>;
     private addVpcNameToServerGroup;
-    convertServerGroupCommandToDeployConfiguration(base: any): any;
+    convertServerGroupCommandToDeployConfiguration(base: IAmazonServerGroupCommand): IAmazonServerGroupDeployConfiguration;
     constructNewStepScalingPolicyTemplate(serverGroup: IAmazonServerGroup): IScalingPolicy;
     constructNewTargetTrackingPolicyTemplate(): ITargetTrackingPolicy;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@spinnaker/amazon",
   "license": "Apache-2.0",
-  "version": "0.11.1",
+  "version": "0.12.3",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
@@ -13,7 +13,7 @@
     "lib": "npm run build"
   },
   "dependencies": {
-    "@spinnaker/core": "^0.14.2",
+    "@spinnaker/core": "^0.16.1",
     "@uirouter/angularjs": "1.0.26",
     "@uirouter/core": "6.0.8",
     "@uirouter/react": "1.0.7",
@@ -39,9 +39,9 @@
     "rxjs": "6.6.7"
   },
   "devDependencies": {
-    "@spinnaker/eslint-plugin": "^3.0.0",
+    "@spinnaker/eslint-plugin": "^3.0.1",
     "@spinnaker/mocks": "1.0.7",
-    "@spinnaker/scripts": "^0.2.2",
+    "@spinnaker/scripts": "^0.2.4",
     "@types/angular": "1.6.26",
     "@types/angular-ui-bootstrap": "0.13.41",
     "@types/classnames": "2.2.0",
@@ -55,5 +55,5 @@
     "shx": "0.3.3",
     "typescript": "4.3.5"
   },
-  "gitHead": "dbd5c6c7f9a3f282cd2534887caf132835cf49e2"
+  "gitHead": "17b98201c6de43729a39f6d205656d0c4be1db16"
 }

package/src/domain/IAmazonLaunchTemplate.ts

@@ -39,7 +39,7 @@ export interface ILicenseConfig {
 export interface IMetadataOptions {
   httpEndpoint?: 'disabled' | 'enabled';
   httpPutResponseHopLimit?: number;
-  httpsTokens?: 'required' | 'optional';
+  httpTokens?: 'required' | 'optional';
   state?: 'pending' | 'applied';
 }
 

package/src/domain/IAmazonServerGroup.ts

@@ -5,16 +5,27 @@ import type { IScalingPolicyView } from './IAmazonScalingPolicy';
 import type { IScalingPolicy } from './IScalingPolicy';
 import type { ISuspendedProcess } from './IScalingProcess';
 
+export interface IAmazonAsgTag {
+  key: string;
+  value: string;
+  propagateAtLaunch: boolean;
+  resourceId: string;
+  resourceType: string;
+}
+
 export interface IAmazonAsg extends IAsg {
   availabilityZones: string[];
+  autoScalingGroupName: string;
   defaultCooldown: number;
   healthCheckType: string;
   healthCheckGracePeriod: number;
+  loadBalancerNames: string[];
   terminationPolicies: string[];
   enabledMetrics: Array<{ metric: string }>;
   vpczoneIdentifier?: string;
   suspendedProcesses?: ISuspendedProcess[];
   capacityRebalance?: boolean;
+  tags: IAmazonAsgTag[];
 }
 
 export interface IAmazonServerGroup extends IServerGroup {

package/src/function/details/FunctionActions.spec.tsx

@@ -1,16 +1,17 @@
-import React from 'react';
 import { shallow } from 'enzyme';
+import React from 'react';
 
-import { Application } from '@spinnaker/core';
+import type { Application } from '@spinnaker/core';
 
-import { IAmazonFunction, FunctionActions } from '../../index';
 import { AWSProviderSettings } from '../../aws.settings';
+import type { IAmazonFunction } from '../../index';
+import { FunctionActions } from '../../index';
 
 describe('FunctionActions', () => {
   it('should render correct state when all attributes exist', () => {
-    let app = { name: 'app' } as Application;
+    const app = { name: 'app' } as Application;
 
-    let functionDef = { functionName: 'app-function' } as IAmazonFunction;
+    const functionDef = { functionName: 'app-function' } as IAmazonFunction;
     AWSProviderSettings.adHocInfraWritesEnabled = true;
 
     const wrapper = shallow(
@@ -25,15 +26,15 @@ describe('FunctionActions', () => {
       />,
     );
 
-    let dropDown = wrapper.find('DropdownToggle');
+    const dropDown = wrapper.find('DropdownToggle');
 
     expect(dropDown.childAt(0).text()).toEqual('Function Actions');
   });
 
   it('should not render DropdownToggle if aws.adHocInfraWritesEnabled is false', () => {
-    let app = { name: 'app' } as Application;
+    const app = { name: 'app' } as Application;
 
-    let functionDef = { functionName: 'app-function' } as IAmazonFunction;
+    const functionDef = { functionName: 'app-function' } as IAmazonFunction;
     AWSProviderSettings.adHocInfraWritesEnabled = false;
 
     const wrapper = shallow(
@@ -48,7 +49,7 @@ describe('FunctionActions', () => {
       />,
     );
 
-    let dropDown = wrapper.find('div');
+    const dropDown = wrapper.find('div');
     expect(dropDown.children().length).toEqual(0);
   });
 });

package/src/help/amazon.help.ts

@@ -59,18 +59,20 @@ const helpContents: { [key: string]: string } = {
     '(Optional) <b>Detail</b> is a string of free-form alphanumeric characters and hyphens to describe any other variables.',
   'aws.serverGroup.imageName':
     '(Required) <b>Image</b> is the deployable Amazon Machine Image. Images are restricted to the account and region selected.',
+  'aws.serverGroup.storageType': `AWS offers various storage options like temporary block-level storage via instance store (SSD, HDD) and Amazon Elastic Block Store (EBS). This column lists the storage type supported for the instance type.`,
+  'aws.serverGroup.instancesDistribution': `Learn more in <a target="_blank" href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-purchase-options.html">AWS docs</a>.`,
   'aws.serverGroup.spotMaxPrice':
-    'The maximum price per unit hour to pay for a Spot instance. By default (empty), Amazon EC2 Auto Scaling uses the On-Demand price as the maximum Spot price',
+    'The maximum price per unit hour to pay for a Spot instance. By <b>default (empty)</b>, Amazon EC2 Auto Scaling uses the On-Demand price as the maximum Spot price.',
   'aws.serverGroup.spotAllocationStrategy': `<p>Indicates how to allocate instances across Spot Instance pools.</p>
       <ul>
         <li><b>capacity-optimized (recommended)</b>: Instances launched using Spot pools that are optimally chosen based on the available Spot capacity.</li>
         <li><b>capacity-optimized-prioritized</b>: Instances launched using the priority on a best-effort basis to determine which launch template override to use first, but AWS optimizes for capacity first.</li>
-        <li><b>lowest-price</b>: Instances launched using Spot pools with the lowest price, and evenly allocated across the number of Spot pools specified</li>
+        <li><b>lowest-price (default)</b>: Instances launched using Spot pools with the lowest price, and evenly allocated across the number of Spot pools specified</li>
       </ul>`,
-  'aws.serverGroup.spotInstancePoolCount': `Number of lowest priced Spot Instance pools to diversify across. Only applicable for strategy 'lowest-price'.`,
-  'aws.serverGroup.odAllocationStrategy': `The only strategy / default is 'prioritized'. The order of instance types in the list of launch template overrides is used to determine which instance type to use first when fulfilling On-Demand capacity.`,
-  'aws.serverGroup.odBase': `Minimum amount of the Auto Scaling Group's capacity that must be fulfilled by On-Demand Instances. This base portion is provisioned first as the group scales.`,
-  'aws.serverGroup.odPercentAboveBase': `Percentages of On-Demand and Spot instances for additional capacity beyond OnDemandBaseCapacity.`,
+  'aws.serverGroup.spotInstancePoolCount': `Number of lowest priced Spot Instance pools to diversify across. Only applicable for strategy 'lowest-price'. <b>Default: 2.</b>`,
+  'aws.serverGroup.odAllocationStrategy': `The only strategy / <b>default is 'prioritized'</b>. The order specified in the list of selected instance types is used to determine which instance type to use first when fulfilling On-Demand capacity.`,
+  'aws.serverGroup.odBase': `Minimum amount of the Auto Scaling Group's capacity that must be fulfilled by On-Demand Instances. This base portion is provisioned first as the group scales. <b>Default: 0.</b>`,
+  'aws.serverGroup.odPercentAboveBase': `Percentages of On-Demand and Spot instances for additional capacity beyond OnDemandBaseCapacity.<b>Default: 100.</b>`,
   'aws.serverGroup.instanceTypeWeight': `The number of capacity units gives the instance type a proportional weight to other instance types. When specified, weights count towards desired capacity.`,
   'aws.serverGroup.instanceTypes': `Specify up to 20 instance types.`,
   'aws.serverGroup.multipleInstanceTypes': `Instance types a server group can launch, first (highest priority) to last (lowest priority).`,
@@ -82,6 +84,7 @@ const helpContents: { [key: string]: string } = {
             To burst above the baseline, the instance spends credits that it has accrued in its CPU credit balance.</li>
       </ul>`,
   'aws.serverGroup.capacityRebalance': `Enabling <b>Capacity Rebalance</b> allows EC2 Auto Scaling to proactively replace Spot Instances that have received a rebalance recommendation, <b>before</b> it is interrupted by AWS EC2.`,
+  'aws.serverGroup.advancedMode': `Advanced mode allows you to configure allocation strategies, multiple instance types with weighting, instance distribution across Spot / On-Demand and their proportions in the server group. Learn more in <a target="_blank" href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-purchase-options.html">AWS docs</a>.`,
   'aws.serverGroup.legacyUdf': `<p>(Optional) <b>User Data Format</b> allows overriding of the format used when generating user data during deployment. The default format used is configured
       in the application's attributes, editable via the 'Config' tab.</p>
       <p><b>Default</b> will use the value from the application's configuration.</p>

package/src/image/image.reader.spec.ts

@@ -0,0 +1,75 @@
+import { mock } from 'angular';
+import { $rootScope } from 'ngimport';
+// eslint-disable-next-line @spinnaker/import-from-npm-not-relative
+import { mockHttpClient } from '../../../core/src/api/mock/jasmine';
+import { AwsImageReader } from './image.reader';
+
+describe('Service: aws Image Reader', function () {
+  let service: AwsImageReader;
+
+  beforeEach(() => (service = new AwsImageReader()));
+  beforeEach(mock.inject());
+
+  describe('findImages', function () {
+    const region = 'us-west-2';
+    const buildQueryString = (query: string, region: string) => `/images/find?q=${query}&region=${region}`;
+
+    it('queries gate when 3 characters are supplied', async function () {
+      const q = 'que';
+      const http = mockHttpClient({ autoFlush: true });
+      http.expectGET(buildQueryString(q, region)).respond(200, [{ success: true }]);
+      const result = await service.findImages({ q, region });
+
+      expect(result.length).toBe(1);
+      expect((result[0] as any).success).toBe(true);
+    });
+
+    it('queries gate when more than 3 characters are supplied', async function () {
+      const q = 'abcd';
+      const http = mockHttpClient({ autoFlush: true });
+      http.expectGET(buildQueryString(q, region)).respond(200, [{ success: true }]);
+      const result = await service.findImages({ q, region });
+      expect(result.length).toBe(1);
+      expect((result[0] as any).success).toBe(true);
+    });
+
+    it('returns a message prompting user to enter more characters when less than 3 are supplied', async function () {
+      const q = 'ab';
+      let result: any;
+      service.findImages({ q, region }).then((response) => (result = response));
+      $rootScope.$digest();
+      expect(result.length).toBe(1);
+      expect((result[0] as any).message).toBe('Please enter at least 3 characters...');
+    });
+
+    it('returns an empty array when server errors', async function () {
+      const q = 'abc';
+      const http = mockHttpClient({ autoFlush: true });
+      http.expectGET(buildQueryString(q, region)).respond(404, {});
+      const result = await service.findImages({ q, region });
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('getImage', function () {
+    const imageName = 'abc';
+    const region = 'us-west-1';
+    const credentials = 'test';
+
+    const buildQueryString = () => `/images/${credentials}/${region}/${imageName}?provider=aws`;
+
+    it('returns null if server returns 404', async function () {
+      const http = mockHttpClient({ autoFlush: true });
+      http.expectGET(buildQueryString()).respond(404, {});
+      const result = await service.getImage(imageName, region, credentials);
+      expect(result).toBe(null);
+    });
+
+    it('returns null if server returns an empty list', async function () {
+      const http = mockHttpClient({ autoFlush: true });
+      http.expectGET(buildQueryString()).respond(200, []);
+      const result2 = await service.getImage(imageName, region, credentials);
+      expect(result2).toBe(null);
+    });
+  });
+});