network.js

// 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 ipChangeNotice = function() {
    cloudStack.dialog.confirm({
      message: 'message.ip.address.changed',
      action: function() {
        $('#browser .container').cloudBrowser('selectPanel', {
          panel: $('#browser .panel:last').prev(),
          complete: function() {
            $(window).trigger('cloudStack.fullRefresh');
          }
        });
      }
    });
  };

  var zoneObjs = [];

  var actionFilters = {
    ipAddress: function(args) {
      var allowedActions = args.context.actions;
      var disallowedActions = [];
      var item = args.context.item;
      var status = item.state;   

      if (status == 'Destroyed' ||
          status == 'Releasing' ||
          status == 'Released' ||
          status == 'Creating' ||
          status == 'Allocating' ||
          item.account == 'system' ||
          item.issystem == true ) {
        return [];
      }
			
			if(item.networkOfferingConserveMode == false) {			 
				/*
				(1) If IP is SourceNat, no StaticNat/VPN/PortForwarding/LoadBalancer can be enabled/added. 
				*/
	      if (item.issourcenat == true){
					disallowedActions.push('enableStaticNAT');
					disallowedActions.push('enableVPN');
				}			
				
				/*
				(2) If IP is non-SourceNat, show StaticNat/VPN/PortForwarding/LoadBalancer at first.
				1. Once StaticNat is enabled, hide VPN/PortForwarding/LoadBalancer.
				2. Once VPN is enabled, hide StaticNat/PortForwarding/LoadBalancer.
				3. Once a PortForwarding rule is added, hide StaticNat/VPN/LoadBalancer.
				4. Once a LoadBalancer rule is added, hide StaticNat/VPN/PortForwarding.
				*/
				else { //item.issourcenat == false				   
					if (item.isstaticnat) { //1. Once StaticNat is enabled, hide VPN/PortForwarding/LoadBalancer.
					  disallowedActions.push('enableVPN');
					}
					if (item.vpnenabled) { //2. Once VPN is enabled, hide StaticNat/PortForwarding/LoadBalancer.
					  disallowedActions.push('enableStaticNAT');
					}
								 
					//3. Once a PortForwarding rule is added, hide StaticNat/VPN/LoadBalancer.
					$.ajax({
						url: createURL('listPortForwardingRules'),
						data: {
							ipaddressid: item.id,
							listAll: true
						},
						dataType: 'json',
						async: false,
						success: function(json) {							
							var rules = json.listportforwardingrulesresponse.portforwardingrule;
							if(rules != null && rules.length > 0) {
							  disallowedActions.push('enableVPN');
								disallowedActions.push('enableStaticNAT'); 
							}
						}
					});	
										
					//4. Once a LoadBalancer rule is added, hide StaticNat/VPN/PortForwarding.
					$.ajax({
						url: createURL('listLoadBalancerRules'),
						data: {
							publicipid: item.id,
							listAll: true
						},
						dataType: 'json',
						async: false,
						success: function(json) {
							var rules = json.listloadbalancerrulesresponse.loadbalancerrule;
							if(rules != null && rules.length > 0) {
							  disallowedActions.push('enableVPN');
								disallowedActions.push('enableStaticNAT'); 
							}
						}
					});		
				}			  				
			}			
			
      if (item.isstaticnat) {
        disallowedActions.push('enableStaticNAT');
      } else {
        disallowedActions.push('disableStaticNAT');
      }

			if(item.networkOfferingHavingVpnService == true) {      
        if (item.vpnenabled) {
          disallowedActions.push('enableVPN');
        } else {
          disallowedActions.push('disableVPN');
        }
      } else { //item.networkOfferingHavingVpnService == false
        disallowedActions.push('disableVPN');
        disallowedActions.push('enableVPN');
      }

      if (item.issourcenat){
        disallowedActions.push('enableStaticNAT');
        disallowedActions.push('disableStaticNAT');
        disallowedActions.push('remove');
      }

      allowedActions = $.grep(allowedActions, function(item) {
        return $.inArray(item, disallowedActions) == -1;
      });

      return allowedActions;
    },

    securityGroups: function(args) {
      var allowedActions = [];
      var isSecurityGroupOwner = isAdmin() || isDomainAdmin() ||
        args.context.item.account == args.context.users[0].account;

      if (isSecurityGroupOwner &&
          args.context.item.state != 'Destroyed' &&
          args.context.item.name != 'default') {
        allowedActions.push('remove');
      }

      return allowedActions;
    }
  };

	var networkOfferingObjs = [];
        var checkVpc=0; 	
  cloudStack.sections.network = {
    title: 'label.network',
    id: 'network',
    sectionSelect: {
      preFilter: function(args) {
        var havingSecurityGroupNetwork = false;
        var havingBasicZones = false;
        var havingAdvancedZones = true;

        // Get zone types
        $.ajax({
          url: createURL('listZones'),
          async: false,
          success: function(json) {
            var zones = json.listzonesresponse.zone ?
                  json.listzonesresponse.zone : [];
            var basicZones = $.grep(zones, function(zone) {
              return zone.networktype == 'Basic';
            });
            var advancedZones = $.grep(zones, function(zone) {
              return zone.networktype == 'Advanced';
            });

            
            havingBasicZones = basicZones.length ? true : false;
            havingAdvancedZones = advancedZones.length ? true : false;    
      }
        });
        
        $.ajax({
          url: createURL('listNetworks', { ignoreProject: true }),
          data: {
            supportedServices: 'SecurityGroup',
            listAll: true
          },
          async: false,
          success: function(data) {
            if (data.listnetworksresponse.network != null && data.listnetworksresponse.network.length > 0) {
              havingSecurityGroupNetwork = true;
            }
          }
        });

        var sectionsToShow = ['networks'];

        if (havingAdvancedZones) {
          sectionsToShow.push('vpc');
          sectionsToShow.push('vpnCustomerGateway');
        }
        
        if(havingSecurityGroupNetwork == true)
          sectionsToShow.push('securityGroups');

        return sectionsToShow;
      },

      label: 'label.select-view'
    },
    sections: {
      networks: {
        id: 'networks',
        type: 'select',
        title: 'label.guest.networks',
        listView: {
          actions: {
            add: {
              label: 'label.add.guest.network',

              preFilter: function(args) {
                var basicZoneExists = true; //Modifying the logic behind displaying the tabs depending on the networktype
                $.ajax({
                  url: createURL("listZones"),
                  dataType: "json",
                  async: false,
                  success: function(json) {
                    if(json.listzonesresponse.zone != null && json.listzonesresponse.zone.length > 0) {
                      zoneObjs = json.listzonesresponse.zone;
                      $(zoneObjs).each(function() {
                        if(this.networktype == "Advanced") {
                          basicZoneExists = false; // For any occurence of an Advanced zone with any combination of basic zone , the add guest network tab will be displayed
                          return false; //break each loop
                        }
                      });
                    }
                  }
                })
                return !basicZoneExists; //hide Add guest network button if any basic zone exists
              },

              createForm: {
                title: 'label.add.guest.network',
                desc: 'message.add.guest.network',
                fields: {
                  name: { label: 'label.name', validation: { required: true } },
                  displayText: { label: 'label.display.text', validation: { required: true }},
                  zoneId: {
                    label: 'label.zone',
                    validation: { required: true },


                    select: function(args) {
                      $.ajax({
                        url: createURL('listZones'),
                        success: function(json) {
                          var zones = $.grep(json.listzonesresponse.zone, function(zone) {
                            return zone.networktype == 'Advanced';
                          });

                          args.response.success({
                            data: $.map(zones, function(zone) {
                              return {
                                id: zone.id,
                                description: zone.name
                              };
                            })
                          });
                        }
                      });
                    }
                  },
                  networkOfferingId: {
                    label: 'label.network.offering',
                    validation: { required: true },
										dependsOn: 'zoneId',
                    select: function(args) {
                      $.ajax({
                        url: createURL('listVPCs'),
                        data: {
                          listAll: true
                        },
                        success: function(json) {
                          var items = json.listvpcsresponse.vpc;
                          var baseUrl = 'listNetworkOfferings&zoneid=' + args.zoneId;
                          var listUrl;
                          if(items != null && items.length > 0) 
                            listUrl = baseUrl;
                          else
                            listUrl = baseUrl + '&forVpc=false';
                          $.ajax({
                            url: createURL(listUrl),
                            data: {
                              guestiptype: 'Isolated',
                              supportedServices: 'SourceNat',
                              specifyvlan: false,
                              state: 'Enabled'
                            },
                            success: function(json) {
                              networkOfferingObjs = json.listnetworkofferingsresponse.networkoffering;
                              args.response.success({
                                data: $.map(networkOfferingObjs, function(zone) {
                                  return {
                                    id: zone.id,
                                    description: zone.name
                                  };
                                })
                              });
                            }
                          });                            
                        }
                      });
                    }
                  },

                  vpcid: {
                    label: 'label.vpc',
                    dependsOn: 'networkOfferingId',
                    select: function(args) {
                      var networkOfferingObj;
                      var $form = args.$select.closest('form');
                      $(networkOfferingObjs).each(function(key, value) {
                        if(value.id == args.networkOfferingId) {
                          networkOfferingObj = value;
                          return false; //break each loop
                        }
                      });
                      if(networkOfferingObj.forvpc == true) {
                        args.$select.closest('.form-item').css('display', 'inline-block');
                        $.ajax({
                          url: createURL('listVPCs'),
                          data: {
                            listAll: true
                          },
                          success: function(json) {
                            var items = json.listvpcsresponse.vpc;
                            var data;
                            if(items != null && items.length > 0) {
                              data = $.map(items, function(item) {
                                return {
                                  id: item.id,
                                  description: item.name
                                }
                              });
                            }
                            args.response.success({ data: data });
                          }
                        });
                        $form.find('.form-item[rel=networkDomain]').hide();
                      }
                      else {
                        args.$select.closest('.form-item').hide();
                        $form.find('.form-item[rel=networkDomain]').show();
                        args.response.success({ data: null });
                      }
                    }
                  },

                  guestGateway: { label: 'label.guest.gateway' },
                  guestNetmask: { label: 'label.guest.netmask' },
                  networkDomain: { label: 'label.network.domain' }
                }
              },
              action: function(args) {
                var dataObj = {
                  zoneId: args.data.zoneId,
                  name: args.data.name,
                  displayText: args.data.displayText,
                  networkOfferingId: args.data.networkOfferingId
                };		
		
                if(args.data.guestGateway != null && args.data.guestGateway.length > 0) {                  
                  $.extend(dataObj, {
                    gateway: args.data.guestGateway
                  });
                }								
                if(args.data.guestNetmask != null && args.data.guestNetmask.length > 0) {                  
                  $.extend(dataObj, {
                    netmask: args.data.guestNetmask
                  });									
                }								
                if(args.$form.find('.form-item[rel=vpcid]').css("display") != "none") {                 
                  $.extend(dataObj, {
                    vpcid: args.data.vpcid
                  });
                }
                if(args.data.networkDomain != null && args.data.networkDomain.length > 0 && args.$form.find('.form-item[rel=vpcid]').css("display") == "none") {
                  $.extend(dataObj, {
                    networkDomain: args.data.networkDomain
                  });                
                }
															
                $.ajax({
                  url: createURL('createNetwork'),
									data: dataObj,
                  success: function(json) {
                    args.response.success({
                      data: json.createnetworkresponse.network
                    });
                  },
                  error: function(json) {
                    args.response.error(parseXMLHttpResponse(json));
                  }
                });
              },
              messages: {
                notification: function() { return 'label.add.guest.network'; }
              }
            }
          },
          id: 'networks',
          fields: {
            name: { label: 'label.name' },
            account: { label: 'label.account' },
            //zonename: { label: 'label.zone' },
            type: { label: 'label.type' },
            vlan: { label: 'label.vlan' },
            cidr: { label: 'label.cidr' }
            /*
             state: {
             label: 'label.state',
             indicator: {
             'Implemented': 'on',
             'Setup': 'on',
             'Allocated': 'on',
             'Destroyed': 'off'
             }
             }
             */
          },
          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("listNetworks&page=" + args.page + "&pagesize=" + pageSize + array1.join("")),
              data: {
                listAll: true
              },
              dataType: 'json',
              async: false,
              success: function(data) {
                args.response.success({								  
                  data: data.listnetworksresponse.network
                });
              },
              error: function(data) {
                args.response.error(parseXMLHttpResponse(data));
              }
            });
          },

          detailView: {
            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};
                                  }
                                 }
                                }
                              );
                            }
                          });
                        },
                        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};
                                  }
                                 }
                                }
                              );
                            }
                          });
                        }
                      });
                      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};
                          }
                         }
                        }
                      );
                    }
                  });
                },
                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 = [];
              if(networkOfferingHavingELB == false)
                hiddenTabs.push("addloadBalancer");
              return hiddenTabs;
            },

            isMaximized: true,
            tabs: {
              details: {
                title: 'label.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: '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' },

                    vpcid: {
                      label: 'label.vpc.id',
                      converter: function(args) {
                        if(args != null)
												  return args;
												else
												  return 'N/A';
                      }											
										}
                  }
                ],

                tags: cloudStack.api.tags({ resourceType: 'Network', contextId: 'networks' }),

                
                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
												}
											);		
										}
									});			
                }
              },

              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: {
                          filters: false,
                          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','Expunging'
                                      ]) == -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.vms',
                          addButton: true
                        }
                      },
											
											
                      add: {  //basic zone - elastic IP - Add Load Balancer tab - Add VMs button
                        label: 'label.add.vms',
                        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, {