Integrated with Idmanager and interfacemgr

Change-Id: I2b57fd9ff350dc7264ab9e8fde2100565f779835
Signed-off-by: Sasidharan Sambasivam <sasidharan.s.sambasivam@ericsson.com>

diff --git a/features/src/main/features/features.xml b/features/src/main/features/features.xml
index a44ea7097986a04da672c37e3d5e79415c21a952..bf8e1b3b0e8f46c2d8f8d5d34b8083cd8451b643 100644 (file)
--- a/features/src/main/features/features.xml
+++ b/features/src/main/features/features.xml
@@ -43,12 +43,12 @@ and is available at http://www.eclipse.org/legal/epl-v10.html
     <!--<bundle>mvn:org.opendaylight.vpnservice.third-party/org.apache.thriftlib/1.0.1-SNAPSHOT</bundle>-->
     <bundle>wrap:mvn:org.apache.thrift/libthrift/0.9.1$overwrite=merge&amp;Bundle-Version=0.9.1&amp;Export-Package=*;-noimport:=true;version="0.9.1"</bundle>
     <!--<bundle>wrap:mvn:javax.servlet/servlet-api/2.5</bundle>-->
+       <configfile finalname="idmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/idmanager-impl/${idmanager.version}/xml/config</configfile>
     <configfile finalname="bgpmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/bgpmanager-impl/${vpnservices.version}/xml/config</configfile>
     <configfile finalname="mdsalutil-impl-default-config.xml">mvn:org.opendaylight.vpnservice/mdsalutil-impl/${interfacemgr.version}/xml/config</configfile>
     <configfile finalname="interfacemgr-impl-default-config.xml">mvn:org.opendaylight.vpnservice/interfacemgr-impl/${interfacemgr.version}/xml/config</configfile>
     <configfile finalname="vpnmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/vpnmanager-impl/${vpnmanager.version}/xml/config</configfile>
     <configfile finalname="nexthopmgr-impl-default-config.xml">mvn:org.opendaylight.vpnservice/nexthopmgr-impl/${nexthopmgr.version}/xml/config</configfile>
-    <configfile finalname="idmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/idmanager-impl/${idmanager.version}/xml/config</configfile>
     <configfile finalname="fibmanager-impl-default-config.xml">mvn:org.opendaylight.vpnservice/fibmanager-impl/${fibmanager.version}/xml/config</configfile>
 
   </feature>

diff --git a/vpnmanager/vpnmanager-impl/pom.xml b/vpnmanager/vpnmanager-impl/pom.xml
index 7846979c78517460a25fd4b214bb13e891990e7e..31e1239943b2061c75fabc79f5e0cd3fcb494f74 100644 (file)
--- a/vpnmanager/vpnmanager-impl/pom.xml
+++ b/vpnmanager/vpnmanager-impl/pom.xml
@@ -46,6 +46,11 @@ and is available at http://www.eclipse.org/legal/epl-v10.html
       <artifactId>interfacemgr-api</artifactId>
       <version>${vpnservices.version}</version>
     </dependency>
+    <dependency>
+      <groupId>org.opendaylight.vpnservice</groupId>
+      <artifactId>idmanager-api</artifactId>
+      <version>${vpnservices.version}</version>
+    </dependency>
   </dependencies>
 
 </project>

diff --git a/vpnmanager/vpnmanager-impl/src/main/config/default-config.xml b/vpnmanager/vpnmanager-impl/src/main/config/default-config.xml
index 3d718ff744e4e50793bdd85de40ca4e4be69a244..ac872246db3060a63b9c277c4a24919b4e85a8ed 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/config/default-config.xml
+++ b/vpnmanager/vpnmanager-impl/src/main/config/default-config.xml
@@ -26,6 +26,10 @@ and is available at http://www.eclipse.org/legal/epl-v10.html
             <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
             <name>binding-osgi-broker</name>
           </broker>
+          <rpcregistry>
+            <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-rpc-registry</type>
+            <name>binding-rpc-broker</name>
+          </rpcregistry>
           <bgpmanager>
             <type xmlns:bgpmanager="urn:opendaylight:params:xml:ns:yang:bgpmanager:api">bgpmanager:bgpmanager-api</type>
             <name>bgpmanager</name>

diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnConstants.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnConstants.java
new file mode 100644 (file)
index 0000000..69c190f
--- /dev/null
+++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnConstants.java
@@ -0,0 +1,10 @@
+package org.opendaylight.vpnservice;
+
+public class VpnConstants {
+    public static final String VPN_IDPOOL_NAME = "vpnservices";
+    public static final long VPN_IDPOOL_START = 1L;
+    public static final String VPN_IDPOOL_SIZE = "65535";
+    public static final short LPORT_INGRESS_TABLE = 0;
+    public static final short FIB_TABLE = 21;
+    public static final short DEFAULT_FLOW_PRIORITY = 10;
+}

diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java
index 48926683c75fe9fc7ae6ab3055c9fa48a8c9a32a..f8e04be665a623d6cdf28b56eefa7efb683a4f18 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java
+++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnInterfaceManager.java
@@ -10,6 +10,8 @@ package org.opendaylight.vpnservice;
 import java.math.BigInteger;
 import java.util.List;
 import java.util.ArrayList;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 
 import com.google.common.base.Optional;
 import com.google.common.util.concurrent.Futures;
@@ -31,6 +33,7 @@ import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
+import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
@@ -42,6 +45,10 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.AdjacencyLi
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.VpnInstance1;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies;
 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
@@ -62,6 +69,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
     private final IBgpManager bgpManager;
     private IMdsalApiManager mdsalManager;
     private IInterfaceManager interfaceManager;
+    private IdManagerService idManager;
 
     private static final FutureCallback<Void> DEFAULT_CALLBACK =
             new FutureCallback<Void>() {
@@ -91,6 +99,14 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
         this.mdsalManager = mdsalManager;
     }
 
+    public void setInterfaceManager(IInterfaceManager interfaceManager) {
+        this.interfaceManager = interfaceManager;
+    }
+
+    public void setIdManager(IdManagerService idManager) {
+        this.idManager = idManager;
+    }
+
     @Override
     public void close() throws Exception {
         if (listenerRegistration != null) {
@@ -148,17 +164,17 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
 
             //Get the rd of the vpn instance
             String rd = getRouteDistinguisher(intf.getVpnInstanceName());
-            //TODO: Get the endpoint IP from interface manager
-            String nextHopIp = "10.0.0.1";
+
+            long dpnId = interfaceManager.getDpnForInterface(intfName);
+            String nextHopIp = interfaceManager.getEndpointIpForDpn(dpnId);
 
             if (!nextHops.isEmpty()) {
                 LOG.info("NextHops are {}", nextHops);
                 for (Adjacency nextHop : nextHops) {
-                    //TODO: Generate label for the prefix and store it in the next hop model
-                    long label = 200;
+                    String key = nextHop.getIpAddress();
+                    long label = getUniqueId(key);
 
-                    //TODO: Update BGP
-                    updatePrefixToBGP(rd, nextHop, nextHopIp);
+                    updatePrefixToBGP(rd, nextHop, nextHopIp, label);
                     value.add(new AdjacencyBuilder(nextHop).setLabel(label).build());
                 }
             }
@@ -169,6 +185,25 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
         }
     }
 
+    private Integer getUniqueId(String idKey) {
+        GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder()
+                                           .setPoolName(VpnConstants.VPN_IDPOOL_NAME)
+                                           .setIdKey(idKey).build();
+
+        try {
+            Future<RpcResult<GetUniqueIdOutput>> result = idManager.getUniqueId(getIdInput);
+            RpcResult<GetUniqueIdOutput> rpcResult = result.get();
+            if(rpcResult.isSuccessful()) {
+                return rpcResult.getResult().getIdValue().intValue();
+            } else {
+                LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
+            }
+        } catch (NullPointerException | InterruptedException | ExecutionException e) {
+            LOG.warn("Exception when getting Unique Id",e);
+        }
+        return 0;
+    }
+
     private long getVpnId(String vpnName) {
         InstanceIdentifier<VpnInstance1> id = InstanceIdentifier.builder(VpnInstances.class)
                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).augmentation(VpnInstance1.class).build();
@@ -195,19 +230,21 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
 
     private void bindServiceOnInterface(Interface intf, long vpnId) {
         LOG.info("Bind service on interface {} for VPN: {}", intf, vpnId);
-        //TODO: Create Ingress flow on the interface to bind the VPN service
-        //TODO: Get dpn ID from the interface manager
-        long dpId = 1;
-        short LPORT_INGRESS_TABLE = 0;
-        //TODO: Get the port no from interface manager
-        int portNo = 1;
-        String flowRef = getL3InterfaceFlowRef(dpId, LPORT_INGRESS_TABLE, vpnId, portNo);
+
+        long dpId = interfaceManager.getDpnForInterface(intf.getName()); 
+        if(dpId == 0L) {
+            LOG.warn("DPN for interface {} not found. Bind service on this interface aborted.", intf.getName());
+            return;
+        }
+
+        long portNo = interfaceManager.getPortForInterface(intf.getName());
+        String flowRef = getVpnInterfaceFlowRef(dpId, VpnConstants.LPORT_INGRESS_TABLE, vpnId, portNo);
 
         String flowName = intf.getName();
         BigInteger COOKIE_VM_INGRESS_TABLE = new BigInteger("8000001", 16);
 
-        int priority = 10; //L3Constants.DEFAULT_L3_FLOW_PRIORITY;
-        short gotoTableId = 21; //L3Constants.L3_FIB_TABLE;
+        int priority = VpnConstants.DEFAULT_FLOW_PRIORITY;
+        short gotoTableId = VpnConstants.FIB_TABLE;
 
         List<InstructionInfo> mkInstructions = new ArrayList<InstructionInfo>();
         mkInstructions.add(new InstructionInfo(InstructionType.write_metadata, new BigInteger[] {
@@ -219,23 +256,20 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
         matches.add(new MatchInfo(MatchFieldType.in_port, new long[] {
                 dpId, portNo }));
 
-        FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, LPORT_INGRESS_TABLE, flowRef,
+        FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, VpnConstants.LPORT_INGRESS_TABLE, flowRef,
                           priority, flowName, 0, 0, COOKIE_VM_INGRESS_TABLE, matches, mkInstructions);
 
         mdsalManager.installFlow(flowEntity);
     }
 
-    private String getL3InterfaceFlowRef(long dpId, short tableId,
-            long vpnId, int portNo) {
+    private String getVpnInterfaceFlowRef(long dpId, short tableId,
+            long vpnId, long portNo) {
         return new StringBuilder().append(dpId).append(tableId).append(vpnId).append(portNo).toString();
     }
 
-    private void updatePrefixToBGP(String rd, Adjacency nextHop, String nextHopIp) {
-        //TODO: Update the Prefix to BGP
-        //public void addPrefix(String rd, String prefix, String nextHop, int vpnLabel)
-        int label = nextHop.getLabel().intValue();
+    private void updatePrefixToBGP(String rd, Adjacency nextHop, String nextHopIp, long label) {
         try {
-            bgpManager.addPrefix(rd, nextHop.getIpAddress(), nextHopIp, label);
+            bgpManager.addPrefix(rd, nextHop.getIpAddress(), nextHopIp, (int)label);
         } catch(Exception e) {
             LOG.error("Add prefix failed", e);
         }
@@ -271,7 +305,7 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
         Optional<Interface> port = read(LogicalDatastoreType.CONFIGURATION, id);
         if (port.isPresent()) {
             Interface interf = port.get();
-            unbindServiceOnInterface(interf);
+            unbindServiceOnInterface(interf, getVpnId(vpnInterface.getVpnInstanceName()));
             removeNextHops(identifier, vpnInterface);
         } else {
             LOG.info("No nexthops were available to handle remove event {}", interfaceName);
@@ -283,21 +317,19 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
         InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
         Optional<Adjacencies> adjacencies = read(LogicalDatastoreType.OPERATIONAL, path);
         String intfName = intf.getName();
-
+        String rd = getRouteDistinguisher(intf.getVpnInstanceName());
         if (adjacencies.isPresent()) {
             List<Adjacency> nextHops = adjacencies.get().getAdjacency();
 
             if (!nextHops.isEmpty()) {
                 LOG.trace("NextHops are " + nextHops);
                 for (Adjacency nextHop : nextHops) {
-                    //TODO: Update BGP
-                    removePrefixFromBGP(nextHop);
+                    removePrefixFromBGP(rd, nextHop);
                 }
             }
-
-            InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(intfName);
-            delete(LogicalDatastoreType.OPERATIONAL, interfaceId);
         }
+        InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(intfName);
+        delete(LogicalDatastoreType.OPERATIONAL, interfaceId);
     }
 
     private <T extends DataObject> void delete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
@@ -306,12 +338,39 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
         Futures.addCallback(tx.submit(), DEFAULT_CALLBACK);
     }
 
-    private void unbindServiceOnInterface(Interface intf) {
-        //TODO: Remove Ingress flow on the interface to unbind the VPN service
+    private void unbindServiceOnInterface(Interface intf, long vpnId) {
+        LOG.info("Unbind service on interface {} for VPN: {}", intf, vpnId);
+
+        long dpId = interfaceManager.getDpnForInterface(intf.getName());
+        if(dpId == 0L) {
+            LOG.warn("DPN for interface {} not found. Unbind service on this interface aborted.", intf.getName());
+            return;
+        }
+
+        long portNo = interfaceManager.getPortForInterface(intf.getName());
+        String flowRef = getVpnInterfaceFlowRef(dpId, VpnConstants.LPORT_INGRESS_TABLE, vpnId, portNo);
+
+        String flowName = intf.getName();
+
+        int priority = VpnConstants.DEFAULT_FLOW_PRIORITY;
+
+        List<MatchInfo> matches = new ArrayList<MatchInfo>();
+        matches.add(new MatchInfo(MatchFieldType.in_port, new long[] {
+                dpId, portNo }));
+
+        FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, VpnConstants.LPORT_INGRESS_TABLE, flowRef,
+                          priority, flowName, 0, 0, null, matches, null);
+
+        mdsalManager.removeFlow(flowEntity);
     }
 
-    private void removePrefixFromBGP(Adjacency nextHop) {
-        //TODO: Update the Prefix to BGP
+    private void removePrefixFromBGP(String rd, Adjacency nextHop) {
+        //public void deletePrefix(String rd, String prefix) throws Exception;
+        try {
+            bgpManager.deletePrefix(rd, nextHop.getIpAddress());
+        } catch(Exception e) {
+            LOG.error("Delete prefix failed", e);
+        }
     }
 
     @Override

diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java
index c05506bb739ff74fa14e38623b9ce7e2db47d2af..0e60710092a1bda755592345928e15e4fefc2aa5 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java
+++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnManager.java
@@ -11,6 +11,8 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 
 import org.opendaylight.bgpmanager.api.IBgpManager;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
@@ -20,6 +22,7 @@ import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataCh
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
@@ -32,6 +35,10 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev15
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTables;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.fibentries.VrfTablesKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.vrfentries.VrfEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.GetUniqueIdOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -44,6 +51,7 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
     private ListenerRegistration<DataChangeListener> listenerRegistration, fibListenerRegistration;
     private final DataBroker broker;
     private final IBgpManager bgpManager;
+    private IdManagerService idManager;
     private final FibEntriesListener fibListener;
 
     private static final FutureCallback<Void> DEFAULT_CALLBACK =
@@ -83,24 +91,37 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
         }
     }
 
+    public void setIdManager(IdManagerService idManager) {
+        this.idManager = idManager;
+    }
+
     @Override
-    protected void remove(InstanceIdentifier<VpnInstance> identifier,
-            VpnInstance del) {
-        // TODO Auto-generated method stub
+    protected void remove(InstanceIdentifier<VpnInstance> identifier, VpnInstance del) {
+        LOG.info("Remove event - Key: {}, value: {}", identifier, del);
+        String vpnName = del.getVpnInstanceName();
+        InstanceIdentifier<VpnInstance> vpnIdentifier = VpnUtil.getVpnInstanceIdentifier(vpnName);
+        delete(LogicalDatastoreType.OPERATIONAL, vpnIdentifier);
+
+        String rd = del.getIpv4Family().getRouteDistinguisher();
+        try {
+            bgpManager.deleteVrf(rd);
+        } catch(Exception e) {
+            LOG.error("Exception when removing VRF from BGP", e);
+        }
     }
 
     @Override
     protected void update(InstanceIdentifier<VpnInstance> identifier,
             VpnInstance original, VpnInstance update) {
-        // TODO Auto-generated method stub
+        LOG.info("Update event - Key: {}, value: {}", identifier, update);
     }
 
     @Override
     protected void add(InstanceIdentifier<VpnInstance> identifier,
             VpnInstance value) {
         LOG.info("key: {}, value: {}" +identifier, value);
-        //TODO: Generate VPN ID for this instance, where to store in model ... ?
-        long vpnId = 1000;
+
+        long vpnId = getUniqueId(value.getVpnInstanceName());
         InstanceIdentifier<VpnInstance1> augId = identifier.augmentation(VpnInstance1.class);
         Optional<VpnInstance1> vpnAugmenation = read(LogicalDatastoreType.CONFIGURATION, augId);
         if(vpnAugmenation.isPresent()) {
@@ -114,7 +135,6 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
 
         asyncWrite(LogicalDatastoreType.OPERATIONAL, identifier, opValue, DEFAULT_CALLBACK);
 
-        //TODO: Add VRF to BGP
         //public void addVrf(String rd, Collection<String> importRts, Collection<String> exportRts)
         VpnAfConfig config = value.getIpv4Family();
         String rd = config.getRouteDistinguisher();
@@ -193,6 +213,31 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
         return null;
     }
 
+    private Integer getUniqueId(String idKey) {
+        GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder()
+                                           .setPoolName(VpnConstants.VPN_IDPOOL_NAME)
+                                           .setIdKey(idKey).build();
+
+        try {
+            Future<RpcResult<GetUniqueIdOutput>> result = idManager.getUniqueId(getIdInput);
+            RpcResult<GetUniqueIdOutput> rpcResult = result.get();
+            if(rpcResult.isSuccessful()) {
+                return rpcResult.getResult().getIdValue().intValue();
+            } else {
+                LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
+            }
+        } catch (NullPointerException | InterruptedException | ExecutionException e) {
+            LOG.warn("Exception when getting Unique Id",e);
+        }
+        return 0;
+    }
+
+    private <T extends DataObject> void delete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
+        WriteTransaction tx = broker.newWriteOnlyTransaction();
+        tx.delete(datastoreType, path);
+        Futures.addCallback(tx.submit(), DEFAULT_CALLBACK);
+    }
+
     private class FibEntriesListener extends AbstractDataChangeListener<VrfEntry>  {
 
         public FibEntriesListener() {
@@ -202,8 +247,32 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
         @Override
         protected void remove(InstanceIdentifier<VrfEntry> identifier,
                 VrfEntry del) {
-            // TODO Auto-generated method stub
-
+            LOG.info("Remove Fib event - Key : {}, value : {} ",identifier, del);
+            final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
+            String rd = key.getRouteDistinguisher();
+            Long label = del.getLabel();
+            VpnInstance vpn = getVpnForRD(rd);
+            if(vpn != null) {
+                InstanceIdentifier<VpnInstance> id = VpnUtil.getVpnInstanceIdentifier(vpn.getVpnInstanceName());
+                InstanceIdentifier<VpnInstance1> augId = id.augmentation(VpnInstance1.class);
+                Optional<VpnInstance1> vpnAugmenation = read(LogicalDatastoreType.OPERATIONAL, augId);
+                if(vpnAugmenation.isPresent()) {
+                    VpnInstance1 vpnAug = vpnAugmenation.get();
+                    List<Long> routeIds = vpnAug.getRouteEntryId();
+                    if(routeIds == null) {
+                        LOG.debug("Fib Route entry is empty.");
+                        return;
+                    }
+                    LOG.info("Removing label from vpn info - {}", label);
+                    routeIds.remove(label);
+                    asyncWrite(LogicalDatastoreType.OPERATIONAL, augId,
+                            new VpnInstance1Builder(vpnAug).setRouteEntryId(routeIds).build(), DEFAULT_CALLBACK);
+                } else {
+                    LOG.info("VPN Augmentation not found");
+                }
+            } else {
+                LOG.warn("No VPN Instance found for RD: {}", rd);
+            }
         }
 
         @Override
@@ -216,7 +285,7 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
         @Override
         protected void add(InstanceIdentifier<VrfEntry> identifier,
                 VrfEntry add) {
-            LOG.info("Key : " + identifier + " value : " + add);
+            LOG.info("Add Vrf Entry event - Key : {}, value : {}",identifier, add);
             final VrfTablesKey key = identifier.firstKeyOf(VrfTables.class, VrfTablesKey.class);
             String rd = key.getRouteDistinguisher();
             Long label = add.getLabel();
@@ -231,7 +300,7 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
                     if(routeIds == null) {
                         routeIds = new ArrayList<>();
                     }
-                    LOG.info("Adding label to vpn info " + label);
+                    LOG.info("Adding label to vpn info - {}", label);
                     routeIds.add(label);
                     asyncWrite(LogicalDatastoreType.OPERATIONAL, augId,
                             new VpnInstance1Builder(vpnAug).setRouteEntryId(routeIds).build(), DEFAULT_CALLBACK);

diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnUtil.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnUtil.java
index b7c9721e255946f2011bb1ffb0ce0b2663a9f93f..fc70f055b085d4de055b2611ee1deaccdb694adc 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnUtil.java
+++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnUtil.java
@@ -1,6 +1,9 @@
 package org.opendaylight.vpnservice;
 
 import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
@@ -11,7 +14,11 @@ import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev14081
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.AdjacenciesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.Pools;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPool;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPoolKey;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
 
 public class VpnUtil {
     static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
@@ -32,4 +39,11 @@ public class VpnUtil {
     static Adjacencies getVpnInterfaceAugmentation(List<Adjacency> nextHops) {
         return new AdjacenciesBuilder().setAdjacency(nextHops).build();
     }
+
+    public static InstanceIdentifier<IdPool> getPoolId(String poolName){
+        InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
+                        InstanceIdentifier.builder(Pools.class).child(IdPool.class, new IdPoolKey(poolName));
+        InstanceIdentifier<IdPool> id = idBuilder.build();
+        return id;
+    }
 }

diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java
index a93dc1c2611d4e711452b28b744efb2aa55d819c..441733217736d8aace2164a5bfbe2c93d783a4e2 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java
+++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/vpnservice/VpnserviceProvider.java
@@ -7,7 +7,10 @@
  */
 package org.opendaylight.vpnservice;
 
+import java.math.BigInteger;
 import java.util.Collections;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 
 import org.opendaylight.bgpmanager.api.IBgpManager;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
@@ -15,6 +18,10 @@ import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderCo
 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
 import org.opendaylight.vpnservice.interfacemgr.interfaces.IInterfaceManager;
 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
+import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -27,6 +34,7 @@ public class VpnserviceProvider implements BindingAwareProvider,
     private IBgpManager bgpManager;
     private IMdsalApiManager mdsalManager;
     private IInterfaceManager interfaceManager;
+    private IdManagerService idManager;
 
     @Override
     public void onSessionInitiated(ProviderContext session) {
@@ -34,8 +42,12 @@ public class VpnserviceProvider implements BindingAwareProvider,
         try {
             final  DataBroker dataBroker = session.getSALService(DataBroker.class);
             vpnManager = new VpnManager(dataBroker, bgpManager);
+            vpnManager.setIdManager(idManager);
             vpnInterfaceManager = new VpnInterfaceManager(dataBroker, bgpManager);
             vpnInterfaceManager.setMdsalManager(mdsalManager);
+            vpnInterfaceManager.setInterfaceManager(interfaceManager);
+            vpnInterfaceManager.setIdManager(idManager);
+            createIdPool();
         } catch (Exception e) {
             LOG.error("Error initializing services", e);
         }
@@ -54,6 +66,26 @@ public class VpnserviceProvider implements BindingAwareProvider,
         this.interfaceManager = interfaceManager;
     }
 
+    public void setIdManager(IdManagerService idManager) {
+        this.idManager = idManager;
+    }
+
+    private void createIdPool() {
+        CreateIdPoolInput createPool = new CreateIdPoolInputBuilder()
+            .setPoolName(VpnConstants.VPN_IDPOOL_NAME)
+            .setIdStart(VpnConstants.VPN_IDPOOL_START)
+            .setPoolSize(new BigInteger(VpnConstants.VPN_IDPOOL_SIZE))
+            .build();
+        try {
+           Future<RpcResult<Void>> result = idManager.createIdPool(createPool);
+           if ((result != null) && (result.get().isSuccessful())) {
+                LOG.info("Created IdPool for VPN Service");
+            }
+        } catch (InterruptedException | ExecutionException e) {
+            LOG.error("Failed to create idPool for VPN Service",e);
+        }
+    }
+
     @Override
     public void close() throws Exception {
         vpnManager.close();

diff --git a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpnservice/impl/rev150216/VpnserviceImplModule.java b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpnservice/impl/rev150216/VpnserviceImplModule.java
index cbab6e84ac2e254779ed46784e5e2d6ab2db5922..14e2539d15b3399cdacea0f70088a9abd69cc3d9 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpnservice/impl/rev150216/VpnserviceImplModule.java
+++ b/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/vpnservice/impl/rev150216/VpnserviceImplModule.java
@@ -8,6 +8,7 @@
 package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpnservice.impl.rev150216;
 
 import org.opendaylight.vpnservice.VpnserviceProvider;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
 
 public class VpnserviceImplModule extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpnservice.impl.rev150216.AbstractVpnserviceImplModule {
     public VpnserviceImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
@@ -25,10 +26,12 @@ public class VpnserviceImplModule extends org.opendaylight.yang.gen.v1.urn.opend
 
     @Override
     public java.lang.AutoCloseable createInstance() {
+        IdManagerService idManager = getRpcregistryDependency().getRpcService(IdManagerService.class);
         VpnserviceProvider provider = new VpnserviceProvider();
         provider.setBgpManager(getBgpmanagerDependency());
         provider.setMdsalManager(getMdsalutilDependency());
         provider.setInterfaceManager(getOdlinterfaceDependency());
+        provider.setIdManager(idManager);
         getBrokerDependency().registerProvider(provider);
         return provider;
     }

diff --git a/vpnmanager/vpnmanager-impl/src/main/yang/vpnservice-impl.yang b/vpnmanager/vpnmanager-impl/src/main/yang/vpnservice-impl.yang
index b1703e2227d693432a7e3c27c52ff5d00a769d7d..d73c9d621d6aad569804fdbadfdfb699aff2c75f 100644 (file)
--- a/vpnmanager/vpnmanager-impl/src/main/yang/vpnservice-impl.yang
+++ b/vpnmanager/vpnmanager-impl/src/main/yang/vpnservice-impl.yang
@@ -33,6 +33,14 @@ module vpnservice-impl {
                     }
                 }
             }
+            container rpcregistry {
+                uses config:service-ref {
+                    refine type {
+                        mandatory true;
+                        config:required-identity md-sal-binding:binding-rpc-registry;
+                    }
+                }
+            }
             container bgpmanager {
                 uses config:service-ref {
                     refine type {