mirror of https://github.com/rancher/ui.git
664 lines
20 KiB
JavaScript
664 lines
20 KiB
JavaScript
import { isArray } from '@ember/array';
|
|
import Component from '@ember/component';
|
|
import {
|
|
computed, get, observer, set, setProperties
|
|
} from '@ember/object';
|
|
import { alias, equal, union } from '@ember/object/computed';
|
|
import { next } from '@ember/runloop';
|
|
import { inject as service } from '@ember/service';
|
|
import { isEmpty } from '@ember/utils';
|
|
import { all } from 'rsvp';
|
|
import ClusterDriver from 'shared/mixins/cluster-driver';
|
|
import { sortableNumericSuffix } from 'shared/utils/util';
|
|
import { DEFAULT_GKE_CONFIG, DEFAULT_GKE_NODE_POOL_CONFIG } from 'ui/models/cluster';
|
|
import layout from './template';
|
|
|
|
export default Component.extend(ClusterDriver, {
|
|
google: service(),
|
|
intl: service(),
|
|
serivceVersions: service('version-choices'),
|
|
layout,
|
|
|
|
configField: 'gkeConfig',
|
|
|
|
step: 1,
|
|
errors: null,
|
|
otherErrors: null,
|
|
clusterErrors: null,
|
|
save: false,
|
|
clusterAdvanced: false,
|
|
maintenanceWindowTimes: null,
|
|
locationType: null,
|
|
monitoringServiceChoices: null,
|
|
loggingServiceChoices: null,
|
|
sharedSubnets: null,
|
|
|
|
allErrors: union('errors', 'otherErrors', 'clusterErrors'),
|
|
isNew: equal('mode', 'new'),
|
|
editing: equal('mode', 'edit'),
|
|
|
|
clusterState: alias('model.originalCluster.state'),
|
|
|
|
init() {
|
|
this._super(...arguments);
|
|
|
|
setProperties(this, {
|
|
errors: [],
|
|
otherErrors: [],
|
|
clusterErrors: [],
|
|
maintenanceWindowTimes: this.google.maintenanceWindows,
|
|
locationType: this.google.defaultZoneType,
|
|
monitoringServiceChoices: [
|
|
{
|
|
label: this.intl.t('generic.none'),
|
|
value: 'none'
|
|
},
|
|
{
|
|
label: this.intl.t('clusterNew.googlegke.monitoringService.default'),
|
|
value: 'monitoring.googleapis.com/kubernetes'
|
|
},
|
|
],
|
|
loggingServiceChoices: [
|
|
{
|
|
label: this.intl.t('generic.none'),
|
|
value: 'none'
|
|
},
|
|
{
|
|
label: this.intl.t('clusterNew.googlegke.loggingService.default'),
|
|
value: 'logging.googleapis.com/kubernetes'
|
|
},
|
|
],
|
|
});
|
|
|
|
let config = get(this, 'cluster.gkeConfig');
|
|
|
|
if (!config) {
|
|
config = this.globalStore.createRecord(this.defaultConfig());
|
|
|
|
set(this, 'cluster.gkeConfig', config);
|
|
}
|
|
|
|
setProperties(this, {
|
|
locationType: get(this, 'config.zone') ? this.google.defaultZoneType : this.google.defaultRegionType,
|
|
regionChoices: this.google.regions.map((region) => ({ name: region })),
|
|
});
|
|
},
|
|
|
|
actions: {
|
|
finishAndSelectCloudCredential(cred) {
|
|
if (cred) {
|
|
next(this, () => {
|
|
set(this, 'config.googleCredentialSecret', get(cred, 'id'));
|
|
|
|
if (cred?.googlecredentialConfig?.projectId) {
|
|
set(this, 'config.projectID', cred.googlecredentialConfig.projectId);
|
|
this.send('loadZones');
|
|
}
|
|
})
|
|
}
|
|
},
|
|
|
|
addNodePool() {
|
|
let { config } = this;
|
|
let { nodePools = [], kubernetesVersion } = config;
|
|
const npConfig = { ...DEFAULT_GKE_NODE_POOL_CONFIG };
|
|
|
|
if (!isArray(nodePools)) {
|
|
nodePools = [];
|
|
}
|
|
|
|
const nodeGroup = this.globalStore.createRecord(npConfig);
|
|
|
|
set(nodeGroup, 'version', kubernetesVersion);
|
|
|
|
nodePools.pushObject(nodeGroup);
|
|
|
|
set(this, 'config.nodePools', nodePools);
|
|
},
|
|
|
|
removeNodePool(nodePool) {
|
|
let { config: { nodePools = [] } } = this;
|
|
|
|
if (!isEmpty(nodePools)) {
|
|
nodePools.removeObject(nodePool);
|
|
}
|
|
|
|
set(this, 'config.nodePools', nodePools);
|
|
},
|
|
|
|
loadZones(cb = () => {}) {
|
|
set(this, 'errors', []);
|
|
|
|
const config = get(this, `cluster.${ this.configField }`);
|
|
|
|
return all([
|
|
this.google.fetchZones(config, this.saved),
|
|
]).then((resp) => {
|
|
const [zones] = resp;
|
|
|
|
setProperties(this, {
|
|
step: 2,
|
|
zones,
|
|
})
|
|
|
|
cb(true);
|
|
}).catch((err) => {
|
|
this.send('errorHandler', err);
|
|
|
|
cb(false);
|
|
});
|
|
},
|
|
|
|
checkServiceAccount(cb) {
|
|
set(this, 'errors', []);
|
|
|
|
const config = get(this, `cluster.${ this.configField }`);
|
|
|
|
return all([
|
|
this.google.fetchVersions(config, this.saved),
|
|
this.google.fetchMachineTypes(config, this.saved),
|
|
this.google.fetchNetworks(config, this.saved),
|
|
this.google.fetchSubnetworks(config, get(this, 'locationType'), this.saved),
|
|
this.google.fetchSharedSubnets(config, this.saved),
|
|
this.google.fetchServiceAccounts(config, this.saved),
|
|
]).then((resp) => {
|
|
const [versions, machineTypes, networks, subNetworks, sharedSubnets, servicesAccounts] = resp;
|
|
|
|
setProperties(this, {
|
|
step: 3,
|
|
subNetworks,
|
|
machineTypes,
|
|
networks,
|
|
servicesAccounts,
|
|
sharedSubnets,
|
|
versions,
|
|
})
|
|
|
|
// const filter = servicesAccounts.filter((o) => o.displayName === 'Compute Engine default service account')
|
|
|
|
if (get(this, 'mode') === 'new') {
|
|
// set(this, 'config.serviceAccount', filter?.firstObject && filter.firstObject.uniqueId)
|
|
set(this, 'config.network', networks?.firstObject && networks.firstObject.name)
|
|
}
|
|
|
|
if (isEmpty(config.kubernetesVersion)) {
|
|
set(this, 'config.kubernetesVersion', versions?.defaultClusterVersion);
|
|
}
|
|
|
|
cb(true);
|
|
}).catch((err) => {
|
|
this.send('errorHandler', err);
|
|
|
|
cb(false);
|
|
});
|
|
},
|
|
|
|
addMSAN() {
|
|
const cidrBlocks = (this.config?.masterAuthorizedNetworks?.cidrBlocks ?? []).slice();
|
|
|
|
cidrBlocks.pushObject(this.globalStore.createRecord({
|
|
cidrBlock: '',
|
|
displayName: '',
|
|
type: 'cidrblock',
|
|
}));
|
|
|
|
set(this, 'config.masterAuthorizedNetworks.cidrBlocks', cidrBlocks);
|
|
},
|
|
|
|
removeMSAN(MSAN) {
|
|
const cidrBlocks = this.config?.masterAuthorizedNetworks?.cidrBlocks.slice() ?? [];
|
|
|
|
cidrBlocks.removeObject(MSAN);
|
|
|
|
set(this, 'config.masterAuthorizedNetworks.cidrBlocks', cidrBlocks);
|
|
},
|
|
},
|
|
|
|
clusterLocationChanged: observer('locationType', function() {
|
|
const { locationType } = this;
|
|
|
|
if (locationType === 'regional') {
|
|
setProperties(this, {
|
|
'config.zone': null,
|
|
'config.locations': [],
|
|
});
|
|
} else {
|
|
set(this, 'config.region', null);
|
|
}
|
|
}),
|
|
|
|
clusterSecondaryRangeNameChanged: observer('config.ipAllocationPolicy.clusterSecondaryRangeName', 'secondaryIpRangeContent.[]', function() {
|
|
if (this.isDestroyed || this.isDestroying || this.saving) {
|
|
return;
|
|
}
|
|
|
|
const clusterSecondaryRangeName = get(this, 'config.ipAllocationPolicy.clusterSecondaryRangeName');
|
|
const secondaryIpRangeContent = get(this, 'secondaryIpRangeContent') || [];
|
|
const rangeMatch = secondaryIpRangeContent.findBy('value', clusterSecondaryRangeName);
|
|
|
|
if (isEmpty(rangeMatch)) {
|
|
if (!(isEmpty(get(this, 'config.ipAllocationPolicy.clusterIpv4CidrBlock')))) {
|
|
set(this, 'config.ipAllocationPolicy.clusterIpv4CidrBlock', null);
|
|
}
|
|
} else {
|
|
set(this, 'config.ipAllocationPolicy.clusterIpv4CidrBlock', rangeMatch.ipCidrRange);
|
|
}
|
|
}),
|
|
|
|
enablePrivateNodes: observer('config.privateClusterConfig.enablePrivateNodes', 'config.ipAllocationPolicy.useIpAliases', function() {
|
|
if (this.isDestroyed || this.isDestroying || this.saving) {
|
|
return;
|
|
}
|
|
|
|
const { config } = this;
|
|
const { privateClusterConfig: { enablePrivateNodes = false }, } = config ?? {};
|
|
|
|
if (enablePrivateNodes) {
|
|
setProperties(config, {
|
|
'ipAllocationPolicy.useIpAliases': true,
|
|
'masterAuthorizedNetworks.enabled': true,
|
|
});
|
|
}
|
|
}),
|
|
|
|
networkChange: observer('config.network', 'subNetworkContent.[]', function() {
|
|
if (this.isDestroyed || this.isDestroying || this.saving) {
|
|
return;
|
|
}
|
|
|
|
const subNetworkContent = get(this, 'subNetworkContent') || []
|
|
|
|
if (subNetworkContent.length >= 1) {
|
|
const firstNonNullSubnetMatch = subNetworkContent.find((sn) => !isEmpty(sn.value));
|
|
|
|
setProperties(this, {
|
|
'config.subnetwork': firstNonNullSubnetMatch?.value || '',
|
|
'config.ipAllocationPolicy.createSubnetwork': false,
|
|
'config.ipAllocationPolicy.subnetworkName': null,
|
|
'config.ipAllocationPolicy.nodeIpv4CidrBlock': null,
|
|
});
|
|
} else {
|
|
setProperties(this, {
|
|
'config.subnetwork': '',
|
|
'config.ipAllocationPolicy.createSubnetwork': true,
|
|
'config.ipAllocationPolicy.clusterSecondaryRangeName': null,
|
|
'config.ipAllocationPolicy.servicesSecondaryRangeName': null,
|
|
});
|
|
}
|
|
}),
|
|
|
|
servicesSecondaryRangeNameChanged: observer('config.ipAllocationPolicy.servicesSecondaryRangeName', 'secondaryIpRangeContent.[]', function() {
|
|
if (this.isDestroyed || this.isDestroying || this.saving) {
|
|
return;
|
|
}
|
|
|
|
const servicesSecondaryRangeName = get(this, 'config.ipAllocationPolicy.servicesSecondaryRangeName');
|
|
const secondaryIpRangeContent = get(this, 'secondaryIpRangeContent') || [];
|
|
const rangeMatch = secondaryIpRangeContent.findBy('value', servicesSecondaryRangeName);
|
|
|
|
if (isEmpty(rangeMatch)) {
|
|
if (!isEmpty(get(this, 'config.ipAllocationPolicy.servicesIpv4CidrBlock'))) {
|
|
set(this, 'config.ipAllocationPolicy.servicesIpv4CidrBlock', null);
|
|
}
|
|
} else {
|
|
set(this, 'config.ipAllocationPolicy.servicesIpv4CidrBlock', rangeMatch.ipCidrRange);
|
|
}
|
|
}),
|
|
|
|
secondaryIpRangeContentChange: observer('secondaryIpRangeContent.[]', 'config.ipAllocationPolicy.useIpAliases', 'config.{network,subnetwork}', function() {
|
|
if (this.isDestroyed || this.isDestroying || this.saving) {
|
|
return;
|
|
}
|
|
|
|
const secondaryIpRangeContent = get(this, 'secondaryIpRangeContent') || []
|
|
|
|
if (secondaryIpRangeContent.length === 0) {
|
|
setProperties(this, {
|
|
'config.ipAllocationPolicy.createSubnetwork': true,
|
|
'config.ipAllocationPolicy.clusterSecondaryRangeName': null,
|
|
'config.ipAllocationPolicy.servicesSecondaryRangeName': null,
|
|
});
|
|
}
|
|
}),
|
|
|
|
subnetworkChange: observer('config.subnetwork', function() {
|
|
if (this.isDestroyed || this.isDestroying || this.saving) {
|
|
return;
|
|
}
|
|
|
|
const { config: { subnetwork } } = this;
|
|
|
|
if (isEmpty(subnetwork)) {
|
|
setProperties(this, {
|
|
'config.ipAllocationPolicy.createSubnetwork': true,
|
|
'config.ipAllocationPolicy.clusterSecondaryRangeName': null,
|
|
'config.ipAllocationPolicy.servicesSecondaryRangeName': null,
|
|
});
|
|
} else {
|
|
setProperties(this, {
|
|
'config.ipAllocationPolicy.createSubnetwork': false,
|
|
'config.ipAllocationPolicy.subnetworkName': null,
|
|
'config.ipAllocationPolicy.nodeIpv4CidrBlock': null,
|
|
});
|
|
}
|
|
}),
|
|
|
|
useIpAliasesChanged: observer('config.ipAllocationPolicy.useIpAliases', function() {
|
|
if (this.isDestroyed || this.isDestroying || this.saving) {
|
|
return;
|
|
}
|
|
|
|
const useIpAliases = get(this, 'config.ipAllocationPolicy.useIpAliases');
|
|
|
|
if (useIpAliases) {
|
|
if (!isEmpty(this.config.subnetwork)) {
|
|
set(this, 'config.ipPolicyCreateSubnetwork', false);
|
|
}
|
|
} else {
|
|
setProperties(this, {
|
|
'config.ipAllocationPolicy.clusterSecondaryRangeName': null,
|
|
'config.ipAllocationPolicy.servicesSecondaryRangeName': null,
|
|
});
|
|
}
|
|
}),
|
|
|
|
postSaveChanged: observer('isPostSave', function() {
|
|
const {
|
|
isNew,
|
|
isPostSave,
|
|
config: { privateClusterConfig: { enablePrivateNodes } },
|
|
importedClusterIsPending,
|
|
} = this;
|
|
|
|
if ((enablePrivateNodes || importedClusterIsPending) && isPostSave) {
|
|
if (isNew) {
|
|
set(this, 'step', 5);
|
|
} else {
|
|
this.close();
|
|
}
|
|
} else {
|
|
this.close();
|
|
}
|
|
}),
|
|
|
|
importedClusterIsPending: computed('clusterIsPending', 'model.originalCluster', function() {
|
|
const { clusterIsPending } = this;
|
|
const originalCluster = get(this, 'model.originalCluster');
|
|
const ourClusterSpec = get(( originalCluster ?? {} ), 'gkeConfig');
|
|
const upstreamSpec = get(( originalCluster ?? {} ), 'gkeStatus.upstreamSpec');
|
|
|
|
return clusterIsPending && get(ourClusterSpec, 'imported') && !isEmpty(upstreamSpec);
|
|
}),
|
|
|
|
clusterIsPending: computed('clusterState', function() {
|
|
const { clusterState } = this;
|
|
|
|
return ['pending', 'provisioning', 'waiting'].includes(clusterState);
|
|
}),
|
|
|
|
|
|
cloudCredentials: computed('model.cloudCredentials', function() {
|
|
const { model: { cloudCredentials } } = this;
|
|
|
|
return cloudCredentials.filter((cc) => Object.prototype.hasOwnProperty.call(cc, 'googlecredentialConfig'));
|
|
}),
|
|
|
|
disableSecondaryRangeNames: computed('config.ipAllocationPolicy.{createSubnetwork,useIpAliases}', function() {
|
|
const ipAllocationPolicy = get(this, 'config.ipAllocationPolicy');
|
|
const { createSubnetwork = false, useIpAliases = false } = ipAllocationPolicy ?? {
|
|
createSubnetwork: false,
|
|
useIpAliases: false
|
|
};
|
|
|
|
if (!useIpAliases && !createSubnetwork) {
|
|
return true;
|
|
}
|
|
|
|
if (useIpAliases && !createSubnetwork) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}),
|
|
|
|
locationContent: computed('config.zone', 'zoneChoices', function() {
|
|
const zone = get(this, 'config.zone')
|
|
|
|
if ( !zone ) {
|
|
return [];
|
|
}
|
|
const arr = zone.split('-')
|
|
const locationName = `${ arr[0] }-${ arr[1] }`
|
|
const zoneChoices = get(this, 'zoneChoices')
|
|
|
|
return zoneChoices.filter((z) => (z.name || '').startsWith(locationName) && z.name !== zone)
|
|
}),
|
|
|
|
maintenanceWindowChoice: computed('maintenanceWindowTimes.[]', 'config.maintenanceWindow', function() {
|
|
return get(this, 'maintenanceWindowTimes').findBy('value', get(this, 'config.maintenanceWindow')) || { label: 'Any Time' };
|
|
}),
|
|
|
|
|
|
networkContent: computed('config.zone', 'networks', 'sharedSubnets', function() {
|
|
const networks = (get(this, 'networks') || []).map((net) => {
|
|
return {
|
|
...net,
|
|
group: 'VPC',
|
|
shared: false
|
|
};
|
|
});
|
|
const sharedSubnets = (get(this, 'sharedSubnets') || []).map((ssn) => {
|
|
return {
|
|
...ssn,
|
|
group: 'Shared VPC',
|
|
shared: true,
|
|
name: ssn?.network,
|
|
};
|
|
})
|
|
const merged = [...networks, ...sharedSubnets];
|
|
|
|
return merged;
|
|
}),
|
|
|
|
secondaryIpRangeContent: computed('subNetworkContent.[]', 'config.{network,subnetwork}', function() {
|
|
const { subNetworkContent = [], config: { subnetwork } } = this;
|
|
const subnetworkMatch = subNetworkContent.findBy('value', subnetwork);
|
|
|
|
if (subnetworkMatch) {
|
|
const { secondaryIpRanges = [] } = subnetworkMatch;
|
|
|
|
return secondaryIpRanges.map((s) => {
|
|
return {
|
|
label: `${ s.rangeName }(${ s.ipCidrRange })`,
|
|
value: s.rangeName,
|
|
ipCidrRange: s.ipCidrRange,
|
|
}
|
|
});
|
|
}
|
|
|
|
return [];
|
|
}),
|
|
|
|
subNetworkContent: computed('subNetworks.[]', 'sharedSubnets.[]', 'config.network', 'config.zone', function() {
|
|
const {
|
|
config: { network: networkName },
|
|
networkContent,
|
|
subNetworks = [],
|
|
sharedSubnets = [],
|
|
} = this;
|
|
const networkMatch = networkContent.findBy('name', networkName);
|
|
let filteredSubnets = [];
|
|
let mappedSubnets = [];
|
|
let out = [];
|
|
|
|
if (!isEmpty(networkMatch) && networkMatch.shared) {
|
|
const sharedVpcs = sharedSubnets.filterBy('network', networkName);
|
|
|
|
mappedSubnets = sharedVpcs.map((sVpc) => {
|
|
const networkDisplayName = sVpc.network;
|
|
|
|
return {
|
|
label: `${ sVpc.subnetwork } (${ sVpc.ipCidrRange })`,
|
|
value: sVpc.subnetwork,
|
|
secondaryIpRanges: sVpc.secondaryIpRanges,
|
|
networkDisplayName
|
|
}
|
|
});
|
|
|
|
out = [...mappedSubnets];
|
|
} else {
|
|
filteredSubnets = (subNetworks || []).filter((s) => {
|
|
const network = networkContent.findBy('selfLink', s.network);
|
|
const networkDisplayName = network.name;
|
|
|
|
if (networkDisplayName === networkName) {
|
|
return true
|
|
}
|
|
});
|
|
mappedSubnets = filteredSubnets.map((o) => {
|
|
const network = networkContent.findBy('selfLink', o.network);
|
|
const networkDisplayName = network.name;
|
|
|
|
return {
|
|
label: `${ o.name }(${ o.ipCidrRange })`,
|
|
value: o.name,
|
|
secondaryIpRanges: o.secondaryIpRanges,
|
|
networkDisplayName
|
|
}
|
|
});
|
|
|
|
const defaultSubnetAry = [{
|
|
label: this.intl.t('clusterNew.googlegke.ipPolicyCreateSubnetwork.autoLabel'),
|
|
value: '',
|
|
}];
|
|
|
|
out = [...defaultSubnetAry, ...mappedSubnets];
|
|
}
|
|
|
|
return out;
|
|
}),
|
|
|
|
selectedCloudCredential: computed('config.googleCredentialSecret', function() {
|
|
const {
|
|
model: { cloudCredentials = [] },
|
|
config: { googleCredentialSecret }
|
|
} = this;
|
|
|
|
if (isEmpty(cloudCredentials) && isEmpty(googleCredentialSecret)) {
|
|
return null;
|
|
} else {
|
|
return cloudCredentials.findBy('id', googleCredentialSecret.includes('cattle-global-data:') ? googleCredentialSecret : `cattle-global-data:${ googleCredentialSecret }`);
|
|
}
|
|
}),
|
|
|
|
versionChoices: computed('versions.validMasterVersions.[]', 'config.kubernetesVersion', function() {
|
|
const {
|
|
versions: { validMasterVersions = [] },
|
|
config: { kubernetesVersion },
|
|
mode,
|
|
} = this;
|
|
|
|
return this.serivceVersions.parseCloudProviderVersionChoices(validMasterVersions, kubernetesVersion, mode);
|
|
}),
|
|
|
|
zoneChoices: computed('zones.[]', function() {
|
|
let out = (get(this, 'zones') || []).slice();
|
|
|
|
out.forEach((obj) => {
|
|
set(obj, 'sortName', sortableNumericSuffix(obj.name));
|
|
set(obj, 'displayName', `${ obj.name } (${ obj.description })`);
|
|
set(obj, 'disabled', obj.status.toLowerCase() !== 'up');
|
|
});
|
|
|
|
return out.sortBy('sortName')
|
|
}),
|
|
|
|
defaultConfig() {
|
|
const neu = { ...DEFAULT_GKE_CONFIG };
|
|
const neuNp = { ...DEFAULT_GKE_NODE_POOL_CONFIG };
|
|
|
|
set(neu, 'nodePools', [neuNp]);
|
|
|
|
return neu;
|
|
},
|
|
|
|
validatePrivateConfig() {
|
|
const config = get(this, 'config') || {}
|
|
const { privateClusterConfig } = config;
|
|
|
|
if (isEmpty(privateClusterConfig)) {
|
|
return true;
|
|
}
|
|
|
|
if (privateClusterConfig?.enablePrivateNodes && isEmpty(privateClusterConfig?.masterIpv4CidrBlock)) {
|
|
this.send('errorHandler', this.intl.t('clusterNew.googlegke.masterIpv4CidrBlock.error'));
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
|
|
willSave() {
|
|
this.validateNodePools();
|
|
this.validatePrivateConfig();
|
|
|
|
if (!isEmpty(this.errors)) {
|
|
return false;
|
|
}
|
|
|
|
const config = get(this, 'config') || {}
|
|
|
|
const locationType = get(this, 'locationType');
|
|
|
|
if ( locationType === this.google.defaultZoneType ) {
|
|
set(config, 'region', null);
|
|
} else {
|
|
set(config, 'zone', null);
|
|
}
|
|
|
|
if (get(this, 'config.useIpAliases')) {
|
|
set(config, 'clusterIpv4Cidr', null);
|
|
}
|
|
|
|
if (!get(config, 'masterAuthorizedNetworks.enabled')) {
|
|
delete config.masterAuthorizedNetworks.cidrBlocks
|
|
}
|
|
|
|
const locationContent = get(this, 'locationContent')
|
|
const locations = locationContent.filter((l) => l.checked).map((l) => l.name)
|
|
|
|
if (this.locationType === 'zonal') {
|
|
if (locations.length > 0) {
|
|
locations.push(get(config, 'zone'))
|
|
set(config, 'locations', locations)
|
|
}
|
|
}
|
|
|
|
return this._super(...arguments);
|
|
},
|
|
|
|
validateNodePools() {
|
|
const nodePools = get(this, 'primaryResource.gkeConfig.nodePools');
|
|
const errors = [];
|
|
|
|
if (!isEmpty(nodePools)) {
|
|
const nodePoolErrors = [];
|
|
|
|
nodePools.forEach((np) => {
|
|
const npErr = np.validationErrors();
|
|
|
|
nodePoolErrors.push(npErr)
|
|
});
|
|
|
|
if (!isEmpty(nodePoolErrors)) {
|
|
errors.pushObjects(nodePoolErrors.flat());
|
|
}
|
|
}
|
|
|
|
set(this, 'errors', errors);
|
|
|
|
return errors.length >= 1 ? true : null;
|
|
},
|
|
});
|