Bug 5770: Ensuring proper cleanup of VPNControlpath.

1. Fix to ensure proper cleanup of Config and Oper DS
for VPN on removal of VPNs.

2. Fix for delayed release of VPN IDs by ensuring that
we release IDs for VPN and VPNInterfaces only when
the IDs are removed from respective OpDataStores.

Change-Id: Idda295e845af77355c2d7bdf0f60864782a9538c
Signed-off-by: Suraj Ranjan <suraj.ranjan@ericsson.com>
Co-Authored-By: Vivekanandan Narasimhan <n.vivekanandan@ericsson.com>

diff --git a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibConstants.java b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibConstants.java
index a2cfc76e81e4b625ecea50a14b50bee0b2cb7c3d..52dc950e84c243c2a7dbe190099dda3119c1b5bc 100644 (file)
--- a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibConstants.java
+++ b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibConstants.java
@@ -15,4 +15,6 @@ public class FibConstants {
     static final BigInteger COOKIE_TUNNEL = new BigInteger("9000000", 16);
     static final int DEFAULT_FIB_FLOW_PRIORITY = 10;
     static final String FLOWID_PREFIX = "L3.";
+    static final String VPN_IDPOOL_NAME = "vpnservices";
+    static final String SEPARATOR = ".";
 }

diff --git a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java
index 28419440cb9806aca1aa91f382b4a056f7ff0e18..a1e729f7aec9207ed7bf368e4f1178fdde82a7b8 100644 (file)
--- a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java
+++ b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManager.java
@@ -56,6 +56,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instanc
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.overlay.rev150105.TunnelTypeVxlan;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.itm.rpcs.rev151217.ItmRpcService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.Vpn;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.VpnKey;
@@ -93,6 +94,7 @@ public class FibManager extends AbstractDataChangeListener<VrfEntry> implements
   private NexthopManager nextHopManager;
   private ItmRpcService itmManager;
   private OdlInterfaceRpcService interfaceManager;
+  private IdManagerService idManager;
   private static final BigInteger COOKIE_VM_LFIB_TABLE = new BigInteger("8000002", 16);
   private static final BigInteger COOKIE_VM_FIB_TABLE =  new BigInteger("8000003", 16);
   private static final int DEFAULT_FIB_FLOW_PRIORITY = 10;
@@ -140,6 +142,10 @@ public class FibManager extends AbstractDataChangeListener<VrfEntry> implements
       this.interfaceManager = ifManager;
   }
 
+  public void setIdManager(IdManagerService idManager) {
+      this.idManager = idManager;
+  }
+
   private void registerListener(final DataBroker db) {
     try {
       listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
@@ -182,12 +188,13 @@ public class FibManager extends AbstractDataChangeListener<VrfEntry> implements
     Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!");
 
     VpnInstanceOpDataEntry vpnInstance = getVpnInstance(vrfTableKey.getRouteDistinguisher());
-    Preconditions.checkNotNull(vpnInstance, "Vpn Instance not available!");
-    Preconditions.checkNotNull(vpnInstance.getVpnId(), "Vpn Instance with rd " + vpnInstance.getVrfId() + "has null vpnId!");
+    Preconditions.checkNotNull(vpnInstance, "Vpn Instance not available " + vrfTableKey.getRouteDistinguisher());
+    Preconditions.checkNotNull(vpnInstance.getVpnId(), "Vpn Instance with rd " + vpnInstance.getVrfId() + " has null vpnId!");
 
     Collection<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
     Long vpnId = vpnInstance.getVpnId();
-    RdToElanOpEntry rdToElanOpEntry = getRdToElanOpEntry(broker, vrfTableKey.getRouteDistinguisher(),
+    String rd = vrfTableKey.getRouteDistinguisher();
+    RdToElanOpEntry rdToElanOpEntry = getRdToElanOpEntry(broker, rd,
             vrfEntry.getDestPrefix());
     if (rdToElanOpEntry!=null) {
         if (vpnToDpnList!=null) {
@@ -198,14 +205,14 @@ public class FibManager extends AbstractDataChangeListener<VrfEntry> implements
         return;
     }
     BigInteger localDpnId = createLocalFibEntry(vpnInstance.getVpnId(),
-              vrfTableKey.getRouteDistinguisher(), vrfEntry);
+            rd, vrfEntry);
     if (vpnToDpnList != null) {
-      for (VpnToDpnList curDpn : vpnToDpnList) {
-        if (!curDpn.getDpnId().equals(localDpnId)) {
-          createRemoteFibEntry(localDpnId, curDpn.getDpnId(), vpnInstance.getVpnId(),
-                               vrfTableKey, vrfEntry);
+        for (VpnToDpnList curDpn : vpnToDpnList) {
+            if (!curDpn.getDpnId().equals(localDpnId)) {
+                createRemoteFibEntry(localDpnId, curDpn.getDpnId(), vpnInstance.getVpnId(),
+                        vrfTableKey, vrfEntry);
+            }
         }
-      }
     }
   }
 
@@ -567,7 +574,11 @@ public class FibManager extends AbstractDataChangeListener<VrfEntry> implements
           LOG.trace("Clean up vpn interface {} from dpn {} to vpn {} list.", ifName, prefixInfo.getDpnId(), rd);
           FibUtil.delete(broker, LogicalDatastoreType.OPERATIONAL,
                          FibUtil.getVpnInterfaceIdentifier(ifName));
-       }
+      }
+
+      FibUtil.releaseId(idManager, FibConstants.VPN_IDPOOL_NAME,
+         FibUtil.getNextHopLabelKey(rd, vrfEntry.getDestPrefix()));
+
   }
 
   private void deleteFibEntries(final InstanceIdentifier<VrfEntry> identifier,
@@ -576,8 +587,12 @@ public class FibManager extends AbstractDataChangeListener<VrfEntry> implements
     Preconditions.checkNotNull(vrfTableKey, "VrfTablesKey cannot be null or empty!");
     Preconditions.checkNotNull(vrfEntry, "VrfEntry cannot be null or empty!");
 
+    String rd  = vrfTableKey.getRouteDistinguisher();
     VpnInstanceOpDataEntry vpnInstance = getVpnInstance(vrfTableKey.getRouteDistinguisher());
-    Preconditions.checkNotNull(vpnInstance, "Vpn Instance not available!");
+    if (vpnInstance == null) {
+        LOG.debug("VPN Instance for rd {} is not available from VPN Op Instance Datastore", rd);
+        return;
+    }
     Collection<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
     RdToElanOpEntry rdToElanOpEntry= getRdToElanOpEntry(broker,vrfTableKey.getRouteDistinguisher(),
             vrfEntry.getDestPrefix());
@@ -595,16 +610,18 @@ public class FibManager extends AbstractDataChangeListener<VrfEntry> implements
         InstanceIdentifier<RdToElanOpEntry> id = getRdToElanOpEntryDataPath(vrfTableKey.getRouteDistinguisher(),
                 vrfEntry.getDestPrefix());
         MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL,id);
+        FibUtil.releaseId(idManager,FibConstants.VPN_IDPOOL_NAME,
+                FibUtil.getNextHopLabelKey(rd, vrfEntry.getDestPrefix()));
         return;
     }
     BigInteger localDpnId = deleteLocalFibEntry(vpnInstance.getVpnId(),
-              vrfTableKey.getRouteDistinguisher(), vrfEntry);
+            vrfTableKey.getRouteDistinguisher(), vrfEntry);
     if (vpnToDpnList != null) {
-      for (VpnToDpnList curDpn : vpnToDpnList) {
-        if (!curDpn.getDpnId().equals(localDpnId)) {
-          deleteRemoteRoute(localDpnId, curDpn.getDpnId(), vpnInstance.getVpnId(), vrfTableKey, vrfEntry);
+        for (VpnToDpnList curDpn : vpnToDpnList) {
+            if (!curDpn.getDpnId().equals(localDpnId)) {
+                deleteRemoteRoute(localDpnId, curDpn.getDpnId(), vpnInstance.getVpnId(), vrfTableKey, vrfEntry);
+            }
         }
-      }
     }
     //The flow/group entry has been deleted from config DS; need to clean up associated operational
     //DS entries in VPN Op DS, VpnInstanceOpData and PrefixToInterface to complete deletion

diff --git a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManagerProvider.java b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManagerProvider.java
index 52e8fd9409fc759fb907576af3ee0fcaec52fbc7..62f9e7111c0f22bf2f57adbd64b2eb752366f731 100644 (file)
--- a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManagerProvider.java
+++ b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibManagerProvider.java
@@ -55,6 +55,7 @@ public class FibManagerProvider implements BindingAwareProvider, IFibManager, Au
       fibManager.setNextHopManager(nexthopManager);
       fibManager.setITMRpcService(itmManager);
       fibManager.setInterfaceManager(interfaceManager);
+      fibManager.setIdManager(idManager);
       fibNcListener = new FibNodeCapableListener(dataBroker, fibManager);
       FibRpcService fibRpcService = new FibRpcServiceImpl(dataBroker, mdsalManager, this);
       rpcRegistration = getRpcProviderRegistry().addRpcImplementation(FibRpcService.class, fibRpcService);

diff --git a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibUtil.java b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibUtil.java
index 1c13444093e8cc3620308452511e3cfc7972f06e..0ba7296d38902663a2dac3505942b8eb5fd4cdcc 100644 (file)
--- a/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibUtil.java
+++ b/fibmanager/fibmanager-impl/src/main/java/org/opendaylight/vpnservice/fibmanager/FibUtil.java
@@ -21,12 +21,19 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInputBuilder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.math.BigInteger;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 
 public class FibUtil {
     private static final Logger LOG = LoggerFactory.getLogger(FibUtil.class);
@@ -100,6 +107,24 @@ public class FibUtil {
                         new org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.to.extraroute.vpn.ExtrarouteKey(ipPrefix)).build();
     }
 
+    static String getNextHopLabelKey(String rd, String prefix){
+        String key = rd + FibConstants.SEPARATOR + prefix;
+        return key;
+    }
+
+    static void releaseId(IdManagerService idManager, String poolName, String idKey) {
+        ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
+        try {
+            Future<RpcResult<Void>> result = idManager.releaseId(idInput);
+            RpcResult<Void> rpcResult = result.get();
+            if(!rpcResult.isSuccessful()) {
+                LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
+            }
+        } catch (InterruptedException | ExecutionException e) {
+            LOG.warn("Exception when getting Unique Id for key {}", idKey, e);
+        }
+    }
+
     static final FutureCallback<Void> DEFAULT_CALLBACK =
             new FutureCallback<Void>() {
                 public void onSuccess(Void result) {

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 f128faca1b5ecfa50d64cf3ba78cd0d8f4610562..ac639b42fe44d2de47c958d063a980958ef4178f 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
@@ -522,9 +522,10 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
             if (!nextHops.isEmpty()) {
                 LOG.trace("NextHops are " + nextHops);
                 for (Adjacency nextHop : nextHops) {
-                    VpnUtil.releaseId(idManager, VpnConstants.VPN_IDPOOL_NAME,
+                    // Commenting the release of ID here as it will be released by FIB
+                   /* VpnUtil.releaseId(idManager, VpnConstants.VPN_IDPOOL_NAME,
                                       VpnUtil.getNextHopLabelKey(rd, nextHop.getIpAddress()));
-                    /*VpnUtil.delete(broker, LogicalDatastoreType.OPERATIONAL,
+                    VpnUtil.delete(broker, LogicalDatastoreType.OPERATIONAL,
                                    VpnUtil.getPrefixToInterfaceIdentifier(
                                        VpnUtil.getVpnId(broker, intf.getVpnInstanceName()),
                                        nextHop.getIpAddress()),
@@ -736,8 +737,9 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
                     while (adjIt.hasNext()) {
                         Adjacency adjElem = adjIt.next();
                         if (adjElem.getIpAddress().equals(adj.getIpAddress())) {
-                            VpnUtil.releaseId(idManager, VpnConstants.VPN_IDPOOL_NAME,
-                                    VpnUtil.getNextHopLabelKey(rd, adj.getIpAddress()));
+                            // Commenting the release of ID here as it will be released by FIB
+                           /* VpnUtil.releaseId(idManager, VpnConstants.VPN_IDPOOL_NAME,
+                                    VpnUtil.getNextHopLabelKey(rd, adj.getIpAddress()));*/
                             adjIt.remove();
 
                             Adjacencies aug = VpnUtil.getVpnInterfaceAugmentation(adjacencies);
@@ -822,16 +824,6 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
                         interfaceName, rd, vpnName, vpnInstOp);
 
                 if (vpnInstOp != null) {
-                    Long ifCnt = 0L;
-                    ifCnt = vpnInstOp.getVpnInterfaceCount();
-                    LOG.trace("VpnInterfaceOpListener removed: interface name {} rd {} vpnName {} Intf count {}",
-                            interfaceName, rd, vpnName, ifCnt);
-                    if ((ifCnt != null) && (ifCnt > 0)) {
-                        VpnUtil.asyncUpdate(broker, LogicalDatastoreType.OPERATIONAL,
-                                VpnUtil.getVpnInstanceOpDataIdentifier(rd),
-                                VpnUtil.updateIntfCntInVpnInstOpData(ifCnt - 1, rd), VpnUtil.DEFAULT_CALLBACK);
-                    }
-
                     // Vpn Interface removed => No more adjacencies from it.
                     // Hence clean up interface from vpn-dpn-interface list.
                     Adjacency adjacency = del.getAugmentation(Adjacencies.class).getAdjacency().get(0);
@@ -851,6 +843,15 @@ public class VpnInterfaceManager extends AbstractDataChangeListener<VpnInterface
                                 VpnUtil.DEFAULT_CALLBACK);
                         updateDpnDbs(prefixToInterface.get().getDpnId(), del.getVpnInstanceName(), interfaceName, false);
                     }
+                    Long ifCnt = 0L;
+                    ifCnt = vpnInstOp.getVpnInterfaceCount();
+                    LOG.trace("VpnInterfaceOpListener removed: interface name {} rd {} vpnName {} Intf count {}",
+                            interfaceName, rd, vpnName, ifCnt);
+                    if ((ifCnt != null) && (ifCnt > 0)) {
+                        VpnUtil.asyncUpdate(broker, LogicalDatastoreType.OPERATIONAL,
+                                VpnUtil.getVpnInstanceOpDataIdentifier(rd),
+                                VpnUtil.updateIntfCntInVpnInstOpData(ifCnt - 1, rd), VpnUtil.DEFAULT_CALLBACK);
+                    }
                 }
             } else {
                 LOG.error("rd not retrievable as vpninstancetovpnid for vpn {} is absent, trying rd as ", vpnName, vpnName);

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 b41225ceef323f25f7f08a9f68169de9dcbec31a..e5d7a44aa0c8c8af842e64e8a2204912adc671ff 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
@@ -115,16 +115,20 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
         this.vpnInterfaceManager = vpnInterfaceManager;
     }
 
-    private void waitForOpDataRemoval(String id, long timeout) {
+    private void waitForOpRemoval(String id, long timeout) {
         //wait till DCN for update on VPN Instance Op Data signals that vpn interfaces linked to this vpn instance is zero
         Runnable notifyTask = new VpnNotifyTask();
         synchronized (id.intern()) {
-            vpnOpMap.put(id, notifyTask);
-            synchronized (notifyTask) {
-                try {
-                    notifyTask.wait(timeout);
-                } catch (InterruptedException e) {
+            try {
+                vpnOpMap.put(id, notifyTask);
+                synchronized (notifyTask) {
+                    try {
+                        notifyTask.wait(timeout);
+                    } catch (InterruptedException e) {
+                    }
                 }
+            } finally {
+                vpnOpMap.remove(id);
             }
         }
 
@@ -134,23 +138,8 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
     protected void remove(InstanceIdentifier<VpnInstance> identifier, VpnInstance del) {
         LOG.trace("Remove VPN event key: {}, value: {}", identifier, del);
         String vpnName = del.getVpnInstanceName();
-
         String rd = del.getIpv4Family().getRouteDistinguisher();
-
-//        //Clean up vpn Interface
-//        InstanceIdentifier<VpnInterfaces> vpnInterfacesId = InstanceIdentifier.builder(VpnInterfaces.class).build();
-//        Optional<VpnInterfaces> optionalVpnInterfaces = read(LogicalDatastoreType.OPERATIONAL, vpnInterfacesId);
-//
-//        if(optionalVpnInterfaces.isPresent()) {
-//            List<VpnInterface> vpnInterfaces = optionalVpnInterfaces.get().getVpnInterface();
-//            for(VpnInterface vpnInterface : vpnInterfaces) {
-//                if(vpnInterface.getVpnInstanceName().equals(vpnName)) {
-//                    LOG.debug("VpnInterface {} will be removed from VPN {}", vpnInterface.getName(), vpnName);
-//                    vpnInterfaceManager.remove(
-//                            VpnUtil.getVpnInterfaceIdentifier(vpnInterface.getName()), vpnInterface);
-//                }
-//            }
-//        }
+        long vpnId = VpnUtil.getVpnId(broker, vpnName);
 
         //TODO(vpnteam): Entire code would need refactoring to listen only on the parent object - VPNInstance
         Optional<VpnInstanceOpDataEntry> vpnOpValue = null;
@@ -176,39 +165,54 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
                 if (timeout > VpnConstants.MAX_WAIT_TIME_IN_MILLISECONDS) {
                     timeout = VpnConstants.MAX_WAIT_TIME_IN_MILLISECONDS;
                 }
-                LOG.trace("VPNInstance removal interface count at {} for for rd {}, vpnname {}",
+                LOG.trace("VPNInstance removal count of interface at {} for for rd {}, vpnname {}",
                         intfCount, rd, vpnName);
             }
             LOG.trace("VPNInstance removal thread waiting for {} seconds for rd {}, vpnname {}",
                     (timeout/1000), rd, vpnName);
 
             if ((rd != null)  && (!rd.isEmpty())) {
-                waitForOpDataRemoval(rd, timeout);
+                waitForOpRemoval(rd, timeout);
             } else {
-                waitForOpDataRemoval(vpnName, timeout);
+                waitForOpRemoval(vpnName, timeout);
             }
 
             LOG.trace("Returned out of waiting for  Op Data removal for rd {}, vpnname {}", rd, vpnName);
         }
-
-        InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance>
-                vpnIdentifier = VpnUtil.getVpnInstanceToVpnIdIdentifier(vpnName);
-        delete(LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
+        // Clean up VpnInstanceToVpnId from Config DS
+        VpnUtil.removeVpnInstanceToVpnId(broker, vpnName);
         LOG.trace("Removed vpnIdentifier for  rd{} vpnname {}", rd, vpnName);
-        if (rd !=null) {
-
+        if (rd != null) {
             try {
                 bgpManager.deleteVrf(rd);
             } catch (Exception e) {
-                LOG.error("Exception when removing VRF from BGP", e);
+                LOG.error("Exception when removing VRF from BGP for RD {} in VPN {} exception " + e, rd, vpnName);
             }
 
-            delete(LogicalDatastoreType.OPERATIONAL, VpnUtil.getVpnInstanceOpDataIdentifier(rd));
+            // Clean up VPNExtraRoutes Operational DS
+            VpnUtil.removeVpnExtraRouteForVpn(broker, rd);
+
+            // Clean up VPNInstanceOpDataEntry
+            VpnUtil.removeVpnOpInstance(broker, rd);
         } else {
+            // Clean up FIB Entries Config DS
+            VpnUtil.removeVrfTableForVpn(broker, vpnName);
+
+            // Clean up VPNExtraRoutes Operational DS
+            VpnUtil.removeVpnExtraRouteForVpn(broker, vpnName);
 
-            delete(LogicalDatastoreType.OPERATIONAL, VpnUtil.getVpnInstanceOpDataIdentifier(vpnName));
+            // Clean up VPNInstanceOpDataEntry
+            VpnUtil.removeVpnOpInstance(broker, vpnName);
         }
 
+        // Clean up PrefixToInterface Operational DS
+        VpnUtil.removePrefixToInterfaceForVpnId(broker, vpnId);
+
+        // Clean up L3NextHop Operational DS
+        VpnUtil.removeL3nexthopForVpnId(broker, vpnId);
+
+        // Release the ID used for this VPN back to IdManager
+
         VpnUtil.releaseId(idManager, VpnConstants.VPN_IDPOOL_NAME, vpnName);
     }
 
@@ -237,14 +241,20 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
 
 
         if(rd == null) {
+            VpnInstanceOpDataEntryBuilder builder = new VpnInstanceOpDataEntryBuilder();
+            builder.setVrfId(value.getVpnInstanceName()).setVpnId(vpnId);
+            builder.setVpnInterfaceCount(0L);
             syncWrite(LogicalDatastoreType.OPERATIONAL,
                     VpnUtil.getVpnInstanceOpDataIdentifier(value.getVpnInstanceName()),
-                    VpnUtil.getVpnInstanceOpDataBuilder(value.getVpnInstanceName(), vpnId), DEFAULT_CALLBACK);
+                    builder.build(), DEFAULT_CALLBACK);
 
         } else {
+            VpnInstanceOpDataEntryBuilder builder = new VpnInstanceOpDataEntryBuilder();
+            builder.setVrfId(rd).setVpnId(vpnId);
+            builder.setVpnInterfaceCount(0L);
             syncWrite(LogicalDatastoreType.OPERATIONAL,
                        VpnUtil.getVpnInstanceOpDataIdentifier(rd),
-                       VpnUtil.getVpnInstanceOpDataBuilder(rd, vpnId), DEFAULT_CALLBACK);
+                       builder.build(), DEFAULT_CALLBACK);
 
             List<VpnTarget> vpnTargetList = config.getVpnTargets().getVpnTarget();
 
@@ -468,6 +478,7 @@ public class VpnManager extends AbstractDataChangeListener<VpnInstance> implemen
         private void notifyTaskIfRequired(String vpnName) {
             Runnable notifyTask = vpnOpMap.remove(vpnName);
             if (notifyTask == null) {
+                LOG.trace("VpnInstanceOpListener update: No Notify Task queued for vpnName {}", vpnName);
                 return;
             }
             executorService.execute(notifyTask);

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 76ad366faad1b3a4b98d607cd9c5ec9a17a87f8e..50c5eef4a4d64fac607934655cb18a3b8225d919 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
@@ -61,6 +61,9 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.E
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesListKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.fibmanager.rev150330.FibEntries;
+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.idmanager.rev150403.IdPools;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPool;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolKey;
@@ -73,6 +76,9 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007.IfIndexesInterfaceMap;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._if.indexes._interface.map.IfIndexInterface;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.meta.rev151007._if.indexes._interface.map.IfIndexInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.L3nexthop;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.VpnNexthops;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.l3nexthop.rev150409.l3nexthop.VpnNexthopsKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.NeutronPortData;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data.PortFixedipToPortName;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.neutron.port.data.PortFixedipToPortNameKey;
@@ -457,4 +463,66 @@ public class VpnUtil {
         return false;
     }
 
+    public static void removePrefixToInterfaceForVpnId(DataBroker broker, long vpnId) {
+        try {
+            // Clean up PrefixToInterface Operational DS
+            delete(broker, LogicalDatastoreType.OPERATIONAL,
+                    InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build(),
+                    DEFAULT_CALLBACK);
+        } catch (Exception e) {
+            LOG.error("Exception during cleanup of PrefixToInterface for VPN ID {}", vpnId, e);
+        }
+    }
+
+    public static void removeVpnExtraRouteForVpn(DataBroker broker, String vpnName) {
+        try {
+            // Clean up VPNExtraRoutes Operational DS
+            delete(broker, LogicalDatastoreType.OPERATIONAL,
+                    InstanceIdentifier.builder(VpnToExtraroute.class).child(Vpn.class, new VpnKey(vpnName)).build(),
+                    DEFAULT_CALLBACK);
+        } catch (Exception e) {
+            LOG.error("Exception during cleanup of VPNToExtraRoute for VPN {}", vpnName, e);
+        }
+    }
+
+    public static void removeVpnOpInstance(DataBroker broker, String vpnName) {
+        try {
+            // Clean up VPNInstanceOpDataEntry
+            delete(broker, LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName),
+                    DEFAULT_CALLBACK);
+        } catch (Exception e) {
+            LOG.error("Exception during cleanup of VPNInstanceOpDataEntry for VPN {}", vpnName, e);
+        }
+    }
+
+    public static void removeVpnInstanceToVpnId(DataBroker broker, String vpnName) {
+        try {
+            delete(broker, LogicalDatastoreType.CONFIGURATION, getVpnInstanceToVpnIdIdentifier(vpnName),
+                    DEFAULT_CALLBACK);
+        } catch (Exception e) {
+            LOG.error("Exception during clean up of VpnInstanceToVpnId for VPN {}", vpnName, e);
+        }
+    }
+
+    public static void removeVrfTableForVpn(DataBroker broker, String vpnName) {
+        // Clean up FIB Entries Config DS
+        try {
+            delete(broker, LogicalDatastoreType.CONFIGURATION,
+                    InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(vpnName)).build(),
+                    DEFAULT_CALLBACK);
+        } catch (Exception e) {
+            LOG.error("Exception during clean up of VrfTable from FIB for VPN {}", vpnName, e);
+        }
+    }
+
+    public static void removeL3nexthopForVpnId(DataBroker broker, long vpnId) {
+        try {
+            // Clean up L3NextHop Operational DS
+            delete(broker, LogicalDatastoreType.OPERATIONAL,
+                    InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class, new VpnNexthopsKey(vpnId)).build(),
+                    DEFAULT_CALLBACK);
+        } catch (Exception e) {
+            LOG.error("Exception during cleanup of L3NextHop for VPN ID {}", vpnId, e);
+        }
+    }
 }
\ No newline at end of file