mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
feb9509547
This PR aims to polish the UI with following tweaks and changes: - Increase resource and os-logo icons both in list view, user-menu bar and VM deployment form - Fix css issues in VM deployment form when resource icons are on some of the templates/isos but not all - Replace edit icon in the resource icon editting button on the infocard, in resource view - Fix css marging/padding issue for nav bar and left-branding/logo - Introduce a new Limits option in the user menu, to allow users to see their own limits when they log in - Rename resource tab to limits tab for accounts, project and domains - Introduce a new copy-label component, that can be clicked to copy strings; use in info-card and list view for entites such as IP addresses and UUIDs - Add router-link to /zones/ in case of user-accounts (when /zone isn't routable in the UI) - Show better list of nics and ssh keys pairs in infocard for VM resource view - Standardise most resources to show state/status columns right after resource name (wherever applicable) - Remove displayname column in VM list view, add cpu number and memory by default - Add k8s version column in k8s list view - Add size and phy size columns in case of template and ISOs list view, only for root/domain admins - Add phy network router-link in case of guest VLAN list view; rearrange columns list for consistency - Add snapshot phy size column in the snapshot list view; and router-link for volume in the snapshot list view; and missing/useful details in the volume snapshot details view - Add a create and add data disk feature in Instances tab, just like we've add nic feature in the same Signed-off-by: Rohit Yadav <rohit.yadav@shapeblue.com>
931 lines
36 KiB
JavaScript
931 lines
36 KiB
JavaScript
// 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.
|
|
|
|
import { shallowRef, defineAsyncComponent } from 'vue'
|
|
import store from '@/store'
|
|
import tungsten from '@/assets/icons/tungsten.svg?inline'
|
|
import { isAdmin } from '@/role'
|
|
|
|
export default {
|
|
name: 'network',
|
|
title: 'label.network',
|
|
icon: 'wifi-outlined',
|
|
docHelp: 'adminguide/networking_and_traffic.html#advanced-zone-physical-network-configuration',
|
|
children: [
|
|
{
|
|
name: 'guestnetwork',
|
|
title: 'label.guest.networks',
|
|
icon: 'apartment-outlined',
|
|
permission: ['listNetworks'],
|
|
resourceType: 'Network',
|
|
columns: () => {
|
|
var fields = ['name', 'state', 'type', 'vpcname', 'cidr', 'ip6cidr', 'broadcasturi', 'account', 'domain', 'zonename']
|
|
if (!isAdmin()) {
|
|
fields = fields.filter(function (e) { return e !== 'broadcasturi' })
|
|
}
|
|
return fields
|
|
},
|
|
details: () => {
|
|
var fields = ['name', 'id', 'description', 'type', 'traffictype', 'vpcid', 'vlan', 'broadcasturi', 'cidr', 'ip6cidr', 'netmask', 'gateway', 'aclname', 'ispersistent', 'restartrequired', 'reservediprange', 'redundantrouter', 'networkdomain', 'egressdefaultpolicy', 'zonename', 'account', 'domain', 'associatednetwork', 'associatednetworkid', 'ip6firewall', 'ip6routing', 'ip6routes', 'dns1', 'dns2', 'ip6dns1', 'ip6dns2', 'publicmtu', 'privatemtu']
|
|
if (!isAdmin()) {
|
|
fields = fields.filter(function (e) { return e !== 'broadcasturi' })
|
|
}
|
|
return fields
|
|
},
|
|
filters: ['all', 'account', 'domain', 'shared'],
|
|
searchFilters: ['keyword', 'zoneid', 'domainid', 'account', 'type', 'tags'],
|
|
related: [{
|
|
name: 'vm',
|
|
title: 'label.instances',
|
|
param: 'networkid'
|
|
}],
|
|
tabs: [{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
}, {
|
|
name: 'egress.rules',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/EgressRulesTab.vue'))),
|
|
show: (record, route, user) => { return record.type === 'Isolated' && !('vpcid' in record) && 'listEgressFirewallRules' in store.getters.apis && (['Admin', 'DomainAdmin'].includes(user.roletype) || record.account === user.account || record.projectid) }
|
|
}, {
|
|
name: 'ip.v6.firewall',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/Ipv6FirewallRulesTab.vue'))),
|
|
show: (record, route, user) => { return record.type === 'Isolated' && ['IPv6', 'DualStack'].includes(record.internetprotocol) && !('vpcid' in record) && 'listIpv6FirewallRules' in store.getters.apis && (['Admin', 'DomainAdmin'].includes(user.roletype) || record.account === user.account || record.projectid) }
|
|
}, {
|
|
name: 'public.ip.addresses',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/IpAddressesTab.vue'))),
|
|
show: (record, route, user) => { return 'listPublicIpAddresses' in store.getters.apis && (record.type === 'Shared' || (record.type === 'Isolated' && !('vpcid' in record) && (['Admin', 'DomainAdmin'].includes(user.roletype) || record.account === user.account || record.projectid))) }
|
|
}, {
|
|
name: 'virtual.routers',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/RoutersTab.vue'))),
|
|
show: (record) => { return (record.type === 'Isolated' || record.type === 'Shared') && 'listRouters' in store.getters.apis && isAdmin() }
|
|
}, {
|
|
name: 'guest.ip.range',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/GuestIpRanges.vue'))),
|
|
show: (record) => { return 'listVlanIpRanges' in store.getters.apis && (record.type === 'Shared' || (record.service && record.service.filter(x => x.name === 'SourceNat').count === 0)) }
|
|
}, {
|
|
name: 'network.policy',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/tungsten/NetworkPolicyTab.vue'))),
|
|
show: (record) => {
|
|
return ('listTungstenFabricPolicy' in store.getters.apis) && (record.broadcasturi === 'tf://tf' && record.type !== 'Shared')
|
|
}
|
|
}, {
|
|
name: 'tungsten.logical.router',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/tungsten/LogicalRouterTab.vue'))),
|
|
show: (record) => {
|
|
return ('listTungstenFabricLogicalRouter' in store.getters.apis) && (record.broadcasturi === 'tf://tf' && record.type !== 'Shared')
|
|
}
|
|
}, {
|
|
name: 'network.permissions',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/NetworkPermissions.vue'))),
|
|
show: (record, route, user) => { return 'listNetworkPermissions' in store.getters.apis && record.acltype === 'Account' && !('vpcid' in record) && (['Admin', 'DomainAdmin'].includes(user.roletype) || record.account === user.account) && !record.projectid }
|
|
},
|
|
{
|
|
name: 'events',
|
|
resourceType: 'Network',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/EventsTab.vue'))),
|
|
show: () => { return 'listEvents' in store.getters.apis }
|
|
},
|
|
{
|
|
name: 'comments',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/AnnotationsTab.vue')))
|
|
}],
|
|
actions: [
|
|
{
|
|
api: 'createNetwork',
|
|
icon: 'plus-outlined',
|
|
label: 'label.add.network',
|
|
docHelp: 'adminguide/networking_and_traffic.html#configure-guest-traffic-in-an-advanced-zone',
|
|
listView: true,
|
|
popup: true,
|
|
show: () => {
|
|
if (!store.getters.zones || store.getters.zones.length === 0) {
|
|
return false
|
|
}
|
|
const AdvancedZones = store.getters.zones.filter(zone => zone.networktype === 'Advanced')
|
|
const AdvancedZonesWithoutSG = store.getters.zones.filter(zone => zone.securitygroupsenabled === false)
|
|
if ((isAdmin() && AdvancedZones && AdvancedZones.length > 0) || (AdvancedZonesWithoutSG && AdvancedZonesWithoutSG.length > 0)) {
|
|
return true
|
|
}
|
|
return false
|
|
},
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/CreateNetwork.vue')))
|
|
},
|
|
{
|
|
api: 'updateNetwork',
|
|
icon: 'edit-outlined',
|
|
label: 'label.update.network',
|
|
dataView: true,
|
|
popup: true,
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/UpdateNetwork.vue')))
|
|
},
|
|
{
|
|
api: 'restartNetwork',
|
|
icon: 'sync-outlined',
|
|
label: 'label.restart.network',
|
|
message: 'message.restart.network',
|
|
dataView: true,
|
|
args: (record, store, isGroupAction) => {
|
|
var fields = []
|
|
if (isGroupAction || record.vpcid == null) {
|
|
fields.push('cleanup')
|
|
}
|
|
fields.push('livepatch')
|
|
return fields
|
|
},
|
|
show: (record) => record.type !== 'L2',
|
|
groupAction: true,
|
|
popup: true,
|
|
groupMap: (selection, values) => { return selection.map(x => { return { id: x, cleanup: values.cleanup } }) }
|
|
},
|
|
{
|
|
api: 'replaceNetworkACLList',
|
|
icon: 'swap-outlined',
|
|
label: 'label.replace.acl.list',
|
|
message: 'message.confirm.replace.acl.new.one',
|
|
docHelp: 'adminguide/networking_and_traffic.html#configuring-network-access-control-list',
|
|
dataView: true,
|
|
show: (record) => { return record.vpcid },
|
|
args: ['aclid', 'networkid'],
|
|
mapping: {
|
|
aclid: {
|
|
api: 'listNetworkACLLists',
|
|
params: (record) => { return { vpcid: record.vpcid } }
|
|
},
|
|
networkid: {
|
|
value: (record) => { return record.id }
|
|
}
|
|
}
|
|
},
|
|
{
|
|
api: 'deleteNetwork',
|
|
icon: 'delete-outlined',
|
|
label: 'label.action.delete.network',
|
|
message: 'message.action.delete.network',
|
|
dataView: true,
|
|
groupAction: true,
|
|
popup: true,
|
|
groupMap: (selection) => { return selection.map(x => { return { id: x } }) }
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'vpc',
|
|
title: 'label.vpc',
|
|
icon: 'deployment-unit-outlined',
|
|
docHelp: 'adminguide/networking_and_traffic.html#configuring-a-virtual-private-cloud',
|
|
permission: ['listVPCs'],
|
|
resourceType: 'Vpc',
|
|
columns: ['name', 'state', 'displaytext', 'cidr', 'account', 'domain', 'zonename'],
|
|
details: ['name', 'id', 'displaytext', 'cidr', 'networkdomain', 'ip6routes', 'ispersistent', 'redundantvpcrouter', 'restartrequired', 'zonename', 'account', 'domain', 'dns1', 'dns2', 'ip6dns1', 'ip6dns2', 'publicmtu'],
|
|
searchFilters: ['name', 'zoneid', 'domainid', 'account', 'tags'],
|
|
related: [{
|
|
name: 'vm',
|
|
title: 'label.instances',
|
|
param: 'vpcid'
|
|
}, {
|
|
name: 'router',
|
|
title: 'label.virtual.routers',
|
|
param: 'vpcid'
|
|
}, {
|
|
name: 'ilbvm',
|
|
title: 'label.internal.lb',
|
|
param: 'vpcid'
|
|
}],
|
|
tabs: [{
|
|
name: 'vpc',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/VpcTab.vue')))
|
|
}],
|
|
actions: [
|
|
{
|
|
api: 'createVPC',
|
|
icon: 'plus-outlined',
|
|
label: 'label.add.vpc',
|
|
docHelp: 'adminguide/networking_and_traffic.html#adding-a-virtual-private-cloud',
|
|
listView: true,
|
|
popup: true,
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/CreateVpc.vue')))
|
|
},
|
|
{
|
|
api: 'updateVPC',
|
|
icon: 'edit-outlined',
|
|
label: 'label.edit',
|
|
dataView: true,
|
|
args: ['name', 'displaytext', 'publicmtu']
|
|
},
|
|
{
|
|
api: 'restartVPC',
|
|
icon: 'sync-outlined',
|
|
label: 'label.restart.vpc',
|
|
message: (record) => { return record.redundantvpcrouter ? 'message.restart.vpc' : 'message.restart.vpc.remark' },
|
|
dataView: true,
|
|
args: (record) => {
|
|
var fields = ['cleanup']
|
|
if (!record.redundantvpcrouter) {
|
|
fields.push('makeredundant')
|
|
}
|
|
fields.push('livepatch')
|
|
return fields
|
|
},
|
|
groupAction: true,
|
|
popup: true,
|
|
groupMap: (selection, values) => { return selection.map(x => { return { id: x, cleanup: values.cleanup, makeredundant: values.makeredundant } }) }
|
|
},
|
|
{
|
|
api: 'deleteVPC',
|
|
icon: 'delete-outlined',
|
|
label: 'label.remove.vpc',
|
|
message: 'message.remove.vpc',
|
|
dataView: true,
|
|
groupAction: true,
|
|
popup: true,
|
|
groupMap: (selection) => { return selection.map(x => { return { id: x } }) }
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'securitygroups',
|
|
title: 'label.security.groups',
|
|
icon: 'fire-outlined',
|
|
docHelp: 'adminguide/networking_and_traffic.html#security-groups',
|
|
permission: ['listSecurityGroups'],
|
|
resourceType: 'SecurityGroup',
|
|
columns: ['name', 'description', 'account', 'domain'],
|
|
details: ['name', 'id', 'description', 'account', 'domain'],
|
|
tabs: [{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
}, {
|
|
name: 'ingress.rule',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/IngressEgressRuleConfigure.vue')))
|
|
}, {
|
|
name: 'egress.rule',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/IngressEgressRuleConfigure.vue')))
|
|
}],
|
|
show: () => {
|
|
if (!store.getters.zones || store.getters.zones.length === 0) {
|
|
return false
|
|
}
|
|
const listZoneHaveSGEnabled = store.getters.zones.filter(zone => zone.securitygroupsenabled === true)
|
|
if (!listZoneHaveSGEnabled || listZoneHaveSGEnabled.length === 0) {
|
|
return false
|
|
}
|
|
return true
|
|
},
|
|
actions: [
|
|
{
|
|
api: 'createSecurityGroup',
|
|
icon: 'plus-outlined',
|
|
label: 'label.add.security.group',
|
|
docHelp: 'adminguide/networking_and_traffic.html#adding-a-security-group',
|
|
listView: true,
|
|
args: ['name', 'description']
|
|
},
|
|
{
|
|
api: 'updateSecurityGroup',
|
|
icon: 'edit-outlined',
|
|
label: 'label.edit',
|
|
dataView: true,
|
|
args: ['name'],
|
|
show: (record) => { return record.name !== 'default' }
|
|
},
|
|
{
|
|
api: 'deleteSecurityGroup',
|
|
icon: 'delete-outlined',
|
|
label: 'label.action.delete.security.group',
|
|
message: 'message.action.delete.security.group',
|
|
dataView: true,
|
|
show: (record) => { return record.name !== 'default' }
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'publicip',
|
|
title: 'label.public.ip.addresses',
|
|
icon: 'environment-outlined',
|
|
docHelp: 'adminguide/networking_and_traffic.html#reserving-public-ip-addresses-and-vlans-for-accounts',
|
|
permission: ['listPublicIpAddresses'],
|
|
resourceType: 'PublicIpAddress',
|
|
columns: ['ipaddress', 'state', 'associatednetworkname', 'virtualmachinename', 'allocated', 'account', 'domain', 'zonename'],
|
|
details: ['ipaddress', 'id', 'associatednetworkname', 'virtualmachinename', 'networkid', 'issourcenat', 'isstaticnat', 'virtualmachinename', 'vmipaddress', 'vlan', 'allocated', 'account', 'domain', 'zonename'],
|
|
filters: ['allocated', 'reserved', 'free'],
|
|
component: shallowRef(() => import('@/views/network/PublicIpResource.vue')),
|
|
tabs: [{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
}, {
|
|
name: 'firewall',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/FirewallRules.vue'))),
|
|
networkServiceFilter: networkService => networkService.filter(x => x.name === 'Firewall').length > 0,
|
|
groupAction: true,
|
|
popup: true,
|
|
groupMap: (selection) => { return selection.map(x => { return { id: x } }) }
|
|
},
|
|
{
|
|
name: 'portforwarding',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/PortForwarding.vue'))),
|
|
networkServiceFilter: networkService => networkService.filter(x => x.name === 'PortForwarding').length > 0
|
|
}, {
|
|
name: 'loadbalancing',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/LoadBalancing.vue'))),
|
|
networkServiceFilter: networkService => networkService.filter(x => x.name === 'Lb').length > 0
|
|
}, {
|
|
name: 'vpn',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/VpnDetails.vue'))),
|
|
show: (record) => { return record.issourcenat }
|
|
},
|
|
{
|
|
name: 'events',
|
|
resourceType: 'IpAddress',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/EventsTab.vue'))),
|
|
show: () => { return 'listEvents' in store.getters.apis }
|
|
},
|
|
{
|
|
name: 'comments',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/AnnotationsTab.vue')))
|
|
}],
|
|
actions: [
|
|
{
|
|
api: 'enableStaticNat',
|
|
icon: 'plus-circle-outlined',
|
|
label: 'label.action.enable.static.nat',
|
|
docHelp: 'adminguide/networking_and_traffic.html#enabling-or-disabling-static-nat',
|
|
dataView: true,
|
|
show: (record) => { return record.state === 'Allocated' && !record.virtualmachineid && !record.issourcenat },
|
|
popup: true,
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/EnableStaticNat.vue')))
|
|
},
|
|
{
|
|
api: 'disableStaticNat',
|
|
icon: 'minus-circle-outlined',
|
|
label: 'label.action.disable.static.nat',
|
|
message: 'message.action.disable.static.nat',
|
|
docHelp: 'adminguide/networking_and_traffic.html#enabling-or-disabling-static-nat',
|
|
dataView: true,
|
|
show: (record) => { return record.virtualmachineid },
|
|
args: ['ipaddressid'],
|
|
mapping: {
|
|
ipaddressid: {
|
|
value: (record) => { return record.id }
|
|
}
|
|
}
|
|
},
|
|
{
|
|
api: 'disassociateIpAddress',
|
|
icon: 'delete-outlined',
|
|
label: 'label.action.release.ip',
|
|
message: 'message.action.release.ip',
|
|
docHelp: 'adminguide/networking_and_traffic.html#releasing-an-ip-address-alloted-to-a-vpc',
|
|
dataView: true,
|
|
show: (record) => { return record.state === 'Allocated' && !record.issourcenat },
|
|
groupAction: true,
|
|
popup: true,
|
|
groupMap: (selection) => { return selection.map(x => { return { id: x } }) }
|
|
},
|
|
{
|
|
api: 'reserveIpAddress',
|
|
icon: 'lock-outlined',
|
|
label: 'label.action.reserve.ip',
|
|
dataView: true,
|
|
show: (record) => { return record.state === 'Free' },
|
|
popup: true,
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/ReservePublicIP.vue')))
|
|
},
|
|
{
|
|
api: 'releaseIpAddress',
|
|
icon: 'usergroup-delete-outlined',
|
|
label: 'label.action.release.reserved.ip',
|
|
message: 'message.action.release.reserved.ip',
|
|
dataView: true,
|
|
show: (record) => { return record.state === 'Reserved' },
|
|
groupAction: true,
|
|
popup: true,
|
|
groupMap: (selection) => { return selection.map(x => { return { id: x } }) }
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'privategw',
|
|
title: 'label.private.gateway',
|
|
icon: 'gateway-outlined',
|
|
hidden: true,
|
|
permission: ['listPrivateGateways'],
|
|
columns: ['ipaddress', 'state', 'gateway', 'netmask', 'account', 'domain'],
|
|
details: ['ipaddress', 'gateway', 'netmask', 'vlan', 'sourcenatsupported', 'aclname', 'account', 'domain', 'zone', 'associatednetwork', 'associatednetworkid'],
|
|
tabs: [{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
}, {
|
|
name: 'static.routes',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/StaticRoutesTab.vue'))),
|
|
show: () => true
|
|
}],
|
|
actions: [
|
|
{
|
|
api: 'createPrivateGateway',
|
|
icon: 'plus-outlined',
|
|
label: 'label.add.private.gateway',
|
|
docHelp: 'adminguide/networking_and_traffic.html#adding-a-private-gateway-to-a-vpc',
|
|
listView: true,
|
|
args: (record, store) => {
|
|
var fields = ['vpcid', 'physicalnetworkid', 'vlan', 'ipaddress', 'gateway', 'netmask', 'sourcenatsupported', 'aclid']
|
|
if (store.apis.createPrivateGateway.params.filter(x => x.name === 'bypassvlanoverlapcheck').length > 0) {
|
|
fields.push('bypassvlanoverlapcheck')
|
|
}
|
|
return fields
|
|
},
|
|
mapping: {
|
|
aclid: {
|
|
api: 'listNetworkACLLists'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
api: 'replaceNetworkACLList',
|
|
icon: 'swap-outlined',
|
|
label: 'label.replace.acl.list',
|
|
message: 'message.confirm.replace.acl.new.one',
|
|
docHelp: 'adminguide/networking_and_traffic.html#acl-on-private-gateway',
|
|
dataView: true,
|
|
args: ['aclid', 'gatewayid'],
|
|
mapping: {
|
|
aclid: {
|
|
api: 'listNetworkACLLists',
|
|
params: (record) => { return { vpcid: record.vpcid } }
|
|
},
|
|
gatewayid: {
|
|
value: (record) => { return record.id }
|
|
}
|
|
}
|
|
},
|
|
{
|
|
api: 'deletePrivateGateway',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.gateway',
|
|
message: 'message.delete.gateway',
|
|
dataView: true
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 's2svpn',
|
|
title: 'label.site.to.site.vpn',
|
|
icon: 'lock-outlined',
|
|
hidden: true,
|
|
permission: ['listVpnGateways'],
|
|
columns: ['publicip', 'account', 'domain'],
|
|
details: ['publicip', 'account', 'domain'],
|
|
actions: [
|
|
{
|
|
api: 'createVpnGateway',
|
|
icon: 'plus-outlined',
|
|
label: 'label.add.vpn.gateway',
|
|
docHelp: 'adminguide/networking_and_traffic.html#creating-a-vpn-gateway-for-the-vpc',
|
|
listView: true,
|
|
args: ['vpcid']
|
|
},
|
|
{
|
|
api: 'deleteVpnGateway',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.vpn.gateway',
|
|
message: 'message.delete.vpn.gateway',
|
|
docHelp: 'adminguide/networking_and_traffic.html#restarting-and-removing-a-vpn-connection',
|
|
dataView: true
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 's2svpnconn',
|
|
title: 'label.site.to.site.vpn.connections',
|
|
docHelp: 'adminguide/networking_and_traffic.html#setting-up-a-site-to-site-vpn-connection',
|
|
icon: 'sync-outlined',
|
|
hidden: true,
|
|
permission: ['listVpnConnections'],
|
|
columns: ['publicip', 'state', 'gateway', 'ipsecpsk', 'ikepolicy', 'esppolicy'],
|
|
details: ['publicip', 'gateway', 'passive', 'cidrlist', 'ipsecpsk', 'ikepolicy', 'esppolicy', 'ikelifetime', 'ikeversion', 'esplifetime', 'dpd', 'splitconnections', 'forceencap', 'created'],
|
|
actions: [
|
|
{
|
|
api: 'createVpnConnection',
|
|
icon: 'plus-outlined',
|
|
label: 'label.create.vpn.connection',
|
|
docHelp: 'adminguide/networking_and_traffic.html#creating-a-vpn-connection',
|
|
listView: true,
|
|
args: ['s2scustomergatewayid', 's2svpngatewayid', 'passive'],
|
|
mapping: {
|
|
s2scustomergatewayid: {
|
|
api: 'listVpnCustomerGateways'
|
|
},
|
|
s2svpngatewayid: {
|
|
api: 'listVpnGateways'
|
|
}
|
|
}
|
|
},
|
|
{
|
|
api: 'resetVpnConnection',
|
|
icon: 'reload-outlined',
|
|
label: 'label.reset.vpn.connection',
|
|
message: 'message.reset.vpn.connection',
|
|
docHelp: 'adminguide/networking_and_traffic.html#restarting-and-removing-a-vpn-connection',
|
|
dataView: true
|
|
},
|
|
{
|
|
api: 'deleteVpnConnection',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.vpn.connection',
|
|
message: 'message.delete.vpn.connection',
|
|
docHelp: 'adminguide/networking_and_traffic.html#restarting-and-removing-a-vpn-connection',
|
|
dataView: true
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'acllist',
|
|
title: 'label.network.acl.lists',
|
|
icon: 'bars-outlined',
|
|
docHelp: 'adminguide/networking_and_traffic.html#configuring-network-access-control-list',
|
|
hidden: true,
|
|
permission: ['listNetworkACLLists'],
|
|
columns: ['name', 'description', 'id'],
|
|
details: ['name', 'description', 'id'],
|
|
tabs: [{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
}, {
|
|
name: 'acl.list.rules',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/AclListRulesTab.vue'))),
|
|
show: () => true
|
|
}],
|
|
actions: [
|
|
{
|
|
api: 'createNetworkACLList',
|
|
icon: 'plus-outlined',
|
|
label: 'label.add.acl.list',
|
|
docHelp: 'adminguide/networking_and_traffic.html#creating-acl-lists',
|
|
listView: true,
|
|
args: ['name', 'description', 'vpcid']
|
|
},
|
|
{
|
|
api: 'updateNetworkACLList',
|
|
icon: 'edit-outlined',
|
|
label: 'label.edit.acl.list',
|
|
dataView: true,
|
|
args: ['name', 'description']
|
|
},
|
|
{
|
|
api: 'deleteNetworkACLList',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.acl.list',
|
|
message: 'message.confirm.delete.acl.list',
|
|
dataView: true
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'ilb',
|
|
title: 'label.internal.lb',
|
|
docHelp: 'adminguide/networking_and_traffic.html#load-balancing-across-tiers',
|
|
icon: 'share-alt-outlined',
|
|
hidden: true,
|
|
permission: ['listLoadBalancers'],
|
|
columns: ['name', 'sourceipaddress', 'loadbalancerrule', 'algorithm', 'account', 'domain'],
|
|
details: ['name', 'sourceipaddress', 'loadbalancerrule', 'algorithm', 'account', 'domain'],
|
|
tabs: [{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
}, {
|
|
name: 'loadbalancerinstance',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/InternalLBAssignedVmTab.vue'))),
|
|
show: () => true
|
|
}],
|
|
actions: [
|
|
{
|
|
api: 'createLoadBalancer',
|
|
icon: 'plus-outlined',
|
|
label: 'label.add.internal.lb',
|
|
docHelp: 'adminguide/networking_and_traffic.html#creating-an-internal-lb-rule',
|
|
listView: true,
|
|
args: ['name', 'description', 'sourceipaddress', 'sourceport', 'instanceport', 'algorithm', 'networkid', 'sourceipaddressnetworkid', 'scheme'],
|
|
mapping: {
|
|
algorithm: {
|
|
options: ['source', 'roundrobin', 'leastconn']
|
|
},
|
|
scheme: {
|
|
value: (record) => { return 'Internal' }
|
|
},
|
|
networkid: {
|
|
api: 'listNetworks',
|
|
params: (record) => { return { forvpc: true } }
|
|
},
|
|
sourceipaddressnetworkid: {
|
|
api: 'listNetworks',
|
|
params: (record) => { return { forvpc: true } }
|
|
}
|
|
}
|
|
},
|
|
{
|
|
api: 'assignToLoadBalancerRule',
|
|
icon: 'plus-outlined',
|
|
label: 'label.assign.vms',
|
|
dataView: true,
|
|
popup: true,
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/InternalLBAssignVmForm.vue')))
|
|
},
|
|
{
|
|
api: 'deleteLoadBalancer',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.internal.lb',
|
|
message: 'message.confirm.delete.internal.lb',
|
|
dataView: true
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'vpnuser',
|
|
title: 'label.vpn.users',
|
|
icon: 'user-switch-outlined',
|
|
permission: ['listVpnUsers'],
|
|
columns: ['username', 'state', 'account', 'domain'],
|
|
details: ['username', 'state', 'account', 'domain'],
|
|
actions: [
|
|
{
|
|
api: 'addVpnUser',
|
|
icon: 'plus-outlined',
|
|
label: 'label.add.vpn.user',
|
|
listView: true,
|
|
args: (record, store) => {
|
|
if (store.userInfo.roletype === 'User') {
|
|
return ['username', 'password']
|
|
}
|
|
|
|
return ['username', 'password', 'domainid', 'account']
|
|
}
|
|
},
|
|
{
|
|
api: 'removeVpnUser',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.vpn.user',
|
|
message: 'message.action.delete.vpn.user',
|
|
dataView: true,
|
|
args: ['username', 'domainid', 'account'],
|
|
mapping: {
|
|
username: {
|
|
value: (record) => { return record.username }
|
|
},
|
|
domainid: {
|
|
value: (record) => { return record.domainid }
|
|
},
|
|
account: {
|
|
value: (record) => { return record.account }
|
|
}
|
|
},
|
|
groupAction: true,
|
|
popup: true,
|
|
groupMap: (selection, values, record) => {
|
|
return selection.map(x => {
|
|
const data = record.filter(y => { return y.id === x })
|
|
return {
|
|
username: data[0].username, account: data[0].account, domainid: data[0].domainid
|
|
}
|
|
})
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'vpncustomergateway',
|
|
title: 'label.vpncustomergatewayid',
|
|
icon: 'lock-outlined',
|
|
permission: ['listVpnCustomerGateways'],
|
|
columns: ['name', 'gateway', 'cidrlist', 'ipsecpsk', 'account', 'domain'],
|
|
details: ['name', 'id', 'gateway', 'cidrlist', 'ipsecpsk', 'ikepolicy', 'ikelifetime', 'ikeversion', 'esppolicy', 'esplifetime', 'dpd', 'splitconnections', 'forceencap', 'account', 'domain'],
|
|
searchFilters: ['keyword', 'domainid', 'account'],
|
|
resourceType: 'VPNCustomerGateway',
|
|
tabs: [
|
|
{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
},
|
|
{
|
|
name: 'comments',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/AnnotationsTab.vue')))
|
|
}
|
|
],
|
|
actions: [
|
|
{
|
|
api: 'createVpnCustomerGateway',
|
|
icon: 'plus-outlined',
|
|
label: 'label.add.vpn.customer.gateway',
|
|
docHelp: 'adminguide/networking_and_traffic.html#creating-and-updating-a-vpn-customer-gateway',
|
|
listView: true,
|
|
popup: true,
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/CreateVpnCustomerGateway.vue')))
|
|
},
|
|
{
|
|
api: 'updateVpnCustomerGateway',
|
|
icon: 'edit-outlined',
|
|
label: 'label.edit',
|
|
docHelp: 'adminguide/networking_and_traffic.html#updating-and-removing-a-vpn-customer-gateway',
|
|
dataView: true,
|
|
args: ['name', 'gateway', 'cidrlist', 'ipsecpsk', 'ikepolicy', 'ikelifetime', 'ikeversion', 'esppolicy', 'esplifetime', 'dpd', 'splitconnections', 'forceencap'],
|
|
mapping: {
|
|
ikeversion: {
|
|
options: ['ike', 'ikev1', 'ikev2']
|
|
}
|
|
}
|
|
},
|
|
{
|
|
api: 'deleteVpnCustomerGateway',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.vpn.customer.gateway',
|
|
message: 'message.delete.vpn.customer.gateway',
|
|
docHelp: 'adminguide/networking_and_traffic.html#updating-and-removing-a-vpn-customer-gateway',
|
|
dataView: true,
|
|
groupAction: true,
|
|
popup: true,
|
|
groupMap: (selection) => { return selection.map(x => { return { id: x } }) }
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'tungstenfabric',
|
|
title: 'label.tungsten.fabric',
|
|
icon: shallowRef(tungsten),
|
|
permission: ['listTungstenFabricProviders'],
|
|
columns: [
|
|
{
|
|
field: 'name',
|
|
customTitle: 'tungsten.fabric.provider'
|
|
},
|
|
'zonename'
|
|
],
|
|
details: ['name', 'tungstengateway', 'tungstenproviderhostname', 'tungstenproviderintrospectport', 'tungstenproviderport', 'tungstenprovideruuid', 'tungstenprovidervrouterport', 'zonename'],
|
|
resourceType: 'TungstenFabric',
|
|
tabs: [
|
|
{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
},
|
|
{
|
|
name: 'tungsten.fabric',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/tungsten/TungstenFabric.vue'))),
|
|
show: (record) => { return !record.securitygroupsenabled }
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'tungstenpolicy',
|
|
title: 'label.network.policy',
|
|
icon: shallowRef(tungsten),
|
|
hidden: true,
|
|
permission: ['listTungstenFabricPolicy'],
|
|
columns: ['name', 'zonename'],
|
|
details: ['name', 'zonename'],
|
|
tabs: [
|
|
{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
},
|
|
{
|
|
name: 'rule',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/tungsten/TungstenFabricPolicyRule.vue')))
|
|
},
|
|
{
|
|
name: 'tag',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/tungsten/TungstenFabricPolicyTag.vue')))
|
|
}
|
|
],
|
|
actions: [
|
|
{
|
|
api: 'deleteTungstenFabricPolicy',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.tungsten.policy',
|
|
message: 'label.confirm.delete.tungsten.policy',
|
|
dataView: true,
|
|
mapping: {
|
|
policyuuid: {
|
|
value: (record) => { return record.uuid }
|
|
},
|
|
zoneid: {
|
|
value: (record) => { return record.zoneid }
|
|
}
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'tungstenpolicyset',
|
|
title: 'label.application.policy.set',
|
|
icon: shallowRef(tungsten),
|
|
hidden: true,
|
|
permission: ['listTungstenFabricApplicationPolicySet'],
|
|
columns: ['name', 'zonename'],
|
|
details: ['name', 'zonename'],
|
|
tabs: [
|
|
{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
},
|
|
{
|
|
name: 'firewall.policy',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/tungsten/FirewallPolicyTab.vue')))
|
|
},
|
|
{
|
|
name: 'tag',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/tungsten/FirewallTagTab.vue')))
|
|
}
|
|
],
|
|
actions: [
|
|
{
|
|
api: 'deleteTungstenFabricApplicationPolicySet',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.tungsten.policy.set',
|
|
message: 'label.confirm.delete.tungsten.policy.set',
|
|
dataView: true,
|
|
mapping: {
|
|
applicationpolicysetuuid: {
|
|
value: (record) => { return record.uuid }
|
|
},
|
|
zoneid: {
|
|
value: (record) => { return record.zoneid }
|
|
}
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'tungstenfirewallpolicy',
|
|
title: 'label.firewall.policy',
|
|
icon: shallowRef(tungsten),
|
|
hidden: true,
|
|
permission: ['listTungstenFabricFirewallPolicy'],
|
|
columns: ['name', 'zonename'],
|
|
details: ['uuid', 'name', 'zonename'],
|
|
tabs: [
|
|
{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
},
|
|
{
|
|
name: 'firewallrule',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/tungsten/FirewallRuleTab.vue')))
|
|
}
|
|
],
|
|
actions: [
|
|
{
|
|
api: 'deleteTungstenFabricFirewallPolicy',
|
|
icon: 'delete-outlined',
|
|
label: 'label.delete.tungsten.firewall.policy',
|
|
message: 'label.confirm.delete.tungsten.firewall.policy',
|
|
dataView: true,
|
|
mapping: {
|
|
firewallpolicyuuid: {
|
|
value: (record) => { return record.uuid }
|
|
},
|
|
zoneid: {
|
|
value: (record) => { return record.zoneid }
|
|
}
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: 'guestvlans',
|
|
title: 'label.guest.vlan',
|
|
icon: 'folder-outlined',
|
|
permission: ['listGuestVlans'],
|
|
resourceType: 'GuestVlan',
|
|
filters: ['allocatedonly', 'all'],
|
|
columns: ['vlan', 'allocationstate', 'physicalnetworkname', 'taken', 'account', 'project', 'domain', 'zonename'],
|
|
details: ['vlan', 'allocationstate', 'physicalnetworkname', 'taken', 'account', 'project', 'domain', 'isdedicated', 'zonename'],
|
|
searchFilters: ['zoneid'],
|
|
tabs: [{
|
|
name: 'details',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/components/view/DetailsTab.vue')))
|
|
}, {
|
|
name: 'guest.networks',
|
|
component: shallowRef(defineAsyncComponent(() => import('@/views/network/GuestVlanNetworksTab.vue'))),
|
|
show: (record) => { return (record.allocationstate === 'Allocated') }
|
|
}],
|
|
show: () => {
|
|
if (!store.getters.zones || store.getters.zones.length === 0) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
]
|
|
}
|