zoneWizard.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 selectedNetworkOfferingHavingSG = false;
  var selectedNetworkOfferingHavingEIP = false;
  var selectedNetworkOfferingHavingELB = false;
	var selectedNetworkOfferingHavingNetscaler = false;
  var returnedPublicVlanIpRanges = []; //public VlanIpRanges returned by API
  var configurationUseLocalStorage = false;
	var skipGuestTrafficStep = false;
  var selectedNetworkOfferingObj = {};
	var baremetalProviders = ["BaremetalDhcpProvider", "BaremetalPxeProvider", "BaremetaUserdataProvider"];
	var selectedBaremetalProviders = [];
	
  // Makes URL string for traffic label
  var trafficLabelParam = function(trafficTypeID, data, physicalNetworkID) {
    var zoneType = data.zone.networkType;
    var hypervisor = data.zone.hypervisor;
    physicalNetworkID = zoneType == 'Advanced' ? physicalNetworkID : 0;
    var physicalNetwork = data.physicalNetworks ? data.physicalNetworks[physicalNetworkID] : null;
    var trafficConfig = physicalNetwork ? physicalNetwork.trafficTypeConfiguration[trafficTypeID] : null;
    var trafficLabel = trafficConfig ? trafficConfig.label : null;
    var hypervisorAttr, trafficLabelStr;

    switch(hypervisor) {
      case 'XenServer':
        hypervisorAttr = 'xennetworklabel';
        break;
      case 'KVM':
        hypervisorAttr = 'kvmnetworklabel';
        break;
      case 'VMware':
        hypervisorAttr = 'vmwarenetworklabel';
        break;
      case 'BareMetal':
        hypervisorAttr = 'baremetalnetworklabel';
        break;
      case 'Ovm':
        hypervisorAttr = 'ovmnetworklabel';
        break;
    }

    trafficLabelStr = trafficLabel ? '&' + hypervisorAttr + '=' + trafficLabel : '';

    return trafficLabelStr;
  };

  cloudStack.zoneWizard = {
    // Return required traffic types, for configure physical network screen
    requiredTrafficTypes: function(args) {
      if (args.data.zone.networkType == 'Basic') {
			  if(selectedNetworkOfferingHavingEIP || selectedNetworkOfferingHavingELB) {
					return [
						'management',
						'guest',
						'public'
					];
				}
				else {
				  return [
						'management',
						'guest'
					];
				}
      } 
			else { // args.data.zone.networkType == 'Advanced'
			  if(args.data.zone.sgEnabled	!= true) {
					return [
						'management',
						'public',
						'guest'
					];
				}
				else {
				  return [
						'management',						
						'guest'
					];
				}
      } 			
    },

    disabledTrafficTypes: function(args) {
      if (args.data.zone.networkType == 'Basic') {
			  if(selectedNetworkOfferingHavingEIP || selectedNetworkOfferingHavingELB)
          return [];
				else
				  return ['public'];
      }
			else { // args.data.zone.networkType == 'Advanced'
			  if(args.data.zone.sgEnabled	!= true) {
          return [];
				}
				else {
				  return ['public'];
				}
      }
    },

    cloneTrafficTypes: function(args) {
      if (args.data.zone.networkType == 'Advanced') {
        return ['guest'];
      } else {
        return [];
      }
    },

    customUI: {
      publicTrafficIPRange: function(args) {
        var multiEditData = [];
        var totalIndex = 0;

        return $('<div>').multiEdit({
          context: args.context,
          noSelect: true,															
          fields: {
            'gateway': { edit: true, label: 'label.gateway' },
            'netmask': { edit: true, label: 'label.netmask' },
            'vlanid': { edit: true, label: 'label.vlan', isOptional: true },
            'startip': { edit: true, label: 'label.start.IP' },
            'endip': { edit: true, label: 'label.end.IP' },
            'add-rule': { label: 'label.add', addButton: true }
          },
          add: {
            label: 'label.add',
            action: function(args) {
              multiEditData.push($.extend(args.data, {
                index: totalIndex
              }));

              totalIndex++;
              args.response.success();
            }
          },
          actions: {
            destroy: {
              label: 'label.remove.rule',
              action: function(args) {
                multiEditData = $.grep(multiEditData, function(item) {
                  return item.index != args.context.multiRule[0].index;
                });
                args.response.success();
              }
            }
          },
          dataProvider: function(args) {
            args.response.success({
              data: multiEditData
            });
          }
        });
      },

      storageTrafficIPRange: function(args) {
        var multiEditData = [];
        var totalIndex = 0;

        return $('<div>').multiEdit({
          context: args.context,
          noSelect: true,
          fields: {
					  'gateway': { edit: true, label: 'label.gateway' },			
            'netmask': { edit: true, label: 'label.netmask' },
            'vlan': { edit: true, label: 'label.vlan', isOptional: true },
            'startip': { edit: true, label: 'label.start.IP' },
            'endip': { edit: true, label: 'label.end.IP' },
            'add-rule': { label: 'label.add', addButton: true }
          },
          add: {
            label: 'label.add',
            action: function(args) {
              multiEditData.push($.extend(args.data, {
                index: totalIndex
              }));

              totalIndex++;
              args.response.success();
            }
          },
          actions: {
            destroy: {
              label: 'label.remove.rule',
              action: function(args) {
                multiEditData = $.grep(multiEditData, function(item) {
                  return item.index != args.context.multiRule[0].index;
                });
                args.response.success();
              }
            }
          },
          dataProvider: function(args) {
            args.response.success({
              data: multiEditData
            });
          }
        });
      }
    },

    preFilters: {
		  addNetscalerDevice: function(args) { //add Netscaler
        var isShown;        
				if(selectedNetworkOfferingHavingNetscaler == true) {
          isShown = true;
          $('.conditional.netscaler').show();
        } else {
          isShown= false;
          $('.conditional.netscaler').hide();
        }
        return isShown;
      },
		
      addPublicNetwork: function(args) {		
        var isShown;
				var $publicTrafficDesc = $('.zone-wizard:visible').find('#add_zone_public_traffic_desc');	 
        if(args.data['network-model'] == 'Basic') {
          if(selectedNetworkOfferingHavingSG == true && selectedNetworkOfferingHavingEIP == true && selectedNetworkOfferingHavingELB == true) {
            isShown = true;
          }
          else {            
            isShown = false;
          }			
					
					$publicTrafficDesc.find('#for_basic_zone').css('display', 'inline');
					$publicTrafficDesc.find('#for_advanced_zone').hide();					
        }
        else { //args.data['network-model'] == 'Advanced'          
          if(args.data["zone-advanced-sg-enabled"] !=	"on")          
					  isShown = true;					
					else
					  isShown = false;
					
					$publicTrafficDesc.find('#for_advanced_zone').css('display', 'inline');
					$publicTrafficDesc.find('#for_basic_zone').hide();					
        }
        return isShown;
      },   

      setupPhysicalNetwork: function(args) {
        if (args.data['network-model'] == 'Basic' &&
            !(selectedNetworkOfferingHavingELB && selectedNetworkOfferingHavingEIP)) {
          $('.setup-physical-network .info-desc.conditional.basic').show();
          $('.setup-physical-network .info-desc.conditional.advanced').hide();
          $('.subnav li.public-network').hide();
        } else {
          $('.setup-physical-network .info-desc.conditional.basic').hide();
          $('.setup-physical-network .info-desc.conditional.advanced').show();
          $('.subnav li.public-network').show();
        }
        return true; // Both basic & advanced zones show physical network UI
      },

      configureGuestTraffic: function(args) {			  
        if ((args.data['network-model'] == 'Basic') || (args.data['network-model'] == 'Advanced' && args.data["zone-advanced-sg-enabled"] ==	"on")) {
          $('.setup-guest-traffic').addClass('basic');
          $('.setup-guest-traffic').removeClass('advanced');
					skipGuestTrafficStep = false; //set value
        } 
				else { //args.data['network-model'] == 'Advanced' && args.data["zone-advanced-sg-enabled"] !=	"on"
          $('.setup-guest-traffic').removeClass('basic');
          $('.setup-guest-traffic').addClass('advanced');
															
					//skip the step if OVS tunnel manager is enabled	
					skipGuestTrafficStep = false; //reset it before ajax call
					$.ajax({
						url: createURL('listConfigurations'),
						data: {
							name: 'sdn.ovs.controller'
						},
						dataType: "json",
						async: false,
						success: function(json) {					 
							var items = json.listconfigurationsresponse.configuration; //2 entries returned: 'sdn.ovs.controller', 'sdn.ovs.controller.default.label'
							$(items).each(function(){						  
								if(this.name == 'sdn.ovs.controller') {
									if(this.value == 'true' || this.value == true) {
										skipGuestTrafficStep = true;
									}
									return false; //break each loop
								}
							});						
						}
					});	
        }
				return !skipGuestTrafficStep;
      },

      configureStorageTraffic: function(args) {
        return $.grep(args.groupedData.physicalNetworks, function(network) {
          return $.inArray('storage', network.trafficTypes) > -1;
        }).length;
      },

      addHost: function(args) {		
        return (args.groupedData.zone.hypervisor != "VMware");
      },
						
			addPrimaryStorage: function(args) {
        return args.data.localstorageenabled != 'on';
      }	
    },

    forms: {
      zone: {
        preFilter: function(args) {
          var $form = args.$form;

          if (args.data['network-model'] == 'Basic') {
            args.$form.find('[rel=networkOfferingId]').show();
            args.$form.find('[rel=guestcidraddress]').hide();						
						args.$form.find('[rel=ip6dns1]').hide();
						args.$form.find('[rel=ip6dns2]').hide();
          }
          else { //args.data['network-model'] == 'Advanced'
            args.$form.find('[rel=networkOfferingId]').hide();
						
						if(args.data["zone-advanced-sg-enabled"] !=	"on")
              args.$form.find('[rel=guestcidraddress]').show();
						else //args.data["zone-advanced-sg-enabled"] ==	"on
						  args.$form.find('[rel=guestcidraddress]').hide();
          					  
						args.$form.find('[rel=ip6dns1]').show();
						args.$form.find('[rel=ip6dns2]').show();
					}													
										
          setTimeout(function() {
            if ($form.find('input[name=ispublic]').is(':checked')) {
              $form.find('[rel=domain]').hide();
            }
          });
        },
        fields: {
          name: {
            label: 'label.name', validation: { required: true },
            desc: 'message.tooltip.zone.name'
          },
          ip4dns1: {
            label: 'IPv4 DNS1', validation: { required: true },
            desc: 'message.tooltip.dns.1'
          },
          ip4dns2: {
            label: 'IPv4 DNS2',
            desc: 'message.tooltip.dns.2'
          },
                    
          ip6dns1: {
            label: 'IPv6 DNS1', 
            desc: 'message.tooltip.dns.1'
          },
          ip6dns2: {
            label: 'IPv6 DNS2',
            desc: 'message.tooltip.dns.2'
          },      
          
          internaldns1: {
            label: 'label.internal.dns.1', validation: { required: true },
            desc: 'message.tooltip.internal.dns.1'
          },
          internaldns2: {
            label: 'label.internal.dns.2',
            desc: 'message.tooltip.internal.dns.2'
          },
          hypervisor: {
            label: 'label.hypervisor',
            validation: { required: true },
            select: function(args) {
              $.ajax({
                url: createURL('listHypervisors'),
                async: false,
                data: { listAll: true },
                success: function(json) {								 
									var items = json.listhypervisorsresponse.hypervisor;
									var array1 = [];
									
									var firstOption = "XenServer";
									var nonSupportedHypervisors = {};									
									if(args.context.zones[0]['network-model']	== "Advanced" && args.context.zones[0]['zone-advanced-sg-enabled'] ==	"on") {
									  firstOption = "KVM";
										nonSupportedHypervisors["XenServer"] = 1;  //to developers: comment this line if you need to test Advanced SG-enabled zone with XenServer hypervisor
										nonSupportedHypervisors["VMware"] = 1;
										nonSupportedHypervisors["BareMetal"] = 1;
										nonSupportedHypervisors["Ovm"] = 1;
									}
									
									if(items != null) {
									  for(var i = 0; i < items.length; i++) {
										  if(items[i].name in nonSupportedHypervisors)
											  continue;
										
										  if(items[i].name == firstOption)
											  array1.unshift({id: items[i].name, description: items[i].name});
											else
											  array1.push({id: items[i].name, description: items[i].name});
										}
									}								  
                  args.response.success({
                    data: array1
                  });
                }
              });
            }
          },
          networkOfferingId: {
            label: 'label.network.offering',
						dependsOn: 'hypervisor',
            select: function(args) {
              var selectedNetworkOfferingObj = {};
              var networkOfferingObjs = [];
              
							args.$select.unbind("change").bind("change", function(){									  
								//reset when different network offering is selected
								selectedNetworkOfferingHavingSG = false;
								selectedNetworkOfferingHavingEIP = false;
								selectedNetworkOfferingHavingELB = false;
								selectedNetworkOfferingHavingNetscaler = false;
								
								var selectedNetworkOfferingId = $(this).val();  
								$(networkOfferingObjs).each(function(){
									if(this.id == selectedNetworkOfferingId) {
										selectedNetworkOfferingObj = this;
										return false; //break $.each() loop
									}
								});
								
								if(selectedNetworkOfferingObj.havingNetscaler == true)
									selectedNetworkOfferingHavingNetscaler = true;
								if(selectedNetworkOfferingObj.havingSG == true)
									selectedNetworkOfferingHavingSG = true;
								if(selectedNetworkOfferingObj.havingEIP == true)
									selectedNetworkOfferingHavingEIP = true;
								if(selectedNetworkOfferingObj.havingELB == true)
									selectedNetworkOfferingHavingELB = true;	
							});									
							

              $.ajax({
                url: createURL("listNetworkOfferings&state=Enabled&guestiptype=Shared"),
                dataType: "json",
                async: false,
                success: function(json) {
                  networkOfferingObjs = json.listnetworkofferingsresponse.networkoffering;
									var availableNetworkOfferingObjs = [];							
									$(networkOfferingObjs).each(function() {									  
										var thisNetworkOffering = this;
										$(this.service).each(function(){
											var thisService = this;
																								
											$(thisService.provider).each(function(){										
												if(this.name == "Netscaler") {
													thisNetworkOffering.havingNetscaler = true;													
												}												
												else if($.inArray(this.name, baremetalProviders) != -1) {												
												  selectedBaremetalProviders.push(this.name);
												}
											});													
										
											if(thisService.name == "SecurityGroup") {
												thisNetworkOffering.havingSG = true;
											}
											else if(thisService.name == "StaticNat") {
												$(thisService.capability).each(function(){
													if(this.name == "ElasticIp" && this.value == "true") {
														thisNetworkOffering.havingEIP = true;
														return false; //break $.each() loop
													}
												});
											}
											else if(thisService.name == "Lb") {
												$(thisService.capability).each(function(){
													if(this.name == "ElasticLb" && this.value == "true") {
														thisNetworkOffering.havingELB = true;
														return false; //break $.each() loop
													}
												});
											}
										});
										               
										if(thisNetworkOffering.havingEIP == true && thisNetworkOffering.havingELB == true) { //EIP ELB 
											if(args.hypervisor == "VMware" || args.hypervisor == "BareMetal") { //VMware, BareMetal don't support EIP ELB 
												return true; //move to next item in $.each() loop
											}
											if(args.context.zones[0]["network-model"]	== "Advanced" && args.context.zones[0]["zone-advanced-sg-enabled"] ==	"on") { // Advanced SG-enabled zone doesn't support EIP ELB 
											  return true; //move to next item in $.each() loop
											}
										}
																				
										if(args.context.zones[0]["network-model"]	== "Advanced" && args.context.zones[0]["zone-advanced-sg-enabled"] ==	"on") { // Advanced SG-enabled zone
										  if(thisNetworkOffering.havingSG != true) {
											  return true; //move to next item in $.each() loop
											}
										}
										
										availableNetworkOfferingObjs.push(thisNetworkOffering);										
									});																	
									
                  args.response.success({
                    data: $.map(availableNetworkOfferingObjs, function(offering) {
                      return {
                        id: offering.id,
                        description: offering.name
                      };
                    })
                  });		
                  
                }
              });										
            }
          },
          networkdomain: {
            label: 'label.network.domain',
            desc: 'message.tooltip.network.domain'
          },
          guestcidraddress: {
            label: 'label.guest.cidr',
            defaultValue: '10.1.1.0/24',
            validation: { required: false }
          },
          ispublic: {
            isReverse: true,
            isBoolean: true,
            label: 'label.public',
            isChecked: true //checked by default (public zone)
          },
          domain: {
            label: 'label.domain',
            dependsOn: 'ispublic',
            isHidden: true,
            select: function(args) {
              $.ajax({
                url: createURL("listDomains&listAll=true"),
                data: { viewAll: true },
                dataType: "json",
                async: false,
                success: function(json) {
                  domainObjs = json.listdomainsresponse.domain;
                  args.response.success({
                    data: $.map(domainObjs, function(domain) {
                      return {
                        id: domain.id,
                        description: domain.path
                      };
                    })
                  });
                }
              });
            }
          },
          localstorageenabled: {
            label: 'label.local.storage.enabled',
            isBoolean: true,
            onChange: function(args) {
              var $checkbox = args.$checkbox;

              if ($checkbox.is(':checked')) {
                cloudStack.dialog.confirm({
                  message: 'message.zoneWizard.enable.local.storage',
                  action: function() {
                    $checkbox.attr('checked', true);
                  },
                  cancelAction: function() {
                    $checkbox.attr('checked', false);
                  }
                });

                return false;
              }

              return true;
            }
          }
        }
      },

      pod: {
        fields: {
          name: {
            label: 'label.pod.name',
            validation: { required: true },
            desc: 'message.tooltip.pod.name'
          },
          reservedSystemGateway: {
            label: 'label.reserved.system.gateway',
            validation: { required: true },
            desc: 'message.tooltip.reserved.system.gateway'
          },
          reservedSystemNetmask: {
            label: 'label.reserved.system.netmask',
            validation: { required: true },
            desc: 'message.tooltip.reserved.system.netmask'
          },
          reservedSystemStartIp: {
            label: 'label.start.reserved.system.IP',
            validation: { required: true }
          },
          reservedSystemEndIp: {
            label: 'label.end.reserved.system.IP',
            validation: { required: false }
          }
        }
      },

      basicPhysicalNetwork: { //"Netscaler" now
        preFilter: function(args) {
          if (args.data['network-model'] == 'Basic' && (selectedNetworkOfferingHavingELB || selectedNetworkOfferingHavingEIP)) {
            args.$form.find('[rel=dedicated]').hide();
          } else {
            args.$form.find('[rel=dedicated]').show();
          };
          cloudStack.preFilter.addLoadBalancerDevice
        },
        fields: {
         ip: {
            label: 'label.ip.address'
          },
          username: {
            label: 'label.username'
          },
          password: {
            label: 'label.password',
            isPassword: true
          },
          networkdevicetype: {
            label: 'label.type',
            select: function(args) {
              var items = [];
              items.push({id: "NetscalerMPXLoadBalancer", description: "NetScaler MPX LoadBalancer"});
              items.push({id: "NetscalerVPXLoadBalancer", description: "NetScaler VPX LoadBalancer"});
              items.push({id: "NetscalerSDXLoadBalancer", description: "NetScaler SDX LoadBalancer"});
              args.response.success({data: items});
            }
          },
          publicinterface: {
            label: 'label.public.interface'
          },
          privateinterface: {
            label: 'label.private.interface'
          },
          numretries: {
            label: 'label.numretries',
            defaultValue: '2'
          },  
          dedicated: {
            label: 'label.dedicated',
            isBoolean: true,
            isChecked: false
          },
					capacity: {
            label: 'label.capacity',
            validation: { required: false, number: true }
          }
        }
      },

      guestTraffic: {
        preFilter: function(args) {				                 		
          var $guestTrafficDesc = $('.zone-wizard:visible').find('#add_zone_guest_traffic_desc');	 	          
					if ((args.data['network-model'] == 'Basic') || (args.data['network-model'] == 'Advanced' && args.data["zone-advanced-sg-enabled"] ==	"on")) {
						$guestTrafficDesc.find('#for_basic_zone').css('display', 'inline');
						$guestTrafficDesc.find('#for_advanced_zone').hide();
					}
					else { //args.data['network-model'] == 'Advanced' && args.data["zone-advanced-sg-enabled"] !=	"on"
						$guestTrafficDesc.find('#for_advanced_zone').css('display', 'inline');
						$guestTrafficDesc.find('#for_basic_zone').hide();
					}		
				
          var selectedZoneObj = {
            networktype: args.data['network-model']
          };          				
          					
					if (selectedZoneObj.networktype == 'Basic') {
					  args.$form.find('[rel="guestGateway"]').show();
						args.$form.find('[rel="guestNetmask"]').show();
						args.$form.find('[rel="guestStartIp"]').show();
						args.$form.find('[rel="guestEndIp"]').show();	
            args.$form.find('[rel="vlanId"]').hide();						
            args.$form.find('[rel="vlanRange"]').hide();						
					}
					else if(selectedZoneObj.networktype == 'Advanced' && args.data["zone-advanced-sg-enabled"] ==	"on") { 
					  args.$form.find('[rel="guestGateway"]').show();
						args.$form.find('[rel="guestNetmask"]').show();
						args.$form.find('[rel="guestStartIp"]').show();
						args.$form.find('[rel="guestEndIp"]').show();
            args.$form.find('[rel="vlanId"]').show();						
            args.$form.find('[rel="vlanRange"]').hide();	
					}					
					else if (selectedZoneObj.networktype == 'Advanced' && args.data["zone-advanced-sg-enabled"] !=	"on") { //this conditional statement is useless because the div will be replaced with other div(multiple tabs in Advanced zone without SG) later
					  args.$form.find('[rel="guestGateway"]').hide();
						args.$form.find('[rel="guestNetmask"]').hide();
						args.$form.find('[rel="guestStartIp"]').hide();
						args.$form.find('[rel="guestEndIp"]').hide();		
						args.$form.find('[rel="vlanId"]').hide();
            args.$form.find('[rel="vlanRange"]').show();	
					}					
        },

        fields: {          
          guestGateway: { label: 'label.guest.gateway' },  //Basic, Advanced with SG
          guestNetmask: { label: 'label.guest.netmask' },  //Basic, Advanced with SG
          guestStartIp: { label: 'label.guest.start.ip' }, //Basic, Advanced with SG
          guestEndIp: { label: 'label.guest.end.ip' },     //Basic, Advanced with SG
					vlanId: { label: 'VLAN ID' },              //Advanced with SG
             						
          vlanRange: { //in multiple tabs (tabs is as many as Guest Traffic types in multiple physical networks in Advanced Zone without SG)
            label: 'label.vlan.range',
            range: ['vlanRangeStart', 'vlanRangeEnd'],
            validation: { required: false, digits: true }  //Bug 13517 - AddZone wizard->Configure guest traffic: Vlan Range is optional
          }          
        }
      },
      cluster: {
        fields: {
          hypervisor: {
            label: 'label.hypervisor',
            select: function(args) {
              // Disable select -- selection is made on zone setup step
              args.$select.attr('disabled', 'disabled');

              $.ajax({
                url: createURL("listHypervisors"),
                dataType: "json",
                async: false,
                success: function(json) {
                  var hypervisors = json.listhypervisorsresponse.hypervisor;
                  var items = [];
                  $(hypervisors).each(function() {
                    items.push({id: this.name, description: this.name})
                  });
                  args.response.success({data: items});
                  args.$select.val(args.context.zones[0].hypervisor);
                  args.$select.change();
                }
              });

              var vSwitchEnabled = false;
              var dvSwitchEnabled = false;
              // Check whether vSwitch capability is enabled
              $.ajax({
                url: createURL('listConfigurations'),
                data: {
                  name: 'vmware.use.nexus.vswitch'
                },
                async: false,
                success: function(json) {
                  if (json.listconfigurationsresponse.configuration[0].value == 'true') {
                    vSwitchEnabled = true;
                  }
                }
              });

                 //Check whether dvSwitch is enabled or not
              $.ajax({
                 url: createURL('listConfigurations'),
                 data: {
                   name: 'vmware.use.dvswitch'
                      },
                 async: false,
                 success: function(json) {                                                                                                                                                                                if (json.listconfigurationsresponse.configuration[0].value == 'true') {                                                                                                                                   dvSwitchEnabled = true;
                                                                                                                                                                                                                          }
                  }                                                                                                                                                                                                                    });

              args.$select.bind("change", function(event) {
                var $form = $(this).closest('form');
                var $vsmFields = $form.find('[rel]').filter(function() {
                  var vsmFields = [
                    'vsmipaddress',
                    'vsmusername',
                    'vsmpassword'
                  ];

                  return $.inArray($(this).attr('rel'), vsmFields) > -1;
                }); 

                if($(this).val() == "VMware") {
                  //$('li[input_sub_group="external"]', $dialogAddCluster).show();
                  if(dvSwitchEnabled ){
                     /*   $form.find('.form-item[rel=vSwitchPublicType]').css('display', 'inline-block');
                        $form.find('.form-item[rel=vSwitchGuestType]').css('display', 'inline-block');
                       
                        $form.find('.form-item[rel=vSwitchPublicName]').css('display','inline-block');
                        $form.find('.form-item[rel=vSwitchGuestName]').css('display','inline-block');
                      
                       $form.find('.form-item[rel=overridepublictraffic]').find('input[type=checkbox]').css('display','inline-block');
                        $form.find('.form-item[rel=overrideguesttraffic]').find('input[type=checkbox]').css('display','inline-block');*/

                        $form.find('.form-item[rel=overridepublictraffic]').css('display','inline-block');
                          $form.find('.form-item[rel=overridepublictraffic]').find('input[type=checkbox]').removeAttr('checked');

                          $form.find('.form-item[rel=overrideguesttraffic]').css('display','inline-block');
                          $form.find('.form-item[rel=overrideguesttraffic]').find('input[type=checkbox]').removeAttr('checked');


 
                 }
                    else {
                     /*    $form.find('.form-item[rel=vSwitchPublicType]').css('display', 'none');
                         $form.find('.form-item[rel=vSwitchGuestType]').css('display', 'none');
                          $form.find('.form-item[rel=vSwitchPublicName]').css('display','none');
                          $form.find('.form-item[rel=vSwitchGuestName]').css('display','none');*/
                          $form.find('.form-item[rel=overridepublictraffic]').css('display','none');
                          $form.find('.form-item[rel=overrideguesttraffic]').css('display','none');

                      }
                                                                                                                     
                  $form.find('[rel=vCenterHost]').css('display', 'block');
                  $form.find('[rel=vCenterUsername]').css('display', 'block');
                  $form.find('[rel=vCenterPassword]').css('display', 'block');
                  $form.find('[rel=vCenterDatacenter]').css('display', 'block');

                  if (vSwitchEnabled) {
                    $vsmFields.css('display', 'block');
                  } else {
                    $vsmFields.css('display', 'none'); 
                  } 
                  //$("#cluster_name_label", $dialogAddCluster).text("vCenter Cluster:");
                }
                else {
                  //$('li[input_group="vmware"]', $dialogAddCluster).hide();
                  
                  $form.find('.form-item[rel=overridepublictraffic]').css('display', 'none');
                  $form.find('.form-item[rel=overrideguesttraffic]').css('display', 'none');
                  $form.find('.form-item[rel=vSwitchPublicType]').css('display', 'none');
                  $form.find('.form-item[rel=vSwitchGuestType]').css('display', 'none');
                  $form.find('.form-item[rel=vSwitchPublicName]').css('display','none');
                  $form.find('.form-item[rel=vSwitchGuestName]').css('display','none');


                  $form.find('[rel=vCenterHost]').css('display', 'none');
                  $form.find('[rel=vCenterUsername]').css('display', 'none');
                  $form.find('[rel=vCenterPassword]').css('display', 'none');
                  $form.find('[rel=vCenterDatacenter]').css('display', 'none');

                  //$("#cluster_name_label", $dialogAddCluster).text("Cluster:");
                }
              });
            }
          },
          name: {
            label: 'label.cluster.name',
            validation: { required: true }
          },

          //hypervisor==VMWare begins here
 
          vCenterHost: {
            label: 'label.vcenter.host',
            validation: { required: true }
          },
          vCenterUsername: {
            label: 'label.vcenter.username',
            validation: { required: true }
          },
          vCenterPassword: {
            label: 'label.vcenter.password',
            validation: { required: true },
            isPassword: true
          },
          vCenterDatacenter: {
            label: 'label.vcenter.datacenter',
            validation: { required: true }
          },

         overridepublictraffic:{
           label:'Override Public-Traffic',
           isBoolean:true,
           isHidden:true

             },


          vSwitchPublicType:{
                label: 'Public Traffic vSwitch Type',
                select: function(args) {
                    var items = []
                     var vSwitchEnabled = false;
                             $.ajax({
                        url: createURL('listConfigurations'),
                        data: {
                          name: 'vmware.use.nexus.vswitch'
                        },
                        async: false,
                        success: function(json) {
                          if (json.listconfigurationsresponse.configuration[0].value == 'true') {
                            vSwitchEnabled = true;
                          }
                        }
                      });

                            if(vSwitchEnabled) {

                              items.push({ id:"nexusdvs" , description: "Cisco Nexus 1000v Distributed Virtual Switch"});

                              items.push({id: "vmwaresvs", description: "VMware vNetwork Standard Virtual Switch"});
                              items.push({id: "vmwaredvs", description: "VMware vNetwork Distributed Virtual Switch"});




                              }

                  //  items.push({id: " ", description: " "});
                       else{
                     items.push({id:"vmwaredvs", description: "VMware vNetwork Distributed Virtual Switch"});
                    items.push({ id: "vmwaresvs", description: "VMware vNetwork Standard Virtual Switch"});
                    items.push({ id:"nexusdvs" , description: "Cisco Nexus 1000v Distributed Virtual Switch"});

                   }
                    args.response.success({data: items});
                    },
                    isHidden:true,
                    dependsOn:'overridepublictraffic'
                 },

          vSwitchPublicName:{
                label:'Public Traffic vSwitch Name',
                dependsOn:'overridepublictraffic',
                isHidden:true


                     },

           overrideguesttraffic:{
            label:'Override Guest-Traffic',
            isBoolean:true,
            isHidden:true

                  },


          vSwitchGuestType:{
               label: 'Guest Traffic vSwitch Type',
               select: function(args) {
               var items = []
              //items.push({ id:" ", description:" "});

                var vSwitchEnabled = false;
                            var items = []
                             $.ajax({
                        url: createURL('listConfigurations'),
                        data: {
                          name: 'vmware.use.nexus.vswitch'
                        },
                        async: false,
                        success: function(json) {
                          if (json.listconfigurationsresponse.configuration[0].value == 'true') {
                            vSwitchEnabled = true;
                          }
                        }
                      });

                            if(vSwitchEnabled) {

                              items.push({ id:"nexusdvs" , description: "Cisco Nexus 1000v Distributed Virtual Switch"});
                              items.push({id: "vmwaresvs", description: "VMware vNetwork Standard Virtual Switch"});
                              items.push({id: "vmwaredvs", description: "VMware vNetwork Distributed Virtual Switch"});




                              }
               else{

               items.push({id: "vmwaredvs", description: "VMware vNetwork Distributed Virtual Switch"});
               items.push({id: "vmwaresvs", description: "VMware vNetwork Standard Virtual Switch"});
               items.push({ id:"nexusdvs" , description: "Cisco Nexus 1000v Distributed Virtual Switch"});

                }
                                    args.response.success({data: items});

                                      },                                                                                                                                                                                                   isHidden:true,
           dependsOn:'overrideguesttraffic'

               },

         vSwitchGuestName:{
               label:'Guest Traffic vSwitch Name',
               dependsOn:'overrideguesttraffic',
               isHidden:true

               },

        //Cisco Nexus Vswitch 
          vsmipaddress: {
            label: 'Nexus 1000v IP Address',
            validation: { required: true },
            isHidden: true