ITM recovery is not working

Tunnels were not getting recovered and what we found is
Itm Direct Tunnel support was missing for tep and
transportzone recovery. So this patch is adding that.

Change-Id: Ie0c4df35065384e26dce9d271d229868daa4c8ce
Signed-off-by: Nidhi <nidhi.adhvaryu@ericsson.com>

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java
index 0ec7cfd74953c2b9658410fcaac5c5146c75cce7..09606d65142c324c4e7c0d15caab7021ecd2f315 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/impl/ItmUtils.java
@@ -117,6 +117,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.ho
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.not.hosted.transport.zones.TepsInNotHostedTransportZoneKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
@@ -1107,4 +1108,23 @@ public final class ItmUtils {
         return tunType ;
     }
 
+    public static List<BigInteger> getDpIdFromTransportzone(DataBroker dataBroker, String tzone) {
+        List<BigInteger> listOfDpId = new ArrayList<>();
+        InstanceIdentifier<TransportZone> path = InstanceIdentifier.builder(TransportZones.class)
+                .child(TransportZone.class, new TransportZoneKey(tzone)).build();
+        Optional<TransportZone> transportZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
+                path, dataBroker);
+        if (transportZoneOptional.isPresent()) {
+            TransportZone transportZone = transportZoneOptional.get();
+            if (transportZone.getVteps() != null && !transportZone.getVteps().isEmpty()) {
+                List<Vteps> vtepsList = transportZone.getVteps();
+                if (vtepsList != null && !vtepsList.isEmpty()) {
+                    for (Vteps vtep : vtepsList) {
+                        listOfDpId.add(vtep.getDpnId());
+                    }
+                }
+            }
+        }
+        return listOfDpId;
+    }
 }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTepInstanceRecoveryHandler.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTepInstanceRecoveryHandler.java
index d0bc3a085b70855dfe231d967d04980103a56791..8b1a0ace220fed7957c3569e620e74eb7c661210 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTepInstanceRecoveryHandler.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTepInstanceRecoveryHandler.java
@@ -9,6 +9,7 @@ package org.opendaylight.genius.itm.recovery.impl;
 
 import java.time.Duration;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -45,6 +46,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.tunnel.end.points.TzMembership;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTeps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey;
@@ -71,6 +74,8 @@ public class ItmTepInstanceRecoveryHandler implements ServiceRecoveryInterface {
     private final IMdsalApiManager imdsalApiManager;
     private final DataTreeEventCallbackRegistrar eventCallbacks;
     private final ManagedNewTransactionRunner txRunner;
+    private final IInterfaceManager interfaceManager;
+    private final DpnTepStateCache dpnTepStateCache;
 
     @Inject
     public ItmTepInstanceRecoveryHandler(DataBroker dataBroker,
@@ -104,6 +109,8 @@ public class ItmTepInstanceRecoveryHandler implements ServiceRecoveryInterface {
                 tunnelMonitoringConfig, interfaceManager, dpnTepStateCache, ovsBridgeEntryCache,
                 ovsBridgeRefEntryCache, tunnelStateCache, directTunnelUtils, ofEndPointCache, itmConfig);
         serviceRecoveryRegistry.registerServiceRecoveryRegistry(getServiceRegistryKey(), this);
+        this.interfaceManager = interfaceManager;
+        this.dpnTepStateCache = dpnTepStateCache;
     }
 
     private String getServiceRegistryKey() {
@@ -152,11 +159,27 @@ public class ItmTepInstanceRecoveryHandler implements ServiceRecoveryInterface {
                 jobCoordinator.enqueueJob(tzName, tepRemoveWorker);
                 AtomicInteger eventCallbackCount = new AtomicInteger(0);
                 AtomicInteger eventRegistrationCount = new AtomicInteger(0);
-                tunnelList.stream().filter(internalTunnel -> Objects.equals(internalTunnel
-                        .getDestinationDPN(), dpnTepsToRecover.getDPNID()) || Objects.equals(
-                        internalTunnel.getSourceDPN(), dpnTepsToRecover.getDPNID())).forEach(internalTunnel -> {
-                            eventRegistrationCount.incrementAndGet();
-                            interfaceListToRecover.add(String.valueOf(internalTunnel.getTunnelInterfaceNames())); });
+                if (interfaceManager.isItmDirectTunnelsEnabled()) {
+                    Collection<DpnsTeps> dpnsTeps = dpnTepStateCache.getAllPresent();
+                    for (DpnsTeps dpnTep : dpnsTeps) {
+                        List<RemoteDpns> rmtdpns = dpnTep.getRemoteDpns();
+                        for (RemoteDpns remoteDpn : rmtdpns) {
+                            if (remoteDpn.getDestinationDpnId().equals(dpnTepsToRecover.getDPNID())
+                                    || dpnTep.getSourceDpnId().equals(dpnTepsToRecover.getDPNID())) {
+                                eventRegistrationCount.incrementAndGet();
+                                interfaceListToRecover.add(remoteDpn.getTunnelName());
+                            }
+                        }
+                    }
+                    LOG.trace("List of tunnels to be recovered : {}", interfaceListToRecover);
+                } else {
+                    tunnelList.stream().filter(internalTunnel -> Objects.equals(internalTunnel
+                            .getDestinationDPN(), dpnTepsToRecover.getDPNID()) || Objects.equals(
+                            internalTunnel.getSourceDPN(), dpnTepsToRecover.getDPNID())).forEach(internalTunnel -> {
+                                eventRegistrationCount.incrementAndGet();
+                                interfaceListToRecover.add(String.valueOf(internalTunnel.getTunnelInterfaceNames()));
+                            });
+                }
 
                 if (!interfaceListToRecover.isEmpty()) {
                     interfaceListToRecover.forEach(interfaceName -> {
@@ -180,7 +203,6 @@ public class ItmTepInstanceRecoveryHandler implements ServiceRecoveryInterface {
         }
     }
 
-
     private void recreateTEP(String tzName, List tepts, AtomicInteger eventCallbackCount, int registeredEventSize) {
         eventCallbackCount.incrementAndGet();
         if (eventCallbackCount.intValue() == registeredEventSize || registeredEventSize == 0) {
@@ -188,9 +210,6 @@ public class ItmTepInstanceRecoveryHandler implements ServiceRecoveryInterface {
             ItmTepAddWorker tepAddWorker = new ItmTepAddWorker(tepts, null, dataBroker, imdsalApiManager,
                     itmInternalTunnelAddWorker, itmExternalTunnelAddWorker);
             jobCoordinator.enqueueJob(tzName, tepAddWorker);
-        } else {
-            LOG.trace("{} call back events registered for {} tunnel interfaces",
-                    registeredEventSize, eventCallbackCount);
         }
     }
 

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTzInstanceRecoveryHandler.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTzInstanceRecoveryHandler.java
index 163e71897fc4c7a8391905fd49bc01e99731efe4..dc952c4c5425aa0ae63f1e76de22c9f6af9b8b87 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTzInstanceRecoveryHandler.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/recovery/impl/ItmTzInstanceRecoveryHandler.java
@@ -7,7 +7,10 @@
  */
 package org.opendaylight.genius.itm.recovery.impl;
 
+import java.math.BigInteger;
 import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -18,6 +21,8 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.genius.itm.cache.DpnTepStateCache;
 import org.opendaylight.genius.itm.globals.ITMConstants;
 import org.opendaylight.genius.itm.impl.ItmUtils;
 import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
@@ -27,6 +32,8 @@ import org.opendaylight.serviceutils.srm.ServiceRecoveryInterface;
 import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
 import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelsState;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTeps;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
@@ -47,6 +54,8 @@ public class ItmTzInstanceRecoveryHandler extends
     private final EntityOwnershipUtils entityOwnershipUtils;
     private final DataTreeEventCallbackRegistrar eventCallbacks;
     private final EntityOwnershipService entityOwnershipService;
+    private final IInterfaceManager interfaceManager;
+    private final DpnTepStateCache dpnTepStateCache;
 
     @Inject
     public ItmTzInstanceRecoveryHandler(DataBroker dataBroker,
@@ -54,7 +63,9 @@ public class ItmTzInstanceRecoveryHandler extends
                                         ServiceRecoveryRegistry serviceRecoveryRegistry,
                                         EntityOwnershipUtils entityOwnershipUtils,
                                         EntityOwnershipService entityOwnershipService,
-                                        DataTreeEventCallbackRegistrar eventCallbacks) {
+                                        DataTreeEventCallbackRegistrar eventCallbacks,
+                                        IInterfaceManager interfaceManager,
+                                        DpnTepStateCache dpnTepStateCache) {
         super(dataBroker, LogicalDatastoreType.OPERATIONAL,
                 InstanceIdentifier.create(TunnelsState.class).child(StateTunnelList.class));
         this.dataBroker = dataBroker;
@@ -64,6 +75,9 @@ public class ItmTzInstanceRecoveryHandler extends
         this.entityOwnershipService = entityOwnershipService;
         serviceRecoveryRegistry.registerServiceRecoveryRegistry(getServiceRegistryKey(), this);
         this.eventCallbacks = eventCallbacks;
+        this.interfaceManager = interfaceManager;
+        this.dpnTepStateCache = dpnTepStateCache;
+
     }
 
     private String getServiceRegistryKey() {
@@ -85,7 +99,23 @@ public class ItmTzInstanceRecoveryHandler extends
 
     private void recoverTransportZone(String entityId) throws InterruptedException {
         //List of Internel tunnels
-        List<String> tunnelList = ItmUtils.getInternalTunnelInterfaces(dataBroker);
+        List<String> tunnelList = new ArrayList<>();
+        if (interfaceManager.isItmDirectTunnelsEnabled()) {
+            Collection<DpnsTeps> dpnsTeps = dpnTepStateCache.getAllPresent();
+            List<BigInteger> listOfDpnIds = ItmUtils.getDpIdFromTransportzone(dataBroker, entityId);
+            for (DpnsTeps dpnTep : dpnsTeps) {
+                List<RemoteDpns> rmtdpns = dpnTep.getRemoteDpns();
+                for (RemoteDpns remoteDpn : rmtdpns) {
+                    if (listOfDpnIds.contains(remoteDpn.getDestinationDpnId())) {
+                        tunnelList.add(remoteDpn.getTunnelName());
+                    }
+                }
+            }
+            LOG.trace("List of tunnels to be recovered : {}", tunnelList);
+        } else {
+            //List of Internal tunnels
+            tunnelList.addAll(ItmUtils.getInternalTunnelInterfaces(dataBroker));
+        }
         LOG.debug("List of tunnel interfaces: {}" , tunnelList);
         InstanceIdentifier<TransportZone> tzII = ItmUtils.getTZInstanceIdentifier(entityId);
         TransportZone tz = ItmUtils.getTransportZoneFromConfigDS(entityId , dataBroker);
@@ -101,7 +131,7 @@ public class ItmTzInstanceRecoveryHandler extends
                     LOG.trace("TunnelStateKey: {} for interface: {}", tlKey, tunnelInterface);
                     InstanceIdentifier<StateTunnelList> stListId = ItmUtils.buildStateTunnelListId(tlKey);
                     eventCallbacks.onRemove(LogicalDatastoreType.OPERATIONAL, stListId, (unused) -> {
-                        LOG.trace("callback event for a delete {} interface instance", stListId);
+                        LOG.trace("on removal of {}, event callback triggered", stListId);
                         // recreating the transportZone
                         recreateTZ(entityId, tz, tzII, tunnelList.size(), eventCallbackCount);
                         return DataTreeEventCallbackRegistrar.NextAction.UNREGISTER;
@@ -110,6 +140,7 @@ public class ItmTzInstanceRecoveryHandler extends
                             recreateTZ(entityId, tz, tzII, tunnelList.size(), eventCallbackCount); });
                 });
             } else {
+                LOG.trace("List of tunnels to be recovered is empty, still recreate transportzone {}",entityId);
                 recreateTZ(entityId, tz, tzII, tunnelList.size(), eventCallbackCount);
             }
         }
@@ -125,9 +156,6 @@ public class ItmTzInstanceRecoveryHandler extends
                 txRunner.callWithNewWriteOnlyTransactionAndSubmit(
                     tx -> tx.merge(LogicalDatastoreType.CONFIGURATION, tzII, tz))),
                 ITMConstants.JOB_MAX_RETRIES);
-        } else {
-            LOG.trace("{} call back events registered for {} tunnel interfaces",
-                    registeredEvents, sizeOfTunnelList);
         }
     }
 }
\ No newline at end of file