cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From prachida...@apache.org
Subject [13/50] [abbrv] CLOUDSTACK-653 : High Availability: implement GSLB (Global Server Load Balancing) capability for ELB service
Date Fri, 29 Mar 2013 18:20:29 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/plugins/network-elements/netscaler/src/com/cloud/network/resource/NetscalerResource.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/netscaler/src/com/cloud/network/resource/NetscalerResource.java b/plugins/network-elements/netscaler/src/com/cloud/network/resource/NetscalerResource.java
index c09869b..b82176b 100644
--- a/plugins/network-elements/netscaler/src/com/cloud/network/resource/NetscalerResource.java
+++ b/plugins/network-elements/netscaler/src/com/cloud/network/resource/NetscalerResource.java
@@ -16,17 +16,6 @@
 // under the License.
 package com.cloud.network.resource;
 
-import java.util.ArrayList;
-import java.util.Formatter;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
-import javax.naming.ConfigurationException;
-
-import org.apache.log4j.Logger;
-
 import com.citrix.netscaler.nitro.exception.nitro_exception;
 import com.citrix.netscaler.nitro.resource.base.base_response;
 import com.citrix.netscaler.nitro.resource.config.autoscale.autoscalepolicy;
@@ -35,23 +24,10 @@ import com.citrix.netscaler.nitro.resource.config.basic.server_service_binding;
 import com.citrix.netscaler.nitro.resource.config.basic.service_lbmonitor_binding;
 import com.citrix.netscaler.nitro.resource.config.basic.servicegroup;
 import com.citrix.netscaler.nitro.resource.config.basic.servicegroup_lbmonitor_binding;
-import com.citrix.netscaler.nitro.resource.config.lb.lbmetrictable;
-import com.citrix.netscaler.nitro.resource.config.lb.lbmetrictable_metric_binding;
-import com.citrix.netscaler.nitro.resource.config.lb.lbmonitor;
-import com.citrix.netscaler.nitro.resource.config.lb.lbmonitor_metric_binding;
-import com.citrix.netscaler.nitro.resource.config.lb.lbvserver;
-import com.citrix.netscaler.nitro.resource.config.lb.lbvserver_service_binding;
-import com.citrix.netscaler.nitro.resource.config.lb.lbvserver_servicegroup_binding;
-import com.citrix.netscaler.nitro.resource.config.network.Interface;
-import com.citrix.netscaler.nitro.resource.config.network.inat;
-import com.citrix.netscaler.nitro.resource.config.network.vlan;
-import com.citrix.netscaler.nitro.resource.config.network.vlan_interface_binding;
-import com.citrix.netscaler.nitro.resource.config.network.vlan_nsip_binding;
-import com.citrix.netscaler.nitro.resource.config.ns.nsconfig;
-import com.citrix.netscaler.nitro.resource.config.ns.nshardware;
-import com.citrix.netscaler.nitro.resource.config.ns.nsip;
-import com.citrix.netscaler.nitro.resource.config.ns.nstimer;
-import com.citrix.netscaler.nitro.resource.config.ns.nstimer_autoscalepolicy_binding;
+import com.citrix.netscaler.nitro.resource.config.gslb.*;
+import com.citrix.netscaler.nitro.resource.config.lb.*;
+import com.citrix.netscaler.nitro.resource.config.network.*;
+import com.citrix.netscaler.nitro.resource.config.ns.*;
 import com.citrix.netscaler.nitro.resource.stat.lb.lbvserver_stats;
 import com.citrix.netscaler.nitro.service.nitro_service;
 import com.citrix.netscaler.nitro.util.filtervalue;
@@ -60,38 +36,12 @@ import com.citrix.sdx.nitro.resource.config.mps;
 import com.citrix.sdx.nitro.resource.config.ns;
 import com.citrix.sdx.nitro.resource.config.xen_vpx_image;
 import com.cloud.agent.IAgentControl;
-import com.cloud.agent.api.Answer;
-import com.cloud.agent.api.Command;
-import com.cloud.agent.api.ExternalNetworkResourceUsageAnswer;
-import com.cloud.agent.api.ExternalNetworkResourceUsageCommand;
-import com.cloud.agent.api.MaintainAnswer;
-import com.cloud.agent.api.MaintainCommand;
-import com.cloud.agent.api.PingCommand;
-import com.cloud.agent.api.ReadyAnswer;
-import com.cloud.agent.api.ReadyCommand;
-import com.cloud.agent.api.StartupCommand;
-import com.cloud.agent.api.StartupExternalLoadBalancerCommand;
-import com.cloud.agent.api.routing.CreateLoadBalancerApplianceCommand;
-import com.cloud.agent.api.routing.DestroyLoadBalancerApplianceCommand;
-import com.cloud.agent.api.routing.HealthCheckLBConfigAnswer;
-import com.cloud.agent.api.routing.HealthCheckLBConfigCommand;
-import com.cloud.agent.api.routing.IpAssocAnswer;
-import com.cloud.agent.api.routing.IpAssocCommand;
-import com.cloud.agent.api.routing.LoadBalancerConfigCommand;
-import com.cloud.agent.api.routing.SetStaticNatRulesAnswer;
-import com.cloud.agent.api.routing.SetStaticNatRulesCommand;
+import com.cloud.agent.api.*;
+import com.cloud.agent.api.routing.*;
 import com.cloud.agent.api.to.IpAddressTO;
 import com.cloud.agent.api.to.LoadBalancerTO;
-import com.cloud.agent.api.to.LoadBalancerTO.AutoScalePolicyTO;
-import com.cloud.agent.api.to.LoadBalancerTO.AutoScaleVmGroupTO;
-import com.cloud.agent.api.to.LoadBalancerTO.AutoScaleVmProfileTO;
-import com.cloud.agent.api.to.LoadBalancerTO.ConditionTO;
-import com.cloud.agent.api.to.LoadBalancerTO.CounterTO;
-import com.cloud.agent.api.to.LoadBalancerTO.DestinationTO;
-import com.cloud.agent.api.to.LoadBalancerTO.HealthCheckPolicyTO;
-import com.cloud.agent.api.to.LoadBalancerTO.StickinessPolicyTO;
+import com.cloud.agent.api.to.LoadBalancerTO.*;
 import com.cloud.agent.api.to.StaticNatRuleTO;
-import org.apache.cloudstack.api.ApiConstants;
 import com.cloud.host.Host;
 import com.cloud.host.Host.Type;
 import com.cloud.network.rules.LbStickinessMethod.StickinessMethodType;
@@ -102,6 +52,11 @@ import com.cloud.utils.Pair;
 import com.cloud.utils.exception.ExecutionException;
 import com.cloud.utils.net.NetUtils;
 import com.google.gson.Gson;
+import org.apache.cloudstack.api.ApiConstants;
+import org.apache.log4j.Logger;
+
+import javax.naming.ConfigurationException;
+import java.util.*;
 
 class NitroError {
     static final int NS_RESOURCE_EXISTS = 273;
@@ -109,6 +64,7 @@ class NitroError {
     static final int NS_NO_SERIVCE = 344;
     static final int NS_OPERATION_NOT_PERMITTED = 257;
     static final int NS_INTERFACE_ALREADY_BOUND_TO_VLAN = 2080;
+    static final int NS_GSLB_DOMAIN_ALREADY_BOUND = 1842;
 }
 
 public class NetscalerResource implements ServerResource {
@@ -401,9 +357,11 @@ public class NetscalerResource implements ServerResource {
             return execute((DestroyLoadBalancerApplianceCommand) cmd, numRetries);
         } else if (cmd instanceof SetStaticNatRulesCommand) {
             return execute((SetStaticNatRulesCommand) cmd, numRetries);
+        } else if (cmd instanceof GlobalLoadBalancerConfigCommand) {
+            return execute((GlobalLoadBalancerConfigCommand) cmd, numRetries);
         } else if (cmd instanceof HealthCheckLBConfigCommand) {
            return execute((HealthCheckLBConfigCommand) cmd, numRetries);
-        }else {
+        } else {
             return Answer.createUnsupportedCommandAnswer(cmd);
         }
     }
@@ -896,6 +854,592 @@ public class NetscalerResource implements ServerResource {
         }
     }
 
+    private Answer execute(GlobalLoadBalancerConfigCommand gslbCmd, int numRetries) {
+
+        String lbMethod = gslbCmd.getLoadBalancerMethod();
+        String persistenceType = gslbCmd.getPersistenceType();
+        String serviceType = gslbCmd.getServiceType();
+        boolean forRevoke = gslbCmd.isForRevoke();
+        long gslbId = gslbCmd.getGslbId();
+        List<SiteLoadBalancerConfig> sites = gslbCmd.getSiteDetails();
+
+        String domainName = gslbCmd.getDomainName();
+        String vserverName = GSLB.generateVirtualServerName(domainName);
+
+        try {
+
+            if (!forRevoke) { //check if the global load balancer rule is being added
+
+                // Add a GSLB virtual server
+                GSLB.createVirtualServer(_netscalerService, vserverName, lbMethod, persistenceType, gslbId, serviceType);
+
+                if (sites != null) { // check if there are any sites that are participating in global load balancing
+                    for (SiteLoadBalancerConfig site : sites) {
+
+                        String sitePrivateIP = site.getGslbProviderPrivateIp();
+                        String sitePublicIP =  site.getGslbProviderPublicIp();
+                        String servicePublicIp = site.getServicePublicIp();
+                        String servicePublicPort = site.getServicePort();
+                        String siteName = GSLB.generateUniqueSiteName(sitePrivateIP, sitePublicIP, site.getDataCenterId());
+
+                        // Add/Delete GSLB local and remote sites that are part of GSLB virtual server
+                        if (!site.forRevoke()) {
+                            String siteType = (site.isLocal()) ? "LOCAL" : "REMOTE";
+                            if (GSLB.getSiteObject(_netscalerService, siteName) != null) {
+                                GSLB.updateSite(_netscalerService, siteType, siteName, site.getGslbProviderPrivateIp(),
+                                        site.getGslbProviderPublicIp());
+                            } else {
+                                GSLB.createSite(_netscalerService, siteName, siteType, site.getGslbProviderPrivateIp(),
+                                        site.getGslbProviderPublicIp());
+                            }
+                        }
+
+                        // Add/Delete GSLB service corresponding the service running on each site
+                        String serviceName = GSLB.generateUniqueServiceName(siteName, servicePublicIp, servicePublicPort);
+                        if (!site.forRevoke()) {
+                            // create a 'gslbservice' object
+                            GSLB.createService(_netscalerService, serviceName, site.getServiceType(),
+                                    servicePublicIp, servicePublicPort, siteName);
+
+                            // Bind 'gslbservice' service object to GSLB virtual server
+                            GSLB.createVserverServiceBinding(_netscalerService, serviceName, vserverName);
+
+                        } else {
+                            // Unbind GSLB service with GSLB virtual server
+                            GSLB.deleteVserverServiceBinding(_netscalerService, serviceName, vserverName);
+
+                            // delete 'gslbservice' object
+                            gslbservice service = GSLB.getServiceObject(_netscalerService, serviceName);
+                            GSLB.deleteService(_netscalerService, serviceName);
+                        }
+
+                        if (site.forRevoke()) { // delete the site if its for revoke
+                            GSLB.deleteSite(_netscalerService, siteName);
+                        }
+                    }
+                }
+
+                // Bind GSLB vserver to domain
+                GSLB.createVserverDomainBinding(_netscalerService, vserverName, domainName);
+
+            } else {  // global load balancer rule is being deleted, so clean up all objects created
+
+                // remove binding between virtual server and the domain name
+                GSLB.deleteVserverDomainBinding(_netscalerService, vserverName, domainName);
+
+                if (sites != null) {
+                    for (SiteLoadBalancerConfig site : sites) {
+
+                        String sitePrivateIP = site.getGslbProviderPrivateIp();
+                        String sitePublicIP =  site.getGslbProviderPublicIp();
+                        String servicePublicIp = site.getServicePublicIp();
+                        String servicePublicPort = site.getServicePort();
+                        String siteName = GSLB.generateUniqueSiteName(sitePrivateIP, sitePublicIP, site.getDataCenterId());
+
+                        // remove binding between virtual server and services
+                        String serviceName = GSLB.generateUniqueServiceName(siteName, servicePublicIp, servicePublicPort);
+                        GSLB.deleteVserverServiceBinding(_netscalerService, serviceName, vserverName);
+
+                        // delete service object
+                        GSLB.deleteService(_netscalerService, serviceName);
+
+                        // delete GSLB site object
+                        GSLB.deleteSite(_netscalerService, siteName);
+                    }
+                }
+
+                // delete GSLB virtual server
+                GSLB.deleteVirtualServer(_netscalerService, vserverName);
+            }
+
+            saveConfiguration();
+
+        } catch (Exception e) {
+            String errMsg =  "Failed to apply GSLB configuration due to " + e.getMessage();
+            if (shouldRetry(numRetries)) {
+                return retry(gslbCmd, numRetries);
+            }
+            return new GlobalLoadBalancerConfigAnswer(false, errMsg);
+        }
+
+        return new GlobalLoadBalancerConfigAnswer(true, "Successfully applied GSLB configuration.");
+    }
+
+    /*
+     * convenience class to create/update/delete/get the GSLB specific NetScaler objects
+     *     - gslbsite
+     *     - gslbvserver
+     *     - gslbservice
+     *     - vserver-service binding
+     *     - vserver-domain bindings
+     */
+    private static class GSLB {
+
+        // create a 'gslbsite' object representing a site
+        private static void createSite(nitro_service client, String siteName,
+                                       String siteType, String siteIP, String sitePublicIP) throws  ExecutionException{
+            try {
+                gslbsite site;
+                site = getSiteObject(client, siteName);
+
+                boolean isUpdateSite = false;
+                if (site == null) {
+                    site = new gslbsite();
+                } else {
+                    isUpdateSite = true;
+                }
+
+                assert("LOCAL".equalsIgnoreCase(siteType) || "REMOTE".equalsIgnoreCase(siteType));
+                site.set_sitetype(siteType);
+                site.set_sitename(siteName);
+                site.set_siteipaddress(siteIP);
+                site.set_publicip(sitePublicIP);
+                site.set_metricexchange("ENABLED");
+                site.set_nwmetricexchange("ENABLED");
+                site.set_sessionexchange("ENABLED");
+                if (isUpdateSite) {
+                    gslbsite.update(client, site);
+                } else {
+                    gslbsite.add(client, site);
+                }
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Successfully created GSLB site: " + siteName);
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to create GSLB site: " + siteName + " due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // delete 'gslbsite' object representing a site
+        private static void deleteSite(nitro_service client, String siteName) throws ExecutionException{
+            try {
+                gslbsite site = getSiteObject(client, siteName);
+                if (site != null) {
+                    gslbsite_gslbservice_binding[] serviceBindings = gslbsite_gslbservice_binding.get(client, siteName);
+                    if (serviceBindings != null && serviceBindings.length > 0) {
+                        if (s_logger.isDebugEnabled()) {
+                            s_logger.debug("There are services associated with GSLB site: "
+                                    + siteName + " so ignoring site deletion");
+                        }
+                    }
+                    gslbsite.delete(client, siteName);
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.debug("Successfully deleted GSLB site: " + siteName);
+                    }
+                } else {
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.warn("Ignoring delete request for non existing  GSLB site: " + siteName);
+                    }
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to delete GSLB site: " + siteName + " due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // update 'gslbsite' object representing a site
+        private static void updateSite(nitro_service client, String siteType, String siteName,
+                                       String siteIP, String sitePublicIP) throws ExecutionException {
+            try {
+                gslbsite site;
+                site = getSiteObject(client, siteName);
+                if (site == null) {
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.warn("Ignoring update request for non existing  GSLB site: " + siteName);
+                    }
+                    return;
+                }
+                assert ("LOCAL".equalsIgnoreCase(siteType) || "REMOTE".equalsIgnoreCase(siteType));
+                site.set_sitetype(siteType);
+                site.set_sitename(siteName);
+                site.set_siteipaddress(siteIP);
+                site.set_publicip(sitePublicIP);
+                site.set_metricexchange("ENABLED");
+                site.set_nwmetricexchange("ENABLED");
+                site.set_sessionexchange("ENABLED");
+                gslbsite.update(client, site);
+
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Successfully updated GSLB site: " + siteName);
+                }
+
+            } catch (Exception e) {
+                String errMsg = "Failed to update GSLB site: " + siteName + " due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // create a 'gslbvserver' object representing a globally load balanced service
+        private static void createVirtualServer(nitro_service client, String vserverName, String lbMethod,
+                                         String persistenceType, long persistenceId, String serviceType)
+                    throws ExecutionException {
+            try {
+                gslbvserver vserver;
+                vserver = getVserverObject(client, vserverName);
+
+                boolean isUpdateSite = false;
+                if (vserver == null) {
+                    vserver = new gslbvserver();
+                } else {
+                    isUpdateSite = true;
+                }
+
+                vserver.set_name(vserverName);
+                vserver.set_lbmethod(lbMethod);
+                vserver.set_persistencetype(persistenceType);
+                if ("SOURCEIP".equalsIgnoreCase(persistenceType)) {
+                    vserver.set_persistenceid(persistenceId);
+                }
+                vserver.set_servicetype(serviceType);
+                vserver.set_state("ENABLED");
+                vserver.set_cookietimeout(null);
+                vserver.set_domainname(null);
+                if (isUpdateSite) {
+                    if ("roundrobin".equalsIgnoreCase(lbMethod)) {
+                        vserver.set_netmask(null);
+                        vserver.set_v6netmasklen(null);
+                    }
+                    gslbvserver.update(client, vserver);
+                } else {
+                    gslbvserver.add(client, vserver);
+                }
+
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Successfully added GSLB virtual server: " + vserverName);
+                }
+
+            } catch (Exception e) {
+                String errMsg = "Failed to add GSLB virtual server: " + vserverName + " due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // delete 'gslbvserver' object representing a globally load balanced service
+        private static void deleteVirtualServer(nitro_service client, String vserverName) throws  ExecutionException {
+            try {
+                gslbvserver vserver = getVserverObject(client, vserverName);
+                if (vserver != null) {
+                    gslbvserver.delete(client, vserver);
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.debug("Successfully deleted GSLB virtual server: " + vserverName);
+                    }
+                } else {
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.warn("Ignoring delete request for non existing  GSLB virtual server: " + vserverName);
+                    }
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to delete GSLB virtual server: " + vserverName + " due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // enable 'gslbvserver' object representing a globally load balanced service
+        private static void enableVirtualServer(nitro_service client, String vserverName) throws ExecutionException {
+            try {
+                gslbvserver vserver = getVserverObject(client, vserverName);
+                if (vserver != null) {
+                    gslbvserver.enable(client, vserver);
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to enable GSLB virtual server: " + vserverName + " due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // disable 'gslbvserver' object representing a globally load balanced service
+        private static void disableVirtualServer(nitro_service client, String vserverName) throws ExecutionException{
+            try {
+                gslbvserver vserver = getVserverObject(client, vserverName);
+                if (vserver != null) {
+                    gslbvserver.disable(client, vserver);
+                }
+            } catch (Exception e) {
+                String errMsg =  "Failed to disable GSLB virtual server: " + vserverName + " due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // update 'gslbvserver' object representing a globally load balanced service
+        private static void updateVirtualServer(nitro_service client, String vserverName, String lbMethod,
+                                                String persistenceType, String serviceType) throws ExecutionException {
+            try {
+                gslbvserver vServer = getVserverObject(client, vserverName);
+                if (vServer != null) {
+                    vServer.set_lbmethod(lbMethod);
+                    vServer.set_persistencetype(persistenceType);
+                    vServer.set_servicetype(serviceType);
+                    gslbvserver.update(client, vServer);
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.debug("Successfully updated GSLB virtual server: " + vserverName);
+                    }
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to update GSLB virtual server: " + vserverName + " due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // create, delete, update, get the GSLB services
+        private static void createService(nitro_service client, String serviceName, String serviceType, String serviceIp,
+                                   String servicePort, String siteName) throws ExecutionException{
+            try {
+                gslbservice service;
+                service = getServiceObject(client, serviceName);
+
+                boolean isUpdateSite = false;
+                if (service == null) {
+                    service = new gslbservice();
+                } else {
+                    isUpdateSite = true;
+                }
+
+                service.set_sitename(siteName);
+                service.set_servername(serviceIp);
+                int port = Integer.parseInt(servicePort);
+                service.set_port(port);
+                service.set_servicename(serviceName);
+                service.set_servicetype(serviceType);
+                if (isUpdateSite) {
+                    service.set_viewip(null);
+                    service.set_viewname(null);
+                    gslbservice.update(client, service);
+                } else {
+                    gslbservice.add(client, service);
+                }
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Successfully created service: " + serviceName + " at site: " + siteName);
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to created service: " + serviceName + " at site: " + siteName;
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        private static void deleteService(nitro_service client, String serviceName) throws ExecutionException {
+            try {
+                gslbservice service = getServiceObject(client, serviceName);
+                if (service != null) {
+                    gslbservice.delete(client, serviceName);
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.debug("Successfully deleted service: " + serviceName);
+                    }
+                } else {
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.warn("Ignoring delete request for non existing  service: " + serviceName);
+                    }
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to delete service: " + serviceName + " due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        private static void updateService(nitro_service client, String serviceName, String serviceType, String publicIp,
+                                          String publicPort, String siteName) throws ExecutionException {
+            try {
+                gslbservice service;
+                service = getServiceObject(client, serviceName);
+
+                if (service != null) {
+                    service.set_sitename(siteName);
+                    service.set_publicip(publicIp);
+                    service.set_publicport(Integer.getInteger(publicPort));
+                    service.set_servicename(serviceName);
+                    service.set_servicetype(serviceType);
+                    gslbservice.update(client, service);
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.debug("Successfully updated service: " + serviceName + " at site: " + siteName);
+                    }
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to update service: " + serviceName + " at site: " + siteName;
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        private static void createVserverServiceBinding(nitro_service client, String serviceName, String vserverName)
+                    throws ExecutionException {
+            try {
+                gslbvserver_gslbservice_binding binding = new gslbvserver_gslbservice_binding();
+                binding.set_name(vserverName);
+                binding.set_servicename(serviceName);
+                gslbvserver_gslbservice_binding.add(client, binding);
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Successfully created service: " + serviceName + " and virtual server: "
+                            + vserverName + " binding");
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to create service: " + serviceName + " and virtual server: "
+                        + vserverName + " binding due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        private static void deleteVserverServiceBinding(nitro_service client, String serviceName, String vserverName)
+                    throws  ExecutionException {
+            try {
+                gslbvserver_gslbservice_binding[] bindings = gslbvserver_gslbservice_binding.get(client, vserverName);
+                if (bindings != null) {
+                    for (gslbvserver_gslbservice_binding binding: bindings) {
+                        if (binding.get_servicename().equalsIgnoreCase(serviceName) &&
+                                binding.get_name().equals(vserverName)) {
+                            gslbvserver_gslbservice_binding.delete(client, binding);
+                            if (s_logger.isDebugEnabled()) {
+                                s_logger.debug("Successfully deleted service: " + serviceName + " and virtual server: "
+                                        + vserverName + " binding");
+                            }
+                            break;
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to create service: " + serviceName + " and virtual server: "
+                        + vserverName + " binding due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // create, delete GSLB virtual server and domain bindings
+        private static void createVserverDomainBinding(nitro_service client, String vserverName, String domainName)
+                    throws ExecutionException {
+            String errMsg;
+            try {
+                gslbvserver_domain_binding binding = new gslbvserver_domain_binding();
+                binding.set_domainname(domainName);
+                binding.set_name(vserverName);
+                gslbvserver_domain_binding.add(client, binding);
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Successfully added virtual server: "
+                            + vserverName + " domain name: " + domainName + " binding");
+                }
+                return;
+            } catch (nitro_exception e) {
+                if (e.getErrorCode() == NitroError.NS_GSLB_DOMAIN_ALREADY_BOUND) {
+                    return;
+                }
+                errMsg = e.getMessage();
+            } catch (Exception e) {
+                errMsg = e.getMessage();
+            }
+            errMsg = "Failed to create virtual server: " + vserverName + " domain name: " + domainName + " binding" + errMsg;
+            if (s_logger.isDebugEnabled()) {
+                s_logger.debug(errMsg);
+            }
+            throw new ExecutionException(errMsg);
+        }
+
+        private static void deleteVserverDomainBinding(nitro_service client, String vserverName, String domainName)
+                        throws ExecutionException {
+            try {
+                gslbvserver_domain_binding[] bindings = gslbvserver_domain_binding.get(client, vserverName);
+                if (bindings != null) {
+                    for (gslbvserver_domain_binding binding: bindings) {
+                        if (binding.get_domainname().equalsIgnoreCase(domainName)) {
+                            gslbvserver_domain_binding.delete(client, binding);
+                            if (s_logger.isDebugEnabled()) {
+                                s_logger.debug("Successfully deleted virtual server: " + vserverName + " and "
+                                        + " domain: " + domainName + " binding");
+                            }
+                            break;
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                String errMsg = "Failed to delete virtual server: "
+                        + vserverName + " and domain " + domainName +" binding due to " + e.getMessage();
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug(errMsg);
+                }
+                throw new ExecutionException(errMsg);
+            }
+        }
+
+        // get 'gslbsite' object corresponding to a site name
+        private static gslbsite getSiteObject(nitro_service client, String siteName) {
+            try {
+                gslbsite site = gslbsite.get(client, siteName);
+                if (site != null) {
+                    return site;
+                }
+            } catch (Exception e) {
+
+            }
+            return null;
+        }
+
+        private static gslbvserver getVserverObject(nitro_service client, String vserverName) {
+            try {
+                gslbvserver vserver = gslbvserver.get(client, vserverName);
+                return vserver;
+            } catch (Exception e) {
+                return null;
+            }
+        }
+
+        private static gslbservice getServiceObject(nitro_service client, String serviceName) {
+            try {
+                gslbservice service = gslbservice.get(client, serviceName);
+                return service;
+            } catch (Exception e) {
+                return null;
+            }
+        }
+
+        private static String generateUniqueSiteName(String sitePrivateIp, String sitePublicIP, long dataCenterId) {
+            return "cloudsite" + String.valueOf(dataCenterId);
+        }
+
+        private static String generateVirtualServerName(String domainName) {
+            return "cloud-gslb-vserver-" + domainName;
+        }
+
+        private static String generateUniqueServiceName(String siteName, String publicIp, String publicPort) {
+            return "cloud-gslb-service-" + siteName + "-" + publicIp + "-" + publicPort;
+        }
+    }
+
+
     private void enableVPXInterfaces(String publicIf, String privateIf, ns ns_obj) {
         // enable VPX to use 10 gigabit Ethernet interfaces if public/private interface
         // on SDX is a 10Gig interface

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/server/src/com/cloud/api/ApiResponseHelper.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/api/ApiResponseHelper.java b/server/src/com/cloud/api/ApiResponseHelper.java
index 663139d..f33601f 100755
--- a/server/src/com/cloud/api/ApiResponseHelper.java
+++ b/server/src/com/cloud/api/ApiResponseHelper.java
@@ -117,29 +117,12 @@ import com.cloud.event.Event;
 import com.cloud.host.Host;
 import com.cloud.host.HostVO;
 import com.cloud.hypervisor.HypervisorCapabilities;
-import com.cloud.network.IpAddress;
-import com.cloud.network.Network;
+import com.cloud.network.*;
 import com.cloud.network.Network.Capability;
 import com.cloud.network.Network.Provider;
 import com.cloud.network.Network.Service;
-import com.cloud.network.NetworkProfile;
 import com.cloud.network.Networks.TrafficType;
-import com.cloud.network.PhysicalNetwork;
-import com.cloud.network.PhysicalNetworkServiceProvider;
-import com.cloud.network.PhysicalNetworkTrafficType;
-import com.cloud.network.RemoteAccessVpn;
-import com.cloud.network.Site2SiteCustomerGateway;
-import com.cloud.network.Site2SiteVpnConnection;
-import com.cloud.network.Site2SiteVpnGateway;
-import com.cloud.network.VirtualRouterProvider;
-import com.cloud.network.VpnUser;
-import com.cloud.network.as.AutoScalePolicy;
-import com.cloud.network.as.AutoScaleVmGroup;
-import com.cloud.network.as.AutoScaleVmProfile;
-import com.cloud.network.as.AutoScaleVmProfileVO;
-import com.cloud.network.as.Condition;
-import com.cloud.network.as.ConditionVO;
-import com.cloud.network.as.Counter;
+import com.cloud.network.as.*;
 import com.cloud.network.dao.IPAddressVO;
 import com.cloud.network.dao.NetworkVO;
 import com.cloud.network.dao.PhysicalNetworkVO;
@@ -168,6 +151,7 @@ import com.cloud.org.Cluster;
 import com.cloud.projects.Project;
 import com.cloud.projects.ProjectAccount;
 import com.cloud.projects.ProjectInvitation;
+import com.cloud.region.ha.GlobalLoadBalancerRule;
 import com.cloud.server.Criteria;
 import com.cloud.server.ResourceTag;
 import com.cloud.server.ResourceTag.TaggedResourceType;
@@ -220,6 +204,7 @@ import com.cloud.vm.snapshot.VMSnapshot;
 import org.apache.cloudstack.api.ResponseGenerator;                                                                                 
 import org.apache.cloudstack.api.response.VMSnapshotResponse;
 import org.apache.log4j.Logger;
+import org.springframework.stereotype.Component;
 
 import java.text.DecimalFormat;
 import java.util.*;
@@ -685,6 +670,19 @@ public class ApiResponseHelper implements ResponseGenerator {
     }
 
     @Override
+    public GlobalLoadBalancerResponse createGlobalLoadBalancerResponse(GlobalLoadBalancerRule globalLoadBalancerRule) {
+        GlobalLoadBalancerResponse response = new GlobalLoadBalancerResponse();
+        response.setAlgorithm(globalLoadBalancerRule.getAlgorithm());
+        response.setStickyMethod(globalLoadBalancerRule.getPersistence());
+        response.setServiceDomainName(globalLoadBalancerRule.getGslbDomain());
+        response.setName(globalLoadBalancerRule.getName());
+        response.setDescription(globalLoadBalancerRule.getDescription());
+        response.setRegionIdId(globalLoadBalancerRule.getRegion());
+        response.setId(globalLoadBalancerRule.getUuid());
+        return response;
+    }
+
+    @Override
     public PodResponse createPodResponse(Pod pod, Boolean showCapacities) {
         String[] ipRange = new String[2];
         if (pod.getDescription() != null && pod.getDescription().length() > 0) {

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/server/src/com/cloud/api/ApiServer.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/api/ApiServer.java b/server/src/com/cloud/api/ApiServer.java
index 0439c6e..3c08575 100755
--- a/server/src/com/cloud/api/ApiServer.java
+++ b/server/src/com/cloud/api/ApiServer.java
@@ -16,51 +16,39 @@
 // under the License.
 package com.cloud.api;
 
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InterruptedIOException;
-import java.net.InetAddress;
-import java.net.ServerSocket;
-import java.net.Socket;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.net.URLEncoder;
-import java.security.SecureRandom;
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.*;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
-import javax.annotation.PostConstruct;
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-import javax.inject.Inject;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
-
+import com.cloud.api.response.ApiResponseSerializer;
+import com.cloud.async.AsyncCommandQueued;
+import com.cloud.async.AsyncJob;
+import com.cloud.async.AsyncJobManager;
+import com.cloud.async.AsyncJobVO;
+import com.cloud.configuration.Config;
+import com.cloud.configuration.ConfigurationVO;
+import com.cloud.configuration.dao.ConfigurationDao;
+import com.cloud.domain.Domain;
+import com.cloud.domain.DomainVO;
+import com.cloud.event.ActionEventUtils;
+import com.cloud.exception.*;
+import com.cloud.user.*;
+import com.cloud.utils.NumbersUtil;
+import com.cloud.utils.Pair;
+import com.cloud.utils.StringUtils;
+import com.cloud.utils.component.ComponentContext;
+import com.cloud.utils.component.PluggableService;
+import com.cloud.utils.concurrency.NamedThreadFactory;
+import com.cloud.utils.db.SearchCriteria;
+import com.cloud.utils.db.Transaction;
+import com.cloud.utils.exception.CloudRuntimeException;
 import org.apache.cloudstack.acl.APIChecker;
-import org.apache.cloudstack.api.APICommand;
-import org.apache.cloudstack.api.ApiErrorCode;
-import org.apache.cloudstack.api.BaseAsyncCmd;
-import org.apache.cloudstack.api.BaseAsyncCreateCmd;
-import org.apache.cloudstack.api.BaseCmd;
-import org.apache.cloudstack.api.BaseListCmd;
-import org.apache.cloudstack.api.ResponseObject;
-import org.apache.cloudstack.api.ServerApiException;
+import org.apache.cloudstack.api.*;
 import org.apache.cloudstack.api.command.admin.host.ListHostsCmd;
 import org.apache.cloudstack.api.command.admin.router.ListRoutersCmd;
 import org.apache.cloudstack.api.command.admin.storage.ListStoragePoolsCmd;
 import org.apache.cloudstack.api.command.admin.user.ListUsersCmd;
-import com.cloud.event.ActionEventUtils;
-import org.apache.cloudstack.acl.APILimitChecker;
-import org.apache.cloudstack.api.*;
 import org.apache.cloudstack.api.command.user.account.ListAccountsCmd;
 import org.apache.cloudstack.api.command.user.account.ListProjectAccountsCmd;
 import org.apache.cloudstack.api.command.user.event.ListEventsCmd;
+import org.apache.cloudstack.api.command.user.offering.ListDiskOfferingsCmd;
+import org.apache.cloudstack.api.command.user.offering.ListServiceOfferingsCmd;
 import org.apache.cloudstack.api.command.user.project.ListProjectInvitationsCmd;
 import org.apache.cloudstack.api.command.user.project.ListProjectsCmd;
 import org.apache.cloudstack.api.command.user.securitygroup.ListSecurityGroupsCmd;
@@ -68,17 +56,12 @@ import org.apache.cloudstack.api.command.user.tag.ListTagsCmd;
 import org.apache.cloudstack.api.command.user.vm.ListVMsCmd;
 import org.apache.cloudstack.api.command.user.vmgroup.ListVMGroupsCmd;
 import org.apache.cloudstack.api.command.user.volume.ListVolumesCmd;
+import org.apache.cloudstack.api.command.user.zone.ListZonesByCmd;
 import org.apache.cloudstack.api.response.ExceptionResponse;
 import org.apache.cloudstack.api.response.ListResponse;
-import org.apache.cloudstack.api.command.user.zone.ListZonesByCmd;
+import org.apache.cloudstack.region.RegionManager;
 import org.apache.commons.codec.binary.Base64;
-import org.apache.http.ConnectionClosedException;
-import org.apache.http.HttpException;
-import org.apache.http.HttpRequest;
-import org.apache.http.HttpResponse;
-import org.apache.http.HttpServerConnection;
-import org.apache.http.HttpStatus;
-import org.apache.http.NameValuePair;
+import org.apache.http.*;
 import org.apache.http.client.utils.URLEncodedUtils;
 import org.apache.http.entity.BasicHttpEntity;
 import org.apache.http.impl.DefaultHttpResponseFactory;
@@ -89,57 +72,29 @@ import org.apache.http.params.BasicHttpParams;
 import org.apache.http.params.CoreConnectionPNames;
 import org.apache.http.params.CoreProtocolPNames;
 import org.apache.http.params.HttpParams;
-import org.apache.http.protocol.BasicHttpContext;
-import org.apache.http.protocol.BasicHttpProcessor;
-import org.apache.http.protocol.HttpContext;
-import org.apache.http.protocol.HttpRequestHandler;
-import org.apache.http.protocol.HttpRequestHandlerRegistry;
-import org.apache.http.protocol.HttpService;
-import org.apache.http.protocol.ResponseConnControl;
-import org.apache.http.protocol.ResponseContent;
-import org.apache.http.protocol.ResponseDate;
-import org.apache.http.protocol.ResponseServer;
+import org.apache.http.protocol.*;
 import org.apache.log4j.Logger;
 import org.springframework.stereotype.Component;
 
-import org.apache.cloudstack.api.command.user.offering.ListDiskOfferingsCmd;
-import org.apache.cloudstack.api.command.user.offering.ListServiceOfferingsCmd;
-import com.cloud.api.response.ApiResponseSerializer;
-import org.apache.cloudstack.region.RegionManager;
-
-import com.cloud.async.AsyncCommandQueued;
-import com.cloud.async.AsyncJob;
-import com.cloud.async.AsyncJobManager;
-import com.cloud.async.AsyncJobVO;
-import com.cloud.configuration.Config;
-import com.cloud.configuration.ConfigurationVO;
-import com.cloud.configuration.dao.ConfigurationDao;
-import com.cloud.domain.Domain;
-import com.cloud.domain.DomainVO;
-import com.cloud.exception.AccountLimitException;
-import com.cloud.exception.CloudAuthenticationException;
-import com.cloud.exception.InsufficientCapacityException;
-import com.cloud.exception.InvalidParameterValueException;
-import com.cloud.exception.PermissionDeniedException;
-import com.cloud.exception.RequestLimitException;
-import com.cloud.exception.ResourceAllocationException;
-import com.cloud.exception.ResourceUnavailableException;
-import com.cloud.user.Account;
-import com.cloud.user.AccountManager;
-import com.cloud.user.DomainManager;
-import com.cloud.user.User;
-import com.cloud.user.UserAccount;
-import com.cloud.user.UserContext;
-import com.cloud.user.UserVO;
-import com.cloud.utils.NumbersUtil;
-import com.cloud.utils.Pair;
-import com.cloud.utils.StringUtils;
-import com.cloud.utils.component.ComponentContext;
-import com.cloud.utils.component.PluggableService;
-import com.cloud.utils.concurrency.NamedThreadFactory;
-import com.cloud.utils.db.SearchCriteria;
-import com.cloud.utils.db.Transaction;
-import com.cloud.utils.exception.CloudRuntimeException;
+import javax.annotation.PostConstruct;
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import javax.inject.Inject;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.*;
+import java.security.SecureRandom;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 
 @Component
 public class ApiServer implements HttpRequestHandler, ApiServerService {
@@ -208,11 +163,11 @@ public class ApiServer implements HttpRequestHandler, ApiServerService {
         for(PluggableService pluggableService: _pluggableServices)
             cmdClasses.addAll(pluggableService.getCommands());
 
-        for(Class<?> cmdClass: cmdClasses) {
-            APICommand at = cmdClass.getAnnotation(APICommand.class);
-            if (at == null) {
+        for(Class<?> cmdClass: cmdClasses) {
+            APICommand at = cmdClass.getAnnotation(APICommand.class);
+            if (at == null) {
                 throw new CloudRuntimeException(String.format("%s is claimed as a API command, but it doesn't have @APICommand annotation", cmdClass.getName()));
-            }
+            }
             String apiName = at.name();
             if (_apiNameCmdClassMap.containsKey(apiName)) {
                 s_logger.error("API Cmd class " + cmdClass.getName() + " has non-unique apiname" + apiName);

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/server/src/com/cloud/configuration/Config.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/configuration/Config.java b/server/src/com/cloud/configuration/Config.java
index 9db7dbd..1a57a64 100755
--- a/server/src/com/cloud/configuration/Config.java
+++ b/server/src/com/cloud/configuration/Config.java
@@ -36,6 +36,10 @@ import com.cloud.template.TemplateManager;
 import com.cloud.vm.UserVmManager;
 import com.cloud.vm.snapshot.VMSnapshotManager;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
 public enum Config {
 
 	// Alert
@@ -387,7 +391,9 @@ public enum Config {
     VMSnapshotMax("Advanced", VMSnapshotManager.class, Integer.class, "vmsnapshot.max", "10", "Maximum vm snapshots for a vm", null),
     VMSnapshotCreateWait("Advanced", VMSnapshotManager.class, Integer.class, "vmsnapshot.create.wait", "600", "In second, timeout for create vm snapshot", null),
     VMSnapshotExpungeInterval("Advanced", VMSnapshotManager.class, Integer.class, "vmsnapshot.expunge.interval", "60", "The interval (in seconds) to wait before running the expunge thread.", null),
-    VMSnapshotExpungeWorkers("Advanced", VMSnapshotManager.class, Integer.class, "vmsnapshot.expunge.workers",  "1", "Number of workers performing expunge ", null);
+    VMSnapshotExpungeWorkers("Advanced", VMSnapshotManager.class, Integer.class, "vmsnapshot.expunge.workers",  "1", "Number of workers performing expunge ", null),
+
+    CloudDnsName("Advanced", ManagementServer.class, String.class, "cloud.dns.name", "default", " DNS name of the cloud", null);
     
 	
 	private final String _category;

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/server/src/com/cloud/network/ExternalLoadBalancerDeviceManager.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/network/ExternalLoadBalancerDeviceManager.java b/server/src/com/cloud/network/ExternalLoadBalancerDeviceManager.java
index dee3ca9..9f11b85 100644
--- a/server/src/com/cloud/network/ExternalLoadBalancerDeviceManager.java
+++ b/server/src/com/cloud/network/ExternalLoadBalancerDeviceManager.java
@@ -47,7 +47,9 @@ public interface ExternalLoadBalancerDeviceManager extends Manager{
      * @param server resource that will handle the commands specific to this device 
      * @return Host object for the device added
      */
-    public ExternalLoadBalancerDeviceVO addExternalLoadBalancer(long physicalNetworkId, String url, String username, String password, String deviceName, ServerResource resource);
+    public ExternalLoadBalancerDeviceVO addExternalLoadBalancer(long physicalNetworkId, String url, String username,
+                String password, String deviceName, ServerResource resource, boolean gslbProvider,
+                String gslbSitePublicIp, String gslbSitePrivateIp);
 
     /**
      * deletes load balancer device added in to a physical network

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/server/src/com/cloud/network/ExternalLoadBalancerDeviceManagerImpl.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/network/ExternalLoadBalancerDeviceManagerImpl.java b/server/src/com/cloud/network/ExternalLoadBalancerDeviceManagerImpl.java
index b2a56fc..cafe95a 100644
--- a/server/src/com/cloud/network/ExternalLoadBalancerDeviceManagerImpl.java
+++ b/server/src/com/cloud/network/ExternalLoadBalancerDeviceManagerImpl.java
@@ -122,6 +122,15 @@ import com.cloud.vm.Nic;
 import com.cloud.vm.NicVO;
 import com.cloud.vm.dao.DomainRouterDao;
 import com.cloud.vm.dao.NicDao;
+import org.apache.cloudstack.api.ApiConstants;
+import org.apache.cloudstack.api.response.ExternalLoadBalancerResponse;
+import org.apache.cloudstack.network.ExternalNetworkDeviceManager.NetworkDevice;
+import org.apache.log4j.Logger;
+
+import javax.inject.Inject;
+import javax.naming.ConfigurationException;
+import java.net.URI;
+import java.util.*;
 
 public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase implements ExternalLoadBalancerDeviceManager, ResourceStateAdapter {
 
@@ -189,7 +198,9 @@ public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase
 
     @Override
     @DB
-    public ExternalLoadBalancerDeviceVO addExternalLoadBalancer(long physicalNetworkId, String url, String username, String password, String deviceName, ServerResource resource) {
+    public ExternalLoadBalancerDeviceVO addExternalLoadBalancer(long physicalNetworkId, String url,
+                String username, String password, String deviceName, ServerResource resource, boolean gslbProvider,
+                String gslbSitePublicIp, String gslbSitePrivateIp) {
 
         PhysicalNetworkVO pNetwork = null;
         NetworkDevice ntwkDevice = NetworkDevice.getNetworkDevice(deviceName);
@@ -204,15 +215,25 @@ public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase
         if (pNetwork == null) {
             throw new InvalidParameterValueException("Could not find phyical network with ID: " + physicalNetworkId);
         }
-        zoneId = pNetwork.getDataCenterId();
 
+        zoneId = pNetwork.getDataCenterId();
         PhysicalNetworkServiceProviderVO ntwkSvcProvider = _physicalNetworkServiceProviderDao.findByServiceProvider(pNetwork.getId(), ntwkDevice.getNetworkServiceProvder());
-        if (ntwkSvcProvider == null) {
-            throw new CloudRuntimeException("Network Service Provider: " + ntwkDevice.getNetworkServiceProvder() +
-                    " is not enabled in the physical network: " + physicalNetworkId + "to add this device");
-        } else if (ntwkSvcProvider.getState() == PhysicalNetworkServiceProvider.State.Shutdown) {
-            throw new CloudRuntimeException("Network Service Provider: " + ntwkSvcProvider.getProviderName() +
-                    " is in shutdown state in the physical network: " + physicalNetworkId + "to add this device");
+
+        if (gslbProvider) {
+            ExternalLoadBalancerDeviceVO zoneGslbProvider = _externalLoadBalancerDeviceDao.findGslbServiceProvider(
+                    physicalNetworkId, ntwkDevice.getNetworkServiceProvder());
+            if (zoneGslbProvider != null) {
+                throw new CloudRuntimeException("There is a GSLB service provider configured in the zone alredy.");
+            }
+        } else {
+            ntwkSvcProvider = _physicalNetworkServiceProviderDao.findByServiceProvider(pNetwork.getId(), ntwkDevice.getNetworkServiceProvder());
+            if (ntwkSvcProvider == null) {
+                throw new CloudRuntimeException("Network Service Provider: " + ntwkDevice.getNetworkServiceProvder() +
+                        " is not enabled in the physical network: " + physicalNetworkId + "to add this device");
+            } else if (ntwkSvcProvider.getState() == PhysicalNetworkServiceProvider.State.Shutdown) {
+                throw new CloudRuntimeException("Network Service Provider: " + ntwkSvcProvider.getProviderName() +
+                        " is in shutdown state in the physical network: " + physicalNetworkId + "to add this device");
+            }
         }
 
         URI uri;
@@ -253,11 +274,15 @@ public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase
                     capacity = _defaultLbCapacity;
                 }
 
+                ExternalLoadBalancerDeviceVO lbDeviceVO;
                 txn.start();
-                ExternalLoadBalancerDeviceVO lbDeviceVO = new ExternalLoadBalancerDeviceVO(host.getId(), pNetwork.getId(), ntwkSvcProvider.getProviderName(),
-                        deviceName, capacity, dedicatedUse);
+                lbDeviceVO = new ExternalLoadBalancerDeviceVO(host.getId(), pNetwork.getId(), ntwkDevice.getNetworkServiceProvder(),
+                        deviceName, capacity, dedicatedUse, gslbProvider);
                 _externalLoadBalancerDeviceDao.persist(lbDeviceVO);
-
+                if (!gslbProvider) {
+                    lbDeviceVO.setGslbSitePrivateIP(gslbSitePublicIp);
+                    lbDeviceVO.setGslbSitePrivateIP(gslbSitePrivateIp);
+                }
                 DetailVO hostDetail = new DetailVO(host.getId(), ApiConstants.LOAD_BALANCER_DEVICE_ID, String.valueOf(lbDeviceVO.getId()));
                 _hostDetailDao.persist(hostDetail);
 
@@ -501,7 +526,9 @@ public abstract class ExternalLoadBalancerDeviceManagerImpl extends AdapterBase
                                     "&publicipvlan=" + publicIPVlanTag + "&publicipgateway=" + publicIPgateway;
                             ExternalLoadBalancerDeviceVO lbAppliance = null;
                             try {
-                                lbAppliance = addExternalLoadBalancer(physicalNetworkId, url, username, password, createLbAnswer.getDeviceName(), createLbAnswer.getServerResource());
+                                lbAppliance = addExternalLoadBalancer(physicalNetworkId, url, username, password,
+                                        createLbAnswer.getDeviceName(), createLbAnswer.getServerResource(), false,
+                                        null, null);
                             } catch (Exception e) {
                                 s_logger.error("Failed to add load balancer appliance in to cloudstack due to " + e.getMessage() + ". So provisioned load balancer appliance will be destroyed.");
                             }

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDao.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDao.java b/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDao.java
index 1bd2107..b7baa7e 100644
--- a/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDao.java
+++ b/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDao.java
@@ -16,12 +16,12 @@
 // under the License.
 package com.cloud.network.dao;
 
-import java.util.List;
-
 import com.cloud.network.dao.ExternalLoadBalancerDeviceVO.LBDeviceAllocationState;
 import com.cloud.network.dao.ExternalLoadBalancerDeviceVO.LBDeviceState;
 import com.cloud.utils.db.GenericDao;
 
+import java.util.List;
+
 public interface ExternalLoadBalancerDeviceDao extends GenericDao<ExternalLoadBalancerDeviceVO, Long> {
 
     /**
@@ -64,4 +64,11 @@ public interface ExternalLoadBalancerDeviceDao extends GenericDao<ExternalLoadBa
      * @return list of ExternalLoadBalancerDeviceVO for the devices in to this physical network of a managed type
      */
     List<ExternalLoadBalancerDeviceVO> listByProviderAndManagedType(long physicalNetworkId, String provider_name, boolean managed);
+
+    /**
+     * Find the external load balancer device that is provisioned as GSLB service provider in the pyshical network
+     * @param physicalNetworkId physical Network Id
+     * @return ExternalLoadBalancerDeviceVO for the device acting as GSLB provider in the physical network
+     */
+    ExternalLoadBalancerDeviceVO findGslbServiceProvider(long physicalNetworkId, String providerName);
 }

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDaoImpl.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDaoImpl.java b/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDaoImpl.java
index e559fad..ea6437d 100644
--- a/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDaoImpl.java
+++ b/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceDaoImpl.java
@@ -16,11 +16,6 @@
 // under the License.
 package com.cloud.network.dao;
 
-import java.util.List;
-import javax.ejb.Local;
-
-import org.springframework.stereotype.Component;
-
 import com.cloud.network.dao.ExternalLoadBalancerDeviceVO.LBDeviceAllocationState;
 import com.cloud.network.dao.ExternalLoadBalancerDeviceVO.LBDeviceState;
 import com.cloud.utils.db.DB;
@@ -28,6 +23,10 @@ import com.cloud.utils.db.GenericDaoBase;
 import com.cloud.utils.db.SearchBuilder;
 import com.cloud.utils.db.SearchCriteria;
 import com.cloud.utils.db.SearchCriteria.Op;
+import org.springframework.stereotype.Component;
+
+import javax.ejb.Local;
+import java.util.List;
 
 @Component
 @Local(value=ExternalLoadBalancerDeviceDao.class) @DB(txn=false)
@@ -37,6 +36,7 @@ public class ExternalLoadBalancerDeviceDaoImpl extends GenericDaoBase<ExternalLo
     final SearchBuilder<ExternalLoadBalancerDeviceVO> allocationStateSearch;
     final SearchBuilder<ExternalLoadBalancerDeviceVO> deviceStatusSearch;
     final SearchBuilder<ExternalLoadBalancerDeviceVO> deviceManagedTypeSearch;
+    final SearchBuilder<ExternalLoadBalancerDeviceVO> gslbProviderSearch;
 
     public ExternalLoadBalancerDeviceDaoImpl() {
         super();
@@ -67,6 +67,12 @@ public class ExternalLoadBalancerDeviceDaoImpl extends GenericDaoBase<ExternalLo
         deviceManagedTypeSearch.and("providerName", deviceManagedTypeSearch.entity().getProviderName(), Op.EQ);
         deviceManagedTypeSearch.and("managedType", deviceManagedTypeSearch.entity().getIsManagedDevice(), Op.EQ);
         deviceManagedTypeSearch.done();
+
+        gslbProviderSearch = createSearchBuilder();
+        gslbProviderSearch.and("physicalNetworkId", gslbProviderSearch.entity().getPhysicalNetworkId(), Op.EQ);
+        gslbProviderSearch.and("providerName", gslbProviderSearch.entity().getProviderName(), Op.EQ);
+        gslbProviderSearch.and("gslbProvider", gslbProviderSearch.entity().getGslbProvider(), Op.EQ);
+
     }
 
     public List<ExternalLoadBalancerDeviceVO> listByPhysicalNetwork(long physicalNetworkId) {
@@ -109,4 +115,13 @@ public class ExternalLoadBalancerDeviceDaoImpl extends GenericDaoBase<ExternalLo
         sc.setParameters("managedType", managed);
         return search(sc, null);
     }
+
+    @Override
+    public ExternalLoadBalancerDeviceVO findGslbServiceProvider(long physicalNetworkId, String providerName) {
+        SearchCriteria<ExternalLoadBalancerDeviceVO> sc = gslbProviderSearch.create();
+        sc.setParameters("physicalNetworkId", physicalNetworkId);
+        sc.setParameters("providerName", providerName);
+        sc.setParameters("gslbProvider", true);
+        return findOneBy(sc);
+    }
 }

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceVO.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceVO.java b/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceVO.java
index cd9dffd..04714a6 100644
--- a/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceVO.java
+++ b/server/src/com/cloud/network/dao/ExternalLoadBalancerDeviceVO.java
@@ -20,17 +20,9 @@ import org.apache.cloudstack.api.Identity;
 import org.apache.cloudstack.api.InternalIdentity;
 import org.apache.cloudstack.network.ExternalNetworkDeviceManager;
 
+import javax.persistence.*;
 import java.util.UUID;
 
-import javax.persistence.Column;
-import javax.persistence.Entity;
-import javax.persistence.EnumType;
-import javax.persistence.Enumerated;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.Table;
-
 /**
  * ExternalLoadBalancerDeviceVO contains information on external load balancer devices (F5/Netscaler VPX,MPX,SDX) added into a deployment
   */
@@ -73,6 +65,15 @@ public class ExternalLoadBalancerDeviceVO implements InternalIdentity, Identity
     @Column(name="is_dedicated")
     private boolean isDedicatedDevice;
 
+    @Column(name="is_gslb_provider")
+    private boolean gslbProvider;
+
+    @Column(name="gslb_site_publicip")
+    private String gslbSitePublicIP;
+
+    @Column(name="gslb_site_privateip")
+    private String gslbSitePrivateIP;
+
     @Column(name = "parent_host_id")
     private long parentHostId;
 
@@ -93,7 +94,7 @@ public class ExternalLoadBalancerDeviceVO implements InternalIdentity, Identity
     }
 
     public ExternalLoadBalancerDeviceVO(long hostId, long physicalNetworkId, String provider_name, String device_name,
-            long capacity, boolean dedicated) {
+            long capacity, boolean dedicated, boolean gslbProvider) {
         this.physicalNetworkId = physicalNetworkId;
         this.providerName = provider_name;
         this.deviceName = device_name;
@@ -105,7 +106,9 @@ public class ExternalLoadBalancerDeviceVO implements InternalIdentity, Identity
         this.isManagedDevice = false;
         this.state = LBDeviceState.Enabled;
         this.uuid = UUID.randomUUID().toString();
-
+        this.gslbProvider = gslbProvider;
+        this.gslbSitePublicIP = null;
+        this.gslbSitePrivateIP = null;
         if (device_name.equalsIgnoreCase(ExternalNetworkDeviceManager.NetworkDevice.NetscalerSDXLoadBalancer.getName())) {
             this.allocationState = LBDeviceAllocationState.Provider;
         }
@@ -113,7 +116,7 @@ public class ExternalLoadBalancerDeviceVO implements InternalIdentity, Identity
 
     public ExternalLoadBalancerDeviceVO(long hostId, long physicalNetworkId, String provider_name, String device_name,
             long capacity, boolean dedicated, boolean managed, long parentHostId) {
-        this(hostId, physicalNetworkId, provider_name, device_name, capacity, dedicated);
+        this(hostId, physicalNetworkId, provider_name, device_name, capacity, dedicated, false);
         this.isManagedDevice = managed;
         this.parentHostId = parentHostId;
     }
@@ -190,6 +193,30 @@ public class ExternalLoadBalancerDeviceVO implements InternalIdentity, Identity
         isDedicatedDevice = isDedicated;
     }
 
+    public boolean getGslbProvider() {
+        return gslbProvider;
+    }
+
+    public void setGslbProvider(boolean gslbProvider) {
+        gslbProvider = gslbProvider;
+    }
+
+    public void setGslbSitePublicIP(String gslbSitePublicIP) {
+        this.gslbSitePublicIP = gslbSitePublicIP;
+    }
+
+    public String getGslbSitePublicIP() {
+        return gslbSitePublicIP;
+    }
+
+    public void setGslbSitePrivateIP(String gslbSitePrivateIP) {
+        this.gslbSitePrivateIP = gslbSitePrivateIP;
+    }
+
+    public String getGslbSitePrivateIP() {
+        return gslbSitePrivateIP;
+    }
+
     public String getUuid() {
         return uuid;
     }

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/c5fb8349/server/src/com/cloud/network/lb/LoadBalancingRulesManagerImpl.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/network/lb/LoadBalancingRulesManagerImpl.java b/server/src/com/cloud/network/lb/LoadBalancingRulesManagerImpl.java
index 80e75cd..7ad1070 100755
--- a/server/src/com/cloud/network/lb/LoadBalancingRulesManagerImpl.java
+++ b/server/src/com/cloud/network/lb/LoadBalancingRulesManagerImpl.java
@@ -16,35 +16,6 @@
 // under the License.
 package com.cloud.network.lb;
 
-import java.security.InvalidParameterException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import javax.ejb.Local;
-import javax.inject.Inject;
-
-import com.cloud.event.UsageEventUtils;
-import org.apache.log4j.Logger;
-
-import org.apache.cloudstack.api.ApiConstants;
-import org.apache.cloudstack.api.command.user.loadbalancer.CreateLBHealthCheckPolicyCmd;
-import org.apache.cloudstack.api.command.user.loadbalancer.CreateLBStickinessPolicyCmd;
-import org.apache.cloudstack.api.command.user.loadbalancer.CreateLoadBalancerRuleCmd;
-import org.apache.cloudstack.api.command.user.loadbalancer.ListLBHealthCheckPoliciesCmd;
-import org.apache.cloudstack.api.command.user.loadbalancer.ListLBStickinessPoliciesCmd;
-import org.apache.cloudstack.api.command.user.loadbalancer.ListLoadBalancerRuleInstancesCmd;
-import org.apache.cloudstack.api.command.user.loadbalancer.ListLoadBalancerRulesCmd;
-import org.apache.cloudstack.api.command.user.loadbalancer.UpdateLoadBalancerRuleCmd;
-import org.apache.cloudstack.api.response.ServiceResponse;
-import org.springframework.stereotype.Component;
-
 import com.cloud.agent.api.to.LoadBalancerTO;
 import com.cloud.configuration.Config;
 import com.cloud.configuration.ConfigurationManager;
@@ -56,72 +27,24 @@ import com.cloud.dc.dao.VlanDao;
 import com.cloud.domain.dao.DomainDao;
 import com.cloud.event.ActionEvent;
 import com.cloud.event.EventTypes;
+import com.cloud.event.UsageEventUtils;
 import com.cloud.event.dao.EventDao;
 import com.cloud.event.dao.UsageEventDao;
-import com.cloud.exception.InsufficientAddressCapacityException;
-import com.cloud.exception.InvalidParameterValueException;
-import com.cloud.exception.NetworkRuleConflictException;
-import com.cloud.exception.PermissionDeniedException;
-import com.cloud.exception.ResourceUnavailableException;
-import com.cloud.network.ExternalLoadBalancerUsageManager;
-import com.cloud.network.IpAddress;
-import com.cloud.network.LBHealthCheckPolicyVO;
-import com.cloud.network.Network;
+import com.cloud.exception.*;
+import com.cloud.network.*;
 import com.cloud.network.Network.Capability;
 import com.cloud.network.Network.Provider;
 import com.cloud.network.Network.Service;
-import com.cloud.network.NetworkManager;
-import com.cloud.network.NetworkModel;
-import com.cloud.network.NetworkRuleApplier;
-import com.cloud.network.as.AutoScalePolicy;
-import com.cloud.network.as.AutoScalePolicyConditionMapVO;
-import com.cloud.network.as.AutoScaleVmGroup;
-import com.cloud.network.as.AutoScaleVmGroupPolicyMapVO;
-import com.cloud.network.as.AutoScaleVmGroupVO;
-import com.cloud.network.as.AutoScaleVmProfile;
+import com.cloud.network.as.*;
 import com.cloud.network.as.Condition;
-import com.cloud.network.as.Counter;
-import com.cloud.network.as.dao.AutoScalePolicyConditionMapDao;
-import com.cloud.network.as.dao.AutoScalePolicyDao;
-import com.cloud.network.as.dao.AutoScaleVmGroupDao;
-import com.cloud.network.as.dao.AutoScaleVmGroupPolicyMapDao;
-import com.cloud.network.as.dao.AutoScaleVmProfileDao;
-import com.cloud.network.as.dao.ConditionDao;
-import com.cloud.network.as.dao.CounterDao;
-import com.cloud.network.dao.FirewallRulesCidrsDao;
-import com.cloud.network.dao.FirewallRulesDao;
-import com.cloud.network.dao.IPAddressDao;
-import com.cloud.network.dao.IPAddressVO;
-import com.cloud.network.dao.LBHealthCheckPolicyDao;
-import com.cloud.network.dao.LBStickinessPolicyDao;
-import com.cloud.network.dao.LBStickinessPolicyVO;
-import com.cloud.network.dao.LoadBalancerDao;
-import com.cloud.network.dao.LoadBalancerVMMapDao;
-import com.cloud.network.dao.LoadBalancerVMMapVO;
-import com.cloud.network.dao.LoadBalancerVO;
-import com.cloud.network.dao.NetworkDao;
-import com.cloud.network.dao.NetworkServiceMapDao;
-import com.cloud.network.dao.NetworkVO;
+import com.cloud.network.as.dao.*;
+import com.cloud.network.dao.*;
 import com.cloud.network.element.LoadBalancingServiceProvider;
-import com.cloud.network.element.NetworkElement;
-import com.cloud.network.lb.LoadBalancingRule.LbAutoScalePolicy;
-import com.cloud.network.lb.LoadBalancingRule.LbAutoScaleVmGroup;
-import com.cloud.network.lb.LoadBalancingRule.LbAutoScaleVmProfile;
-import com.cloud.network.lb.LoadBalancingRule.LbCondition;
-import com.cloud.network.lb.LoadBalancingRule.LbDestination;
-import com.cloud.network.lb.LoadBalancingRule.LbHealthCheckPolicy;
-import com.cloud.network.lb.LoadBalancingRule.LbStickinessPolicy;
-import com.cloud.network.rules.FirewallManager;
-import com.cloud.network.rules.FirewallRule;
+import com.cloud.network.lb.LoadBalancingRule.*;
+import com.cloud.network.rules.*;
 import com.cloud.network.rules.FirewallRule.FirewallRuleType;
 import com.cloud.network.rules.FirewallRule.Purpose;
-import com.cloud.network.rules.FirewallRuleVO;
-import com.cloud.network.rules.HealthCheckPolicy;
-import com.cloud.network.rules.LbStickinessMethod;
 import com.cloud.network.rules.LbStickinessMethod.LbStickinessMethodParam;
-import com.cloud.network.rules.LoadBalancer;
-import com.cloud.network.rules.RulesManager;
-import com.cloud.network.rules.StickinessPolicy;
 import com.cloud.network.vpc.VpcManager;
 import com.cloud.offering.NetworkOffering;
 import com.cloud.projects.Project.ListProjectResourcesCriteria;
@@ -130,24 +53,14 @@ import com.cloud.service.dao.ServiceOfferingDao;
 import com.cloud.storage.dao.VMTemplateDao;
 import com.cloud.tags.ResourceTagVO;
 import com.cloud.tags.dao.ResourceTagDao;
-import com.cloud.user.Account;
-import com.cloud.user.AccountManager;
-import com.cloud.user.DomainService;
-import com.cloud.user.User;
-import com.cloud.user.UserContext;
+import com.cloud.user.*;
 import com.cloud.user.dao.AccountDao;
 import com.cloud.user.dao.UserDao;
 import com.cloud.uservm.UserVm;
 import com.cloud.utils.Pair;
 import com.cloud.utils.Ternary;
-import com.cloud.utils.component.Manager;
 import com.cloud.utils.component.ManagerBase;
-import com.cloud.utils.db.DB;
-import com.cloud.utils.db.Filter;
-import com.cloud.utils.db.JoinBuilder;
-import com.cloud.utils.db.SearchBuilder;
-import com.cloud.utils.db.SearchCriteria;
-import com.cloud.utils.db.Transaction;
+import com.cloud.utils.db.*;
 import com.cloud.utils.exception.CloudRuntimeException;
 import com.cloud.utils.net.NetUtils;
 import com.cloud.vm.Nic;
@@ -157,6 +70,16 @@ import com.cloud.vm.dao.NicDao;
 import com.cloud.vm.dao.UserVmDao;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
+import org.apache.cloudstack.api.ApiConstants;
+import org.apache.cloudstack.api.command.user.loadbalancer.*;
+import org.apache.cloudstack.api.response.ServiceResponse;
+import org.apache.log4j.Logger;
+import org.springframework.stereotype.Component;
+
+import javax.ejb.Local;
+import javax.inject.Inject;
+import java.security.InvalidParameterException;
+import java.util.*;
 
 @Component
 @Local(value = { LoadBalancingRulesManager.class, LoadBalancingRulesService.class })


Mime
View raw message