| // 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. |
| (function($, cloudStack) { |
| var aclMultiEdit = { |
| noSelect: true, |
| fieldPreFilter: function(args) { |
| var context = args.context; |
| var hiddenFields = []; |
| |
| if (context.networks) { // from tier detail view |
| hiddenFields.push('networkid'); |
| } |
| |
| return hiddenFields; // Returns fields to be hidden |
| }, |
| fields: { |
| 'cidrlist': { edit: true, label: 'label.cidr' }, |
| 'protocol': { |
| label: 'label.protocol', |
| select: function(args) { |
| args.$select.change(function() { |
| var $inputs = args.$form.find('input'); |
| var $icmpFields = $inputs.filter(function() { |
| var name = $(this).attr('name'); |
| |
| return $.inArray(name, [ |
| 'icmptype', |
| 'icmpcode' |
| ]) > -1; |
| }); |
| var $otherFields = $inputs.filter(function() { |
| var name = $(this).attr('name'); |
| |
| return name != 'icmptype' && name != 'icmpcode' && name != 'cidrlist'; |
| }); |
| |
| if ($(this).val() == 'icmp') { |
| $icmpFields.show(); |
| $icmpFields.attr('disabled', false); |
| $otherFields.attr('disabled', 'disabled'); |
| $otherFields.hide(); |
| $otherFields.parent().find('label.error').hide(); |
| } else { |
| $otherFields.show(); |
| $otherFields.parent().find('label.error').hide(); |
| $otherFields.attr('disabled', false); |
| $icmpFields.attr('disabled', 'disabled'); |
| $icmpFields.hide(); |
| $icmpFields.parent().find('label.error').hide(); |
| } |
| }); |
| |
| args.response.success({ |
| data: [ |
| { name: 'tcp', description: 'TCP' }, |
| { name: 'udp', description: 'UDP' }, |
| { name: 'icmp', description: 'ICMP' } |
| ] |
| }); |
| } |
| }, |
| 'startport': { edit: true, label: 'label.start.port' }, |
| 'endport': { edit: true, label: 'label.end.port' }, |
| 'networkid': { |
| label: 'Select Tier', |
| select: function(args) { |
| var data = { |
| listAll: true, |
| vpcid: args.context.vpc[0].id |
| }; |
| |
| // Only show selected tier, if viewing from detail view |
| if (args.context.networks && |
| args.context.networks[0] && |
| args.context.networks[0].vpcid) { |
| $.extend(data, { |
| id: args.context.networks[0].id |
| }); |
| } |
| |
| // Ajax Call to display the Tiers |
| $.ajax({ |
| url: createURL('listNetworks'), |
| data: data, |
| success: function(json) { |
| var networks = json.listnetworksresponse.network; |
| |
| args.response.success({ |
| data: $(networks).map(function(index, network) { |
| return { |
| name: network.id, |
| description: network.name |
| }; |
| }) |
| }); |
| } |
| }); |
| } |
| }, |
| 'icmptype': { edit: true, label: 'ICMP.type', isDisabled: true, desc:'Please specify -1 if you want to allow all ICMP types', defaultValue:'-1' }, |
| 'icmpcode': { edit: true, label: 'ICMP.code', isDisabled: true, desc:'Please specify -1 if you want to allow all ICMP codes', defaultValue:'-1' }, |
| 'traffictype' : { |
| label: 'label.traffic.type', |
| select: function(args) { |
| args.response.success({ |
| data: [ |
| { name: 'Ingress', description: 'Ingress' }, |
| { name: 'Egress', description: 'Egress' } |
| ] |
| }); |
| } |
| }, |
| 'add-rule': { |
| label: 'label.add.rule', |
| addButton: true |
| } |
| }, |
| |
| tags: cloudStack.api.tags({ resourceType: 'NetworkACL', contextId: 'multiRule' }), |
| |
| add: { |
| label: 'label.add', |
| action: function(args) { |
| var $multi = args.$multi; |
| |
| $.ajax({ |
| url: createURL('createNetworkACL'), |
| data: $.extend(args.data, { |
| networkid: args.context.networks ? |
| args.context.networks[0].id : args.data.networkid |
| }), |
| dataType: 'json', |
| success: function(data) { |
| args.response.success({ |
| _custom: { |
| jobId: data.createnetworkaclresponse.jobid, |
| getUpdatedItem: function(json) { |
| var networkName = $multi.find('select[name=networkid] option[value=' + args.data.networkid + ']').html(); |
| var data = $.extend(json.queryasyncjobresultresponse.jobresult.networkacl, { |
| networkid: networkName |
| }); |
| var aclRules = $multi.data('acl-rules'); |
| |
| aclRules.push(data); |
| $multi.data('acl-rules', aclRules); |
| $(window).trigger('cloudStack.fullRefresh'); |
| |
| return data; |
| } |
| }, |
| notification: { |
| label: 'label.add.ACL', |
| poll: pollAsyncJobResult |
| } |
| }); |
| }, |
| error: function(data) { |
| args.response.error(parseXMLHttpResponse(data)); |
| } |
| }); |
| } |
| }, |
| actions: { |
| destroy: { |
| label: 'label.remove.ACL', |
| action: function(args) { |
| $.ajax({ |
| url: createURL('deleteNetworkACL'), |
| data: { |
| id: args.context.multiRule[0].id |
| }, |
| dataType: 'json', |
| async: true, |
| success: function(data) { |
| var jobID = data.deletenetworkaclresponse.jobid; |
| args.response.success({ |
| _custom: { |
| jobId: jobID, |
| getUpdatedItem: function() { |
| $(window).trigger('cloudStack.fullRefresh'); |
| } |
| }, |
| notification: { |
| label: 'label.remove.ACL', |
| poll: pollAsyncJobResult |
| } |
| }); |
| }, |
| error: function(data) { |
| args.response.error(parseXMLHttpResponse(data)); |
| } |
| }); |
| } |
| } |
| }, |
| dataProvider: function(args) { |
| var $multi = args.$multi; |
| var data = { |
| vpcid: args.context.vpc[0].id, |
| listAll: true |
| }; |
| |
| if (!$multi.data('acl-rules')) { |
| $multi.data('acl-rules', []); |
| } |
| |
| if (args.context.networks && |
| args.context.networks[0] && |
| args.context.networks[0].vpcid) { |
| data.networkid = args.context.networks[0].id; |
| |
| $.ajax({ |
| url: createURL('listNetworkACLs'), |
| data: data, |
| dataType: 'json', |
| async: true, |
| success: function(json) { |
| args.response.success({ |
| data: $(json.listnetworkaclsresponse.networkacl).map(function(index, acl) { |
| return $.extend(acl, { |
| networkid: args.context.networks[0].name |
| }); |
| }) |
| }); |
| }, |
| error: function(XMLHttpResponse) { |
| args.response.error(parseXMLHttpResponse(XMLHttpResponse)); |
| } |
| }); |
| } else { |
| args.response.success({ data: $multi.data('acl-rules') }); |
| } |
| } |
| }; |
| |
| cloudStack.vpc = { |
| routerDetailView: function() { |
| return { |
| title: 'VPC router details', |
| updateContext: function(args) { |
| var router; |
| |
| $.ajax({ |
| url: createURL("listRouters&listAll=true&vpcid=" +args.context.vpc[0].id), |
| dataType: "json", |
| async: false, |
| success: function(json) { |
| router = json.listroutersresponse.router[0]; |
| } |
| }); |
| |
| return { |
| routers: [router] |
| }; |
| }, |
| actions: cloudStack.sections.system.subsections.virtualRouters |
| .listView.detailView.actions, |
| tabs: { |
| routerDetails: cloudStack.sections.network.sections.vpc |
| .listView.detailView.tabs.router |
| } |
| }; |
| }, |
| vmListView: { |
| id: 'vpcTierInstances', |
| listView: { |
| filters: { |
| all: { label: 'label.menu.all.instances' }, |
| running: { label: 'label.menu.running.instances' }, |
| stopped: { label: 'label.menu.stopped.instances' }, |
| destroyed: { label: 'label.menu.destroyed.instances' } |
| }, |
| fields: { |
| name: { label: 'label.name', editable: true }, |
| account: { label: 'label.account' }, |
| zonename: { label: 'label.zone' }, |
| state: { |
| label: 'label.status', |
| indicator: { |
| 'Running': 'on', |
| 'Stopped': 'off', |
| 'Destroyed': 'off' |
| } |
| } |
| }, |
| |
| // List view actions |
| actions: { |
| start: { |
| label: 'label.action.start.instance' , |
| action: function(args) { |
| $.ajax({ |
| url: createURL("startVirtualMachine&id=" + args.context.vpcTierInstances[0].id), |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var jid = json.startvirtualmachineresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.virtualmachine; |
| }, |
| getActionFilter: function() { |
| return cloudStack.actionFilter.vmActionFilter; |
| } |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| messages: { |
| confirm: function(args) { |
| return 'message.action.start.instance'; |
| }, |
| notification: function(args) { |
| return 'label.action.start.instance'; |
| }, |
| complete: function(args) { |
| if(args.password != null) { |
| alert('Password of the VM is ' + args.password); |
| } |
| return 'label.action.start.instance'; |
| } |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| stop: { |
| label: 'label.action.stop.instance', |
| addRow: 'false', |
| createForm: { |
| title: 'label.action.stop.instance', |
| desc: 'message.action.stop.instance', |
| fields: { |
| forced: { |
| label: 'force.stop', |
| isBoolean: true, |
| isChecked: false |
| } |
| } |
| }, |
| action: function(args) { |
| var array1 = []; |
| array1.push("&forced=" + (args.data.forced == "on")); |
| $.ajax({ |
| url: createURL("stopVirtualMachine&id=" + args.context.vpcTierInstances[0].id + array1.join("")), |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var jid = json.stopvirtualmachineresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.virtualmachine; |
| }, |
| getActionFilter: function() { |
| return cloudStack.actionFilter.vmActionFilter; |
| } |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| messages: { |
| confirm: function(args) { |
| return 'message.action.stop.instance'; |
| }, |
| |
| notification: function(args) { |
| return 'label.action.stop.instance'; |
| } |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| restart: { |
| label: 'instances.actions.reboot.label', |
| action: function(args) { |
| $.ajax({ |
| url: createURL("rebootVirtualMachine&id=" + args.context.vpcTierInstances[0].id), |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var jid = json.rebootvirtualmachineresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.virtualmachine; |
| }, |
| getActionFilter: function() { |
| return cloudStack.actionFilter.vmActionFilter; |
| } |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| messages: { |
| confirm: function(args) { |
| return 'message.action.reboot.instance'; |
| }, |
| notification: function(args) { |
| return 'instances.actions.reboot.label'; |
| } |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| destroy: { |
| label: 'label.action.destroy.instance', |
| messages: { |
| confirm: function(args) { |
| return 'message.action.destroy.instance'; |
| }, |
| notification: function(args) { |
| return 'label.action.destroy.instance'; |
| } |
| }, |
| action: function(args) { |
| $.ajax({ |
| url: createURL("destroyVirtualMachine&id=" + args.context.vpcTierInstances[0].id), |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var jid = json.destroyvirtualmachineresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.virtualmachine; |
| }, |
| getActionFilter: function() { |
| return cloudStack.actionFilter.vmActionFilter; |
| } |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| restore: { |
| label: 'label.action.restore.instance', |
| messages: { |
| confirm: function(args) { |
| return 'message.action.restore.instance'; |
| }, |
| notification: function(args) { |
| return 'label.action.restore.instance'; |
| } |
| }, |
| action: function(args) { |
| $.ajax({ |
| url: createURL("recoverVirtualMachine&id=" + args.context.vpcTierInstances[0].id), |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var item = json.recovervirtualmachineresponse.virtualmachine; |
| args.response.success({data:item}); |
| } |
| }); |
| } |
| }, |
| viewConsole: { |
| label: 'label.view.console', |
| action: { |
| externalLink: { |
| url: function(args) { |
| return clientConsoleUrl + '?cmd=access&vm=' + args.context.vpcTierInstances[0].id; |
| }, |
| title: function(args) { |
| return args.context.vpcTierInstances[0].id.substr(0,8); //title in window.open() can't have space nor longer than 8 characters. Otherwise, IE browser will have error. |
| }, |
| width: 820, |
| height: 640 |
| } |
| } |
| } |
| }, |
| dataProvider: function(args) { |
| var array1 = []; |
| if(args.filterBy != null) { |
| if(args.filterBy.kind != null) { |
| switch(args.filterBy.kind) { |
| case "all": |
| array1.push("&listAll=true"); |
| break; |
| case "mine": |
| if (!args.context.projects) array1.push("&domainid=" + g_domainid + "&account=" + g_account); |
| break; |
| case "running": |
| array1.push("&listAll=true&state=Running"); |
| break; |
| case "stopped": |
| array1.push("&listAll=true&state=Stopped"); |
| break; |
| case "destroyed": |
| array1.push("&listAll=true&state=Destroyed"); |
| break; |
| } |
| } |
| if(args.filterBy.search != null && args.filterBy.search.by != null && args.filterBy.search.value != null) { |
| switch(args.filterBy.search.by) { |
| case "name": |
| if(args.filterBy.search.value.length > 0) |
| array1.push("&keyword=" + args.filterBy.search.value); |
| break; |
| } |
| } |
| } |
| |
| $.ajax({ |
| url: createURL('listVirtualMachines' + array1.join("")), |
| data: { |
| networkid: args.context.networks[0].id |
| }, |
| success: function(json) { |
| args.response.success({ |
| data: json.listvirtualmachinesresponse.virtualmachine, |
| actionFilter: cloudStack.actionFilter.vmActionFilter |
| }); |
| } |
| }); |
| } |
| } |
| }, |
| ipAddresses: { |
| listView: function() { |
| var listView = $.extend(true, {}, cloudStack.sections.network.sections.ipAddresses); |
| |
| listView.listView.fields = { |
| ipaddress: listView.listView.fields.ipaddress, |
| zonename: listView.listView.fields.zonename, |
| associatednetworkname: { label: 'label.network.name' }, |
| state: listView.listView.fields.state |
| }; |
| |
| return listView; |
| } |
| }, |
| acl: { |
| multiEdit: aclMultiEdit, |
| |
| listView: { |
| listView: { |
| id: 'networks', |
| fields: { |
| tierName: { label: 'label.tier' }, |
| aclTotal: { label: 'label.network.ACL.total' } |
| }, |
| dataProvider: function(args) { |
| $.ajax({ |
| url: createURL('listNetworks'), |
| data: { |
| listAll: true, |
| vpcid: args.context.vpc[0].id |
| }, |
| success: function(json) { |
| var networks = json.listnetworksresponse.network ? |
| json.listnetworksresponse.network : []; |
| |
| args.response.success({ |
| data: $.map(networks, function(tier) { |
| var aclTotal = 0; |
| |
| // Get ACL total |
| $.ajax({ |
| url: createURL('listNetworkACLs'), |
| async: false, |
| data: { |
| listAll: true, |
| networkid: tier.id |
| }, |
| success: function(json) { |
| aclTotal = json.listnetworkaclsresponse.networkacl ? |
| json.listnetworkaclsresponse.networkacl.length : 0; |
| } |
| }); |
| |
| return $.extend(tier, { |
| tierName: tier.name, |
| aclTotal: aclTotal |
| }); |
| }) |
| }); |
| } |
| }); |
| } |
| } |
| } |
| }, |
| gateways: { |
| add: { |
| preCheck: function(args) { |
| if(isAdmin()) { //root-admin |
| var items; |
| $.ajax({ |
| url: createURL('listPrivateGateways'), |
| async: false, |
| data: { |
| vpcid: args.context.vpc[0].id, |
| listAll: true |
| }, |
| success: function(json) { |
| items = json.listprivategatewaysresponse.privategateway; |
| } |
| }); |
| if (items && items.length) { |
| return true; //show private gateway listView |
| } |
| else { |
| return false; //show create private gateway dialog |
| } |
| } |
| else { //regular-user, domain-admin |
| return true; //show private gateway listView instead of create private gateway dialog because only root-admin is allowed to create private gateway |
| } |
| }, |
| label: 'label.add.new.gateway', |
| messages: { |
| notification: function(args) { |
| return 'label.add.new.gateway'; |
| } |
| }, |
| createForm: { |
| title: 'label.add.new.gateway', |
| desc: 'message.add.new.gateway.to.vpc', |
| fields: { |
| physicalnetworkid: { |
| docID: 'helpVPCGatewayPhysicalNetwork', |
| label: 'label.physical.network', |
| select: function(args) { |
| $.ajax({ |
| url: createURL("listPhysicalNetworks"), |
| data: { |
| zoneid: args.context.vpc[0].zoneid |
| }, |
| success: function(json) { |
| var objs = json.listphysicalnetworksresponse.physicalnetwork; |
| var items = []; |
| $(objs).each(function() { |
| items.push({id: this.id, description: this.name}); |
| }); |
| args.response.success({data: items}); |
| } |
| }); |
| } |
| }, |
| vlan: { |
| label: 'label.vlan', validation: { required: true }, |
| docID: 'helpVPCGatewayVLAN' |
| }, |
| ipaddress: { |
| label: 'label.ip.address', validation: { required: true }, |
| docID: 'helpVPCGatewayIP' |
| }, |
| gateway: { |
| label: 'label.gateway', validation: { required: true }, |
| docID: 'helpVPCGatewayGateway' |
| }, |
| netmask: { |
| label: 'label.netmask', validation: { required: true }, |
| docID: 'helpVPCGatewayNetmask' |
| } |
| } |
| }, |
| action: function(args) { |
| $.ajax({ |
| url: createURL('createPrivateGateway'), |
| data: { |
| physicalnetworkid: args.data.physicalnetworkid, |
| vpcid: args.context.vpc[0].id, |
| ipaddress: args.data.ipaddress, |
| gateway: args.data.gateway, |
| netmask: args.data.netmask, |
| vlan: args.data.vlan |
| }, |
| success: function(json) { |
| var jid = json.createprivategatewayresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.privategateway; |
| } |
| } |
| } |
| ); |
| }, |
| error: function(json) { |
| args.response.error(parseXMLHttpResponse(json)); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| listView: function() { |
| return { |
| listView: { |
| id: 'vpcGateways', |
| fields: { |
| ipaddress: { label: 'label.ip.address', validation: { required: true }}, |
| gateway: { label: 'label.gateway', validation: { required: true }}, |
| netmask: { label: 'label.netmask', validation: { required: true }}, |
| vlan: { label: 'label.vlan', validation: { required: true }} |
| }, |
| dataProvider: function(args) { |
| $.ajax({ |
| url: createURL('listPrivateGateways'), |
| data: { |
| vpcid: args.context.vpc[0].id, |
| listAll: true |
| }, |
| success: function(json) { |
| var items = json.listprivategatewaysresponse.privategateway; |
| args.response.success({ data: items }); |
| } |
| }); |
| }, |
| detailView: { |
| name: 'label.details', |
| actions: { |
| remove: { |
| label: 'label.delete.gateway', |
| messages: { |
| confirm: function(args) { |
| return 'message.delete.gateway'; |
| }, |
| notification: function(args) { |
| return 'label.delete.gateway'; |
| } |
| }, |
| action: function(args) { |
| $.ajax({ |
| url: createURL("deletePrivateGateway&id=" + args.context.vpcGateways[0].id), |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var jid = json.deleteprivategatewayresponse.jobid; |
| args.response.success( |
| {_custom: |
| { |
| jobId: jid |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| } |
| }, |
| tabs: { |
| details: { |
| title: 'label.details', |
| fields: [ |
| { |
| ipaddress: { label: 'label.ip.address' } |
| }, |
| { |
| gateway: { label: 'label.gateway' }, |
| netmask: { label: 'label.netmask'}, |
| vlan: { label: 'label.vlan' }, |
| state: { label: 'label.state' }, |
| id: { label: 'label.id' }, |
| zonename: { label: 'label.zone' }, |
| domain: { label: 'label.domain' }, |
| account: { label: 'label.account' } |
| } |
| ], |
| dataProvider: function(args) { |
| $.ajax({ |
| url: createURL('listPrivateGateways'), |
| data: { |
| id: args.context.vpcGateways[0].id, |
| listAll: true |
| }, |
| success: function(json) { |
| var item = json.listprivategatewaysresponse.privategateway[0]; |
| args.response.success({ |
| data: item, |
| actionFilter: function(args) { |
| var allowedActions = []; |
| if(isAdmin()) { |
| allowedActions.push("remove"); |
| } |
| return allowedActions; |
| } |
| }); |
| } |
| }); |
| } |
| }, |
| staticRoutes: { |
| title: 'Static Routes', |
| custom: function(args) { |
| return $('<div>').multiEdit({ |
| noSelect: true, |
| context: args.context, |
| fields: { |
| cidr: { edit: true, label: 'label.CIDR.of.destination.network' }, |
| 'add-rule': { |
| label: 'label.add.route', |
| addButton: true |
| } |
| }, |
| |
| tags: cloudStack.api.tags({ resourceType: 'StaticRoute', contextId: 'multiRule' }), |
| |
| add: { |
| label: 'label.add', |
| action: function(args) { |
| $.ajax({ |
| url: createURL('createStaticRoute'), |
| data: { |
| gatewayid: args.context.vpcGateways[0].id, |
| cidr: args.data.cidr |
| }, |
| success: function(data) { |
| args.response.success({ |
| _custom: { |
| jobId: data.createstaticrouteresponse.jobid |
| }, |
| notification: { |
| label: 'label.add.static.route', |
| poll: pollAsyncJobResult |
| } |
| }); |
| }, |
| error: function(data) { |
| args.response.error(parseXMLHttpResponse(data)); |
| } |
| }); |
| } |
| }, |
| actions: { |
| destroy: { |
| label: 'label.remove.static.route', |
| action: function(args) { |
| $.ajax({ |
| url: createURL('deleteStaticRoute'), |
| data: { |
| id: args.context.multiRule[0].id |
| }, |
| dataType: 'json', |
| async: true, |
| success: function(data) { |
| var jobID = data.deletestaticrouteresponse.jobid; |
| |
| args.response.success({ |
| _custom: { |
| jobId: jobID |
| }, |
| notification: { |
| label: 'label.remove.static.route', |
| poll: pollAsyncJobResult |
| } |
| }); |
| } |
| }); |
| } |
| } |
| }, |
| dataProvider: function(args) { |
| $.ajax({ |
| url: createURL('listStaticRoutes'), |
| data: { |
| gatewayid: args.context.vpcGateways[0].id, |
| listAll: true |
| }, |
| success: function(json) { |
| var items = json.liststaticroutesresponse.staticroute; |
| args.response.success({ data: items }); |
| } |
| }); |
| } |
| }); |
| } |
| } |
| } |
| } |
| } |
| }; |
| } |
| }, |
| siteToSiteVPN: { |
| title: 'label.site.to.site.VPN', |
| id: 'siteToSiteVpn', |
| sectionSelect: { |
| preFilter: function(args) { |
| return ["vpnGateway", "vpnConnection"]; |
| }, |
| label: 'label.select-view' |
| }, |
| |
| // This is a custom add function -- does not show in list view |
| add: { |
| // Check if VPN gateways exist |
| // -- if false, don't show list view |
| preCheck: function(args) { |
| var items; |
| |
| $.ajax({ |
| url: createURL('listVpnGateways&listAll=true'), |
| data: { |
| vpcid: args.context.vpc[0].id |
| }, |
| async: false, |
| success: function(json) { |
| items = json.listvpngatewaysresponse.vpngateway; |
| } |
| }); |
| |
| if (items && items.length) { |
| return true; |
| } |
| |
| return false; |
| }, |
| label: 'label.add.VPN.gateway', |
| messages: { |
| notification: function(args) { |
| return 'label.add.VPN.gateway'; |
| } |
| }, |
| createForm: { |
| title: 'label.add.VPN.gateway', |
| desc: 'message.add.VPN.gateway', |
| fields: {} |
| }, |
| action: function(args) { |
| $.ajax({ |
| url: createURL("createVpnGateway"), |
| data: { |
| vpcid: args.context.vpc[0].id |
| }, |
| success: function(json) { |
| var jid = json.createvpngatewayresponse.jobid; |
| args.response.success( |
| {_custom: |
| { |
| jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.vpngateway; |
| } |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| |
| sections: { |
| vpnGateway: { |
| type: 'select', |
| title: 'label.VPN.gateway', |
| listView: { |
| id: 'vpnGateway', |
| label: 'label.VPN.gateway', |
| fields: { |
| publicip: { label: 'label.ip.address' }, |
| account: { label: 'label.account' }, |
| domain: { label: 'label.domain' } |
| }, |
| dataProvider: function(args) { |
| var array1 = []; |
| if(args.filterBy != null) { |
| if(args.filterBy.search != null && args.filterBy.search.by != null && args.filterBy.search.value != null) { |
| switch(args.filterBy.search.by) { |
| case "name": |
| if(args.filterBy.search.value.length > 0) |
| array1.push("&keyword=" + args.filterBy.search.value); |
| break; |
| } |
| } |
| } |
| $.ajax({ |
| url: createURL("listVpnGateways&listAll=true&page=" + args.page + "&pagesize=" + pageSize + array1.join("")), |
| data: { |
| vpcid: args.context.vpc[0].id |
| }, |
| async: false, |
| success: function(json) { |
| var items = json.listvpngatewaysresponse.vpngateway; |
| args.response.success({data: items}); |
| } |
| }); |
| }, |
| detailView: { |
| name: 'label.details', |
| actions: { |
| remove: { |
| label: 'label.delete.VPN.gateway', |
| messages: { |
| confirm: function(args) { |
| return 'message.delete.VPN.gateway'; |
| }, |
| notification: function(args) { |
| return 'label.delete.VPN.gateway'; |
| } |
| }, |
| action: function(args) { |
| $.ajax({ |
| url: createURL("deleteVpnGateway"), |
| data: { |
| id: args.context.vpnGateway[0].id |
| }, |
| success: function(json) { |
| var jid = json.deletevpngatewayresponse.jobid; |
| args.response.success( |
| {_custom: |
| { |
| jobId: jid |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| } |
| }, |
| tabs: { |
| details: { |
| title: 'label.details', |
| fields: [ |
| { |
| publicip: { label: 'label.ip.address' } |
| }, |
| { |
| id: { label: 'label.id' }, |
| domain: { label: 'label.domain' }, |
| account: { label: 'label.account' } |
| } |
| ], |
| dataProvider: function(args) { |
| $.ajax({ |
| url: createURL("listVpnGateways"), |
| data: { |
| id: args.context.vpnGateway[0].id |
| }, |
| async: true, |
| success: function(json) { |
| var item = json.listvpngatewaysresponse.vpngateway[0]; |
| args.response.success({data: item}); |
| } |
| }); |
| } |
| } |
| } |
| } |
| } |
| }, |
| vpnConnection: { |
| type: 'select', |
| title: 'label.VPN.connection', |
| listView: { |
| id: 'vpnConnection', |
| label: 'label.VPN.connection', |
| fields: { |
| publicip: { label: 'label.ip.address' }, |
| gateway: { label: 'label.gateway' }, |
| state: { |
| label: 'label.state', |
| indicator: { |
| 'Connected': 'on', |
| 'Disconnected': 'off', |
| 'Error': 'off' |
| } |
| }, |
| ipsecpsk: { label: 'label.IPsec.preshared.key' }, |
| ikepolicy: { label: 'label.IKE.policy' }, |
| esppolicy: { label: 'label.ESP.policy' } |
| }, |
| dataProvider: function(args) { |
| var array1 = []; |
| if(args.filterBy != null) { |
| if(args.filterBy.search != null && args.filterBy.search.by != null && args.filterBy.search.value != null) { |
| switch(args.filterBy.search.by) { |
| case "name": |
| if(args.filterBy.search.value.length > 0) |
| array1.push("&keyword=" + args.filterBy.search.value); |
| break; |
| } |
| } |
| } |
| $.ajax({ |
| url: createURL("listVpnConnections&listAll=true&page=" + args.page + "&pagesize=" + pageSize + array1.join("")), |
| data: { |
| vpcid: args.context.vpc[0].id |
| }, |
| success: function(json) { |
| var items = json.listvpnconnectionsresponse.vpnconnection; |
| args.response.success({data:items}); |
| } |
| }); |
| }, |
| |
| actions:{ |
| add: { |
| label: 'label.create.VPN.connection', |
| messages: { |
| notification: function(args) { |
| return 'label.create.VPN.connection'; |
| } |
| }, |
| createForm: { |
| title: 'label.create.VPN.connection', |
| fields: { |
| vpncustomergatewayid: { |
| label: 'label.VPN.customer.gateway', |
| validation: { required: true }, |
| select: function(args) { |
| $.ajax({ |
| url: createURL("listVpnCustomerGateways"), |
| data: { |
| listAll: true |
| }, |
| success: function(json) { |
| var items = json.listvpncustomergatewaysresponse.vpncustomergateway; |
| args.response.success({ |
| data: $.map(items, function(item) { |
| return { |
| id: item.id, |
| description: item.name |
| }; |
| }) |
| |
| }); |
| } |
| }); |
| } |
| } |
| } |
| }, |
| action: function(args) { |
| var vpngatewayid = null; |
| $.ajax({ |
| url: createURL('listVpnGateways'), |
| data: { |
| vpcid: args.context.vpc[0].id |
| }, |
| async: false, |
| success: function(json) { |
| var items = json.listvpngatewaysresponse.vpngateway; |
| if(items != null && items.length > 0) { |
| vpngatewayid = items[0].id; |
| } |
| } |
| }); |
| if(vpngatewayid == null) { |
| args.response.error('The selected VPC does not have a VPN gateway. Please create a VPN gateway for the VPC first.'); |
| return; |
| } |
| |
| $.ajax({ |
| url: createURL('createVpnConnection'), |
| data: { |
| s2svpngatewayid: vpngatewayid, |
| s2scustomergatewayid: args.data.vpncustomergatewayid |
| }, |
| success: function(json) { |
| var jid = json.createvpnconnectionresponse.jobid; |
| args.response.success( |
| {_custom: |
| { |
| jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.vpnconnection; |
| } |
| } |
| } |
| ); |
| }, |
| error: function(xmlHttpResponse) { |
| args.response.error(parseXMLHttpResponse(xmlHttpResponse)); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| } |
| }, |
| |
| detailView: { |
| name: 'label.details', |
| tabs: { |
| details: { |
| title: 'label.details', |
| fields: [ |
| { |
| id: { label: 'label.id' }, |
| |
| //s2svpngatewayid: { label: 'VPN gateway ID' }, |
| publicip: { label: 'label.ip.address' }, |
| |
| //s2scustomergatewayid: { label: 'Customer gateway ID' }, |
| gateway: { label: 'label.gateway' }, |
| cidrlist: { label: 'label.CIDR.list' }, |
| ipsecpsk: { label: 'label.IPsec.preshared.key' }, |
| ikepolicy: { label: 'label.IKE.policy' }, |
| esppolicy: { label: 'label.ESP.policy' }, |
| ikelifetime: { label: 'label.IKE.lifetime' }, |
| esplifetime: {label: 'label.ESP.lifetime' }, |
| dpd: { |
| label: 'label.dead.peer.detection', |
| converter: function(str) { |
| return str ? 'Yes' : 'No'; |
| } |
| }, |
| state: {label: 'label.state' }, |
| created: { label: 'label.date', converter: cloudStack.converters.toLocalDate } |
| } |
| ], |
| |
| dataProvider: function(args) { |
| $.ajax({ |
| url: createURL("listVpnConnections&id=" + args.context.vpnConnection[0].id), |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var item = json.listvpnconnectionsresponse.vpnconnection[0]; |
| args.response.success({data: item}); |
| } |
| }); |
| } |
| } |
| }, |
| actions: { |
| restart: { |
| label: 'label.reset.VPN.connection', |
| messages: { |
| confirm: function(args) { |
| return 'message.reset.VPN.connection' ; |
| }, |
| notification: function(args) { |
| return 'label.reset.VPN.connection'; |
| } |
| }, |
| action: function(args) { |
| $.ajax({ |
| url: createURL("resetVpnConnection"), |
| data: { |
| id: args.context.vpnConnection[0].id |
| }, |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var jid = json.resetvpnconnectionresponse.jobid; |
| args.response.success( |
| {_custom: |
| { |
| jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.vpnconnection; |
| } |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| |
| remove: { |
| label: 'label.delete.VPN.connection', |
| messages: { |
| confirm: function(args) { |
| return 'message.delete.VPN.connection'; |
| }, |
| notification: function(args) { |
| return 'label.delete.VPN.connection'; |
| } |
| }, |
| action: function(args) { |
| $.ajax({ |
| url: createURL("deleteVpnConnection"), |
| dataType: "json", |
| data: { |
| id: args.context.vpnConnection[0].id |
| }, |
| async: true, |
| success: function(json) { |
| var jid = json.deletevpnconnectionresponse.jobid; |
| args.response.success( |
| {_custom: |
| { |
| jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.vpnconnection; |
| } |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| }, |
| |
| tiers: { |
| detailView: { //duplicate from cloudStack.sections.network.sections.networks.listView.detailView (begin) |
| name: 'Guest network details', |
| viewAll: { |
| path: 'network.ipAddresses', |
| label: 'label.menu.ipaddresses', |
| preFilter: function(args) { |
| if (args.context.networks[0].state == 'Destroyed') |
| return false; |
| |
| var services = args.context.networks[0].service; |
| if(services == null) |
| return false; |
| |
| if(args.context.networks[0].type == "Isolated") { |
| for(var i=0; i < services.length; i++) { |
| var service = services[i]; |
| if(service.name == "SourceNat") { |
| return true; |
| } |
| } |
| } |
| else if(args.context.networks[0].type == "Shared") { |
| var havingSecurityGroupService = false; |
| var havingElasticIpCapability = false; |
| var havingElasticLbCapability = false; |
| |
| for(var i=0; i < services.length; i++) { |
| var service = services[i]; |
| if(service.name == "SecurityGroup") { |
| havingSecurityGroupService = true; |
| } |
| else if(service.name == "StaticNat") { |
| $(service.capability).each(function(){ |
| if(this.name == "ElasticIp" && this.value == "true") { |
| havingElasticIpCapability = true; |
| return false; //break $.each() loop |
| } |
| }); |
| } |
| else if(service.name == "Lb") { |
| $(service.capability).each(function(){ |
| if(this.name == "ElasticLb" && this.value == "true") { |
| havingElasticLbCapability = true; |
| return false; //break $.each() loop |
| } |
| }); |
| } |
| } |
| |
| if(havingSecurityGroupService == true && havingElasticIpCapability == true && havingElasticLbCapability == true) |
| return true; |
| else |
| return false; |
| } |
| |
| return false; |
| } |
| }, |
| actions: { |
| edit: { |
| label: 'label.edit', |
| messages: { |
| notification: function(args) { |
| return 'label.edit.network.details'; |
| } |
| }, |
| action: function(args) { |
| var array1 = []; |
| array1.push("&name=" + todb(args.data.name)); |
| array1.push("&displaytext=" + todb(args.data.displaytext)); |
| |
| //args.data.networkdomain is null when networkdomain field is hidden |
| if(args.data.networkdomain != null && args.data.networkdomain != args.context.networks[0].networkdomain) |
| array1.push("&networkdomain=" + todb(args.data.networkdomain)); |
| |
| //args.data.networkofferingid is null when networkofferingid field is hidden |
| if(args.data.networkofferingid != null && args.data.networkofferingid != args.context.networks[0].networkofferingid) { |
| array1.push("&networkofferingid=" + todb(args.data.networkofferingid)); |
| |
| if(args.context.networks[0].type == "Isolated") { //Isolated network |
| cloudStack.dialog.confirm({ |
| message: 'Do you want to keep the current guest network CIDR unchanged?', |
| action: function() { //"Yes" button is clicked |
| array1.push("&changecidr=false"); |
| $.ajax({ |
| url: createURL("updateNetwork&id=" + args.context.networks[0].id + array1.join("")), |
| dataType: "json", |
| success: function(json) { |
| var jid = json.updatenetworkresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid, |
| getUpdatedItem: function(json) { |
| var item = json.queryasyncjobresultresponse.jobresult.network; |
| return {data: item}; |
| } |
| } |
| } |
| ); |
| }, |
| error:function(json) { |
| args.response.error(parseXMLHttpResponse(json)); |
| } |
| }); |
| }, |
| cancelAction: function() { //"Cancel" button is clicked |
| array1.push("&changecidr=true"); |
| $.ajax({ |
| url: createURL("updateNetwork&id=" + args.context.networks[0].id + array1.join("")), |
| dataType: "json", |
| success: function(json) { |
| var jid = json.updatenetworkresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid, |
| getUpdatedItem: function(json) { |
| var item = json.queryasyncjobresultresponse.jobresult.network; |
| return {data: item}; |
| } |
| } |
| } |
| ); |
| }, |
| error:function(json) { |
| args.response.error(parseXMLHttpResponse(json)); |
| } |
| }); |
| } |
| }); |
| return; |
| } |
| } |
| |
| $.ajax({ |
| url: createURL("updateNetwork&id=" + args.context.networks[0].id + array1.join("")), |
| dataType: "json", |
| success: function(json) { |
| var jid = json.updatenetworkresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid, |
| getUpdatedItem: function(json) { |
| var item = json.queryasyncjobresultresponse.jobresult.network; |
| return {data: item}; |
| } |
| } |
| } |
| ); |
| }, |
| error:function(json) { |
| args.response.error(parseXMLHttpResponse(json)); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| |
| 'restart': { |
| label: 'label.restart.network', |
| createForm: { |
| title: 'label.restart.network', |
| desc: 'message.restart.network', |
| preFilter: function(args) { |
| var zoneObj; |
| $.ajax({ |
| url: createURL("listZones&id=" + args.context.networks[0].zoneid), |
| dataType: "json", |
| async: false, |
| success: function(json){ |
| zoneObj = json.listzonesresponse.zone[0]; |
| } |
| }); |
| if(zoneObj.networktype == "Basic") { |
| args.$form.find('.form-item[rel=cleanup]').find('input').removeAttr('checked'); //unchecked |
| args.$form.find('.form-item[rel=cleanup]').hide(); //hidden |
| } |
| else { |
| args.$form.find('.form-item[rel=cleanup]').find('input').attr('checked', 'checked'); //checked |
| args.$form.find('.form-item[rel=cleanup]').css('display', 'inline-block'); //shown |
| } |
| }, |
| fields: { |
| cleanup: { |
| label: 'label.clean.up', |
| isBoolean: true |
| } |
| } |
| }, |
| messages: { |
| notification: function(args) { |
| return 'label.restart.network'; |
| } |
| }, |
| action: function(args) { |
| var array1 = []; |
| array1.push("&cleanup=" + (args.data.cleanup == "on")); |
| $.ajax({ |
| url: createURL("restartNetwork&id=" + args.context.networks[0].id + array1.join("")), |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var jid = json.restartnetworkresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid, |
| getUpdatedItem: function(json) { |
| return json.queryasyncjobresultresponse.jobresult.network; |
| } |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| |
| remove: { |
| label: 'label.action.delete.network', |
| messages: { |
| confirm: function(args) { |
| return 'message.action.delete.network'; |
| }, |
| notification: function(args) { |
| return 'label.action.delete.network'; |
| } |
| }, |
| action: function(args) { |
| $.ajax({ |
| url: createURL("deleteNetwork&id=" + args.context.networks[0].id), |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var jid = json.deletenetworkresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| } |
| }, |
| |
| tabFilter: function(args) { |
| var networkOfferingHavingELB = false; |
| $.ajax({ |
| url: createURL("listNetworkOfferings&id=" + args.context.networks[0].networkofferingid), |
| dataType: "json", |
| async: false, |
| success: function(json) { |
| var networkoffering = json.listnetworkofferingsresponse.networkoffering[0]; |
| $(networkoffering.service).each(function(){ |
| var thisService = this; |
| if(thisService.name == "Lb") { |
| $(thisService.capability).each(function(){ |
| if(this.name == "ElasticLb" && this.value == "true") { |
| networkOfferingHavingELB = true; |
| return false; //break $.each() loop |
| } |
| }); |
| return false; //break $.each() loop |
| } |
| }); |
| } |
| }); |
| |
| var hiddenTabs = ['ipAddresses']; // Disable IP address tab; it is redundant with 'view all' button |
| |
| if(networkOfferingHavingELB == false) |
| hiddenTabs.push("addloadBalancer"); |
| return hiddenTabs; |
| }, |
| |
| isMaximized: true, |
| tabs: { |
| details: { |
| title: 'Network Details', |
| preFilter: function(args) { |
| var hiddenFields = []; |
| var zone; |
| |
| $.ajax({ |
| url: createURL('listZones'), |
| data: { |
| id: args.context.networks[0].zoneid |
| }, |
| async: false, |
| success: function(json) { |
| zone = json.listzonesresponse.zone[0]; |
| } |
| }); |
| |
| if(zone.networktype == "Basic") { |
| hiddenFields.push("account"); |
| hiddenFields.push("gateway"); |
| hiddenFields.push("vlan"); |
| hiddenFields.push("cidr"); |
| //hiddenFields.push("netmask"); |
| } |
| |
| if(args.context.networks[0].type == "Isolated") { |
| hiddenFields.push("networkofferingdisplaytext"); |
| hiddenFields.push("networkdomaintext"); |
| hiddenFields.push("gateway"); |
| hiddenFields.push("networkofferingname"); |
| //hiddenFields.push("netmask"); |
| } |
| else { //selectedGuestNetworkObj.type == "Shared" |
| hiddenFields.push("networkofferingid"); |
| hiddenFields.push("networkdomain"); |
| } |
| return hiddenFields; |
| }, |
| fields: [ |
| { |
| name: { |
| label: 'label.name', |
| isEditable: true |
| } |
| }, |
| { |
| id: { label: 'label.id' }, |
| zonename: { label: 'label.zone' }, |
| displaytext: { |
| label: 'label.description', |
| isEditable: true |
| }, |
| type: { |
| label: 'label.type' |
| }, |
| state: { |
| label: 'label.state' |
| }, |
| restartrequired: { |
| label: 'label.restart.required', |
| converter: function(booleanValue) { |
| if(booleanValue == true) |
| return "<font color='red'>Yes</font>"; |
| else if(booleanValue == false) |
| return "No"; |
| } |
| }, |
| vlan: { label: 'label.vlan.id' }, |
| |
| networkofferingname: { label: 'label.network.offering' }, |
| |
| networkofferingid: { |
| label: 'label.network.offering', |
| isEditable: true, |
| select: function(args){ |
| if (args.context.networks[0].state == 'Destroyed') { |
| args.response.success({ data: [] }); |
| return; |
| } |
| |
| var items = []; |
| $.ajax({ |
| url: createURL("listNetworkOfferings&networkid=" + args.context.networks[0].id), |
| dataType: "json", |
| async: false, |
| success: function(json) { |
| var networkOfferingObjs = json.listnetworkofferingsresponse.networkoffering; |
| $(networkOfferingObjs).each(function() { |
| items.push({id: this.id, description: this.displaytext}); |
| }); |
| } |
| }); |
| $.ajax({ |
| url: createURL("listNetworkOfferings&id=" + args.context.networks[0].networkofferingid), //include currently selected network offeirng to dropdown |
| dataType: "json", |
| async: false, |
| success: function(json) { |
| var networkOfferingObjs = json.listnetworkofferingsresponse.networkoffering; |
| $(networkOfferingObjs).each(function() { |
| items.push({id: this.id, description: this.displaytext}); |
| }); |
| } |
| }); |
| args.response.success({data: items}); |
| } |
| }, |
| |
| gateway: { label: 'label.gateway' }, |
| |
| //netmask: { label: 'Netmask' }, |
| cidr: { label: 'label.cidr' }, |
| |
| networkdomaintext: { |
| label: 'label.network.domain.text' |
| }, |
| networkdomain: { |
| label: 'label.network.domain', |
| isEditable: true |
| }, |
| |
| domain: { label: 'label.domain' }, |
| account: { label: 'label.account' } |
| } |
| ], |
| dataProvider: function(args) { |
| $.ajax({ |
| url: createURL("listNetworks&id=" + args.context.networks[0].id + "&listAll=true"), //pass "&listAll=true" to "listNetworks&id=xxxxxxxx" for now before API gets fixed. |
| data: { listAll: true }, |
| dataType: "json", |
| async: true, |
| success: function(json) { |
| var jsonObj = json.listnetworksresponse.network[0]; |
| args.response.success( |
| { |
| actionFilter: cloudStack.actionFilter.guestNetwork, |
| data: jsonObj |
| } |
| ); |
| } |
| }); |
| } |
| }, |
| |
| acl: { |
| title: 'label.network.ACL', |
| custom: function(args) { |
| // Widget renders ACL multi-edit, overriding this fn |
| return $('<div>'); |
| } |
| }, |
| |
| ipAddresses: { |
| title: 'label.menu.ipaddresses', |
| custom: function(args) { |
| // Widget renders IP addresses, overriding this fn |
| return $('<div>'); |
| } |
| }, |
| |
| addloadBalancer: { |
| title: 'label.add.load.balancer', |
| custom: function(args) { |
| var context = args.context; |
| |
| return $('<div>').multiEdit( |
| { |
| context: context, |
| listView: $.extend(true, {}, cloudStack.sections.instances, { |
| listView: { |
| dataProvider: function(args) { |
| var networkid; |
| if('vpc' in args.context) |
| networkid = args.context.multiData.tier; |
| else |
| networkid = args.context.ipAddresses[0].associatednetworkid; |
| |
| var data = { |
| page: args.page, |
| pageSize: pageSize, |
| networkid: networkid, |
| listAll: true |
| }; |
| |
| $.ajax({ |
| url: createURL('listVirtualMachines'), |
| data: data, |
| dataType: 'json', |
| async: true, |
| success: function(data) { |
| args.response.success({ |
| data: $.grep( |
| data.listvirtualmachinesresponse.virtualmachine ? |
| data.listvirtualmachinesresponse.virtualmachine : [], |
| function(instance) { |
| return $.inArray(instance.state, [ |
| 'Destroyed' |
| ]) == -1; |
| } |
| ) |
| }); |
| }, |
| error: function(data) { |
| args.response.error(parseXMLHttpResponse(data)); |
| } |
| }); |
| } |
| } |
| }), |
| multipleAdd: true, |
| fields: { |
| 'name': { edit: true, label: 'label.name' }, |
| 'publicport': { edit: true, label: 'label.public.port' }, |
| 'privateport': { edit: true, label: 'label.private.port' }, |
| 'algorithm': { |
| label: 'label.algorithm', |
| select: function(args) { |
| args.response.success({ |
| data: [ |
| { name: 'roundrobin', description: _l('label.round.robin') }, |
| { name: 'leastconn', description: _l('label.least.connections') }, |
| { name: 'source', description: _l('label.source') } |
| ] |
| }); |
| } |
| }, |
| 'sticky': { |
| label: 'label.stickiness', |
| custom: { |
| buttonLabel: 'label.configure', |
| action: cloudStack.lbStickyPolicy.dialog() |
| } |
| }, |
| 'add-vm': { |
| label: 'label.add.vm', |
| addButton: true |
| } |
| }, |
| add: { |
| label: 'label.add.vm', |
| action: function(args) { |
| var data = { |
| algorithm: args.data.algorithm, |
| name: args.data.name, |
| privateport: args.data.privateport, |
| publicport: args.data.publicport, |
| openfirewall: false, |
| domainid: g_domainid, |
| account: g_account |
| }; |
| |
| if('vpc' in args.context) { //from VPC section |
| if(args.data.tier == null) { |
| args.response.error('Tier is required'); |
| return; |
| } |
| $.extend(data, { |
| networkid: args.data.tier |
| }); |
| } |
| else { //from Guest Network section |
| $.extend(data, { |
| networkid: args.context.networks[0].id |
| }); |
| } |
| |
| var stickyData = $.extend(true, {}, args.data.sticky); |
| |
| $.ajax({ |
| url: createURL('createLoadBalancerRule'), |
| data: data, |
| dataType: 'json', |
| async: true, |
| success: function(data) { |
| var itemData = args.itemData; |
| var jobID = data.createloadbalancerruleresponse.jobid; |
| |
| $.ajax({ |
| url: createURL('assignToLoadBalancerRule'), |
| data: { |
| id: data.createloadbalancerruleresponse.id, |
| virtualmachineids: $.map(itemData, function(elem) { |
| return elem.id; |
| }).join(',') |
| }, |
| dataType: 'json', |
| async: true, |
| success: function(data) { |
| var lbCreationComplete = false; |
| |
| args.response.success({ |
| _custom: { |
| jobId: jobID |
| }, |
| notification: { |
| label: 'label.add.load.balancer', |
| poll: function(args) { |
| var complete = args.complete; |
| var error = args.error; |
| |
| pollAsyncJobResult({ |
| _custom: args._custom, |
| complete: function(args) { |
| if (lbCreationComplete) { |
| return; |
| } |
| |
| lbCreationComplete = true; |
| cloudStack.dialog.notice({ |
| message: _l('message.add.load.balancer.under.ip') + |
| args.data.loadbalancer.publicip |
| }); |
| |
| if (stickyData && |
| stickyData.methodname && |
| stickyData.methodname != 'None') { |
| cloudStack.lbStickyPolicy.actions.add( |
| args.data.loadbalancer.id, |
| stickyData, |
| complete, // Complete |
| complete // Error |
| ); |
| } else { |
| complete(); |
| } |
| }, |
| error: error |
| }); |
| } |
| } |
| }); |
| }, |
| error: function(data) { |
| args.response.error(parseXMLHttpResponse(data)); |
| } |
| }); |
| }, |
| error: function(data) { |
| args.response.error(parseXMLHttpResponse(data)); |
| } |
| }); |
| } |
| }, |
| dataProvider: function(args) { |
| args.response.success({ //no LB listing in AddLoadBalancer tab |
| data: [] |
| }); |
| } |
| } |
| ); |
| } |
| } |
| } |
| }, //duplicate from cloudStack.sections.network.sections.networks.listView.detailView (begin) |
| |
| actionPreFilter: function(args) { |
| var tier = args.context.networks[0]; |
| var state = tier.state; |
| |
| return state == 'Running' ? ['start'] : ['stop']; |
| }, |
| actions: { |
| add: { |
| label: 'label.add.new.tier', |
| createForm: { |
| title: 'label.add.new.tier', |
| fields: { |
| name: { |
| label: 'label.name', |
| validation: { required: true }, |
| docID: 'helpTierName' |
| }, |
| networkOfferingId: { |
| label: 'label.network.offering', |
| docID: 'helpTierNetworkOffering', |
| validation: { required: true }, |
| dependsOn: 'zoneId', |
| select: function(args) { |
| var networkSupportingLbExists = false; |
| $.ajax({ |
| url: createURL('listNetworks'), |
| data: { |
| vpcid: args.context.vpc[0].id, |
| supportedservices: 'LB' |
| }, |
| success: function(json) { |
| var networkSupportingLbExists; |
| if(json.listnetworksresponse.network != null && json.listnetworksresponse.network.length > 0) |
| networkSupportingLbExists = true; |
| else |
| networkSupportingLbExists = false; |
| |
| $.ajax({ |
| url: createURL('listNetworkOfferings'), |
| data: { |
| forvpc: true, |
| zoneid: args.zoneId, |
| guestiptype: 'Isolated', |
| supportedServices: 'SourceNat', |
| specifyvlan: false, |
| state: 'Enabled' |
| }, |
| success: function(json) { |
| var networkOfferings = json.listnetworkofferingsresponse.networkoffering; |
| |
| var items; |
| if(networkSupportingLbExists == true) { |
| items = $.grep(networkOfferings, function(networkOffering) { |
| var includingLbService = false; |
| $(networkOffering.service).each(function(){ |
| var thisService = this; |
| if(thisService.name == "Lb") { |
| includingLbService = true; |
| return false; //break $.each() loop |
| } |
| }); |
| return !includingLbService; |
| }); |
| } |
| else { |
| items = networkOfferings; |
| } |
| |
| args.response.success({ |
| data: $.map(items, function(item) { |
| return { |
| id: item.id, |
| description: item.name |
| }; |
| }) |
| }); |
| } |
| }); |
| } |
| }); |
| } |
| }, |
| gateway: { |
| label: 'label.gateway', |
| docID: 'helpTierGateway', |
| validation: { required: true } |
| }, |
| netmask: { |
| label: 'label.netmask', |
| docID: 'helpTierNetmask', |
| validation: { required: true } |
| } |
| } |
| }, |
| action: function(args) { |
| var dataObj = { |
| zoneId: args.context.vpc[0].zoneid, |
| vpcid: args.context.vpc[0].id, |
| domainid: args.context.vpc[0].domainid, |
| account: args.context.vpc[0].account, |
| networkOfferingId: args.data.networkOfferingId, |
| name: args.data.name, |
| displayText: args.data.name, |
| gateway: args.data.gateway, |
| netmask: args.data.netmask |
| }; |
| |
| $.ajax({ |
| url: createURL('createNetwork'), |
| dataType: 'json', |
| data: dataObj, |
| success: function(json) { |
| args.response.success({ |
| data: json.createnetworkresponse.network |
| }); |
| }, |
| error: function(XMLHttpResponse) { |
| args.response.error(parseXMLHttpResponse(XMLHttpResponse)); |
| } |
| }); |
| }, |
| messages: { |
| notification: function() { return 'Add new tier'; } |
| } |
| }, |
| |
| /* |
| start: { |
| label: 'Start tier', |
| shortLabel: 'Start', |
| action: function(args) { |
| args.response.success(); |
| }, |
| notification: { |
| poll: function(args) { args.complete({ data: { state: 'Running' } }); } |
| } |
| }, |
| */ |
| |
| /* |
| stop: { |
| label: 'Stop tier', |
| shortLabel: 'Stop', |
| action: function(args) { |
| args.response.success(); |
| }, |
| notification: { |
| poll: function(args) { args.complete({ data: { state: 'Stopped' } }); } |
| } |
| }, |
| */ |
| |
| addVM: { |
| label: 'label.add.VM.to.tier', |
| shortLabel: 'label.add.vm', |
| action: cloudStack.uiCustom.instanceWizard( |
| $.extend(true, {}, cloudStack.instanceWizard, { |
| pluginForm: { |
| name: 'vpcTierInstanceWizard' |
| } |
| }) |
| ), |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| }, |
| |
| // Removing ACL buttons from the tier chart |
| /* acl: { |
| label: 'Configure ACL for tier', |
| shortLabel: 'ACL', |
| multiEdit: aclMultiEdit |
| }, */ |
| |
| remove: { |
| label: 'label.remove.tier', |
| action: function(args) { |
| $.ajax({ |
| url: createURL('deleteNetwork'), |
| dataType: "json", |
| data: { |
| id: args.context.networks[0].id |
| }, |
| success: function(json) { |
| var jid = json.deletenetworkresponse.jobid; |
| args.response.success( |
| {_custom: |
| {jobId: jid |
| } |
| } |
| ); |
| } |
| }); |
| }, |
| notification: { |
| poll: pollAsyncJobResult |
| } |
| } |
| }, |
| |
| // Get tiers |
| dataProvider: function(args) { |
| $.ajax({ |
| url: createURL("listNetworks"), |
| dataType: "json", |
| data: { |
| vpcid: args.context.vpc[0].id, |
| //listAll: true, //do not pass listAll to listNetworks under VPC |
| domainid: args.context.vpc[0].domainid, |
| account: args.context.vpc[0].account |
| }, |
| async: true, |
| success: function(json) { |
| var networks = json.listnetworksresponse.network; |
| if(networks != null && networks.length > 0) { |
| for(var i = 0; i < networks.length; i++) { |
| $.ajax({ |
| url: createURL("listVirtualMachines"), |
| dataType: "json", |
| data: { |
| networkid: networks[i].id, |
| listAll: true |
| }, |
| async: false, |
| success: function(json) { |
| networks[i].virtualMachines = json.listvirtualmachinesresponse.virtualmachine; |
| } |
| }); |
| } |
| } |
| args.response.success({ tiers: networks }); |
| } |
| }); |
| } |
| } |
| }; |
| }(jQuery, cloudStack)); |
