mirror of https://github.com/rancher/ui.git
846 lines
22 KiB
JavaScript
846 lines
22 KiB
JavaScript
import Component from '@ember/component'
|
|
import ClusterDriver from 'shared/mixins/cluster-driver';
|
|
import layout from './template';
|
|
import { equal } from '@ember/object/computed'
|
|
|
|
import {
|
|
get, set, computed, observer, setProperties
|
|
} from '@ember/object';
|
|
import { inject as service } from '@ember/service';
|
|
import $ from 'jquery';
|
|
|
|
export default Component.extend(ClusterDriver, {
|
|
intl: service(),
|
|
layout,
|
|
configField: 'huaweiEngineConfig',
|
|
zones: [
|
|
{
|
|
label: 'cn-north-1',
|
|
value: 'cn-north-1',
|
|
}],
|
|
clusterType: [
|
|
{
|
|
label: 'VirtualMachine',
|
|
value: 'VirtualMachine',
|
|
}, {
|
|
label: 'BareMetal',
|
|
value: 'BareMetal',
|
|
}],
|
|
masterVersions: [
|
|
{
|
|
label: 'v1.11.3',
|
|
value: 'v1.11.3',
|
|
}],
|
|
eipChargeModeContent: [
|
|
{
|
|
label: 'BandWith',
|
|
value: null,
|
|
}, {
|
|
label: 'Traffic',
|
|
value: 'traffic',
|
|
}],
|
|
containerNetworkMode: [
|
|
{
|
|
label: 'overlay_l2',
|
|
value: 'overlay_l2',
|
|
}, {
|
|
label: 'underlay_ipvlan',
|
|
value: 'underlay_ipvlan',
|
|
}, {
|
|
label: 'vpc-router',
|
|
value: 'vpc-router',
|
|
}],
|
|
volumeTypeContent: [
|
|
{
|
|
label: 'SATA',
|
|
value: 'SATA',
|
|
}, {
|
|
label: 'SAS',
|
|
value: 'SAS',
|
|
}, {
|
|
label: 'SSD',
|
|
value: 'SSD',
|
|
}],
|
|
eipTypeContent: [
|
|
{
|
|
label: '5_bgp',
|
|
value: '5_bgp',
|
|
}, {
|
|
label: '5_sbgp',
|
|
value: '5_sbgp',
|
|
}],
|
|
containerNetworkModeContent: [
|
|
{
|
|
label: 'overlay_l2',
|
|
value: 'overlay_l2',
|
|
}, {
|
|
label: 'underlay_ipvlan',
|
|
value: 'underlay_ipvlan',
|
|
}, {
|
|
label: 'vpc-router',
|
|
value: 'vpc-router',
|
|
}],
|
|
nodeOperationSystemContent: [
|
|
{
|
|
label: 'EulerOS 2.2',
|
|
value: 'EulerOS 2.2',
|
|
}, {
|
|
label: 'CentOS 7.4',
|
|
value: 'CentOS 7.4',
|
|
}],
|
|
containerNetworkCidrContent: [
|
|
{
|
|
label: '172.16.0.0/16',
|
|
value: '172.16.0.0/16'
|
|
}
|
|
],
|
|
validityPeriodContent: [
|
|
{
|
|
label: '1 month',
|
|
value: '1 month'
|
|
},
|
|
{
|
|
label: '2 months',
|
|
value: '2 month'
|
|
},
|
|
{
|
|
label: '3 months',
|
|
value: '3 month'
|
|
},
|
|
{
|
|
label: '4 months',
|
|
value: '4 month'
|
|
},
|
|
{
|
|
label: '5 months',
|
|
value: '5 month'
|
|
},
|
|
{
|
|
label: '6 months',
|
|
value: '6 month'
|
|
},
|
|
{
|
|
label: '7 months',
|
|
value: '7 month'
|
|
},
|
|
{
|
|
label: '8 months',
|
|
value: '8 month'
|
|
},
|
|
{
|
|
label: '9 months',
|
|
value: '9 month'
|
|
},
|
|
{
|
|
label: '1 year',
|
|
value: '1 year'
|
|
},
|
|
],
|
|
eipShareTypeContent: [
|
|
{
|
|
label: 'PER',
|
|
value: 'PER'
|
|
},
|
|
],
|
|
vpcs: null,
|
|
subnets: null,
|
|
eipIds: null,
|
|
nodeFlavors: null,
|
|
keypairs: null,
|
|
availableZones: null,
|
|
step: 1,
|
|
eipSelection: 'none',
|
|
highAvailabilityEnabled: 's2',
|
|
managementScale: 'small',
|
|
validityPeriod: '1 month',
|
|
authConfigred: false,
|
|
publicCloud: null,
|
|
|
|
editing: equal('mode', 'edit'),
|
|
init() {
|
|
this._super(...arguments);
|
|
|
|
let config = get(this, 'cluster.huaweiEngineConfig');
|
|
|
|
if ( !config ) {
|
|
config = this.get('globalStore').createRecord({
|
|
type: 'huaweiEngineConfig',
|
|
accessKey: null,
|
|
secretKey: null,
|
|
region: 'cn-north-1',
|
|
projectId: null,
|
|
dataVolumeSize: 100,
|
|
vpcId: null,
|
|
clusterType: 'VirtualMachine',
|
|
masterVersion: 'v1.11.3',
|
|
billingMode: 0,
|
|
containerNetworkMode: 'overlay_l2',
|
|
clusterFlavor: 'cce.s2.small',
|
|
dataVolumeType: 'SATA',
|
|
rootVolumeType: 'SATA',
|
|
nodeCount: 1,
|
|
rootVolumeSize: 40,
|
|
externalServerEnabled: false,
|
|
nodeOperationSystem: 'EulerOS 2.2',
|
|
containerNetworkCidr: '172.16.0.0/16',
|
|
bmsIsAutoRenew: 'false',
|
|
userName: 'root',
|
|
});
|
|
|
|
set(this, 'cluster.huaweiEngineConfig', config);
|
|
this.validityPeriodChange()
|
|
} else {
|
|
const clusterFlavor = get(config, 'clusterFlavor')
|
|
|
|
if ( clusterFlavor ) {
|
|
const arr = clusterFlavor.split('.')
|
|
|
|
setProperties(this, {
|
|
'highAvailabilityEnabled': arr[1],
|
|
'managementScale': arr[2]
|
|
})
|
|
}
|
|
|
|
setProperties(config, {
|
|
accessKey: null,
|
|
secretKey: null,
|
|
})
|
|
|
|
if ( get(config, 'nodeLabels') === null ) {
|
|
set(config, 'nodeLabels', {})
|
|
}
|
|
|
|
if ( get(config, 'eipIds') === null ) {
|
|
set(config, 'eipIds', []);
|
|
}
|
|
}
|
|
},
|
|
|
|
actions: {
|
|
multiEipSelect() {
|
|
let options = Array.prototype.slice.call($('.existing-eips')[0], 0);
|
|
let selectedOptions = [];
|
|
|
|
options.filterBy('selected', true).forEach((cap) => {
|
|
return selectedOptions.push(cap.value);
|
|
});
|
|
|
|
set(this, 'config.eipIds', selectedOptions || []);
|
|
},
|
|
|
|
checkAccount(cb) {
|
|
const requiredConfig = ['projectId', 'accessKey', 'secretKey', 'region']
|
|
const requiredCluster = ['name']
|
|
|
|
set(this, 'errors', [])
|
|
let errors = [];
|
|
|
|
errors = this.validateFields(errors, requiredConfig, 'config')
|
|
errors = this.validateFields(errors, requiredCluster, 'cluster')
|
|
if (errors.length > 0) {
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
|
|
setProperties(this, {
|
|
'errors': null,
|
|
'config.accessKey': (get(this, 'config.accessKey') || '').trim(),
|
|
'config.secretKey': (get(this, 'config.secretKey') || '').trim(),
|
|
});
|
|
|
|
try {
|
|
const location = window.location;
|
|
const region = get(this, 'config.region')
|
|
let endpoint = `vpc.${ region }.myhuaweicloud.com`;
|
|
|
|
endpoint = `${ get(this, 'app.proxyEndpoint') }/${ endpoint.replace('//', '/') }`;
|
|
endpoint = `${ location.origin }${ endpoint }`;
|
|
|
|
var client = new HW.ECS({
|
|
ak: get(this, 'config.accessKey'),
|
|
sk: get(this, 'config.secretKey'),
|
|
projectId: get(this, 'config.projectId'),
|
|
endpoint,
|
|
region,
|
|
toSignedHost: `vpc.${ region }.myhuaweicloud.com`,
|
|
})
|
|
|
|
client.getVpcs((err, response) => {
|
|
if ( err ) {
|
|
let errors = this.get('errors') || [];
|
|
|
|
errors.pushObject(err);
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
|
|
set(this, 'vpcs', response.body.vpcs)
|
|
|
|
if (get(this, 'mode') === 'new') {
|
|
set(this, 'config.vpcId', response.body.vpcs[0] && response.body.vpcs[0].id || null)
|
|
}
|
|
|
|
client.getSubnet((err, response) => {
|
|
if (err) {
|
|
let errors = this.get('errors') || [];
|
|
|
|
errors.pushObject(err);
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
|
|
set(this, 'subnets', response.body.subnets)
|
|
|
|
if (get(this, 'mode') === 'new') {
|
|
set(this, 'config.subnetId', response.body.subnets[0] && response.body.subnets[0].id || null)
|
|
}
|
|
|
|
client.getPublicips((err, response) => {
|
|
if (err) {
|
|
let errors = this.get('errors') || [];
|
|
|
|
errors.pushObject(err);
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
|
|
set(this, 'eipIds', response.body.publicips)
|
|
|
|
client.getNetwork((err, response) => {
|
|
if (err) {
|
|
let errors = this.get('errors') || []
|
|
|
|
errors.pushObject(err)
|
|
set(this, 'errors', errors)
|
|
cb()
|
|
|
|
return
|
|
}
|
|
set(this, 'publicCloud', true)
|
|
set(this, 'networks', response.body.networks)
|
|
|
|
set(this, 'step', 2);
|
|
cb();
|
|
})
|
|
})
|
|
})
|
|
})
|
|
} catch (err) {
|
|
const errors = get(this, 'errors') || [];
|
|
|
|
errors.pushObject(err.message || err);
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
},
|
|
|
|
configreNode(cb) {
|
|
const requiredConfig = ['vpcId', 'subnetId', 'containerNetworkCidr']
|
|
|
|
set(this, 'errors', [])
|
|
let errors = [];
|
|
|
|
errors = this.validateFields(errors, requiredConfig, 'config')
|
|
if (errors.length > 0) {
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
|
|
if (get(this, 'authConfigred')) {
|
|
set(this, 'step', 3)
|
|
cb()
|
|
|
|
return
|
|
}
|
|
try {
|
|
const location = window.location;
|
|
const region = get(this, 'config.region')
|
|
let endpoint = `ecs.${ region }.myhuaweicloud.com`;
|
|
|
|
endpoint = `${ get(this, 'app.proxyEndpoint') }/${ endpoint.replace('//', '/') }`;
|
|
endpoint = `${ location.origin }${ endpoint }`;
|
|
|
|
var client = new HW.ECS({
|
|
ak: get(this, 'config.accessKey'),
|
|
sk: get(this, 'config.secretKey'),
|
|
projectId: get(this, 'config.projectId'),
|
|
endpoint,
|
|
region,
|
|
toSignedHost: `ecs.${ region }.myhuaweicloud.com`,
|
|
service: 'ecs',
|
|
})
|
|
|
|
client.listCloudServerFlavors((err, response) => {
|
|
if (err) {
|
|
let errors = this.get('errors') || [];
|
|
|
|
errors.pushObject(err);
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
|
|
set(this, 'nodeFlavors', response.body.flavors)
|
|
|
|
if (get(this, 'mode') === 'new') {
|
|
set(this, 'config.nodeFlavor', response.body.flavors[0] && response.body.flavors[0].name || null)
|
|
}
|
|
client.listKeypairs((err, response) => {
|
|
if (err) {
|
|
let errors = this.get('errors') || [];
|
|
|
|
errors.pushObject(err);
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
|
|
set(this, 'keypairs', response.body.keypairs)
|
|
|
|
const keypairs = response.body.keypairs || []
|
|
|
|
set(this, 'config.sshKey', keypairs[0] && keypairs[0].keypair.name)
|
|
|
|
client.getAvaliableZone((err, response) => {
|
|
if (err) {
|
|
let errors = this.get('errors') || [];
|
|
|
|
errors.pushObject(err);
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
|
|
const availableZones = (response.body.availabilityZoneInfo || []).filter((z) => z.zoneState.available)
|
|
|
|
set(this, 'availableZones', availableZones)
|
|
|
|
if (get(this, 'mode') === 'new') {
|
|
setProperties(this, {
|
|
'config.keypairs': response.body.availabilityZoneInfo[0] && response.body.availabilityZoneInfo[0].zoneName || null,
|
|
'config.availableZone': availableZones.get('firstObject.zoneName'),
|
|
})
|
|
}
|
|
set(this, 'step', 3)
|
|
})
|
|
})
|
|
})
|
|
} catch (err) {
|
|
const errors = get(this, 'errors') || [];
|
|
|
|
errors.pushObject(err.message || err);
|
|
set(this, 'errors', errors);
|
|
cb();
|
|
|
|
return;
|
|
}
|
|
},
|
|
|
|
setLabels(section) {
|
|
let obj = {}
|
|
|
|
section.map((s) => {
|
|
if (s.key && s.value) {
|
|
obj[s.key] = s.value
|
|
}
|
|
})
|
|
set(this, 'config.labels', obj)
|
|
},
|
|
|
|
setNodeLabels(section) {
|
|
let obj = {}
|
|
|
|
section.map((s) => {
|
|
if (s.key && s.value) {
|
|
obj[s.key] = s.value
|
|
}
|
|
})
|
|
set(this, 'config.nodeLabels', obj)
|
|
},
|
|
},
|
|
clusterTypeChange: observer('config.clusterType', function() {
|
|
const clusterType = get(this, 'config.clusterType')
|
|
const publicCloud = get(this, 'publicCloud')
|
|
|
|
if (clusterType === 'VirtualMachine') {
|
|
set(this, 'config.billingMode', 0)
|
|
set(this, 'config.highwaySubnet', null)
|
|
set(this, 'highAvailabilityEnabled', 's2')
|
|
}
|
|
if (clusterType !== 'BareMetal' || get(this, 'mode') !== 'new') {
|
|
return
|
|
}
|
|
const networks = get(this, 'networks') || []
|
|
let filter = []
|
|
|
|
if (publicCloud) {
|
|
filter = networks.filter((n) => n.status === 'ACTIVE' && n.tenant_id === get(this, 'config.projectId') && n[`provider:network_type`] === 'geneve')
|
|
} else {
|
|
filter = networks.filter((n) => n.status === 'ACTIVE')
|
|
}
|
|
set(this, 'config.highwaySubnet', filter[0] && filter[0].id)
|
|
set(this, 'highAvailabilityEnabled', 't2')
|
|
}),
|
|
|
|
vpcIdChange: observer('config.vpcId', function() {
|
|
const vpcId = get(this, 'config.vpcId')
|
|
const subnets = get(this, 'subnets') || []
|
|
|
|
const filter = subnets.filter((s) => s.vpc_id === vpcId)
|
|
|
|
set(this, 'config.subnetId', filter[0] && filter[0].id || null)
|
|
}),
|
|
|
|
eipSelectionChange: observer('eipSelection', function() {
|
|
const eipSelection = get(this, 'eipSelection')
|
|
|
|
if (eipSelection === 'none') {
|
|
setProperties(this, {
|
|
'config.eipIds': [],
|
|
'config.eipCount': null,
|
|
'config.eipType': null,
|
|
'config.eipShareType': null,
|
|
'config.eipChargeMode': null,
|
|
'config.eipBandwidthSize': null,
|
|
})
|
|
}
|
|
if (eipSelection === 'exist') {
|
|
setProperties(this, {
|
|
'config.eipCount': null,
|
|
'config.eipType': null,
|
|
'config.eipShareType': null,
|
|
'config.eipChargeMode': null,
|
|
'config.eipBandwidthSize': null,
|
|
})
|
|
}
|
|
if (eipSelection === 'new') {
|
|
setProperties(this, {
|
|
'config.eipIds': [],
|
|
'config.eipCount': 1,
|
|
'config.eipType': '5_bgp',
|
|
'config.eipBandwidthSize': 1,
|
|
'config.eipShareType': 'PER',
|
|
})
|
|
}
|
|
}),
|
|
|
|
externalServerChange: observer('config.externalServerEnabled', function() {
|
|
const externalServerEnabled = get(this, 'config.externalServerEnabled')
|
|
|
|
if ( !externalServerEnabled ) {
|
|
set(this, 'config.clusterEipId', null)
|
|
}
|
|
}),
|
|
|
|
clusterFlavorObserver: observer('managementScale', 'highAvailabilityEnabled', function() {
|
|
const { managementScale, highAvailabilityEnabled } = this;
|
|
|
|
set(this, 'config.clusterFlavor', `cce.${ highAvailabilityEnabled }.${ managementScale }`)
|
|
}),
|
|
|
|
validityPeriodChange: observer('validityPeriod', function() {
|
|
const validityPeriod = get(this, 'validityPeriod')
|
|
|
|
if (!validityPeriod) {
|
|
setProperties(this, {
|
|
'config.bmsPeriodNum': null,
|
|
'config.bmsPeriodType': null,
|
|
})
|
|
|
|
return
|
|
}
|
|
const arr = validityPeriod.split(' ')
|
|
|
|
setProperties(this, {
|
|
'config.bmsPeriodNum': parseInt(arr[0]),
|
|
'config.bmsPeriodType': arr[1]
|
|
})
|
|
}),
|
|
|
|
billingModeChange: observer('config.billingMode', function() {
|
|
const billingMode = get(this, 'config.billingMode')
|
|
|
|
if (billingMode === 0) {
|
|
setProperties(this, {
|
|
'validityPeriod': null,
|
|
'config.bmsIsAutoRenew': null,
|
|
})
|
|
}
|
|
if (billingMode === 2) {
|
|
setProperties(this, {
|
|
'config.bmsIsAutoRenew': 'false',
|
|
'validityPeriod': '1 month',
|
|
})
|
|
}
|
|
}),
|
|
|
|
managementScaleContent: computed('config.clusterType', function() {
|
|
const clusterType = get(this, 'config.clusterType')
|
|
|
|
if (clusterType === 'BareMetal') {
|
|
return [
|
|
{
|
|
label: '10',
|
|
value: 'small',
|
|
}, {
|
|
label: '100',
|
|
value: 'medium',
|
|
}, {
|
|
label: '500',
|
|
value: 'large',
|
|
}]
|
|
}
|
|
|
|
return [
|
|
{
|
|
label: '50',
|
|
value: 'small',
|
|
}, {
|
|
label: '200',
|
|
value: 'medium',
|
|
}, {
|
|
label: '1000',
|
|
value: 'large',
|
|
}]
|
|
}),
|
|
|
|
vpcContent: computed('vpcs.[]', function() {
|
|
const vpcs = get(this, 'vpcs') || []
|
|
|
|
return vpcs.map((v) => {
|
|
return {
|
|
label: v.name,
|
|
value: v.id
|
|
}
|
|
})
|
|
}),
|
|
|
|
editedVpcName: computed('config.vpcId', 'vpcs', function() {
|
|
const vpcId = get(this, 'config.vpcId')
|
|
const vpcs = get(this, 'vpcs') || []
|
|
const filter = vpcs.filter((v) => v.id === vpcId)[0] || {}
|
|
|
|
return filter.name
|
|
}),
|
|
|
|
subnetContent: computed('config.vpcId', 'subnets.[]', function() {
|
|
const subnets = get(this, 'subnets') || []
|
|
const vpcId = get(this, 'config.vpcId')
|
|
const filter = subnets.filter((s) => s.vpc_id === vpcId).map((s) => ({
|
|
label: s.name,
|
|
value: s.id,
|
|
}))
|
|
|
|
return filter
|
|
}),
|
|
|
|
editedSubnetName: computed('config.subnetId', 'subnets', function() {
|
|
const subnetId = get(this, 'config.subnetId')
|
|
const subnets = get(this, 'subnets') || []
|
|
const filter = subnets.filter((s) => s.id === subnetId)[0] || {}
|
|
|
|
return filter.name
|
|
}),
|
|
|
|
eipIdContent: computed('eipIds.[]', function() {
|
|
const eipIds = get(this, 'eipIds') || []
|
|
|
|
return eipIds.filter((e) => e.status === 'DOWN').map((e) => ({
|
|
label: e.public_ip_address,
|
|
value: e.id
|
|
}))
|
|
}),
|
|
|
|
clusterEipName: computed('config.clusterEipId', 'eipIds', function() {
|
|
const eipIds = get(this, 'eipIds') || []
|
|
const clusterEipId = get(this, 'config.clusterEipId')
|
|
const filter = eipIds.filter((e) => e.id === clusterEipId)[0] || {}
|
|
|
|
return filter.public_ip_address
|
|
}),
|
|
|
|
nodeFlavorContent: computed('nodeFlavors.[]', function() {
|
|
const nodeFlavors = get(this, 'nodeFlavors') || []
|
|
|
|
return nodeFlavors.map((n) => {
|
|
return {
|
|
label: `${ n.name } ( vCPUs: ${ n.vcpus }, memory: ${ n.ram / 1024 } GB )`,
|
|
value: n.name
|
|
}
|
|
})
|
|
}),
|
|
|
|
availableZoneContent: computed('availableZones.[]', function() {
|
|
const zones = get(this, 'availableZones')
|
|
|
|
return zones.map((z) => {
|
|
if (z.zoneState.available) {
|
|
return {
|
|
label: z.zoneName,
|
|
value: z.zoneName
|
|
}
|
|
}
|
|
})
|
|
}),
|
|
|
|
sshkeyContent: computed('keypairs.[]', function() {
|
|
const keypairs = get(this, 'keypairs')
|
|
|
|
return keypairs.map((k) => {
|
|
return {
|
|
label: k.keypair.name,
|
|
value: k.keypair.name
|
|
}
|
|
})
|
|
}),
|
|
|
|
editedSshName: computed('config.sshKey', 'keypairs', function() {
|
|
const sshKey = get(this, 'config.sshKey')
|
|
const keypairs = get(this, 'keypairs')
|
|
const filter = keypairs.filter((k) => k.keypair.name === sshKey)[0] || {}
|
|
|
|
return filter.keypair && filter.keypair.name || ''
|
|
}),
|
|
|
|
nodeCountMax: computed('config.clusterFlavor', function() {
|
|
const clusterFlavor = get(this, 'config.clusterFlavor') || ''
|
|
|
|
if (clusterFlavor.endsWith('small')) {
|
|
return 50
|
|
}
|
|
if (clusterFlavor.endsWith('medium')) {
|
|
return 200
|
|
}
|
|
|
|
return 1000
|
|
}),
|
|
|
|
managementScaleDisplay: computed('managementScale', 'managementScaleContent', function() {
|
|
const managementScale = get(this, 'managementScale')
|
|
const managementScaleContent = get(this, 'managementScaleContent') || []
|
|
const filter = managementScaleContent.filter((m) => m.value === managementScale)[0] || {}
|
|
|
|
return filter.label
|
|
}),
|
|
|
|
networkContent: computed('config.projectId', 'networks.[]', 'publicCloud', function() {
|
|
const networks = get(this, 'networks')
|
|
const publicCloud = get(this, 'publicCloud')
|
|
let arr = []
|
|
|
|
if (publicCloud) {
|
|
arr = networks.filter((n) => n.status === 'ACTIVE' && n.tenant_id === get(this, 'config.projectId') && n[`provider:network_type`] === 'geneve')
|
|
} else {
|
|
arr = networks.filter((n) => n.status === 'ACTIVE')
|
|
}
|
|
|
|
return arr.map((a) => ({
|
|
label: a.name,
|
|
value: a.id
|
|
}))
|
|
}),
|
|
|
|
billingModeName: computed('config.billingMode', function() {
|
|
const billingMode = get(this, 'config.billingMode')
|
|
const intl = get(this, 'intl')
|
|
|
|
return billingMode === 0 ? intl.t('clusterNew.huaweicce.billingMode.payPerUse') : intl.t('clusterNew.huaweicce.billingMode.yearly')
|
|
}),
|
|
|
|
billingModeContent: computed('config.clusterType', function() {
|
|
const clusterType = get(this, 'config.clusterType')
|
|
const intl = get(this, 'intl')
|
|
|
|
if (clusterType === 'VirtualMachine') {
|
|
return [
|
|
{
|
|
label: intl.t('clusterNew.huaweicce.billingMode.payPerUse'),
|
|
value: 0,
|
|
}]
|
|
} else {
|
|
return [
|
|
{
|
|
label: intl.t('clusterNew.huaweicce.billingMode.payPerUse'),
|
|
value: 0,
|
|
}, {
|
|
label: intl.t('clusterNew.huaweicce.billingMode.yearly'),
|
|
value: 2,
|
|
}]
|
|
}
|
|
}),
|
|
|
|
validityPeriodName: computed('config.bmsPeriodNum', 'config.bmsPeriodType', function() {
|
|
const { bmsPeriodNum, bmsPeriodType } = get(this, 'config');
|
|
|
|
return `${ bmsPeriodNum } ${ bmsPeriodType }`
|
|
}),
|
|
|
|
bmsIsAutoRenewName: computed('config.bmsIsAutoRenew', function() {
|
|
return get(this, 'config.bmsIsAutoRenew') === 'true' ? 'Enabled' : 'Disabled'
|
|
}),
|
|
|
|
validateFields(errors = [], requiredFields = [], parent = null) {
|
|
const intl = get(this, 'intl')
|
|
|
|
if (parent) {
|
|
requiredFields.map((item) => {
|
|
if (!get(this, `${ parent }.${ item }`)) {
|
|
errors.pushObject(`"${ intl.t(`clusterNew.huaweicce.${ item }.label`) }" ${ intl.t(`generic.isRequired`) }`);
|
|
}
|
|
})
|
|
} else {
|
|
requiredFields.map((item) => {
|
|
if (!get(this, `${ item }`)) {
|
|
errors.pushObject(`"${ intl.t(`clusterNew.huaweicce.${ item }.label`) }" ${ intl.t(`generic.isRequired`) }`);
|
|
}
|
|
})
|
|
}
|
|
|
|
return errors
|
|
},
|
|
|
|
willSave() {
|
|
if (get(this, 'mode') === 'new') {
|
|
const authenticatingProxyCa = get(this, 'authenticatingProxyCa') || ''
|
|
|
|
if (get(this, 'config.authentiactionMode') === 'authenticating_proxy') {
|
|
set(this, 'config.authenticatingProxyCa', AWS.util.base64.encode(authenticatingProxyCa))
|
|
} else {
|
|
set(this, 'config.authenticatingProxyCa', null)
|
|
}
|
|
}
|
|
|
|
return this._super(...arguments);
|
|
},
|
|
|
|
validate() {
|
|
this._super(...arguments);
|
|
let errors = get(this, 'errors') || [];
|
|
|
|
errors = this.validateFields(errors, ['sshKey'], 'config')
|
|
|
|
if (get(this, 'config.authentiactionMode') === 'authenticating_proxy') {
|
|
errors = this.validateFields(errors, ['authenticatingProxyCa'], 'config')
|
|
}
|
|
set(this, 'errors', errors);
|
|
|
|
return errors.length === 0
|
|
},
|
|
|
|
});
|