incubator-cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From muralire...@apache.org
Subject [1/2] git commit: moving out ELB network element to plugins/network-elements/elastic-loadbalancer
Date Mon, 02 Jul 2012 22:02:48 GMT
Updated Branches:
  refs/heads/master 5fafb0e5e -> 9876d34ea


moving out ELB network element to plugins/network-elements/elastic-loadbalancer


Project: http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/commit/9876d34e
Tree: http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/tree/9876d34e
Diff: http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/diff/9876d34e

Branch: refs/heads/master
Commit: 9876d34ea4a7ac79a0c38b35a249dce20295d391
Parents: 5fafb0e
Author: Murali reddy <Murali.Reddy@citrix.com>
Authored: Mon Jul 2 15:05:58 2012 -0700
Committer: Murali reddy <Murali.Reddy@citrix.com>
Committed: Mon Jul 2 15:05:58 2012 -0700

----------------------------------------------------------------------
 build/build-cloud-plugins.xml                      |    9 +-
 client/tomcatconf/components.xml.in                |    2 +
 .../elastic-loadbalancer/.classpath                |   11 +
 .../network-elements/elastic-loadbalancer/.project |   17 +
 .../elastic-loadbalancer/build.xml                 |  129 ++
 .../src/com/cloud/network/ElasticLbVmMapVO.java    |  101 ++
 .../element/ElasticLoadBalancerElement.java        |  199 +++
 .../network/lb/ElasticLoadBalancerManager.java     |   41 +
 .../network/lb/ElasticLoadBalancerManagerImpl.java |  990 +++++++++++++++
 .../cloud/network/lb/dao/ElasticLbVmMapDao.java    |   37 +
 .../network/lb/dao/ElasticLbVmMapDaoImpl.java      |  134 ++
 .../configuration/DefaultComponentLibrary.java     |    4 -
 server/src/com/cloud/network/ElasticLbVmMapVO.java |  101 --
 .../element/ElasticLoadBalancerElement.java        |  199 ---
 .../network/lb/ElasticLoadBalancerManager.java     |   41 -
 .../network/lb/ElasticLoadBalancerManagerImpl.java |  990 ---------------
 .../network/lb/LoadBalancingRulesManagerImpl.java  |   11 +-
 .../cloud/network/lb/dao/ElasticLbVmMapDao.java    |   37 -
 .../network/lb/dao/ElasticLbVmMapDaoImpl.java      |  134 --
 19 files changed, 1675 insertions(+), 1512 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/build/build-cloud-plugins.xml
----------------------------------------------------------------------
diff --git a/build/build-cloud-plugins.xml b/build/build-cloud-plugins.xml
index dcadb93..61b0e62 100755
--- a/build/build-cloud-plugins.xml
+++ b/build/build-cloud-plugins.xml
@@ -279,8 +279,8 @@
 
   <!-- ===================== Network Elements ===================== -->
 
-  <target name="compile-network-elements" depends="compile-netscaler, compile-f5, compile-srx, compile-ovs" description="Compile all network elements"/>
-  <target name="build-network-elements" depends="build-netscaler, build-f5, build-srx, build-ovs" description="build all network elements"/>
+  <target name="compile-network-elements" depends="compile-netscaler, compile-f5, compile-srx, compile-ovs, compile-elb" description="Compile all network elements"/>
+  <target name="build-network-elements" depends="build-netscaler, build-f5, build-srx, build-ovs, build-elb" description="build all network elements"/>
  
   <target name="compile-netscaler" depends="-init, compile-server" description="Compile NetScaler plugin">
   	<ant antfile="${base.dir}/plugins/network-elements/netscaler/build.xml" target="build"/>
@@ -302,6 +302,11 @@
   </target>
   <target name="build-ovs" depends="compile-ovs"/>
 
+  <target name="compile-elb" depends="-init, compile-server" description="Compile ELB plugin">
+  	<ant antfile="${base.dir}/plugins/network-elements/elastic-loadbalancer/build.xml" target="build"/>
+  </target>
+  <target name="build-elb" depends="compile-elb"/>
+
 
   <!-- ===================== File Systems ===================== -->
 

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/client/tomcatconf/components.xml.in
----------------------------------------------------------------------
diff --git a/client/tomcatconf/components.xml.in b/client/tomcatconf/components.xml.in
index e4e062a..f36355d 100755
--- a/client/tomcatconf/components.xml.in
+++ b/client/tomcatconf/components.xml.in
@@ -159,6 +159,7 @@
         </adapters>
         <manager name="VmwareManager" key="com.cloud.hypervisor.vmware.manager.VmwareManager" class="com.cloud.hypervisor.vmware.manager.VmwareManagerImpl"/>
         <manager name="OvsTunnelManager" key="com.cloud.network.ovs.OvsTunnelManager" class="com.cloud.network.ovs.OvsTunnelManagerImpl"/>
+        <manager name="ElasticLoadBalancerManager" key="com.cloud.network.lb.ElasticLoadBalancerManager" class="com.cloud.network.lb.ElasticLoadBalancerManagerImpl"/>
         <pluggableservice name="VirtualRouterElementService" key="com.cloud.network.element.VirtualRouterElementService" class="com.cloud.network.element.VirtualRouterElement"/>
         <pluggableservice name="NetscalerExternalLoadBalancerElementService" key="com.cloud.network.element.NetscalerLoadBalancerElementService" class="com.cloud.network.element.NetscalerElement"/>
         <pluggableservice name="F5ExternalLoadBalancerElementService" key="com.cloud.network.element.F5ExternalLoadBalancerElementService" class="com.cloud.network.element.F5ExternalLoadBalancerElement"/>
@@ -172,6 +173,7 @@
         <dao name="NetappVolume" class="com.cloud.netapp.dao.VolumeDaoImpl" singleton="false"/>
         <dao name="NetappLun" class="com.cloud.netapp.dao.LunDaoImpl" singleton="false"/>
         <manager name="NetappManager" key="com.cloud.netapp.NetappManager" class="com.cloud.netapp.NetappManagerImpl"/>
+        <dao name="ElasticLbVmMapDao" class="com.cloud.network.lb.dao.ElasticLbVmMapDaoImpl" singleton="false"/>
     </management-server>
 
     <configuration-server class="com.cloud.server.ConfigurationServerImpl">

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/plugins/network-elements/elastic-loadbalancer/.classpath
----------------------------------------------------------------------
diff --git a/plugins/network-elements/elastic-loadbalancer/.classpath b/plugins/network-elements/elastic-loadbalancer/.classpath
new file mode 100644
index 0000000..a3f5d12
--- /dev/null
+++ b/plugins/network-elements/elastic-loadbalancer/.classpath
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/api"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/core"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/server"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/utils"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/deps"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/plugins/network-elements/elastic-loadbalancer/.project
----------------------------------------------------------------------
diff --git a/plugins/network-elements/elastic-loadbalancer/.project b/plugins/network-elements/elastic-loadbalancer/.project
new file mode 100644
index 0000000..6165661
--- /dev/null
+++ b/plugins/network-elements/elastic-loadbalancer/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>elastic-loadbalancer</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/plugins/network-elements/elastic-loadbalancer/build.xml
----------------------------------------------------------------------
diff --git a/plugins/network-elements/elastic-loadbalancer/build.xml b/plugins/network-elements/elastic-loadbalancer/build.xml
new file mode 100755
index 0000000..66e42ce
--- /dev/null
+++ b/plugins/network-elements/elastic-loadbalancer/build.xml
@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  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.
+-->
+
+
+<project name="Cloud Stack ELB network element" default="help" basedir=".">
+  <description>
+		Cloud Stack ant build file
+    </description>
+
+  <dirname property="elb.base.dir" file="${ant.file.Cloud Stack ELB network element}/"/>
+  <!-- This directory must be set -->
+  <property name="top.dir" location="${elb.base.dir}/../../.."/>
+  <property name="build.dir" location="${top.dir}/build"/>
+	
+	<echo message="build.dir=${build.dir}; top.dir=${top.dir}; elb.base.dir=${elb.base.dir}"/>
+
+  <!-- Import anything that the user wants to set-->
+  <!-- Import properties files and environment variables here -->
+
+  <property environment="env" />
+
+  <condition property="build-cloud.properties.file" value="${build.dir}/override/build-cloud.properties" else="${build.dir}/build-cloud.properties">
+    <available file="${build.dir}/override/build-cloud.properties" />
+  </condition>
+
+  <condition property="cloud.properties.file" value="${build.dir}/override/cloud.properties" else="${build.dir}/cloud.properties">
+    <available file="${build.dir}/override/cloud.properties" />
+  </condition>
+
+  <condition property="override.file" value="${build.dir}/override/replace.properties" else="${build.dir}/replace.properties">
+    <available file="${build.dir}/override/replace.properties" />
+  </condition>
+
+  <echo message="Using build parameters from ${build-cloud.properties.file}" />
+  <property file="${build-cloud.properties.file}" />
+
+  <echo message="Using company info from ${cloud.properties.file}" />
+  <property file="${cloud.properties.file}" />
+
+  <echo message="Using override file from ${override.file}" />
+  <property file="${override.file}" />
+
+  <property file="${build.dir}/build.number" />
+
+  <!-- In case these didn't get defined in the build-cloud.properties -->
+  <property name="branding.name" value="default" />
+  <property name="deprecation" value="off" />
+  <property name="target.compat.version" value="1.6" />
+  <property name="source.compat.version" value="1.6" />
+  <property name="debug" value="true" />
+  <property name="debuglevel" value="lines,source"/>
+
+  <echo message="target.dir=${target.dir}; top.dir=${top.dir}"/>
+  <!-- directories for build and distribution -->
+  <property name="target.dir" location="${top.dir}/target" />
+  <property name="classes.dir" location="${target.dir}/classes" />
+  <property name="jar.dir" location="${target.dir}/jar" />
+  <property name="dep.cache.dir" location="${target.dir}/dep-cache" />
+  <property name="build.log" location="${target.dir}/ant_verbose.txt" />
+
+  <property name="deps.dir" location="${top.dir}/deps" />
+  
+  <property name="cloud-plugin-elb.jar" value="cloud-plugin-elb.jar" />
+	
+  <import file="${build.dir}/build-common.xml"/>
+
+  <echo message="target.dir=${target.dir}; top.dir=${top.dir}"/>
+	
+  <!-- This section needs to be replaced by some kind of dependency library-->
+  <path id="deps.classpath">
+    <!--filelist files="${deps.classpath}" /-->
+    <fileset dir="${deps.dir}" erroronmissingdir="false">
+      <include name="*.jar" />
+    </fileset>
+  </path>
+	
+  <path id="cloudstack.classpath">
+  	<fileset dir="${jar.dir}">
+  	  <include name="*.jar"/>
+    </fileset>
+  </path>
+	
+  <path id="elb.classpath">
+	<path refid="deps.classpath"/>
+  	<path refid="cloudstack.classpath"/>
+  </path>
+	
+  <!-- This section needs to be replaced by some kind of dependency library-->
+
+  <target name="deploy-elb" >
+  </target>
+
+  <target name="init" description="Initialize binaries directory">
+  	<mkdir dir="${classes.dir}/${cloud-plugin-elb.jar}"/>
+  	<mkdir dir="${jar.dir}"/>
+  </target>
+
+  <target name="compile-elb" depends="init" description="Compile ELB">
+    <compile-java jar.name="${cloud-plugin-elb.jar}" top.dir="${elb.base.dir}" classpath="elb.classpath" />
+  </target>
+
+  <target name="clean-elb">
+    <delete dir="${classes.dir}/${cloud-plugin-elb.jar}"/>
+  </target>
+	
+  <target name="build" depends="compile-elb"/>
+  <target name="clean" depends="clean-elb"/>
+
+  <target name="help" description="help">
+    <echo level="info" message="This is the build file for ELB network element plugin"/>
+    <echo level="info" message="You can do a build by doing ant build or clean by doing ant clean" />
+  </target>
+
+</project>

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/ElasticLbVmMapVO.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/ElasticLbVmMapVO.java b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/ElasticLbVmMapVO.java
new file mode 100644
index 0000000..024dcdc
--- /dev/null
+++ b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/ElasticLbVmMapVO.java
@@ -0,0 +1,101 @@
+// 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.
+package com.cloud.network;
+
+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.PrimaryKeyJoinColumn;
+import javax.persistence.SecondaryTable;
+import javax.persistence.SecondaryTables;
+import javax.persistence.Table;
+
+import com.cloud.utils.net.Ip;
+
+@Entity
+@Table(name = ("elastic_lb_vm_map"))
+@SecondaryTables({ 
+        @SecondaryTable(name = "user_ip_address", pkJoinColumns = { @PrimaryKeyJoinColumn(name = "ip_addr_id", referencedColumnName = "id") })
+        })
+public class ElasticLbVmMapVO {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "lb_id")
+    private Long lbId;
+    
+    @Column(name = "ip_addr_id")
+    private long ipAddressId;
+
+    @Column(name = "elb_vm_id")
+    private long elbVmId;
+
+    /*@Column(name = "name", table = "load_balancing_rules", insertable = false, updatable = false)
+    private String lbName;*/
+    
+    @Column(name = "public_ip_address", table = "user_ip_address", insertable = false, updatable = false)
+    @Enumerated(value=EnumType.STRING)
+    private Ip address = null;
+    
+    public ElasticLbVmMapVO() {
+    }
+
+    public ElasticLbVmMapVO(long ipId, long elbVmId, long lbId) {
+        this.ipAddressId = ipId;
+        this.elbVmId = elbVmId;
+        this.lbId = lbId;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public long getLbId() {
+        return lbId;
+    }
+
+
+    public long getElbVmId() {
+        return elbVmId;
+    }
+
+
+//    public String getLbName() {
+//        return lbName;
+//    }
+
+
+    public long getIpAddressId() {
+        return ipAddressId;
+    }
+
+    public void setLbId(Long lbId) {
+        this.lbId = lbId;
+    }
+
+    public Ip getAddress() {
+        return address;
+    }
+    
+}
+

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/element/ElasticLoadBalancerElement.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/element/ElasticLoadBalancerElement.java b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/element/ElasticLoadBalancerElement.java
new file mode 100644
index 0000000..1f9356f
--- /dev/null
+++ b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/element/ElasticLoadBalancerElement.java
@@ -0,0 +1,199 @@
+// 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.
+package com.cloud.network.element;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.ejb.Local;
+import javax.naming.ConfigurationException;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.configuration.Config;
+import com.cloud.configuration.dao.ConfigurationDao;
+import com.cloud.deploy.DeployDestination;
+import com.cloud.exception.ConcurrentOperationException;
+import com.cloud.exception.InsufficientCapacityException;
+import com.cloud.exception.ResourceUnavailableException;
+import com.cloud.network.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.Networks.TrafficType;
+import com.cloud.network.PhysicalNetworkServiceProvider;
+import com.cloud.network.PublicIpAddress;
+import com.cloud.network.dao.NetworkDao;
+import com.cloud.network.lb.ElasticLoadBalancerManager;
+import com.cloud.network.lb.LoadBalancingRule;
+import com.cloud.offering.NetworkOffering;
+import com.cloud.offerings.dao.NetworkOfferingDao;
+import com.cloud.utils.component.AdapterBase;
+import com.cloud.utils.component.Inject;
+import com.cloud.vm.NicProfile;
+import com.cloud.vm.ReservationContext;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.VirtualMachineProfile;
+
+
+@Local(value=NetworkElement.class)
+public class ElasticLoadBalancerElement extends AdapterBase implements LoadBalancingServiceProvider, IpDeployer {
+    private static final Logger s_logger = Logger.getLogger(ElasticLoadBalancerElement.class);
+    private static final Map<Service, Map<Capability, String>> capabilities = setCapabilities();
+    @Inject NetworkManager _networkManager;
+    @Inject ElasticLoadBalancerManager _lbMgr;
+    @Inject ConfigurationDao _configDao;
+    @Inject NetworkOfferingDao _networkOfferingDao;
+    @Inject NetworkDao _networksDao;
+    
+    boolean _enabled;
+    TrafficType _frontEndTrafficType = TrafficType.Guest;
+    
+    private boolean canHandle(Network network) {
+        if (network.getGuestType() != Network.GuestType.Shared|| network.getTrafficType() != TrafficType.Guest) {
+            s_logger.debug("Not handling network with type  " + network.getGuestType() + " and traffic type " + network.getTrafficType());
+            return false;
+        }
+        
+        return true;
+    }
+    
+    @Override
+    public Provider getProvider() {
+        return Provider.ElasticLoadBalancerVm;
+    }
+    
+    @Override
+    public Map<Service, Map<Capability, String>> getCapabilities() {
+        return capabilities;
+    }
+    
+    private static Map<Service, Map<Capability, String>> setCapabilities() {
+        Map<Service, Map<Capability, String>> capabilities = new HashMap<Service, Map<Capability, String>>();
+        
+        Map<Capability, String> lbCapabilities = new HashMap<Capability, String>();
+        lbCapabilities.put(Capability.SupportedLBAlgorithms, "roundrobin,leastconn,source");
+        lbCapabilities.put(Capability.SupportedLBIsolation, "shared");
+        lbCapabilities.put(Capability.SupportedProtocols, "tcp, udp");
+        
+        capabilities.put(Service.Lb, lbCapabilities);   
+        return capabilities;
+    }
+
+    @Override
+    public boolean implement(Network network, NetworkOffering offering, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException,
+            InsufficientCapacityException {
+        
+        return true;
+    }
+
+    @Override
+    public boolean prepare(Network network, NicProfile nic, VirtualMachineProfile<? extends VirtualMachine> vm, DeployDestination dest, ReservationContext context)
+            throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException {
+       
+        return true;
+    }
+
+    @Override
+    public boolean release(Network network, NicProfile nic, VirtualMachineProfile<? extends VirtualMachine> vm, ReservationContext context) throws ConcurrentOperationException,
+            ResourceUnavailableException {
+        
+        return true;
+    }
+
+    @Override
+    public boolean shutdown(Network network, ReservationContext context, boolean cleanup) throws ConcurrentOperationException, ResourceUnavailableException {
+        // TODO kill all loadbalancer vms by calling the ElasticLoadBalancerManager
+        return false;
+    }
+
+    @Override
+    public boolean destroy(Network network) throws ConcurrentOperationException, ResourceUnavailableException {
+        // TODO  kill all loadbalancer vms by calling the ElasticLoadBalancerManager
+        return false;
+    }
+    
+    @Override
+    public boolean validateLBRule(Network network, LoadBalancingRule rule) {
+        return true;
+    }
+    
+    @Override
+    public boolean applyLBRules(Network network, List<LoadBalancingRule> rules) throws ResourceUnavailableException {
+        if (!canHandle(network)) {
+            return false;
+        }
+        
+        return _lbMgr.applyLoadBalancerRules(network, rules);
+    }
+
+
+    @Override
+    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
+        
+        super.configure(name, params);
+        String enabled = _configDao.getValue(Config.ElasticLoadBalancerEnabled.key());
+        _enabled = (enabled == null) ? false: Boolean.parseBoolean(enabled);
+        if (_enabled) {
+            String traffType = _configDao.getValue(Config.ElasticLoadBalancerNetwork.key());
+            if ("guest".equalsIgnoreCase(traffType)) {
+                _frontEndTrafficType = TrafficType.Guest;
+            } else if ("public".equalsIgnoreCase(traffType)){
+                _frontEndTrafficType = TrafficType.Public;
+            } else
+                throw new ConfigurationException("Traffic type for front end of load balancer has to be guest or public; found : " + traffType);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean isReady(PhysicalNetworkServiceProvider provider) {
+        // TODO Auto-generated method stub
+        return true;
+    }
+
+    @Override
+    public boolean shutdownProviderInstances(PhysicalNetworkServiceProvider provider, ReservationContext context) throws ConcurrentOperationException,
+            ResourceUnavailableException {
+        // TODO Auto-generated method stub
+        return true;
+    }
+
+    @Override
+    public boolean canEnableIndividualServices() {
+        return false;
+    }
+    
+    @Override
+    public boolean verifyServicesCombination(List<String> services) {
+        return true;
+    }
+
+    @Override
+    public boolean applyIps(Network network, List<? extends PublicIpAddress> ipAddress, Set<Service> services) throws ResourceUnavailableException {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public IpDeployer getIpDeployer(Network network) {
+        return this;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManager.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManager.java b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManager.java
new file mode 100644
index 0000000..0dc5b14
--- /dev/null
+++ b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManager.java
@@ -0,0 +1,41 @@
+// 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.
+package com.cloud.network.lb;
+
+import java.util.List;
+
+import com.cloud.api.commands.CreateLoadBalancerRuleCmd;
+import com.cloud.exception.InsufficientAddressCapacityException;
+import com.cloud.exception.NetworkRuleConflictException;
+import com.cloud.exception.ResourceUnavailableException;
+import com.cloud.network.Network;
+import com.cloud.network.rules.FirewallRule;
+import com.cloud.network.rules.LoadBalancer;
+import com.cloud.user.Account;
+
+public interface ElasticLoadBalancerManager {
+    public static final int DEFAULT_ELB_VM_RAMSIZE = 128;            // 512 MB
+    public static final int DEFAULT_ELB_VM_CPU_MHZ = 256;               // 500 MHz
+
+    public boolean applyLoadBalancerRules(Network network, 
+            List<? extends FirewallRule> rules) 
+            throws ResourceUnavailableException;
+
+    public LoadBalancer handleCreateLoadBalancerRule(CreateLoadBalancerRuleCmd lb, Account caller, long networkId) throws InsufficientAddressCapacityException, NetworkRuleConflictException;
+    
+    public void handleDeleteLoadBalancerRule(LoadBalancer lb, long callerUserId, Account caller);
+}

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManagerImpl.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManagerImpl.java b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManagerImpl.java
new file mode 100644
index 0000000..3985c51
--- /dev/null
+++ b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/ElasticLoadBalancerManagerImpl.java
@@ -0,0 +1,990 @@
+// 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.
+package com.cloud.network.lb;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import javax.ejb.Local;
+import javax.naming.ConfigurationException;
+
+import org.apache.log4j.Logger;
+
+import com.cloud.agent.AgentManager;
+import com.cloud.agent.AgentManager.OnError;
+import com.cloud.agent.api.Answer;
+import com.cloud.agent.api.StopAnswer;
+import com.cloud.agent.api.check.CheckSshAnswer;
+import com.cloud.agent.api.check.CheckSshCommand;
+import com.cloud.agent.api.routing.LoadBalancerConfigCommand;
+import com.cloud.agent.api.routing.NetworkElementCommand;
+import com.cloud.agent.api.to.LoadBalancerTO;
+import com.cloud.agent.manager.Commands;
+import com.cloud.api.commands.CreateLoadBalancerRuleCmd;
+import com.cloud.configuration.Config;
+import com.cloud.configuration.dao.ConfigurationDao;
+import com.cloud.dc.DataCenter;
+import com.cloud.dc.DataCenter.NetworkType;
+import com.cloud.dc.DataCenterVO;
+import com.cloud.dc.Pod;
+import com.cloud.dc.PodVlanMapVO;
+import com.cloud.dc.Vlan.VlanType;
+import com.cloud.dc.dao.ClusterDao;
+import com.cloud.dc.dao.DataCenterDao;
+import com.cloud.dc.dao.HostPodDao;
+import com.cloud.dc.dao.PodVlanMapDao;
+import com.cloud.dc.dao.VlanDao;
+import com.cloud.deploy.DataCenterDeployment;
+import com.cloud.deploy.DeployDestination;
+import com.cloud.exception.AgentUnavailableException;
+import com.cloud.exception.ConcurrentOperationException;
+import com.cloud.exception.InsufficientAddressCapacityException;
+import com.cloud.exception.InsufficientCapacityException;
+import com.cloud.exception.InvalidParameterValueException;
+import com.cloud.exception.NetworkRuleConflictException;
+import com.cloud.exception.OperationTimedoutException;
+import com.cloud.exception.ResourceUnavailableException;
+import com.cloud.exception.StorageUnavailableException;
+import com.cloud.hypervisor.Hypervisor.HypervisorType;
+import com.cloud.network.ElasticLbVmMapVO;
+import com.cloud.network.IPAddressVO;
+import com.cloud.network.LoadBalancerVO;
+import com.cloud.network.Network;
+import com.cloud.network.Network.Provider;
+import com.cloud.network.Network.Service;
+import com.cloud.network.NetworkManager;
+import com.cloud.network.NetworkVO;
+import com.cloud.network.Networks.TrafficType;
+import com.cloud.network.PhysicalNetworkServiceProvider;
+import com.cloud.network.VirtualRouterProvider;
+import com.cloud.network.VirtualRouterProvider.VirtualRouterProviderType;
+import com.cloud.network.addr.PublicIp;
+import com.cloud.network.dao.IPAddressDao;
+import com.cloud.network.dao.LoadBalancerDao;
+import com.cloud.network.dao.NetworkDao;
+import com.cloud.network.dao.PhysicalNetworkServiceProviderDao;
+import com.cloud.network.dao.VirtualRouterProviderDao;
+import com.cloud.network.lb.LoadBalancingRule.LbDestination;
+import com.cloud.network.lb.LoadBalancingRule.LbStickinessPolicy;
+import com.cloud.network.lb.dao.ElasticLbVmMapDao;
+import com.cloud.network.router.VirtualNetworkApplianceManager;
+import com.cloud.network.router.VirtualRouter;
+import com.cloud.network.router.VirtualRouter.RedundantState;
+import com.cloud.network.router.VirtualRouter.Role;
+import com.cloud.network.rules.FirewallRule;
+import com.cloud.network.rules.FirewallRule.Purpose;
+import com.cloud.network.rules.LoadBalancer;
+import com.cloud.offering.ServiceOffering;
+import com.cloud.offerings.NetworkOfferingVO;
+import com.cloud.offerings.dao.NetworkOfferingDao;
+import com.cloud.service.ServiceOfferingVO;
+import com.cloud.service.dao.ServiceOfferingDao;
+import com.cloud.storage.VMTemplateVO;
+import com.cloud.storage.dao.VMTemplateDao;
+import com.cloud.user.Account;
+import com.cloud.user.AccountService;
+import com.cloud.user.User;
+import com.cloud.user.UserContext;
+import com.cloud.user.dao.AccountDao;
+import com.cloud.utils.NumbersUtil;
+import com.cloud.utils.Pair;
+import com.cloud.utils.component.Inject;
+import com.cloud.utils.component.Manager;
+import com.cloud.utils.concurrency.NamedThreadFactory;
+import com.cloud.utils.db.DB;
+import com.cloud.utils.db.SearchBuilder;
+import com.cloud.utils.db.SearchCriteria;
+import com.cloud.utils.db.Transaction;
+import com.cloud.utils.exception.CloudRuntimeException;
+import com.cloud.vm.DomainRouterVO;
+import com.cloud.vm.NicProfile;
+import com.cloud.vm.ReservationContext;
+import com.cloud.vm.VMInstanceVO;
+import com.cloud.vm.VirtualMachine;
+import com.cloud.vm.VirtualMachine.State;
+import com.cloud.vm.VirtualMachineGuru;
+import com.cloud.vm.VirtualMachineManager;
+import com.cloud.vm.VirtualMachineName;
+import com.cloud.vm.VirtualMachineProfile;
+import com.cloud.vm.VirtualMachineProfile.Param;
+import com.cloud.vm.dao.DomainRouterDao;
+
+@Local(value = { ElasticLoadBalancerManager.class })
+public class ElasticLoadBalancerManagerImpl implements
+        ElasticLoadBalancerManager, Manager,  VirtualMachineGuru<DomainRouterVO> {
+    private static final Logger s_logger = Logger
+            .getLogger(ElasticLoadBalancerManagerImpl.class);
+    
+    @Inject
+    IPAddressDao _ipAddressDao;
+    @Inject
+    AgentManager _agentMgr;
+    @Inject
+    NetworkManager _networkMgr;
+    @Inject
+    LoadBalancerDao _loadBalancerDao = null;
+    @Inject
+    LoadBalancingRulesManager _lbMgr;
+    @Inject
+    VirtualNetworkApplianceManager _routerMgr;
+    @Inject
+    DomainRouterDao _routerDao = null;
+    @Inject
+    protected HostPodDao _podDao = null;
+    @Inject
+    protected ClusterDao _clusterDao;
+    @Inject
+    DataCenterDao _dcDao = null;
+    @Inject
+    protected NetworkDao _networkDao;
+    @Inject
+    protected NetworkOfferingDao _networkOfferingDao;
+    @Inject
+    VMTemplateDao _templateDao = null;
+    @Inject
+    VirtualMachineManager _itMgr;
+    @Inject
+    ConfigurationDao _configDao;
+    @Inject
+    ServiceOfferingDao _serviceOfferingDao = null;
+    @Inject
+    AccountService _accountService;
+    @Inject
+    LoadBalancerDao _lbDao;
+    @Inject
+    VlanDao _vlanDao;
+    @Inject
+    PodVlanMapDao _podVlanMapDao;
+    @Inject
+    ElasticLbVmMapDao _elbVmMapDao;
+    @Inject 
+    NetworkDao _networksDao;
+    @Inject 
+    AccountDao _accountDao;
+    @Inject
+    PhysicalNetworkServiceProviderDao _physicalProviderDao;
+    @Inject
+    VirtualRouterProviderDao _vrProviderDao;
+
+
+    String _name;
+    String _instance;
+    static final private String _elbVmNamePrefix = "l";
+    static final private String _systemVmType = "elbvm";
+    
+    boolean _enabled;
+    TrafficType _frontendTrafficType = TrafficType.Guest;
+
+    Account _systemAcct;
+    ServiceOfferingVO _elasticLbVmOffering;
+    ScheduledExecutorService _gcThreadPool;
+    String _mgmtCidr;
+    String _mgmtHost;
+    
+    Set<Long> _gcCandidateElbVmIds = Collections.newSetFromMap(new ConcurrentHashMap<Long,Boolean>());
+    
+    int _elasticLbVmRamSize;
+    int _elasticLbvmCpuMHz;
+    int _elasticLbvmNumCpu;
+    
+    private Long getPodIdForDirectIp(IPAddressVO ipAddr) {
+        PodVlanMapVO podVlanMaps = _podVlanMapDao.listPodVlanMapsByVlan(ipAddr.getVlanId());
+        if (podVlanMaps == null) {
+            return null;
+        } else {
+            return podVlanMaps.getPodId();
+        }
+    }
+
+
+    public DomainRouterVO deployLoadBalancerVM(Long networkId, IPAddressVO ipAddr, Long accountId) {  
+        NetworkVO network = _networkDao.findById(networkId);
+        DataCenter dc = _dcDao.findById(network.getDataCenterId());
+        Long podId = getPodIdForDirectIp(ipAddr);
+        Pod pod = podId == null?null:_podDao.findById(podId);
+        Map<VirtualMachineProfile.Param, Object> params = new HashMap<VirtualMachineProfile.Param, Object>(
+                1);
+        params.put(VirtualMachineProfile.Param.ReProgramNetwork, true);
+        Account owner = _accountService.getActiveAccountByName("system", new Long(1));
+        DeployDestination dest = new DeployDestination(dc, pod, null, null);
+        s_logger.debug("About to deploy ELB vm ");
+
+        try {
+            DomainRouterVO elbVm = deployELBVm(network, dest, owner, params);
+            if (elbVm == null) {
+                throw new InvalidParameterValueException("Could not deploy or find existing ELB VM");
+            }
+            s_logger.debug("Deployed ELB  vm = " + elbVm);
+
+            return elbVm;
+           
+        } catch (Throwable t) {
+            s_logger.warn("Error while deploying ELB VM:  ", t);
+            return null;
+        }
+
+    }
+    
+    private boolean sendCommandsToRouter(final DomainRouterVO elbVm,
+            Commands cmds) throws AgentUnavailableException {
+        Answer[] answers = null;
+        try {
+            answers = _agentMgr.send(elbVm.getHostId(), cmds);
+        } catch (OperationTimedoutException e) {
+            s_logger.warn("ELB: Timed Out", e);
+            throw new AgentUnavailableException(
+                    "Unable to send commands to virtual elbVm ",
+                    elbVm.getHostId(), e);
+        }
+
+        if (answers == null) {
+            return false;
+        }
+
+        if (answers.length != cmds.size()) {
+            return false;
+        }
+
+        // FIXME: Have to return state for individual command in the future
+        if (answers.length > 0) {
+            Answer ans = answers[0];
+            return ans.getResult();
+        }
+        return true;
+    }
+
+    private void createApplyLoadBalancingRulesCommands(
+            List<LoadBalancingRule> rules, DomainRouterVO elbVm, Commands cmds) {
+
+
+        LoadBalancerTO[] lbs = new LoadBalancerTO[rules.size()];
+        int i = 0;
+        for (LoadBalancingRule rule : rules) {
+            boolean revoked = (rule.getState()
+                    .equals(FirewallRule.State.Revoke));
+            String protocol = rule.getProtocol();
+            String algorithm = rule.getAlgorithm();
+
+            String elbIp = _networkMgr.getIp(rule.getSourceIpAddressId()).getAddress()
+                    .addr();
+            int srcPort = rule.getSourcePortStart();
+            List<LbDestination> destinations = rule.getDestinations();
+            LoadBalancerTO lb = new LoadBalancerTO(elbIp, srcPort, protocol, algorithm, revoked, false, destinations);
+            lbs[i++] = lb; 
+        }
+
+        LoadBalancerConfigCommand cmd = new LoadBalancerConfigCommand(lbs,elbVm.getPublicIpAddress(),elbVm.getGuestIpAddress(),elbVm.getPrivateIpAddress());
+        cmd.setAccessDetail(NetworkElementCommand.ROUTER_IP,
+                elbVm.getPrivateIpAddress());
+        cmd.setAccessDetail(NetworkElementCommand.ROUTER_NAME,
+                elbVm.getInstanceName());
+        //FIXME: why are we setting attributes directly? Ick!! There should be accessors and
+        //the constructor should set defaults.
+        cmd.lbStatsVisibility = _configDao.getValue(Config.NetworkLBHaproxyStatsVisbility.key());
+        cmd.lbStatsUri = _configDao.getValue(Config.NetworkLBHaproxyStatsUri.key());
+        cmd.lbStatsAuth = _configDao.getValue(Config.NetworkLBHaproxyStatsAuth.key());
+        cmd.lbStatsPort = _configDao.getValue(Config.NetworkLBHaproxyStatsPort.key());
+   
+        cmds.addCommand(cmd);
+
+    }
+
+    protected boolean applyLBRules(DomainRouterVO elbVm,
+            List<LoadBalancingRule> rules) throws ResourceUnavailableException {
+        Commands cmds = new Commands(OnError.Continue);
+        createApplyLoadBalancingRulesCommands(rules, elbVm, cmds);
+        // Send commands to elbVm
+        return sendCommandsToRouter(elbVm, cmds);
+    }
+    
+    protected DomainRouterVO findElbVmForLb(FirewallRule lb) {//TODO: use a table to lookup
+        ElasticLbVmMapVO map = _elbVmMapDao.findOneByIp(lb.getSourceIpAddressId());
+        if (map == null) {
+            return null;
+        }
+        DomainRouterVO elbVm = _routerDao.findById(map.getElbVmId());
+        return elbVm;
+    }
+
+    public boolean applyLoadBalancerRules(Network network,
+            List<? extends FirewallRule> rules)
+            throws ResourceUnavailableException {
+        if (rules == null || rules.isEmpty()) {
+            return true;
+        }
+        if (rules.get(0).getPurpose() != Purpose.LoadBalancing) {
+            s_logger.warn("ELB: Not handling non-LB firewall rules");
+            return false;
+        }
+        
+        DomainRouterVO elbVm = findElbVmForLb(rules.get(0));
+                                                                          
+        if (elbVm == null) {
+            s_logger.warn("Unable to apply lb rules, ELB vm  doesn't exist in the network "
+                    + network.getId());
+            throw new ResourceUnavailableException("Unable to apply lb rules",
+                    DataCenter.class, network.getDataCenterId());
+        }
+
+        if (elbVm.getState() == State.Running) {
+            //resend all rules for the public ip
+            List<LoadBalancerVO> lbs = _lbDao.listByIpAddress(rules.get(0).getSourceIpAddressId());
+            List<LoadBalancingRule> lbRules = new ArrayList<LoadBalancingRule>();
+            for (LoadBalancerVO lb : lbs) {
+                List<LbDestination> dstList = _lbMgr.getExistingDestinations(lb.getId());
+                List<LbStickinessPolicy> policyList = _lbMgr.getStickinessPolicies(lb.getId());
+                LoadBalancingRule loadBalancing = new LoadBalancingRule(
+                        lb, dstList, policyList);
+                lbRules.add(loadBalancing); 
+            }
+            return applyLBRules(elbVm, lbRules);
+        } else if (elbVm.getState() == State.Stopped
+                || elbVm.getState() == State.Stopping) {
+            s_logger.debug("ELB VM is in "
+                    + elbVm.getState()
+                    + ", so not sending apply LoadBalancing rules commands to the backend");
+            return true;
+        } else {
+            s_logger.warn("Unable to apply loadbalancing rules, ELB VM is not in the right state "
+                    + elbVm.getState());
+            throw new ResourceUnavailableException(
+                    "Unable to apply loadbalancing rules, ELB VM is not in the right state",
+                    VirtualRouter.class, elbVm.getId());
+        }
+    }
+
+    @Override
+    public boolean configure(String name, Map<String, Object> params)
+            throws ConfigurationException {
+        _name = name;
+        final Map<String, String> configs = _configDao.getConfiguration("AgentManager", params);
+        _systemAcct = _accountService.getSystemAccount();
+        _instance = configs.get("instance.name");
+        if (_instance == null) {
+            _instance = "VM";
+        }
+        _mgmtCidr = _configDao.getValue(Config.ManagementNetwork.key());
+        _mgmtHost = _configDao.getValue(Config.ManagementHostIPAdr.key());
+        
+        boolean useLocalStorage = Boolean.parseBoolean(configs.get(Config.SystemVMUseLocalStorage.key()));
+
+        _elasticLbVmRamSize = NumbersUtil.parseInt(configs.get(Config.ElasticLoadBalancerVmMemory.key()), DEFAULT_ELB_VM_RAMSIZE);
+        _elasticLbvmCpuMHz = NumbersUtil.parseInt(configs.get(Config.ElasticLoadBalancerVmCpuMhz.key()), DEFAULT_ELB_VM_CPU_MHZ);
+        _elasticLbvmNumCpu = NumbersUtil.parseInt(configs.get(Config.ElasticLoadBalancerVmNumVcpu.key()), 1);
+        _elasticLbVmOffering = new ServiceOfferingVO("System Offering For Elastic LB VM", _elasticLbvmNumCpu, 
+                _elasticLbVmRamSize, _elasticLbvmCpuMHz, 0, 0, true, null, useLocalStorage, 
+                true, null, true, VirtualMachine.Type.ElasticLoadBalancerVm, true);
+        _elasticLbVmOffering.setUniqueName(ServiceOffering.elbVmDefaultOffUniqueName);
+        _elasticLbVmOffering = _serviceOfferingDao.persistSystemServiceOffering(_elasticLbVmOffering);
+        
+        
+        
+        String enabled = _configDao.getValue(Config.ElasticLoadBalancerEnabled.key());
+        _enabled = (enabled == null) ? false: Boolean.parseBoolean(enabled);
+        s_logger.info("Elastic Load balancer enabled: " + _enabled);
+        if (_enabled) {
+            String traffType = _configDao.getValue(Config.ElasticLoadBalancerNetwork.key());
+            if ("guest".equalsIgnoreCase(traffType)) {
+                _frontendTrafficType = TrafficType.Guest;
+            } else if ("public".equalsIgnoreCase(traffType)){
+                _frontendTrafficType = TrafficType.Public;
+            } else
+                throw new ConfigurationException("ELB: Traffic type for front end of load balancer has to be guest or public; found : " + traffType);
+            s_logger.info("ELB: Elastic Load Balancer: will balance on " + traffType );
+            int gcIntervalMinutes =  NumbersUtil.parseInt(configs.get(Config.ElasticLoadBalancerVmGcInterval.key()), 5);
+            if (gcIntervalMinutes < 5) 
+                gcIntervalMinutes = 5;
+            s_logger.info("ELB: Elastic Load Balancer: scheduling GC to run every " + gcIntervalMinutes + " minutes" );
+            _gcThreadPool = Executors.newScheduledThreadPool(1, new NamedThreadFactory("ELBVM-GC"));
+            _gcThreadPool.scheduleAtFixedRate(new CleanupThread(), gcIntervalMinutes, gcIntervalMinutes, TimeUnit.MINUTES);
+            _itMgr.registerGuru(VirtualMachine.Type.ElasticLoadBalancerVm, this);
+        }
+        
+
+        return true;
+    }
+
+    @Override
+    public boolean start() {
+        return true;
+    }
+
+    @Override
+    public boolean stop() {
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return _name;
+    }
+
+    private DomainRouterVO findELBVmWithCapacity(Network guestNetwork, IPAddressVO ipAddr) {
+        List<DomainRouterVO> unusedElbVms = _elbVmMapDao.listUnusedElbVms();
+        if (unusedElbVms.size() > 0) {
+            List<DomainRouterVO> candidateVms = new ArrayList<DomainRouterVO>();
+            for (DomainRouterVO candidateVm: unusedElbVms) {
+                if (candidateVm.getPodIdToDeployIn() == getPodIdForDirectIp(ipAddr))
+                    candidateVms.add(candidateVm);
+            }
+            return candidateVms.size()==0?null:candidateVms.get(new Random().nextInt(candidateVms.size()));
+        }
+        return null;
+    }
+    
+    public DomainRouterVO deployELBVm(Network guestNetwork, DeployDestination dest, Account owner, Map<Param, Object> params) throws
+                ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException {
+        long dcId = dest.getDataCenter().getId();
+
+        // lock guest network
+        Long guestNetworkId = guestNetwork.getId();
+        guestNetwork = _networkDao.acquireInLockTable(guestNetworkId);
+
+        if (guestNetwork == null) {
+            throw new ConcurrentOperationException("Unable to acquire network lock: " + guestNetworkId);
+        }
+
+        try {
+
+            if (_networkMgr.isNetworkSystem(guestNetwork) || guestNetwork.getGuestType() == Network.GuestType.Shared) {
+                owner = _accountService.getSystemAccount();
+            }
+
+            if (s_logger.isDebugEnabled()) {
+                s_logger.debug("Starting a ELB vm for network configurations: " + guestNetwork + " in " + dest);
+            }
+            assert guestNetwork.getState() == Network.State.Implemented 
+                || guestNetwork.getState() == Network.State.Setup 
+                || guestNetwork.getState() == Network.State.Implementing 
+                : "Network is not yet fully implemented: "+ guestNetwork;
+
+            DataCenterDeployment plan = null;
+            DomainRouterVO elbVm = null;
+            
+            plan = new DataCenterDeployment(dcId, dest.getPod().getId(), null, null, null, null);
+
+            if (elbVm == null) {
+                long id = _routerDao.getNextInSequence(Long.class, "id");
+                if (s_logger.isDebugEnabled()) {
+                    s_logger.debug("Creating the ELB vm " + id);
+                }
+ 
+                List<NetworkOfferingVO> offerings = _networkMgr.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemControlNetwork);
+                NetworkOfferingVO controlOffering = offerings.get(0);
+                NetworkVO controlConfig = _networkMgr.setupNetwork(_systemAcct, controlOffering, plan, null, null, false).get(0);
+
+                List<Pair<NetworkVO, NicProfile>> networks = new ArrayList<Pair<NetworkVO, NicProfile>>(2);
+                NicProfile guestNic = new NicProfile();
+                guestNic.setDefaultNic(true);
+                networks.add(new Pair<NetworkVO, NicProfile>((NetworkVO) guestNetwork, guestNic));
+                networks.add(new Pair<NetworkVO, NicProfile>(controlConfig, null));
+                
+                VMTemplateVO template = _templateDao.findSystemVMTemplate(dcId);
+
+                String typeString = "ElasticLoadBalancerVm";
+                Long physicalNetworkId = _networkMgr.getPhysicalNetworkId(guestNetwork);
+                PhysicalNetworkServiceProvider provider = _physicalProviderDao.findByServiceProvider(physicalNetworkId, typeString);
+                if (provider == null) {
+                    throw new CloudRuntimeException("Cannot find service provider " + typeString + " in physical network " + physicalNetworkId);
+                }
+                VirtualRouterProvider vrProvider = _vrProviderDao.findByNspIdAndType(provider.getId(), VirtualRouterProviderType.ElasticLoadBalancerVm);
+                if (vrProvider == null) {
+                    throw new CloudRuntimeException("Cannot find virtual router provider " + typeString + " as service provider " + provider.getId());
+                }
+               
+                elbVm = new DomainRouterVO(id, _elasticLbVmOffering.getId(), vrProvider.getId(), VirtualMachineName.getSystemVmName(id, _instance, _elbVmNamePrefix), template.getId(), template.getHypervisorType(),
+                        template.getGuestOSId(), owner.getDomainId(), owner.getId(), guestNetwork.getId(), false, 0, false, RedundantState.UNKNOWN, _elasticLbVmOffering.getOfferHA(), false, VirtualMachine.Type.ElasticLoadBalancerVm);
+                elbVm.setRole(Role.LB);
+                elbVm = _itMgr.allocate(elbVm, template, _elasticLbVmOffering, networks, plan, null, owner);
+                //TODO: create usage stats
+            }
+
+            State state = elbVm.getState();
+            if (state != State.Running) {
+                elbVm = this.start(elbVm, _accountService.getSystemUser(), _accountService.getSystemAccount(), params);
+            }
+
+
+            return elbVm;
+        } finally {
+            _networkDao.releaseFromLockTable(guestNetworkId);
+        }
+    }
+    
+    private DomainRouterVO start(DomainRouterVO elbVm, User user, Account caller, Map<Param, Object> params) throws StorageUnavailableException, InsufficientCapacityException,
+    ConcurrentOperationException, ResourceUnavailableException {
+        s_logger.debug("Starting ELB VM " + elbVm);
+        if (_itMgr.start(elbVm, params, user, caller) != null) {
+            return _routerDao.findById(elbVm.getId());
+        } else {
+            return null;
+        }
+    }
+    
+    
+    private DomainRouterVO stop(DomainRouterVO elbVm, boolean forced, User user, Account caller) throws ConcurrentOperationException, ResourceUnavailableException {
+        s_logger.debug("Stopping ELB vm " + elbVm);
+        try {
+            if (_itMgr.advanceStop( elbVm, forced, user, caller)) {
+                return _routerDao.findById(elbVm.getId());
+            } else {
+                return null;
+            }
+        } catch (OperationTimedoutException e) {
+            throw new CloudRuntimeException("Unable to stop " + elbVm, e);
+        }
+    }
+    
+    protected List<LoadBalancerVO> findExistingLoadBalancers(String lbName, Long ipId, Long accountId, Long domainId, Integer publicPort) {
+        SearchBuilder<LoadBalancerVO> sb = _lbDao.createSearchBuilder();
+        sb.and("name", sb.entity().getName(), SearchCriteria.Op.EQ); 
+        sb.and("accountId", sb.entity().getAccountId(), SearchCriteria.Op.EQ);
+        sb.and("publicPort", sb.entity().getSourcePortStart(), SearchCriteria.Op.EQ);
+        if (ipId != null) {
+            sb.and("sourceIpAddress", sb.entity().getSourceIpAddressId(), SearchCriteria.Op.EQ);
+        }
+        if (domainId != null) {
+            sb.and("domainId", sb.entity().getDomainId(), SearchCriteria.Op.EQ);
+        }
+        if (publicPort != null) {
+            sb.and("publicPort", sb.entity().getSourcePortStart(), SearchCriteria.Op.EQ);
+        }
+        SearchCriteria<LoadBalancerVO> sc = sb.create();
+        sc.setParameters("name", lbName);
+        sc.setParameters("accountId", accountId);
+        if (ipId != null) {
+            sc.setParameters("sourceIpAddress", ipId);
+        } 
+        if (domainId != null) {
+            sc.setParameters("domainId",domainId);
+        }
+        if (publicPort != null) {
+            sc.setParameters("publicPort", publicPort);
+        }
+        List<LoadBalancerVO> lbs = _lbDao.search(sc, null);
+   
+        return lbs == null || lbs.size()==0 ? null: lbs;
+    }
+    
+    @DB
+    public PublicIp allocDirectIp(Account account, long guestNetworkId) throws InsufficientAddressCapacityException {
+        Network frontEndNetwork = _networkMgr.getNetwork(guestNetworkId);
+        Transaction txn = Transaction.currentTxn();
+        txn.start();
+        
+        PublicIp ip = _networkMgr.assignPublicIpAddress(frontEndNetwork.getDataCenterId(), null, account, VlanType.DirectAttached, frontEndNetwork.getId(), null, true);
+        IPAddressVO ipvo = _ipAddressDao.findById(ip.getId());
+        ipvo.setAssociatedWithNetworkId(frontEndNetwork.getId()); 
+        _ipAddressDao.update(ipvo.getId(), ipvo);
+        txn.commit();
+        s_logger.info("Acquired frontend IP for ELB " + ip);
+
+        return ip;
+    }
+    
+    public void releaseIp(long ipId, long userId, Account caller) {
+        s_logger.info("ELB: Release public IP for loadbalancing " + ipId);
+        IPAddressVO ipvo = _ipAddressDao.findById(ipId);
+        ipvo.setAssociatedWithNetworkId(null); 
+        _ipAddressDao.update(ipvo.getId(), ipvo);
+       _networkMgr.releasePublicIpAddress(ipId, userId, caller);
+       _ipAddressDao.unassignIpAddress(ipId);
+    }
+
+    @Override
+    @DB
+    public LoadBalancer handleCreateLoadBalancerRule(CreateLoadBalancerRuleCmd lb, Account account, long networkId) throws InsufficientAddressCapacityException, NetworkRuleConflictException  {
+        //this part of code is executed when the LB provider is Elastic Load Balancer vm
+    	if (!_networkMgr.isProviderSupportServiceInNetwork(lb.getNetworkId(), Service.Lb, Provider.ElasticLoadBalancerVm)) {
+    		return null;
+    	}
+    	
+    	Long ipId = lb.getSourceIpAddressId();
+        if (ipId != null) {
+            return null;
+        }
+        boolean newIp = false;
+        account = _accountDao.acquireInLockTable(account.getId());
+        if (account == null) {
+            s_logger.warn("ELB: CreateLoadBalancer: Failed to acquire lock on account");
+            throw new CloudRuntimeException("Failed to acquire lock on account");
+        }
+        try {
+            List<LoadBalancerVO> existingLbs = findExistingLoadBalancers(lb.getName(), lb.getSourceIpAddressId(), lb.getAccountId(), lb.getDomainId(), lb.getSourcePortStart());
+            if (existingLbs == null ){
+                existingLbs = findExistingLoadBalancers(lb.getName(), lb.getSourceIpAddressId(), lb.getAccountId(), lb.getDomainId(), null);
+                if (existingLbs == null) {
+                    if (lb.getSourceIpAddressId() != null) {
+                        existingLbs = findExistingLoadBalancers(lb.getName(), null, lb.getAccountId(), lb.getDomainId(), null);
+                        if (existingLbs != null) {
+                            throw new InvalidParameterValueException("Supplied LB name " + lb.getName() + " is not associated with IP " + lb.getSourceIpAddressId() );
+                        } 
+                    } else {
+                        s_logger.debug("Could not find any existing frontend ips for this account for this LB rule, acquiring a new frontent IP for ELB");
+                        PublicIp ip = allocDirectIp(account, networkId);
+                        ipId = ip.getId();
+                        newIp = true;
+                    }
+                } else {
+                    ipId = existingLbs.get(0).getSourceIpAddressId();
+                    s_logger.debug("ELB: Found existing frontend ip for this account for this LB rule " + ipId);
+                }
+            } else {
+                s_logger.warn("ELB: Found existing load balancers matching requested new LB");
+                throw new NetworkRuleConflictException("ELB: Found existing load balancers matching requested new LB");
+            }
+
+            Network network = _networkMgr.getNetwork(networkId);
+            IPAddressVO ipAddr = _ipAddressDao.findById(ipId);
+            
+            LoadBalancer result = null;
+            try {
+                lb.setSourceIpAddressId(ipId);
+                result = _lbMgr.createLoadBalancer(lb, false);
+            } catch (NetworkRuleConflictException e) {
+                s_logger.warn("Failed to create LB rule, not continuing with ELB deployment");
+                if (newIp) {
+                    releaseIp(ipId, UserContext.current().getCallerUserId(), account);
+                }
+                throw e;
+            }
+
+            DomainRouterVO elbVm = null;
+
+
+            if (existingLbs == null) {
+                elbVm = findELBVmWithCapacity(network, ipAddr);
+                if (elbVm == null) {
+                    elbVm = deployLoadBalancerVM(networkId, ipAddr, account.getId());
+                    if (elbVm == null) {
+                        s_logger.warn("Failed to deploy a new ELB vm for ip " + ipAddr + " in network " + network + "lb name=" + lb.getName());
+                        if (newIp)
+                            releaseIp(ipId, UserContext.current().getCallerUserId(), account);
+                    }
+                }
+
+            } else {
+                ElasticLbVmMapVO elbVmMap = _elbVmMapDao.findOneByIp(ipId);
+                if (elbVmMap != null) {
+                    elbVm = _routerDao.findById(elbVmMap.getElbVmId());
+                }
+            }
+            
+            if (elbVm == null) {
+                s_logger.warn("No ELB VM can be found or deployed");
+                s_logger.warn("Deleting LB since we failed to deploy ELB VM");
+                _lbDao.remove(result.getId());
+                return null;
+            }
+            
+            ElasticLbVmMapVO mapping = new ElasticLbVmMapVO(ipId, elbVm.getId(), result.getId());
+            _elbVmMapDao.persist(mapping);
+            return result;
+            
+        } finally {
+            if (account != null) {
+                _accountDao.releaseFromLockTable(account.getId());
+            }
+        }
+        
+    }
+    
+    void garbageCollectUnusedElbVms() {
+        List<DomainRouterVO> unusedElbVms = _elbVmMapDao.listUnusedElbVms();
+        if (unusedElbVms != null && unusedElbVms.size() > 0)
+            s_logger.info("Found " + unusedElbVms.size() + " unused ELB vms");
+        Set<Long> currentGcCandidates = new HashSet<Long>();
+        for (DomainRouterVO elbVm: unusedElbVms) {
+            currentGcCandidates.add(elbVm.getId());
+        }
+        _gcCandidateElbVmIds.retainAll(currentGcCandidates);
+        currentGcCandidates.removeAll(_gcCandidateElbVmIds);
+        User user = _accountService.getSystemUser();
+        for (Long elbVmId : _gcCandidateElbVmIds) {
+            DomainRouterVO elbVm = _routerDao.findById(elbVmId);
+            boolean gceed = false;
+
+            try {
+                s_logger.info("Attempting to stop ELB VM: " + elbVm);
+                stop(elbVm, true, user, _systemAcct);
+                gceed = true;
+            } catch (ConcurrentOperationException e) {
+                s_logger.warn("Unable to stop unused ELB vm " + elbVm + " due to ", e);
+            } catch (ResourceUnavailableException e) {
+                s_logger.warn("Unable to stop unused ELB vm " + elbVm + " due to ", e);
+                continue;
+            }
+            if (gceed) {
+                try {
+                    s_logger.info("Attempting to destroy ELB VM: " + elbVm);
+                    _itMgr.expunge(elbVm, user, _systemAcct);
+                } catch (ResourceUnavailableException e) {
+                    s_logger.warn("Unable to destroy unused ELB vm " + elbVm + " due to ", e);
+                    gceed = false;
+                }
+            }
+            if (!gceed) {
+                currentGcCandidates.add(elbVm.getId());
+            }
+
+        }
+        _gcCandidateElbVmIds = currentGcCandidates;
+    }
+    
+    public class CleanupThread implements Runnable {
+        @Override
+        public void run() {
+            garbageCollectUnusedElbVms();
+            
+        }
+
+        CleanupThread() {
+
+        }
+    }
+
+    @Override
+    public void handleDeleteLoadBalancerRule(LoadBalancer lb, long userId, Account caller) {
+        if (!_enabled) {
+            return;
+        }
+        List<LoadBalancerVO> remainingLbs = _loadBalancerDao.listByIpAddress(lb.getSourceIpAddressId());
+        if (remainingLbs.size() == 0) {
+            s_logger.debug("ELB mgr: releasing ip " + lb.getSourceIpAddressId() + " since  no LB rules remain for this ip address");
+            releaseIp(lb.getSourceIpAddressId(), userId, caller);
+        }
+    }
+
+ 
+    @Override
+    public DomainRouterVO findByName(String name) {
+        if (!VirtualMachineName.isValidSystemVmName(name, _instance, _elbVmNamePrefix)) {
+            return null;
+        }
+
+        return _routerDao.findById(VirtualMachineName.getSystemVmId(name));
+    }
+
+
+    @Override
+    public DomainRouterVO findById(long id) {
+        return _routerDao.findById(id);
+    }
+
+
+    @Override
+    public DomainRouterVO persist(DomainRouterVO elbVm) {
+        return _routerDao.persist(elbVm);
+    }
+
+
+    @Override
+    public boolean finalizeVirtualMachineProfile(VirtualMachineProfile<DomainRouterVO> profile, DeployDestination dest, ReservationContext context) {
+        DomainRouterVO elbVm = profile.getVirtualMachine();
+        NetworkVO network = _networkDao.findById(elbVm.getNetworkId());
+
+        DataCenter dc = dest.getDataCenter();
+
+        StringBuilder buf = profile.getBootArgsBuilder();
+        buf.append(" template=domP type=" + _systemVmType);
+        buf.append(" name=").append(profile.getHostName());
+        NicProfile controlNic = null;
+        String defaultDns1 = null;
+        String defaultDns2 = null;
+
+        for (NicProfile nic : profile.getNics()) {
+            int deviceId = nic.getDeviceId();
+            buf.append(" eth").append(deviceId).append("ip=").append(nic.getIp4Address());
+            buf.append(" eth").append(deviceId).append("mask=").append(nic.getNetmask());
+            if (nic.isDefaultNic()) {
+                buf.append(" gateway=").append(nic.getGateway());
+                defaultDns1 = nic.getDns1();
+                defaultDns2 = nic.getDns2();
+            }
+            if (nic.getTrafficType() == TrafficType.Management) {
+                buf.append(" localgw=").append(dest.getPod().getGateway());
+            } else if (nic.getTrafficType() == TrafficType.Control) {
+                //  control command is sent over management network in VMware
+                if (dest.getHost().getHypervisorType() == HypervisorType.VMware) {
+                    if (s_logger.isInfoEnabled()) {
+                        s_logger.info("Check if we need to add management server explicit route to ELB vm. pod cidr: " + dest.getPod().getCidrAddress() + "/" + dest.getPod().getCidrSize()
+                                + ", pod gateway: " + dest.getPod().getGateway() + ", management host: " + _mgmtHost);
+                    }
+
+                    if (s_logger.isDebugEnabled()) {
+                        s_logger.debug("Added management server explicit route to ELB vm.");
+                    }
+                    // always add management explicit route, for basic networking setup
+                    buf.append(" mgmtcidr=").append(_mgmtCidr);
+                    buf.append(" localgw=").append(dest.getPod().getGateway());
+
+                    if (dc.getNetworkType() == NetworkType.Basic) {
+                        // ask elb vm to setup SSH on guest network
+                        buf.append(" sshonguest=true");
+                    }
+                }
+
+                controlNic = nic;
+            }
+        }
+        String domain = network.getNetworkDomain();
+        if (domain != null) {
+            buf.append(" domain=" + domain);
+        }  
+
+        buf.append(" dns1=").append(defaultDns1);
+        if (defaultDns2 != null) {
+            buf.append(" dns2=").append(defaultDns2);
+        }
+        
+        if (s_logger.isDebugEnabled()) {
+            s_logger.debug("Boot Args for " + profile + ": " + buf.toString());
+        }
+
+        if (controlNic == null) {
+            throw new CloudRuntimeException("Didn't start a control port");
+        }
+
+        return true;
+    }
+
+
+    @Override
+    public boolean finalizeDeployment(Commands cmds, VirtualMachineProfile<DomainRouterVO> profile, DeployDestination dest, ReservationContext context) throws ResourceUnavailableException {
+        DomainRouterVO elbVm = profile.getVirtualMachine();
+
+        List<NicProfile> nics = profile.getNics();
+        for (NicProfile nic : nics) {
+            if (nic.getTrafficType() == TrafficType.Public) {
+                elbVm.setPublicIpAddress(nic.getIp4Address());
+                elbVm.setPublicNetmask(nic.getNetmask());
+                elbVm.setPublicMacAddress(nic.getMacAddress());
+            } else if (nic.getTrafficType() == TrafficType.Guest) {
+                elbVm.setGuestIpAddress(nic.getIp4Address());
+            } else if (nic.getTrafficType() == TrafficType.Control) {
+                elbVm.setPrivateIpAddress(nic.getIp4Address());
+                elbVm.setPrivateMacAddress(nic.getMacAddress());
+            }
+        }
+        _routerDao.update(elbVm.getId(), elbVm);
+
+        finalizeCommandsOnStart(cmds, profile);
+        return true;
+    }
+
+
+    @Override
+    public boolean finalizeStart(VirtualMachineProfile<DomainRouterVO> profile, long hostId, Commands cmds, ReservationContext context) {
+        CheckSshAnswer answer = (CheckSshAnswer) cmds.getAnswer("checkSsh");
+        if (answer == null || !answer.getResult()) {
+            s_logger.warn("Unable to ssh to the ELB VM: " + answer.getDetails());
+            return false;
+        }
+
+        return true;
+    }
+
+
+    @Override
+    public boolean finalizeCommandsOnStart(Commands cmds, VirtualMachineProfile<DomainRouterVO> profile) {
+        DomainRouterVO elbVm = profile.getVirtualMachine();
+        DataCenterVO dcVo = _dcDao.findById(elbVm.getDataCenterIdToDeployIn());
+
+        NicProfile controlNic = null;
+        
+        if(profile.getHypervisorType() == HypervisorType.VMware && dcVo.getNetworkType() == NetworkType.Basic) {
+            // TODO this is a ugly to test hypervisor type here
+            // for basic network mode, we will use the guest NIC for control NIC
+            for (NicProfile nic : profile.getNics()) {
+                if (nic.getTrafficType() == TrafficType.Guest && nic.getIp4Address() != null) {
+                    controlNic = nic;
+                }
+            }
+        } else {
+            for (NicProfile nic : profile.getNics()) {
+                if (nic.getTrafficType() == TrafficType.Control && nic.getIp4Address() != null) {
+                    controlNic = nic;
+                }
+            }
+        }
+
+        if (controlNic == null) {
+            s_logger.error("Control network doesn't exist for the ELB vm " + elbVm);
+            return false;
+        }
+
+        cmds.addCommand("checkSsh", new CheckSshCommand(profile.getInstanceName(), controlNic.getIp4Address(), 3922));
+
+        // Re-apply load balancing rules
+        List<LoadBalancerVO> lbs = _elbVmMapDao.listLbsForElbVm(elbVm.getId());
+        List<LoadBalancingRule> lbRules = new ArrayList<LoadBalancingRule>();
+        for (LoadBalancerVO lb : lbs) {
+            List<LbDestination> dstList = _lbMgr.getExistingDestinations(lb.getId());
+            List<LbStickinessPolicy> policyList = _lbMgr.getStickinessPolicies(lb.getId());
+            LoadBalancingRule loadBalancing = new LoadBalancingRule(lb, dstList, policyList);
+            lbRules.add(loadBalancing);
+        }
+
+        s_logger.debug("Found " + lbRules.size() + " load balancing rule(s) to apply as a part of ELB vm " + elbVm + " start.");
+        if (!lbRules.isEmpty()) {
+            createApplyLoadBalancingRulesCommands(lbRules, elbVm, cmds);
+        }
+
+        return true;
+    }
+
+
+    @Override
+    public void finalizeStop(VirtualMachineProfile<DomainRouterVO> profile, StopAnswer answer) {
+        if (answer != null) {
+            VMInstanceVO vm = profile.getVirtualMachine();
+            DomainRouterVO elbVm = _routerDao.findById(vm.getId());
+            processStopOrRebootAnswer(elbVm, answer);
+        }
+    }
+    
+    public void processStopOrRebootAnswer(final DomainRouterVO elbVm, Answer answer) {
+        //TODO: process network usage stats
+    }
+
+
+    @Override
+    public void finalizeExpunge(DomainRouterVO vm) {
+        // no-op
+        
+    }
+
+
+    @Override
+    public Long convertToId(String vmName) {
+        if (!VirtualMachineName.isValidSystemVmName(vmName, _instance, _elbVmNamePrefix)) {
+            return null;
+        }
+
+        return VirtualMachineName.getSystemVmId(vmName);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/dao/ElasticLbVmMapDao.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/dao/ElasticLbVmMapDao.java b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/dao/ElasticLbVmMapDao.java
new file mode 100644
index 0000000..725377c
--- /dev/null
+++ b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/dao/ElasticLbVmMapDao.java
@@ -0,0 +1,37 @@
+// 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.
+package com.cloud.network.lb.dao;
+
+import java.util.List;
+
+import com.cloud.network.ElasticLbVmMapVO;
+import com.cloud.network.LoadBalancerVO;
+import com.cloud.utils.db.GenericDao;
+import com.cloud.vm.DomainRouterVO;
+
+public interface ElasticLbVmMapDao extends GenericDao<ElasticLbVmMapVO, Long> {
+    ElasticLbVmMapVO findOneByLbIdAndElbVmId(long lbId, long elbVmId);
+    ElasticLbVmMapVO findOneByIpIdAndElbVmId(long ipId, long elbVmId);
+    ElasticLbVmMapVO findOneByIp(long ipId);
+
+    List<ElasticLbVmMapVO> listByElbVmId(long elbVmId);
+    List<ElasticLbVmMapVO> listByLbId(long lbId);
+    int deleteLB(long lbId);
+    List<DomainRouterVO> listUnusedElbVms();
+    List<LoadBalancerVO> listLbsForElbVm(long elbVmId);
+	
+}

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/dao/ElasticLbVmMapDaoImpl.java
----------------------------------------------------------------------
diff --git a/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/dao/ElasticLbVmMapDaoImpl.java b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/dao/ElasticLbVmMapDaoImpl.java
new file mode 100644
index 0000000..08c1efb
--- /dev/null
+++ b/plugins/network-elements/elastic-loadbalancer/src/com/cloud/network/lb/dao/ElasticLbVmMapDaoImpl.java
@@ -0,0 +1,134 @@
+// 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.
+package com.cloud.network.lb.dao;
+
+import java.util.List;
+
+import javax.ejb.Local;
+
+import com.cloud.network.ElasticLbVmMapVO;
+import com.cloud.network.LoadBalancerVO;
+import com.cloud.network.dao.LoadBalancerDao;
+import com.cloud.network.dao.LoadBalancerDaoImpl;
+import com.cloud.network.router.VirtualRouter.Role;
+import com.cloud.network.router.VirtualRouter.Role;
+import com.cloud.utils.component.ComponentLocator;
+import com.cloud.utils.db.GenericDaoBase;
+import com.cloud.utils.db.JoinBuilder.JoinType;
+import com.cloud.utils.db.SearchBuilder;
+import com.cloud.utils.db.SearchCriteria;
+import com.cloud.vm.DomainRouterVO;
+import com.cloud.vm.dao.DomainRouterDao;
+import com.cloud.vm.dao.DomainRouterDaoImpl;
+
+@Local(value={ElasticLbVmMapDao.class})
+public class ElasticLbVmMapDaoImpl extends GenericDaoBase<ElasticLbVmMapVO, Long> implements ElasticLbVmMapDao {
+    protected final DomainRouterDao _routerDao = ComponentLocator.inject(DomainRouterDaoImpl.class);
+    protected final LoadBalancerDao _loadbalancerDao = ComponentLocator.inject(LoadBalancerDaoImpl.class);
+
+    
+    protected final SearchBuilder<ElasticLbVmMapVO> AllFieldsSearch;
+    protected final SearchBuilder<ElasticLbVmMapVO> UnusedVmSearch;
+    protected final SearchBuilder<ElasticLbVmMapVO> LoadBalancersForElbVmSearch;
+
+
+    protected final SearchBuilder<DomainRouterVO> ElbVmSearch;
+    
+    protected final SearchBuilder<LoadBalancerVO> LoadBalancerSearch;
+   
+    protected ElasticLbVmMapDaoImpl() {
+        AllFieldsSearch  = createSearchBuilder();
+        AllFieldsSearch.and("ipId", AllFieldsSearch.entity().getIpAddressId(), SearchCriteria.Op.EQ);
+        AllFieldsSearch.and("lbId", AllFieldsSearch.entity().getLbId(), SearchCriteria.Op.EQ);
+        AllFieldsSearch.and("elbVmId", AllFieldsSearch.entity().getElbVmId(), SearchCriteria.Op.EQ);
+        AllFieldsSearch.done();
+   
+        ElbVmSearch = _routerDao.createSearchBuilder();
+        ElbVmSearch.and("role", ElbVmSearch.entity().getRole(), SearchCriteria.Op.EQ);
+        UnusedVmSearch  = createSearchBuilder();
+        UnusedVmSearch.and("elbVmId", UnusedVmSearch.entity().getElbVmId(), SearchCriteria.Op.NULL);
+        ElbVmSearch.join("UnusedVmSearch", UnusedVmSearch, ElbVmSearch.entity().getId(), UnusedVmSearch.entity().getElbVmId(), JoinType.LEFTOUTER);
+        ElbVmSearch.done();
+        UnusedVmSearch.done();    
+        
+        LoadBalancerSearch = _loadbalancerDao.createSearchBuilder();
+        LoadBalancersForElbVmSearch = createSearchBuilder();
+        LoadBalancersForElbVmSearch.and("elbVmId", LoadBalancersForElbVmSearch.entity().getElbVmId(), SearchCriteria.Op.EQ);
+        LoadBalancerSearch.join("LoadBalancersForElbVm", LoadBalancersForElbVmSearch, LoadBalancerSearch.entity().getId(), LoadBalancersForElbVmSearch.entity().getLbId(), JoinType.INNER);
+        LoadBalancersForElbVmSearch.done();
+        LoadBalancerSearch.done();
+
+    }
+
+    @Override
+    public ElasticLbVmMapVO findOneByLbIdAndElbVmId(long lbId, long elbVmId) {
+        SearchCriteria<ElasticLbVmMapVO> sc = AllFieldsSearch.create();
+        sc.setParameters("lbId", lbId);
+        sc.setParameters("elbVmId", elbVmId);
+        return findOneBy(sc);
+    }
+
+    @Override
+    public List<ElasticLbVmMapVO> listByLbId(long lbId) {
+        SearchCriteria<ElasticLbVmMapVO> sc = AllFieldsSearch.create();
+        sc.setParameters("lbId", lbId);
+        return listBy(sc);
+    }
+
+    @Override
+    public List<ElasticLbVmMapVO> listByElbVmId(long elbVmId) {
+        SearchCriteria<ElasticLbVmMapVO> sc = AllFieldsSearch.create();
+        sc.setParameters("elbVmId", elbVmId);
+        return listBy(sc);
+    }
+
+    @Override
+    public int deleteLB(long lbId) {
+    	SearchCriteria<ElasticLbVmMapVO> sc = AllFieldsSearch.create();
+        sc.setParameters("lbId", lbId);
+        return super.expunge(sc);
+    }
+
+    @Override
+    public ElasticLbVmMapVO findOneByIpIdAndElbVmId(long ipId, long elbVmId) {
+        SearchCriteria<ElasticLbVmMapVO> sc = AllFieldsSearch.create();
+        sc.setParameters("ipId", ipId);
+        sc.setParameters("elbVmId", elbVmId);
+        return findOneBy(sc);
+    }
+
+    @Override
+    public ElasticLbVmMapVO findOneByIp(long ipId) {
+        SearchCriteria<ElasticLbVmMapVO> sc = AllFieldsSearch.create();
+        sc.setParameters("ipId", ipId);
+        return findOneBy(sc);
+    }
+
+    public List<DomainRouterVO> listUnusedElbVms() {
+        SearchCriteria<DomainRouterVO> sc = ElbVmSearch.create();
+        sc.setParameters("role", Role.LB);
+        return _routerDao.search(sc, null);
+    }
+    
+    @Override
+    public List<LoadBalancerVO> listLbsForElbVm(long elbVmId) {
+        SearchCriteria<LoadBalancerVO> sc = LoadBalancerSearch.create();
+        sc.setJoinParameters("LoadBalancersForElbVm", "elbVmId", elbVmId);
+        return _loadbalancerDao.search(sc, null);
+    }
+	
+}

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/server/src/com/cloud/configuration/DefaultComponentLibrary.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/configuration/DefaultComponentLibrary.java b/server/src/com/cloud/configuration/DefaultComponentLibrary.java
index 821c6ed..f6db30b 100755
--- a/server/src/com/cloud/configuration/DefaultComponentLibrary.java
+++ b/server/src/com/cloud/configuration/DefaultComponentLibrary.java
@@ -100,9 +100,7 @@ import com.cloud.network.dao.VpnUserDaoImpl;
 import com.cloud.network.element.VirtualRouterElement;
 import com.cloud.network.element.VirtualRouterElementService;
 import com.cloud.network.firewall.FirewallManagerImpl;
-import com.cloud.network.lb.ElasticLoadBalancerManagerImpl;
 import com.cloud.network.lb.LoadBalancingRulesManagerImpl;
-import com.cloud.network.lb.dao.ElasticLbVmMapDaoImpl;
 import com.cloud.network.router.VirtualNetworkApplianceManagerImpl;
 import com.cloud.network.rules.RulesManagerImpl;
 import com.cloud.network.rules.dao.PortForwardingRulesDaoImpl;
@@ -296,7 +294,6 @@ public class DefaultComponentLibrary extends ComponentLibraryBase implements Com
         addDao("AgentTransferMapDao", HostTransferMapDaoImpl.class);
         addDao("ProjectDao", ProjectDaoImpl.class);
         addDao("InlineLoadBalancerNicMapDao", InlineLoadBalancerNicMapDaoImpl.class);
-        addDao("ElasticLbVmMap", ElasticLbVmMapDaoImpl.class);
         addDao("ProjectsAccountDao", ProjectAccountDaoImpl.class);
         addDao("ProjectInvitationDao", ProjectInvitationDaoImpl.class);
         addDao("IdentityDao", IdentityDaoImpl.class);
@@ -369,7 +366,6 @@ public class DefaultComponentLibrary extends ComponentLibraryBase implements Com
         ComponentInfo<? extends Manager> info = addManager("ConsoleProxyManager", ConsoleProxyManagerImpl.class);
         info.addParameter("consoleproxy.sslEnabled", "true");
         addManager("ProjectManager", ProjectManagerImpl.class);
-        addManager("ElasticLoadBalancerManager", ElasticLoadBalancerManagerImpl.class);
         addManager("SwiftManager", SwiftManagerImpl.class);
         addManager("StorageNetworkManager", StorageNetworkManagerImpl.class);
         addManager("ExternalLoadBalancerUsageManager", ExternalLoadBalancerUsageManagerImpl.class);

http://git-wip-us.apache.org/repos/asf/incubator-cloudstack/blob/9876d34e/server/src/com/cloud/network/ElasticLbVmMapVO.java
----------------------------------------------------------------------
diff --git a/server/src/com/cloud/network/ElasticLbVmMapVO.java b/server/src/com/cloud/network/ElasticLbVmMapVO.java
deleted file mode 100644
index 024dcdc..0000000
--- a/server/src/com/cloud/network/ElasticLbVmMapVO.java
+++ /dev/null
@@ -1,101 +0,0 @@
-// 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.
-package com.cloud.network;
-
-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.PrimaryKeyJoinColumn;
-import javax.persistence.SecondaryTable;
-import javax.persistence.SecondaryTables;
-import javax.persistence.Table;
-
-import com.cloud.utils.net.Ip;
-
-@Entity
-@Table(name = ("elastic_lb_vm_map"))
-@SecondaryTables({ 
-        @SecondaryTable(name = "user_ip_address", pkJoinColumns = { @PrimaryKeyJoinColumn(name = "ip_addr_id", referencedColumnName = "id") })
-        })
-public class ElasticLbVmMapVO {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "id")
-    private Long id;
-
-    @Column(name = "lb_id")
-    private Long lbId;
-    
-    @Column(name = "ip_addr_id")
-    private long ipAddressId;
-
-    @Column(name = "elb_vm_id")
-    private long elbVmId;
-
-    /*@Column(name = "name", table = "load_balancing_rules", insertable = false, updatable = false)
-    private String lbName;*/
-    
-    @Column(name = "public_ip_address", table = "user_ip_address", insertable = false, updatable = false)
-    @Enumerated(value=EnumType.STRING)
-    private Ip address = null;
-    
-    public ElasticLbVmMapVO() {
-    }
-
-    public ElasticLbVmMapVO(long ipId, long elbVmId, long lbId) {
-        this.ipAddressId = ipId;
-        this.elbVmId = elbVmId;
-        this.lbId = lbId;
-    }
-
-    public Long getId() {
-        return id;
-    }
-
-    public long getLbId() {
-        return lbId;
-    }
-
-
-    public long getElbVmId() {
-        return elbVmId;
-    }
-
-
-//    public String getLbName() {
-//        return lbName;
-//    }
-
-
-    public long getIpAddressId() {
-        return ipAddressId;
-    }
-
-    public void setLbId(Long lbId) {
-        this.lbId = lbId;
-    }
-
-    public Ip getAddress() {
-        return address;
-    }
-    
-}
-


Mime
View raw message