mirror of https://github.com/rancher/ui.git
594 lines
20 KiB
JavaScript
594 lines
20 KiB
JavaScript
import Component from '@ember/component';
|
|
import {
|
|
computed, get, observer, set, setProperties
|
|
} from '@ember/object';
|
|
import { equal } from '@ember/object/computed';
|
|
import { on } from '@ember/object/evented';
|
|
import { next } from '@ember/runloop';
|
|
import { inject as service } from '@ember/service';
|
|
import { isEmpty } from '@ember/utils';
|
|
import { Promise } from 'rsvp';
|
|
import { coerce, minor } from 'semver';
|
|
import { INSTANCE_TYPES } from 'shared/utils/amazon';
|
|
import { DEFAULT_NODE_GROUP_CONFIG } from 'ui/models/cluster';
|
|
import layout from './template';
|
|
|
|
|
|
export default Component.extend({
|
|
intl: service(),
|
|
globalStore: service(),
|
|
layout,
|
|
classNames: ['row', 'mb-20'],
|
|
|
|
instanceTypes: INSTANCE_TYPES,
|
|
defaultNodeGroupConfig: DEFAULT_NODE_GROUP_CONFIG,
|
|
|
|
clusterConfig: null,
|
|
keyPairs: null,
|
|
mode: null,
|
|
model: null,
|
|
nodeGroupsVersionCollection: null,
|
|
originalCluster: null,
|
|
versions: null,
|
|
launchTemplates: null,
|
|
allSelectedTemplateVersions: null,
|
|
nodeInstanceRoles: null,
|
|
|
|
clusterSaving: false,
|
|
clusterSaved: false,
|
|
nameIsEditable: true,
|
|
showNodeUpgradePreventionReason: false,
|
|
upgradeVersion: false,
|
|
refreshResourceInstanceTags: true, // simply used for reinit'ing the resource instance tags key value component rather than add weird logic to recomput to the component
|
|
|
|
|
|
editing: equal('mode', 'edit'),
|
|
|
|
init() {
|
|
this._super(...arguments);
|
|
if (!this.launchTemplates) {
|
|
set(this, 'launchTemplates', []);
|
|
}
|
|
|
|
if (this.editing) {
|
|
if (!isEmpty(this.model.nodegroupName)) {
|
|
set(this, 'nameIsEditable', false);
|
|
}
|
|
}
|
|
},
|
|
|
|
actions: {
|
|
setTags(section) {
|
|
if (this.isDestroyed || this.isDestroying) {
|
|
return;
|
|
}
|
|
|
|
set(this, 'model.tags', section);
|
|
},
|
|
|
|
setLabels(section) {
|
|
if (this.isDestroyed || this.isDestroying) {
|
|
return;
|
|
}
|
|
set(this, 'model.labels', section);
|
|
},
|
|
|
|
setResourceTags(section) {
|
|
if (this.isDestroyed || this.isDestroying) {
|
|
return;
|
|
}
|
|
|
|
set(this, 'resourceTags', section);
|
|
},
|
|
},
|
|
|
|
instanceType: computed('defaultNodeGroupConfig.instanceType', 'isNoLaunchTemplate', 'model.instanceType', 'selectedTemplateVersionInfo.LaunchTemplateData.InstanceType', 'selectedTemplateVersionInfo.LaunchTemplateData.InstanceMarketOptions.MarketType', {
|
|
get() {
|
|
let instanceType = this?.model?.instanceType;
|
|
const { selectedTemplateVersionInfo, isNoLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate) {
|
|
return instanceType;
|
|
} else if (selectedTemplateVersionInfo) {
|
|
const LaunchTemplateData = selectedTemplateVersionInfo?.LaunchTemplateData;
|
|
const MarketType = LaunchTemplateData?.InstanceMarketOptions?.MarketType;
|
|
const InstanceType = LaunchTemplateData?.InstanceType ? LaunchTemplateData?.InstanceType : this.defaultNodeGroupConfig.instanceType;
|
|
|
|
if (!isEmpty(MarketType) && MarketType === 'spot') {
|
|
return null;
|
|
}
|
|
|
|
return InstanceType;
|
|
}
|
|
|
|
return instanceType;
|
|
},
|
|
set(_key, instanceType) {
|
|
const {
|
|
selectedTemplateVersionInfo, isNoLaunchTemplate, isRancherLaunchTemplate
|
|
} = this;
|
|
|
|
if (isNoLaunchTemplate || isRancherLaunchTemplate) {
|
|
set(this, 'model.instanceType', instanceType)
|
|
} else if (selectedTemplateVersionInfo) {
|
|
const { LaunchTemplateData: { InstanceMarketOptions: { MarketType } } } = selectedTemplateVersionInfo;
|
|
|
|
if (!isEmpty(MarketType) && MarketType === 'spot') {
|
|
set(this, 'model.instanceType', instanceType);
|
|
}
|
|
}
|
|
|
|
return instanceType;
|
|
}
|
|
}),
|
|
|
|
imageId: computed('defaultNodeGroupConfig.imageId', 'isNoLaunchTemplate', 'model.imageId', 'selectedTemplateVersionInfo.LaunchTemplateData.ImageId', {
|
|
get() {
|
|
let imageId = this?.model?.imageId;
|
|
const { selectedTemplateVersionInfo, isNoLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate) {
|
|
return imageId;
|
|
} else if (selectedTemplateVersionInfo) {
|
|
const { LaunchTemplateData: { ImageId = this.defaultNodeGroupConfig.imageId } } = selectedTemplateVersionInfo;
|
|
|
|
return ImageId ?? this.defaultNodeGroupConfig.imageId;
|
|
}
|
|
|
|
return imageId;
|
|
},
|
|
set(_key, imageId) {
|
|
const { isNoLaunchTemplate, isRancherLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate || isRancherLaunchTemplate) {
|
|
set(this, 'model.imageId', imageId)
|
|
}
|
|
|
|
return imageId;
|
|
}
|
|
}),
|
|
|
|
diskSize: computed('defaultNodeGroupConfig.diskSize', 'isNoLaunchTemplate', 'model.diskSize', 'selectedTemplateVersionInfo.LaunchTemplateData.BlockDeviceMappings.[]', {
|
|
get() {
|
|
let diskSize = this?.model?.diskSize;
|
|
const { selectedTemplateVersionInfo, isNoLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate) {
|
|
return diskSize;
|
|
} else if (selectedTemplateVersionInfo) {
|
|
const blockDeviceMappings = selectedTemplateVersionInfo?.LaunchTemplateData?.BlockDeviceMappings?.firstObject ?? {};
|
|
const DiskSize = blockDeviceMappings?.Ebs?.VolumeSize ?? this.defaultNodeGroupConfig.diskSize;
|
|
|
|
return DiskSize ?? this.defaultNodeGroupConfig.diskSize;
|
|
}
|
|
|
|
return diskSize;
|
|
},
|
|
set(_key, diskSize) {
|
|
const { isNoLaunchTemplate, isRancherLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate || isRancherLaunchTemplate) {
|
|
set(this, 'model.diskSize', diskSize)
|
|
}
|
|
|
|
return diskSize;
|
|
}
|
|
}),
|
|
|
|
ec2SshKey: computed('defaultNodeGroupConfig.ec2SshKey', 'isNoLaunchTemplate', 'model.ec2SshKey', 'selectedTemplateVersionInfo.LaunchTemplateData.KeyName', {
|
|
get() {
|
|
let ec2SshKey = this?.model?.ec2SshKey;
|
|
const { selectedTemplateVersionInfo, isNoLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate) {
|
|
return ec2SshKey;
|
|
} else if (selectedTemplateVersionInfo) {
|
|
const { LaunchTemplateData: { KeyName = this.defaultNodeGroupConfig.ec2SshKey } } = selectedTemplateVersionInfo;
|
|
|
|
return KeyName ?? this.defaultNodeGroupConfig.ec2SshKey;
|
|
}
|
|
|
|
return ec2SshKey;
|
|
},
|
|
set(_key, ec2SshKey) {
|
|
const { isNoLaunchTemplate, isRancherLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate || isRancherLaunchTemplate) {
|
|
set(this, 'model.ec2SshKey', ec2SshKey)
|
|
}
|
|
|
|
return ec2SshKey;
|
|
}
|
|
}),
|
|
|
|
userData: computed('defaultNodeGroupConfig.userData', 'isNoLaunchTemplate', 'model.userData', 'selectedTemplateVersionInfo.LaunchTemplateData.UserData', {
|
|
get() {
|
|
let userData = this?.model?.userData;
|
|
const { selectedTemplateVersionInfo, isNoLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate) {
|
|
return userData;
|
|
} else if (selectedTemplateVersionInfo) {
|
|
let { LaunchTemplateData: { UserData = this.defaultNodeGroupConfig.userData } } = selectedTemplateVersionInfo;
|
|
|
|
try {
|
|
UserData = atob(UserData);
|
|
} catch (_err) {
|
|
}
|
|
|
|
return UserData ?? this.defaultNodeGroupConfig.userData;
|
|
}
|
|
|
|
return userData;
|
|
},
|
|
set(_key, userData) {
|
|
const { isNoLaunchTemplate, isRancherLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate || isRancherLaunchTemplate) {
|
|
set(this, 'model.userData', userData)
|
|
}
|
|
|
|
return userData;
|
|
}
|
|
}),
|
|
|
|
resourceTags: computed('defaultNodeGroupConfig.resourceTags', 'isNoLaunchTemplate', 'model.resourceTags', 'selectedTemplateVersionInfo.LaunchTemplateData.TagSpecifications.[]', {
|
|
get() {
|
|
let resourceTags = this?.model?.resourceTags;
|
|
const { selectedTemplateVersionInfo, isNoLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate) {
|
|
return resourceTags;
|
|
} else if (selectedTemplateVersionInfo) {
|
|
const resourceInstanceTags = ( selectedTemplateVersionInfo?.LaunchTemplateData?.TagSpecifications ?? []).findBy('ResourceType', 'instance');
|
|
const resourceTags = {};
|
|
|
|
(resourceInstanceTags?.Tags ?? []).forEach((tag) => set(resourceTags, get(tag, 'Key'), get(tag, 'Value')));
|
|
|
|
return resourceTags;
|
|
}
|
|
|
|
return resourceTags;
|
|
},
|
|
set(_key, resourceTags) {
|
|
const { isNoLaunchTemplate, isRancherLaunchTemplate } = this;
|
|
|
|
if (isNoLaunchTemplate || isRancherLaunchTemplate) {
|
|
set(this, 'model.resourceTags', resourceTags)
|
|
}
|
|
|
|
return resourceTags;
|
|
}
|
|
}),
|
|
|
|
|
|
isRancherLaunchTemplate: computed('model.{launchTemplate,nodegroupName}', 'originalCluster.eksStatus.managedLaunchTemplateID', function() {
|
|
const { originalCluster, model } = this;
|
|
const { launchTemplate } = model;
|
|
const eksStatus = get((originalCluster ?? {}), 'eksStatus') || {};
|
|
const { managedLaunchTemplateID = null, managedLaunchTemplateVersions = {} } = eksStatus;
|
|
const matchedManagedVersion = get(( managedLaunchTemplateVersions ?? {} ), this.model.nodegroupName);
|
|
|
|
if (isEmpty(launchTemplate) && !isEmpty(managedLaunchTemplateID) && !isEmpty(matchedManagedVersion)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}),
|
|
|
|
isUserLaunchTemplate: computed('model.launchTemplate', 'originalCluster.eksStatus.managedLaunchTemplateID', function() {
|
|
const { model } = this;
|
|
const { launchTemplate } = model;
|
|
|
|
if (!isEmpty(launchTemplate) && !isEmpty(launchTemplate?.id) && !isEmpty(launchTemplate?.version)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}),
|
|
|
|
isNoLaunchTemplate: computed('isRancherLaunchTemplate', 'isUserLaunchTemplate', function() {
|
|
return !this.isRancherLaunchTemplate && !this.isUserLaunchTemplate;
|
|
}),
|
|
|
|
filteredLaunchTemplates: computed('launchTemplates.[]', function() {
|
|
const { launchTemplates } = this;
|
|
|
|
if (isEmpty(launchTemplates)) {
|
|
return [];
|
|
}
|
|
|
|
return launchTemplates.filter(({ LaunchTemplateName }) => !LaunchTemplateName.includes('rancher-managed-lt') ).sortBy('LaunchTemplateName');
|
|
}),
|
|
|
|
selectedTemplateVersionInfo: computed('model.launchTemplate.{id,version}', 'allSelectedTemplateVersions.[]', function() {
|
|
const { model, allSelectedTemplateVersions } = this;
|
|
const version = get(model, 'launchTemplate.version');
|
|
|
|
if (isEmpty(model.launchTemplate) || isEmpty(version)) {
|
|
return null;
|
|
}
|
|
|
|
const match = (allSelectedTemplateVersions || []).findBy('VersionNumber', parseInt(version, 10));
|
|
|
|
if (match) {
|
|
return match;
|
|
}
|
|
|
|
return null;
|
|
}),
|
|
|
|
selectedLaunchTemplateVersion: computed('model.launchTemplate.version', 'model.launchTemplate.id', {
|
|
get() {
|
|
return get(this, 'model.launchTemplate.version') ? get(this, 'model.launchTemplate.version').toString() : null;
|
|
},
|
|
set(_key, value) {
|
|
set(this, 'model.launchTemplate.version', parseInt(value, 10));
|
|
|
|
this.loadTemplateVersionInfo();
|
|
|
|
return value;
|
|
},
|
|
}),
|
|
|
|
|
|
selectedLaunchTemplateVersions: computed('model.launchTemplate.{id,name,version}', 'launchTemplates', function() {
|
|
const { model, launchTemplates } = this;
|
|
const { launchTemplate } = model;
|
|
|
|
if (isEmpty(launchTemplate) || isEmpty(get(launchTemplate, 'id'))) {
|
|
return [];
|
|
}
|
|
|
|
const match = launchTemplates.findBy('LaunchTemplateId', launchTemplate.id);
|
|
|
|
if (match) {
|
|
// this lets us create a range of values 1...XX because the launch template only gives us the 1st and latest numbers but we want all for the version select
|
|
// ++ver -> zero based array so we need to +1 that value to match a non-zero based version number system
|
|
return Array.from(Array(match.LatestVersionNumber).keys()).map((ver) => ({ label: `${ ++ver }` }));
|
|
}
|
|
|
|
return [];
|
|
}),
|
|
|
|
selectedLaunchTemplate: computed('model.launchTemplate', 'filteredLaunchTemplates.[]', {
|
|
get() {
|
|
const launchTemplate = get(this, 'model.launchTemplate') ?? false;
|
|
|
|
if (launchTemplate) {
|
|
const out = this.filteredLaunchTemplates.findBy('LaunchTemplateId', launchTemplate.id);
|
|
|
|
return isEmpty(out) ? null : out;
|
|
}
|
|
|
|
return null;
|
|
},
|
|
|
|
set(_key, launchTemplateId) {
|
|
const launchTemplate = this.filteredLaunchTemplates.findBy('LaunchTemplateId', launchTemplateId);
|
|
const {
|
|
LaunchTemplateId: id, LaunchTemplateName: name, DefaultVersionNumber: version
|
|
} = launchTemplate ?? {};
|
|
|
|
if (isEmpty(launchTemplate)) {
|
|
set(this, 'model.launchTemplate', null);
|
|
|
|
setProperties(this, {
|
|
diskSize: this.defaultNodeGroupConfig.diskSize,
|
|
ec2SshKey: this.defaultNodeGroupConfig.ec2SshKey,
|
|
imageId: this.defaultNodeGroupConfig.imageId,
|
|
instanceType: this.defaultNodeGroupConfig.instanceType,
|
|
requestSpotInstances: this.defaultNodeGroupConfig.requestSpotInstances,
|
|
resourceTags: this.defaultNodeGroupConfig.resourceTags,
|
|
userData: this.defaultNodeGroupConfig.userData,
|
|
});
|
|
} else {
|
|
set(this, 'model.launchTemplate', {
|
|
id,
|
|
name,
|
|
});
|
|
set(this, 'selectedLaunchTemplateVersion', version);
|
|
}
|
|
|
|
return launchTemplateId;
|
|
}
|
|
}),
|
|
|
|
creating: computed('mode', function() {
|
|
const {
|
|
mode, originalCluster, model: { nodegroupName }
|
|
} = this;
|
|
|
|
if (mode === 'new') {
|
|
return true;
|
|
}
|
|
|
|
const upstreamSpec = get(originalCluster, 'eksStatus.upstreamSpec');
|
|
const nodeGroups = upstreamSpec ? get(upstreamSpec, 'nodeGroups') : [];
|
|
|
|
if (nodegroupName && nodeGroups.length >= 1) {
|
|
if (nodeGroups.findBy('nodegroupName', nodegroupName)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}),
|
|
|
|
originalClusterVersion: computed('originalCluster.eksConfig.kubernetesVersion', 'originalCluster.eksStatus.upstreamSpec.kubernetesVersion', function() {
|
|
if (!isEmpty(get(this, 'originalCluster.eksConfig.kubernetesVersion'))) {
|
|
return get(this, 'originalCluster.eksConfig.kubernetesVersion');
|
|
}
|
|
|
|
if (!isEmpty(get(this, 'originalCluster.eksStatus.upstreamSpec.kubernetesVersion'))) {
|
|
return get(this, 'originalCluster.eksStatus.upstreamSpec.kubernetesVersion');
|
|
}
|
|
|
|
return '';
|
|
}),
|
|
|
|
upgradeAvailable: computed('clusterConfig.kubernetesVersion', 'mode', 'model.version', 'originalClusterVersion', 'showNodeUpgradePreventionReason', function() {
|
|
const originalClusterVersion = get(this, 'originalClusterVersion');
|
|
const clusterVersion = get(this, 'clusterConfig.kubernetesVersion');
|
|
const nodeVersion = get(this, 'model.version');
|
|
const mode = get(this, 'mode');
|
|
|
|
const initalClusterMinorVersion = parseInt(minor(coerce(clusterVersion)), 10);
|
|
const initalNodeMinorVersion = parseInt(minor(coerce(nodeVersion)), 10);
|
|
const diff = initalClusterMinorVersion - initalNodeMinorVersion;
|
|
|
|
if (mode === 'edit') {
|
|
// we must upgrade the cluster first
|
|
if (originalClusterVersion !== clusterVersion) {
|
|
set(this, 'showNodeUpgradePreventionReason', true);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (diff === 0 && get(this, 'showNodeUpgradePreventionReason')) {
|
|
set(this, 'showNodeUpgradePreventionReason', false);
|
|
}
|
|
|
|
return diff === 1;
|
|
}),
|
|
|
|
showGPUWarning: computed('model.launchTemplate.{id,version}', 'selectedTemplateVersionInfo', function() {
|
|
const { model, selectedTemplateVersionInfo } = this;
|
|
const ltId = get(model, 'launchTemplate.id');
|
|
const ltVersion = get(model, 'launchTemplate.version');
|
|
const imageId = selectedTemplateVersionInfo ? get(selectedTemplateVersionInfo, 'LaunchTemplateData.ImageId') : undefined;
|
|
|
|
return ltId && ltVersion && selectedTemplateVersionInfo && imageId;
|
|
}),
|
|
|
|
requestedSpotInstances: on('init', observer('model.requestSpotInstances', 'selectedTemplateVersionInfo.LaunchTemplateData.InstanceMarketOptions.MarketType', function() {
|
|
const { model } = this;
|
|
|
|
if (get(model, 'requestSpotInstances')) {
|
|
set(this, 'instanceType', null);
|
|
} else if (!get(model, 'requestSpotInstances') && get(model, 'instanceType') === null) {
|
|
set(this, 'instanceType', 't3.medium');
|
|
}
|
|
})),
|
|
|
|
clusterVersionDidChange: on('init', observer('clusterConfig.kubernetesVersion', function() {
|
|
const { clusterConfig, editing } = this;
|
|
|
|
if (get(clusterConfig, 'kubernetesVersion') && !editing) {
|
|
set(this, 'model.version', clusterConfig.kubernetesVersion);
|
|
}
|
|
})),
|
|
|
|
shouldUpgradeVersion: on('init', observer('upgradeVersion', function() {
|
|
const { upgradeVersion } = this;
|
|
const clusterVersion = get(this, 'clusterConfig.kubernetesVersion');
|
|
const nodeVersion = get(this, 'model.version');
|
|
|
|
if (upgradeVersion && clusterVersion !== nodeVersion) {
|
|
set(this, 'model.version', clusterVersion);
|
|
}
|
|
})),
|
|
|
|
nodeRoleOptions: computed('intl', 'nodeInstanceRoles.[]', function(){
|
|
const { nodeInstanceRoles } = this;
|
|
|
|
return [{
|
|
RoleName: this.intl.t('nodeGroupRow.nodeInstanceRole.defaultOption'),
|
|
RoleId: ''
|
|
}, ...nodeInstanceRoles]
|
|
}),
|
|
|
|
async loadTemplateVersionInfo() {
|
|
if (!this.clusterSaving && !this.clusterSaved) {
|
|
const { launchTemplate = {} } = this.model;
|
|
let defaults = { ...this.defaultNodeGroupConfig };
|
|
|
|
// in this case we dont want the defaults for nodegroup items
|
|
delete defaults.nodegroupName;
|
|
delete defaults.maxSize;
|
|
delete defaults.minSize;
|
|
delete defaults.desiredSize;
|
|
|
|
|
|
if (isEmpty(launchTemplate)) {
|
|
set(this, 'refreshResourceInstanceTags', false);
|
|
|
|
next(() => {
|
|
setProperties(this.model, defaults);
|
|
set(this, 'refreshResourceInstanceTags', true)
|
|
});
|
|
} else if ( !isEmpty(get(launchTemplate, 'id')) ) {
|
|
try {
|
|
const versions = await this.listTemplateVersions();
|
|
const match = versions.findBy('VersionNumber', parseInt(launchTemplate.version, 10)); // newselect doesn't handle numbers as values very well
|
|
const { LaunchTemplateData: launchTemplateData } = match;
|
|
|
|
const overrides = {
|
|
imageId: get(launchTemplateData, 'ImageId') ?? null,
|
|
instanceType: get(launchTemplateData, 'InstanceType') ?? this.defaultNodeGroupConfig.instanceType,
|
|
diskSize: get(launchTemplateData, 'BlockDeviceMappings.firstObject.Ebs.VolumeSize') ?? this.defaultNodeGroupConfig.diskSize,
|
|
ec2SshKey: get(launchTemplateData, 'KeyName') ?? null,
|
|
userData: isEmpty(get(launchTemplateData, 'UserData')) ? null : atob(get(launchTemplateData, 'UserData')),
|
|
};
|
|
|
|
|
|
defaults = Object.assign({}, defaults, overrides);
|
|
|
|
if (get(launchTemplateData, 'InstanceMarketOptions.MarketType') && get(launchTemplateData, 'InstanceMarketOptions.MarketType') === 'spot') {
|
|
set(defaults, 'requestSpotInstances', true);
|
|
set(this, 'instanceType', null);
|
|
}
|
|
|
|
if ( !isEmpty(get(launchTemplateData, 'TagSpecifications')) ) {
|
|
const resourceInstanceTags = get(launchTemplateData, 'TagSpecifications').findBy('ResourceType', 'instance');
|
|
|
|
if (!isEmpty(resourceInstanceTags) && !isEmpty(get(resourceInstanceTags, 'Tags'))) {
|
|
set(defaults, 'resourceTags', {});
|
|
|
|
resourceInstanceTags.Tags.forEach((tag) => set(defaults.resourceTags, get(tag, 'Key'), get(tag, 'Value')));
|
|
}
|
|
}
|
|
|
|
set(this, 'refreshResourceInstanceTags', false);
|
|
|
|
next(() => {
|
|
setProperties(this.model, defaults);
|
|
|
|
set(this, 'allSelectedTemplateVersions', versions);
|
|
set(this, 'refreshResourceInstanceTags', true)
|
|
} );
|
|
} catch (err) { }
|
|
}
|
|
}
|
|
},
|
|
|
|
listTemplateVersions() {
|
|
const { launchTemplate } = this.model;
|
|
const match = this.launchTemplates.findBy('LaunchTemplateId', launchTemplate.id);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const ec2 = new AWS.EC2(this.authCreds());
|
|
|
|
const maxVersion = match.LatestVersionNumber;
|
|
|
|
ec2.describeLaunchTemplateVersions({
|
|
LaunchTemplateId: launchTemplate.id,
|
|
MaxVersion: maxVersion.toString(),
|
|
MinVersion: '1',
|
|
}, (err, data) => {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
|
|
resolve(data.LaunchTemplateVersions);
|
|
});
|
|
})
|
|
},
|
|
|
|
removeNodeGroup() {
|
|
throw new Error('remove node group action is required!');
|
|
},
|
|
|
|
});
|