| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| |
| <template> |
| <div style="width: auto;"> |
| <a-steps |
| v-if="steps.length > 1" |
| ref="resourceStep" |
| progressDot |
| :current="currentStep" |
| size="small" |
| style="margin-left: 0; margin-top: 16px;"> |
| <a-step |
| v-for="(step, index) in steps" |
| :ref="`resourceStep${index}`" |
| :key="step.formKey" |
| :title="$t(step.title)"></a-step> |
| </a-steps> |
| <static-inputs-form |
| v-if="checkVisibleResource('clusterResource')" |
| @nextPressed="nextPressed" |
| @backPressed="handleBack" |
| @fieldsChanged="fieldsChanged" |
| @submitLaunchZone="submitLaunchZone" |
| :fields="clusterFields" |
| :prefillContent="prefillContent" |
| :description="steps[currentStep].description" |
| :isFixError="isFixError" |
| /> |
| |
| <div v-if="hypervisor !== 'VMware'"> |
| <static-inputs-form |
| v-if="checkVisibleResource('hostResource')" |
| @nextPressed="nextPressed" |
| @backPressed="handleBack" |
| @fieldsChanged="fieldsChanged" |
| @submitLaunchZone="submitLaunchZone" |
| :fields="hostFields" |
| :prefillContent="prefillContent" |
| :description="steps[currentStep].description" |
| :isFixError="isFixError" |
| /> |
| <static-inputs-form |
| v-if="!isEdgeZone && (!localstorageenabled || !localstorageenabledforsystemvm) && checkVisibleResource('primaryResource')" |
| @nextPressed="nextPressed" |
| @backPressed="handleBack" |
| @fieldsChanged="fieldsChanged" |
| @submitLaunchZone="submitLaunchZone" |
| :fields="primaryStorageFields" |
| :prefillContent="prefillContent" |
| :description="steps[currentStep].description" |
| :isFixError="isFixError" |
| /> |
| <static-inputs-form |
| v-if="!isEdgeZone && checkVisibleResource('secondaryResource')" |
| @nextPressed="nextPressed" |
| @backPressed="handleBack" |
| @fieldsChanged="fieldsChanged" |
| @submitLaunchZone="submitLaunchZone" |
| :fields="secondaryStorageFields" |
| :prefillContent="prefillContent" |
| :description="steps[currentStep].description" |
| :isFixError="isFixError" |
| /> |
| </div> |
| <div v-else-if="!isEdgeZone"> |
| <static-inputs-form |
| v-if="checkVisibleResource('primaryResource')" |
| @nextPressed="nextPressed" |
| @backPressed="handleBack" |
| @fieldsChanged="fieldsChanged" |
| @submitLaunchZone="submitLaunchZone" |
| :fields="primaryStorageFields" |
| :prefillContent="prefillContent" |
| :description="steps[currentStep].description" |
| :isFixError="isFixError" |
| /> |
| <static-inputs-form |
| v-if="checkVisibleResource('secondaryResource')" |
| @nextPressed="nextPressed" |
| @backPressed="handleBack" |
| @fieldsChanged="fieldsChanged" |
| @submitLaunchZone="submitLaunchZone" |
| :fields="secondaryStorageFields" |
| :prefillContent="prefillContent" |
| :description="steps[currentStep].description" |
| :isFixError="isFixError" |
| /> |
| </div> |
| </div> |
| </template> |
| <script> |
| import { nextTick } from 'vue' |
| import { api } from '@/api' |
| import { mixinDevice } from '@/utils/mixin.js' |
| import StaticInputsForm from '@views/infra/zone/StaticInputsForm' |
| |
| export default { |
| components: { |
| StaticInputsForm |
| }, |
| mixins: [mixinDevice], |
| props: { |
| prefillContent: { |
| type: Object, |
| default: function () { |
| return {} |
| } |
| }, |
| stepChild: { |
| type: String, |
| default: '' |
| }, |
| isFixError: { |
| type: Boolean, |
| default: false |
| } |
| }, |
| computed: { |
| zoneType () { |
| return this.prefillContent?.zoneType || null |
| }, |
| isAdvancedZone () { |
| return this.zoneType === 'Advanced' |
| }, |
| hypervisor () { |
| return this.prefillContent?.hypervisor || null |
| }, |
| localstorageenabled () { |
| return this.prefillContent?.localstorageenabled || false |
| }, |
| localstorageenabledforsystemvm () { |
| return this.prefillContent?.localstorageenabledforsystemvm || false |
| }, |
| isEdgeZone () { |
| return this.prefillContent?.zoneSuperType === 'Edge' || false |
| }, |
| steps () { |
| const steps = [] |
| const hypervisor = this.prefillContent.hypervisor ? this.prefillContent.hypervisor : null |
| if (!this.isEdgeZone) { |
| steps.push({ |
| title: 'label.cluster', |
| fromKey: 'clusterResource', |
| description: 'message.desc.cluster' |
| }) |
| } |
| if (hypervisor !== 'VMware') { |
| steps.push({ |
| title: 'label.host', |
| fromKey: 'hostResource', |
| description: 'message.desc.host' |
| }) |
| } |
| if (!this.isEdgeZone) { |
| if (!this.localstorageenabled || !this.localstorageenabledforsystemvm) { |
| steps.push({ |
| title: 'label.primary.storage', |
| fromKey: 'primaryResource', |
| description: 'message.desc.primary.storage' |
| }) |
| } |
| steps.push({ |
| title: 'label.secondary.storage', |
| fromKey: 'secondaryResource', |
| description: 'message.desc.secondary.storage' |
| }) |
| } |
| |
| return steps |
| }, |
| clusterFields () { |
| return [ |
| { |
| title: 'label.cluster.name', |
| key: 'clusterName', |
| placeHolder: 'message.error.cluster.name', |
| required: true |
| }, |
| { |
| title: 'label.vcenter.host', |
| key: 'vCenterHost', |
| placeHolder: 'message.error.vcenter.host', |
| required: true, |
| display: { |
| hypervisor: ['VMware', 'Ovm3'] |
| } |
| }, |
| { |
| title: 'label.vcenter.username', |
| key: 'vCenterUsername', |
| placeHolder: 'message.error.vcenter.username', |
| required: true, |
| display: { |
| hypervisor: ['VMware', 'Ovm3'] |
| } |
| }, |
| { |
| title: 'label.vcenter.password', |
| key: 'vCenterPassword', |
| placeHolder: 'message.error.vcenter.password', |
| required: true, |
| password: true, |
| display: { |
| hypervisor: ['VMware', 'Ovm3'] |
| } |
| }, |
| { |
| title: 'label.vcenter.datacenter', |
| key: 'vCenterDatacenter', |
| placeHolder: 'message.error.vcenter.datacenter', |
| required: true, |
| display: { |
| hypervisor: ['VMware', 'Ovm3'] |
| } |
| }, |
| { |
| title: 'label.override.public.traffic', |
| key: 'overridepublictraffic', |
| required: false, |
| switch: true, |
| display: { |
| dvSwitchEnabled: true |
| } |
| }, |
| { |
| title: 'label.override.guest.traffic', |
| key: 'overrideguesttraffic', |
| required: false, |
| switch: true, |
| display: { |
| dvSwitchEnabled: true |
| } |
| }, |
| { |
| title: 'label.cisco.nexus1000v.ip.address', |
| key: 'vsmipaddress', |
| placeHolder: 'message.error.nexus1000v.ipaddress', |
| required: false, |
| display: { |
| vSwitchEnabled: true |
| } |
| }, |
| { |
| title: 'label.cisco.nexus1000v.username', |
| key: 'vsmusername', |
| placeHolder: 'message.error.nexus1000v.username', |
| required: false, |
| display: { |
| vSwitchEnabled: true |
| } |
| }, |
| { |
| title: 'label.cisco.nexus1000v.password', |
| key: 'vsmpassword', |
| placeHolder: 'message.error.nexus1000v.password', |
| required: false, |
| display: { |
| vSwitchEnabled: true |
| } |
| } |
| ] |
| }, |
| hostFields () { |
| return [ |
| { |
| title: 'label.host.name', |
| key: 'hostName', |
| placeHolder: 'message.error.host.name', |
| required: true, |
| display: { |
| hypervisor: ['VMware', 'BareMetal', 'Ovm', 'Hyperv', 'KVM', 'XenServer', 'LXC', 'Simulator'] |
| } |
| }, |
| { |
| title: 'label.username', |
| key: 'hostUserName', |
| placeHolder: 'message.error.host.username', |
| required: true, |
| display: { |
| hypervisor: ['VMware', 'BareMetal', 'Ovm', 'Hyperv', 'KVM', 'XenServer', 'LXC', 'Simulator'] |
| } |
| }, |
| { |
| title: 'label.authentication.method', |
| key: 'authmethod', |
| placeHolder: 'message.error.authmethod', |
| required: false, |
| radioGroup: true, |
| defaultValue: 'password', |
| radioOption: [{ |
| label: 'label.password', |
| value: 'password' |
| }, { |
| label: 'label.authentication.sshkey', |
| value: 'sshkey', |
| condition: { |
| hypervisor: ['KVM'] |
| } |
| }], |
| display: { |
| hypervisor: ['BareMetal', 'Ovm', 'Hyperv', 'KVM', 'XenServer', 'LXC', 'Simulator'] |
| }, |
| alert: { |
| message: 'message.add.host.sshkey', |
| display: { |
| authmethod: 'sshkey' |
| } |
| } |
| }, |
| { |
| title: 'label.password', |
| key: 'hostPassword', |
| placeHolder: 'message.error.host.password', |
| required: true, |
| password: true, |
| display: { |
| hypervisor: ['VMware', 'BareMetal', 'Ovm', 'Hyperv', 'KVM', 'XenServer', 'LXC', 'Simulator'], |
| authmethod: 'password' |
| } |
| }, |
| { |
| title: 'label.agent.username', |
| key: 'agentUserName', |
| placeHolder: 'message.error.agent.username', |
| required: false, |
| defaultValue: 'Oracle', |
| display: { |
| hypervisor: 'Ovm' |
| } |
| }, |
| { |
| title: 'label.agent.password', |
| key: 'agentPassword', |
| placeHolder: 'message.error.agent.password', |
| required: true, |
| password: true, |
| display: { |
| hypervisor: 'Ovm' |
| } |
| }, |
| { |
| title: 'label.tags', |
| key: 'hostTags', |
| placeHolder: 'message.error.host.tags', |
| required: false |
| } |
| ] |
| }, |
| primaryStorageFields () { |
| return [ |
| { |
| title: 'label.name', |
| key: 'primaryStorageName', |
| placeHolder: 'message.error.name', |
| required: true |
| }, |
| { |
| title: 'label.scope', |
| key: 'primaryStorageScope', |
| required: false, |
| select: true, |
| options: this.primaryStorageScopes |
| }, |
| { |
| title: 'label.protocol', |
| key: 'primaryStorageProtocol', |
| placeHolder: 'message.error.select', |
| required: true, |
| select: true, |
| options: this.primaryStorageProtocols |
| }, |
| { |
| title: 'label.server', |
| key: 'primaryStorageServer', |
| placeHolder: 'message.error.server', |
| required: true, |
| display: { |
| primaryStorageProtocol: ['nfs', 'iscsi', 'gluster', 'SMB', 'Linstor'] |
| } |
| }, |
| { |
| title: 'label.path', |
| key: 'primaryStoragePath', |
| placeHolder: 'message.error.path', |
| required: true, |
| display: { |
| primaryStorageProtocol: ['nfs', 'SMB', 'SharedMountPoint', 'ocfs2'] |
| } |
| }, |
| { |
| title: 'label.sr.name', |
| key: 'primaryStorageSRLabel', |
| placeHolder: 'message.error.sr.namelabel', |
| required: true, |
| display: { |
| primaryStorageProtocol: 'PreSetup' |
| } |
| }, |
| { |
| title: 'label.target.iqn', |
| key: 'primaryStorageTargetIQN', |
| placeHolder: 'message.error.target.iqn', |
| required: true, |
| display: { |
| primaryStorageProtocol: 'iscsi' |
| } |
| }, |
| { |
| title: 'label.lun.number', |
| key: 'primaryStorageLUN', |
| placeHolder: 'message.error.lun', |
| required: true, |
| display: { |
| primaryStorageProtocol: 'iscsi' |
| } |
| }, |
| { |
| title: 'label.smb.domain', |
| key: 'primaryStorageSMBDomain', |
| placeHolder: 'message.error.sbdomain', |
| required: true, |
| display: { |
| primaryStorageProtocol: 'SMB' |
| } |
| }, |
| { |
| title: 'label.smb.username', |
| key: 'primaryStorageSMBUsername', |
| placeHolder: 'message.error.sbdomain.username', |
| required: true, |
| display: { |
| primaryStorageProtocol: 'SMB' |
| } |
| }, |
| { |
| title: 'label.smb.password', |
| key: 'primaryStorageSMBPassword', |
| placeHolder: 'message.error.sbdomain.password', |
| required: true, |
| password: true, |
| display: { |
| primaryStorageProtocol: 'SMB' |
| } |
| }, |
| { |
| title: 'label.rados.monitor', |
| key: 'primaryStorageRADOSMonitor', |
| placeHolder: 'message.error.rados.monitor', |
| required: false, |
| display: { |
| primaryStorageProtocol: ['rbd'] |
| } |
| }, |
| { |
| title: 'label.rados.pool', |
| key: 'primaryStorageRADOSPool', |
| placeHolder: 'message.error.rados.pool', |
| required: false, |
| display: { |
| primaryStorageProtocol: ['rbd'] |
| } |
| }, |
| { |
| title: 'label.rados.user', |
| key: 'primaryStorageRADOSUser', |
| placeHolder: 'message.error.rados.user', |
| required: false, |
| display: { |
| primaryStorageProtocol: ['rbd'] |
| } |
| }, |
| { |
| title: 'label.rados.secret', |
| key: 'primaryStorageRADOSSecret', |
| placeHolder: 'message.error.rados.secret', |
| required: false, |
| display: { |
| primaryStorageProtocol: ['rbd'] |
| } |
| }, |
| { |
| title: 'label.volgroup', |
| key: 'primaryStorageVolumeGroup', |
| placeHolder: 'message.error.volume.group', |
| required: true, |
| display: { |
| primaryStorageProtocol: 'clvm' |
| } |
| }, |
| { |
| title: 'label.volume', |
| key: 'primaryStorageVolume', |
| placeHolder: 'message.error.volume', |
| required: true, |
| display: { |
| primaryStorageProtocol: 'gluster' |
| } |
| }, |
| { |
| title: 'label.vcenter.datacenter', |
| key: 'primaryStorageVmfsDatacenter', |
| placeHolder: 'message.error.vcenter.datacenter', |
| required: true, |
| display: { |
| primaryStorageProtocol: ['vmfs', 'datastorecluster'] |
| } |
| }, |
| { |
| title: 'label.vcenter.datastore', |
| key: 'primaryStorageVmfsDatastore', |
| placeHolder: 'message.error.vcenter.datastore', |
| required: true, |
| display: { |
| primaryStorageProtocol: ['vmfs', 'datastorecluster'] |
| } |
| }, |
| { |
| title: 'label.resourcegroup', |
| key: 'primaryStorageLinstorResourceGroup', |
| placeHolder: 'message.error.linstor.resourcegroup', |
| required: true, |
| display: { |
| primaryStorageProtocol: 'Linstor' |
| } |
| }, |
| { |
| title: 'label.provider', |
| key: 'provider', |
| placeHolder: 'message.error.select', |
| value: 'DefaultPrimary', |
| select: true, |
| required: true, |
| options: this.primaryStorageProviders |
| }, |
| { |
| title: 'label.ismanaged', |
| key: 'managed', |
| checkbox: true, |
| hidden: { |
| provider: ['DefaultPrimary', 'PowerFlex', 'Linstor'] |
| } |
| }, |
| { |
| title: 'label.capacitybytes', |
| key: 'capacityBytes', |
| hidden: { |
| provider: ['DefaultPrimary', 'PowerFlex', 'Linstor'] |
| } |
| }, |
| { |
| title: 'label.capacityiops', |
| key: 'capacityIops', |
| hidden: { |
| provider: ['DefaultPrimary', 'PowerFlex', 'Linstor'] |
| } |
| }, |
| { |
| title: 'label.url', |
| key: 'url', |
| hidden: { |
| provider: ['DefaultPrimary', 'PowerFlex', 'Linstor'] |
| } |
| }, |
| { |
| title: 'label.powerflex.gateway', |
| key: 'powerflexGateway', |
| required: true, |
| placeHolder: 'message.error.input.value', |
| display: { |
| provider: 'PowerFlex' |
| } |
| }, |
| { |
| title: 'label.powerflex.gateway.username', |
| key: 'powerflexGatewayUsername', |
| required: true, |
| placeHolder: 'message.error.input.value', |
| display: { |
| provider: 'PowerFlex' |
| } |
| }, |
| { |
| title: 'label.powerflex.gateway.password', |
| key: 'powerflexGatewayPassword', |
| required: true, |
| placeHolder: 'message.error.input.value', |
| password: true, |
| display: { |
| provider: 'PowerFlex' |
| } |
| }, |
| { |
| title: 'label.powerflex.storage.pool', |
| key: 'powerflexStoragePool', |
| required: true, |
| placeHolder: 'message.error.input.value', |
| display: { |
| provider: 'PowerFlex' |
| } |
| }, |
| { |
| title: 'label.storage.tags', |
| key: 'primaryStorageTags', |
| placeHolder: 'message.error.storage.tags', |
| required: false |
| } |
| ] |
| }, |
| secondaryStorageFields () { |
| return [ |
| { |
| title: 'label.provider', |
| key: 'secondaryStorageProvider', |
| required: false, |
| select: true, |
| options: this.storageProviders |
| }, |
| { |
| title: 'label.name', |
| key: 'secondaryStorageName', |
| required: false, |
| display: { |
| secondaryStorageProvider: ['NFS', 'SMB', 'S3', 'Swift'] |
| } |
| }, |
| { |
| title: 'label.server', |
| key: 'secondaryStorageServer', |
| required: true, |
| placeHolder: 'message.error.server', |
| display: { |
| secondaryStorageProvider: ['NFS', 'SMB'] |
| } |
| }, |
| { |
| title: 'label.path', |
| key: 'secondaryStoragePath', |
| required: true, |
| placeHolder: 'message.error.path', |
| display: { |
| secondaryStorageProvider: ['NFS', 'SMB'] |
| } |
| }, |
| { |
| title: 'label.smb.domain', |
| key: 'secondaryStorageSMBDomain', |
| required: true, |
| placeHolder: 'message.error.sbdomain', |
| display: { |
| secondaryStorageProvider: ['SMB'] |
| } |
| }, |
| { |
| title: 'label.smb.username', |
| key: 'secondaryStorageSMBUsername', |
| required: true, |
| placeHolder: 'message.error.smb.username', |
| display: { |
| secondaryStorageProvider: ['SMB'] |
| } |
| }, |
| { |
| title: 'label.smb.password', |
| key: 'secondaryStorageSMBPassword', |
| required: true, |
| password: true, |
| placeHolder: 'message.error.smb.password', |
| display: { |
| secondaryStorageProvider: ['SMB'] |
| } |
| }, |
| { |
| title: 'label.s3.access.key', |
| key: 'secondaryStorageAccessKey', |
| required: true, |
| placeHolder: 'message.error.access.key', |
| display: { |
| secondaryStorageProvider: ['S3'] |
| } |
| }, |
| { |
| title: 'label.s3.secret.key', |
| key: 'secondaryStorageSecretKey', |
| required: true, |
| placeHolder: 'message.error.secret.key', |
| display: { |
| secondaryStorageProvider: ['S3'] |
| } |
| }, |
| { |
| title: 'label.s3.bucket', |
| key: 'secondaryStorageBucket', |
| required: true, |
| placeHolder: 'message.error.bucket', |
| display: { |
| secondaryStorageProvider: ['S3'] |
| } |
| }, |
| { |
| title: 'label.s3.endpoint', |
| key: 'secondaryStorageEndpoint', |
| required: false, |
| display: { |
| secondaryStorageProvider: ['S3'] |
| } |
| }, |
| { |
| title: 'label.s3.use.https', |
| key: 'secondaryStorageHttps', |
| required: false, |
| switch: true, |
| checked: true, |
| display: { |
| secondaryStorageProvider: ['S3'] |
| } |
| }, |
| { |
| title: 'label.s3.connection.timeout', |
| key: 'secondaryStorageConnectionTimeout', |
| required: false, |
| display: { |
| secondaryStorageProvider: ['S3'] |
| } |
| }, |
| { |
| title: 'label.s3.max.error.retry', |
| key: 'secondaryStorageMaxError', |
| required: false, |
| display: { |
| secondaryStorageProvider: ['S3'] |
| } |
| }, |
| { |
| title: 'label.s3.socket.timeout', |
| key: 'secondaryStorageSocketTimeout', |
| required: false, |
| display: { |
| secondaryStorageProvider: ['S3'] |
| } |
| }, |
| { |
| title: 'label.create.nfs.secondary.staging.storage', |
| key: 'secondaryStorageNFSStaging', |
| required: false, |
| switch: true, |
| display: { |
| secondaryStorageProvider: ['S3'] |
| } |
| }, |
| { |
| title: 'label.s3.nfs.server', |
| key: 'secondaryStorageNFSServer', |
| required: true, |
| placeHolder: 'message.error.s3nfs.server', |
| display: { |
| secondaryStorageProvider: ['S3'], |
| secondaryStorageNFSStaging: true |
| } |
| }, |
| { |
| title: 'label.s3.nfs.path', |
| key: 'secondaryStorageNFSPath', |
| required: true, |
| placeHolder: 'message.error.s3nfs.path', |
| display: { |
| secondaryStorageProvider: ['S3'], |
| secondaryStorageNFSStaging: true |
| } |
| }, |
| { |
| title: 'label.url', |
| key: 'secondaryStorageURL', |
| required: true, |
| placeHolder: 'message.error.url', |
| display: { |
| secondaryStorageProvider: ['Swift'] |
| } |
| }, |
| { |
| title: 'label.account', |
| key: 'secondaryStorageAccount', |
| required: true, |
| placeHolder: 'message.error.swift.account', |
| display: { |
| secondaryStorageProvider: ['Swift'] |
| } |
| }, |
| { |
| title: 'label.username', |
| key: 'secondaryStorageUsername', |
| required: true, |
| placeHolder: 'message.error.swift.username', |
| display: { |
| secondaryStorageProvider: ['Swift'] |
| } |
| }, |
| { |
| title: 'label.key', |
| key: 'secondaryStorageKey', |
| required: true, |
| placeHolder: 'message.error.swift.key', |
| display: { |
| secondaryStorageProvider: ['Swift'] |
| } |
| }, |
| { |
| title: 'label.storagepolicy', |
| key: 'secondaryStoragePolicy', |
| required: false, |
| display: { |
| secondaryStorageProvider: ['Swift'] |
| } |
| } |
| ] |
| } |
| }, |
| data () { |
| return { |
| physicalNetworks: null, |
| currentHypervisor: null, |
| primaryStorageScopes: [], |
| primaryStorageProtocols: [], |
| primaryStorageProviders: [], |
| storageProviders: [], |
| currentStep: null, |
| options: ['primaryStorageScope', 'primaryStorageProtocol', 'provider', 'primaryStorageProvider'] |
| } |
| }, |
| created () { |
| this.currentStep = this.prefillContent?.resourceStep || 0 |
| if (this.stepChild && this.stepChild !== '') { |
| this.currentStep = this.steps.findIndex(item => item.fromKey === this.stepChild) |
| } |
| this.scrollToStepActive() |
| if (this.prefillContent.hypervisor === 'BareMetal') { |
| this.$emit('nextPressed') |
| } else { |
| this.fetchConfigurationSwitch() |
| this.options.forEach(this.fetchOptions) |
| if (!this.prefillContent.lastHypervisor) { |
| this.$emit('fieldsChanged', { |
| lastHypervisor: this.prefillContent.hypervisor |
| }) |
| } else if (this.prefillContent.lastHypervisor !== this.prefillContent.hypervisor) { |
| this.$emit('fieldsChanged', { |
| lastHypervisor: this.prefillContent.hypervisor, |
| primaryStorageProtocol: null, |
| primaryStorageScope: null |
| }) |
| } |
| } |
| }, |
| watch: { |
| 'prefillContent.provider' (newVal, oldVal) { |
| if (['SolidFire', 'PowerFlex'].includes(newVal) && !['SolidFire', 'PowerFlex'].includes(oldVal)) { |
| this.$emit('fieldsChanged', { primaryStorageProtocol: undefined }) |
| } else if (!['SolidFire', 'PowerFlex'].includes(newVal) && ['SolidFire', 'PowerFlex'].includes(oldVal)) { |
| this.$emit('fieldsChanged', { primaryStorageProtocol: undefined }) |
| } |
| |
| this.fetchProtocol() |
| } |
| }, |
| methods: { |
| nextPressed () { |
| if (this.currentStep === this.steps.length - 1) { |
| this.$emit('nextPressed') |
| } else { |
| this.currentStep++ |
| this.$emit('fieldsChanged', { resourceStep: this.currentStep }) |
| } |
| |
| this.scrollToStepActive() |
| }, |
| handleBack () { |
| if (this.currentStep === 0) { |
| this.$emit('backPressed') |
| } else { |
| this.currentStep-- |
| this.$emit('fieldsChanged', { resourceStep: this.currentStep }) |
| } |
| |
| this.scrollToStepActive() |
| }, |
| scrollToStepActive () { |
| if (!this.isMobile()) { |
| return |
| } |
| nextTick().then(() => { |
| if (!this.$refs.resourceStep) { |
| return |
| } |
| if (this.currentStep === 0) { |
| this.$refs.resourceStep.$el.scrollLeft = 0 |
| return |
| } |
| this.$refs.resourceStep.$el.scrollLeft = this.$refs['resourceStep' + (this.currentStep - 1)][0].$el.offsetLeft |
| }) |
| }, |
| fieldsChanged (changed) { |
| this.$emit('fieldsChanged', changed) |
| }, |
| fetchOptions (name) { |
| switch (name) { |
| case 'primaryStorageScope': |
| this.fetchScope() |
| break |
| case 'primaryStorageProtocol': |
| this.fetchProtocol() |
| break |
| case 'provider': |
| this.fetchProvider() |
| break |
| case 'primaryStorageProvider': |
| this.fetchPrimaryStorageProvider() |
| break |
| default: |
| break |
| } |
| }, |
| fetchScope () { |
| const hypervisor = this.prefillContent?.hypervisor || null |
| const scope = [] |
| if (['KVM', 'VMware', 'Hyperv'].includes(hypervisor)) { |
| scope.push({ |
| id: 'zone', |
| description: this.$t('label.zone') |
| }) |
| scope.push({ |
| id: 'cluster', |
| description: this.$t('label.cluster') |
| }) |
| } else { |
| scope.push({ |
| id: 'cluster', |
| description: this.$t('label.cluster') |
| }) |
| } |
| this.primaryStorageScopes = scope |
| }, |
| fetchProtocol () { |
| const hypervisor = this.prefillContent?.hypervisor || null |
| const protocols = [] |
| if (hypervisor === 'KVM') { |
| protocols.push({ |
| id: 'nfs', |
| description: 'nfs' |
| }) |
| protocols.push({ |
| id: 'SharedMountPoint', |
| description: 'SharedMountPoint' |
| }) |
| protocols.push({ |
| id: 'rbd', |
| description: 'RBD' |
| }) |
| protocols.push({ |
| id: 'clvm', |
| description: 'CLVM' |
| }) |
| protocols.push({ |
| id: 'gluster', |
| description: 'Gluster' |
| }) |
| protocols.push({ |
| id: 'Linstor', |
| description: 'Linstor' |
| }) |
| } else if (hypervisor === 'XenServer') { |
| protocols.push({ |
| id: 'nfs', |
| description: 'nfs' |
| }) |
| protocols.push({ |
| id: 'PreSetup', |
| description: 'PreSetup' |
| }) |
| protocols.push({ |
| id: 'iscsi', |
| description: 'iscsi' |
| }) |
| } else if (hypervisor === 'VMware') { |
| protocols.push({ |
| id: 'nfs', |
| description: 'nfs' |
| }) |
| protocols.push({ |
| id: 'vmfs', |
| description: 'vmfs' |
| }) |
| protocols.push({ |
| id: 'datastorecluster', |
| description: 'datastorecluster' |
| }) |
| } else if (hypervisor === 'Hyperv') { |
| protocols.push({ |
| id: 'SMB', |
| description: 'SMB/CIFS' |
| }) |
| } else if (hypervisor === 'Ovm') { |
| protocols.push({ |
| id: 'nfs', |
| description: 'nfs' |
| }) |
| protocols.push({ |
| id: 'ocfs2', |
| description: 'ocfs2' |
| }) |
| } else if (hypervisor === 'LXC') { |
| protocols.push({ |
| id: 'nfs', |
| description: 'nfs' |
| }) |
| protocols.push({ |
| id: 'SharedMountPoint', |
| description: 'SharedMountPoint' |
| }) |
| protocols.push({ |
| id: 'rbd', |
| description: 'RBD' |
| }) |
| } else { |
| protocols.push({ |
| id: 'nfs', |
| description: 'nfs' |
| }) |
| } |
| |
| protocols.push({ id: 'custom', description: 'custom' }) |
| this.primaryStorageProtocols = protocols |
| }, |
| async fetchConfigurationSwitch () { |
| const hypervisor = this.prefillContent?.hypervisor || null |
| this.$emit('fieldsChanged', { dvSwitchEnabled: false }) |
| this.$emit('fieldsChanged', { vSwitchEnabled: false }) |
| if (hypervisor && hypervisor === 'VMware') { |
| await this.fetchNexusSwitchConfig() |
| await this.fetchDvSwitchConfig() |
| } |
| }, |
| fetchNexusSwitchConfig () { |
| api('listConfigurations', { name: 'vmware.use.nexus.vswitch' }).then(json => { |
| let vSwitchEnabled = false |
| if (json.listconfigurationsresponse.configuration[0].value) { |
| vSwitchEnabled = true |
| } |
| this.$emit('fieldsChanged', { vSwitchEnabled: vSwitchEnabled }) |
| }) |
| }, |
| fetchDvSwitchConfig () { |
| let dvSwitchEnabled = false |
| api('listConfigurations', { name: 'vmware.use.dvswitch' }).then(json => { |
| if (json.listconfigurationsresponse.configuration[0].value) { |
| dvSwitchEnabled = true |
| } |
| this.$emit('fieldsChanged', { dvSwitchEnabled: dvSwitchEnabled }) |
| }) |
| }, |
| fetchProvider () { |
| const storageProviders = [] |
| api('listImageStores', { provider: 'S3' }).then(json => { |
| const s3stores = json.listimagestoresresponse.imagestore |
| if (s3stores != null && s3stores.length > 0) { |
| storageProviders.push({ id: 'S3', description: 'S3' }) |
| } else { |
| storageProviders.push({ id: 'NFS', description: 'NFS' }) |
| storageProviders.push({ id: 'SMB', description: 'SMB/CIFS' }) |
| storageProviders.push({ id: 'S3', description: 'S3' }) |
| storageProviders.push({ id: 'Swift', description: 'Swift' }) |
| } |
| this.storageProviders = storageProviders |
| }) |
| }, |
| fetchPrimaryStorageProvider () { |
| this.primaryStorageProviders = [] |
| api('listStorageProviders', { type: 'primary' }).then(json => { |
| this.primaryStorageProviders = json.liststorageprovidersresponse.dataStoreProvider || [] |
| this.primaryStorageProviders.map((item, idx) => { this.primaryStorageProviders[idx].id = item.name }) |
| }) |
| }, |
| submitLaunchZone () { |
| this.$emit('submitLaunchZone') |
| }, |
| checkVisibleResource (key) { |
| const formKey = this.steps[this.currentStep]?.fromKey || '' |
| return formKey === key |
| } |
| } |
| } |
| |
| </script> |
