GENIUS-251: Event Logger for Genius

Separate Logger to capture events for debugging.

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

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceManagerCommonUtils.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceManagerCommonUtils.java
index bbe058a41cf7176e6a4f3db48438ab098ab81a42..d1da0fbda6b8da1a899121134c05e7551896f8b8 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceManagerCommonUtils.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/commons/InterfaceManagerCommonUtils.java
@@ -104,6 +104,7 @@ import org.slf4j.LoggerFactory;
 @Singleton
 public final class InterfaceManagerCommonUtils {
     private static final Logger LOG = LoggerFactory.getLogger(InterfaceManagerCommonUtils.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private static final String NOVA_PORT_REGEX = "(tap|vhu)[0-9a-f]{8}-[0-9a-f]{2}";
     private static final String TUNNEL_PORT_REGEX = "tun[0-9a-f]{11}";
@@ -441,6 +442,7 @@ public final class InterfaceManagerCommonUtils {
                     + "interface-state is available", interfaceName);
             return;
         }
+        EVENT_LOGGER.debug("IFM-OvsInterfaceConfig,Interface-State,ADD {}", interfaceName);
         LOG.debug("adding interface state for {}", interfaceName);
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
             .ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus operStatus = ifState

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/InterfaceInventoryStateListener.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/InterfaceInventoryStateListener.java
index 5d47eb66e1d27e2fecbbddc2fe5cf270d7d31d4a..d132368f7e7c195c5a90dc6f7e593dd04237d85d 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/InterfaceInventoryStateListener.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/InterfaceInventoryStateListener.java
@@ -80,6 +80,8 @@ public class InterfaceInventoryStateListener
         implements RecoverableListener {
 
     private static final Logger LOG = LoggerFactory.getLogger(InterfaceInventoryStateListener.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
+
     private final DataBroker dataBroker;
     private final ManagedNewTransactionRunner txRunner;
     private final IdManagerService idManager;
@@ -145,6 +147,7 @@ public class InterfaceInventoryStateListener
     protected void remove(InstanceIdentifier<FlowCapableNodeConnector> key,
                           FlowCapableNodeConnector flowCapableNodeConnectorOld) {
         String interfaceName = flowCapableNodeConnectorOld.getName();
+        EVENT_LOGGER.debug("IFM-InterfaceInventoryState,REMOVE {}", interfaceName);
         if (interfacemgrProvider.isItmDirectTunnelsEnabled()
             && InterfaceManagerCommonUtils.isTunnelPort(interfaceName)
             && interfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceName) == null) {
@@ -167,6 +170,8 @@ public class InterfaceInventoryStateListener
         LOG.debug("Received NodeConnector Remove Event: {}, {}", key, flowCapableNodeConnectorOld);
         String portName = InterfaceManagerCommonUtils.getPortNameForInterface(nodeConnectorId,
             flowCapableNodeConnectorOld.getName());
+        EVENT_LOGGER.debug("IFM-InterfaceInventoryState Entity Owner,REMOVE {},{}", portName,
+                nodeConnectorId.getValue());
 
         remove(nodeConnectorId, null, flowCapableNodeConnectorOld, portName, true);
     }
@@ -183,6 +188,8 @@ public class InterfaceInventoryStateListener
     protected void update(InstanceIdentifier<FlowCapableNodeConnector> key, FlowCapableNodeConnector fcNodeConnectorOld,
         FlowCapableNodeConnector fcNodeConnectorNew) {
         String interfaceName = fcNodeConnectorNew.getName();
+        EVENT_LOGGER.debug("IFM-InterfaceInventoryState,UPDATE {},{}", fcNodeConnectorNew.getName(),
+                fcNodeConnectorNew.getReason());
         if (interfacemgrProvider.isItmDirectTunnelsEnabled()
             && InterfaceManagerCommonUtils.isTunnelPort(interfaceName)
             && interfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceName) == null) {
@@ -202,6 +209,8 @@ public class InterfaceInventoryStateListener
         NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
         String portName = InterfaceManagerCommonUtils.getPortNameForInterface(nodeConnectorId,
                 fcNodeConnectorNew.getName());
+        EVENT_LOGGER.debug("IFM-InterfaceInventoryState Entity Owner,UPDATE {},{}", portName,
+                nodeConnectorId.getValue());
 
         InterfaceStateUpdateWorker portStateUpdateWorker = new InterfaceStateUpdateWorker(key, fcNodeConnectorOld,
             fcNodeConnectorNew, portName);
@@ -211,6 +220,7 @@ public class InterfaceInventoryStateListener
     @Override
     protected void add(InstanceIdentifier<FlowCapableNodeConnector> key, FlowCapableNodeConnector fcNodeConnectorNew) {
         String interfaceName = fcNodeConnectorNew.getName();
+        EVENT_LOGGER.debug("IFM-InterfaceInventoryState,ADD {}", interfaceName);
         if (interfacemgrProvider.isItmDirectTunnelsEnabled()
             && InterfaceManagerCommonUtils.isTunnelPort(interfaceName)
             && interfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceName) == null) {
@@ -232,6 +242,7 @@ public class InterfaceInventoryStateListener
         LOG.debug("Received NodeConnector Add Event: {}, {}", key, fcNodeConnectorNew);
         String portName = InterfaceManagerCommonUtils.getPortNameForInterface(nodeConnectorId,
             fcNodeConnectorNew.getName());
+        EVENT_LOGGER.debug("IFM-InterfaceInventoryState Entity Owner,ADD {},{}", portName, nodeConnectorId.getValue());
 
         if (InterfaceManagerCommonUtils.isNovaPort(portName) || InterfaceManagerCommonUtils.isK8SPort(portName)) {
             NodeConnectorId nodeConnectorIdOld = null;
@@ -259,6 +270,7 @@ public class InterfaceInventoryStateListener
                 //VM Migration or Port Number Update: Delete existing interface entry for older DPN
                 LOG.trace("Removing entry for port id {} from map",nodeConnectorIdOld.getValue());
                 portNameCache.remove(nodeConnectorIdOld.getValue());
+                EVENT_LOGGER.debug("IFM-VMMigration,{}", portName);
                 LOG.debug("Triggering NodeConnector Remove Event for the interface: {}, {}, {}", portName,
                     nodeConnectorId, nodeConnectorIdOld);
                 remove(nodeConnectorId, nodeConnectorIdOld, fcNodeConnectorNew, portName, false);
@@ -424,6 +436,7 @@ public class InterfaceInventoryStateListener
                             fcNodeConnectorOld,
                             operTx);
                     } else {
+                        EVENT_LOGGER.debug("IFM-OvsInterfaceState,REMOVE {}", interfaceName);
                         InterfaceManagerCommonUtils.deleteStateEntry(operTx, interfaceName);
                         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
                             .Interface iface = interfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceName);
@@ -444,6 +457,7 @@ public class InterfaceInventoryStateListener
                             FlowBasedServicesUtils.removeIngressFlow(interfaceName, dpId, txRunner, futures);
                             IfmUtil.unbindService(txRunner, coordinator, iface.getName(),
                                     FlowBasedServicesUtils.buildDefaultServiceId(iface.getName()));
+                            EVENT_LOGGER.debug("IFM-InterfaceState, REMOVE, IngressFlow {}", interfaceName);
                         }
                         // Delete the Vpn Interface from DpnToInterface Op DS.
                         InterfaceManagerCommonUtils.deleteDpnToInterface(dpId, interfaceName, operTx);

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/TerminationPointStateListener.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/TerminationPointStateListener.java
index 32b3e7c39b529ff1b94272b06e312458ab7f584e..8b7ed72cb168ed7b669eb239bbf8eda968ba704d 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/TerminationPointStateListener.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/TerminationPointStateListener.java
@@ -42,6 +42,7 @@ public class TerminationPointStateListener extends
         AsyncClusteredDataTreeChangeListenerBase<OvsdbTerminationPointAugmentation, TerminationPointStateListener>
         implements RecoverableListener {
     private static final Logger LOG = LoggerFactory.getLogger(TerminationPointStateListener.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final InterfacemgrProvider interfaceMgrProvider;
     private final DataBroker dataBroker;
@@ -106,6 +107,7 @@ public class TerminationPointStateListener extends
         }
         if (tpOld.getInterfaceBfdStatus() != null) {
             LOG.debug("Received termination point removed notification with bfd status values {}", tpOld.getName());
+            EVENT_LOGGER.debug("IFM-TerminationPointState,REMOVE {}", tpOld.getName());
             RendererStateRemoveWorker rendererStateRemoveWorker = new RendererStateRemoveWorker(tpOld);
             coordinator.enqueueJob(tpOld.getName(), rendererStateRemoveWorker);
         }
@@ -125,7 +127,7 @@ public class TerminationPointStateListener extends
 
 
         LOG.debug("Received Update DataChange Notification for ovsdb termination point {}", tpNew.getName());
-
+        EVENT_LOGGER.debug("IFM-TerminationPointState,UPDATE {}", tpNew.getName());
         if (org.opendaylight.genius.interfacemanager.renderer.ovs.utilities
                 .SouthboundUtils.changeInBfdMonitoringDetected(tpOld, tpNew)
                 || org.opendaylight.genius.interfacemanager.renderer.ovs.utilities

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/hwvtep/utilities/SouthboundUtils.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/hwvtep/utilities/SouthboundUtils.java
index 5e4d7b14ae4ede8db96df490316db7dcb74c778f..159c6a2ab82597d2b2a4ec2c206c04b9982c58d0 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/hwvtep/utilities/SouthboundUtils.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/hwvtep/utilities/SouthboundUtils.java
@@ -49,6 +49,8 @@ import org.slf4j.LoggerFactory;
 
 public final class SouthboundUtils {
     private static final Logger LOG = LoggerFactory.getLogger(SouthboundUtils.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
+
     public static final String HWVTEP_TOPOLOGY = "hwvtep:1";
     public static final TopologyId HWVTEP_TOPOLOGY_ID = new TopologyId(new Uri(HWVTEP_TOPOLOGY));
     public static final String TEP_PREFIX = "vxlan_over_ipv4:";
@@ -204,6 +206,7 @@ public final class SouthboundUtils {
             .buildStateInterfaceId(interfaceInfo.getName());
         ifaceBuilder.withKey(IfmUtil.getStateInterfaceKeyFromName(interfaceInfo.getName()));
         transaction.put(ifStateId, ifaceBuilder.build(), CREATE_MISSING_PARENTS);
+        EVENT_LOGGER.info("IFM-TepInterfaceState,ADD {}", interfaceInfo.getName());
     }
 
     public static void fillBfdParameters(List<BfdParams> bfdParams, IfTunnel ifTunnel) {

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigRemoveHelper.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigRemoveHelper.java
index 12b8cb4a51b5f043bb1d21ca8bd62a1e849edd43..8fd08281ec4271331b1bbd6bb4b88a6242c5fd3a 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigRemoveHelper.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigRemoveHelper.java
@@ -56,6 +56,7 @@ import org.slf4j.LoggerFactory;
 @Singleton
 public final class OvsInterfaceConfigRemoveHelper {
     private static final Logger LOG = LoggerFactory.getLogger(OvsInterfaceConfigRemoveHelper.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final DataBroker dataBroker;
     private final ManagedNewTransactionRunner txRunner;
@@ -120,6 +121,7 @@ public final class OvsInterfaceConfigRemoveHelper {
 
         cleanUpInterfaceWithUnknownState(interfaceName, parentRefs, null, tx);
         BigInteger dpId = IfmUtil.getDpnFromInterface(ifState);
+        EVENT_LOGGER.debug("IFM-OvsInterfaceConfig,REMOVE {}", interfaceName);
         FlowBasedServicesUtils.removeIngressFlow(interfaceName, dpId, txRunner, futures);
 
         interfaceManagerCommonUtils.deleteParentInterfaceEntry(parentRefs.getParentInterface());

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigUpdateHelper.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigUpdateHelper.java
index 77623e956900c422acb78f15dd9b7e0fc1b15127..5b0255b09181ba1ef55d2b9ab083483ee941e7d6 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigUpdateHelper.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigUpdateHelper.java
@@ -47,6 +47,7 @@ import org.slf4j.LoggerFactory;
 @Singleton
 public class OvsInterfaceConfigUpdateHelper {
     private static final Logger LOG = LoggerFactory.getLogger(OvsInterfaceConfigUpdateHelper.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final ManagedNewTransactionRunner txRunner;
     private final JobCoordinator coordinator;
@@ -102,6 +103,7 @@ public class OvsInterfaceConfigUpdateHelper {
             futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
                 tx -> handleTunnelMonitorUpdates(tx, interfaceNew, interfaceOld)));
         } else if (!Objects.equals(interfaceNew.isEnabled(), interfaceOld.isEnabled())) {
+            EVENT_LOGGER.debug("IFM-OvsInterfaceConfig,UPDATE {}", interfaceNew.getName());
             futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
                 tx -> handleInterfaceAdminStateUpdates(tx, interfaceNew, ifState)));
         }

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsVlanMemberConfigAddHelper.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsVlanMemberConfigAddHelper.java
index 3f87609e6110e3be96d4eb2fb89bb1e033ce0816..7e4404c90d7edb7017c8b70acb4ee1f53739ca26 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsVlanMemberConfigAddHelper.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsVlanMemberConfigAddHelper.java
@@ -30,6 +30,7 @@ import org.slf4j.LoggerFactory;
 @Singleton
 public class OvsVlanMemberConfigAddHelper {
     private static final Logger LOG = LoggerFactory.getLogger(OvsVlanMemberConfigAddHelper.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final ManagedNewTransactionRunner txRunner;
     private final InterfaceManagerCommonUtils interfaceManagerCommonUtils;
@@ -43,6 +44,8 @@ public class OvsVlanMemberConfigAddHelper {
 
     public List<ListenableFuture<Void>> addConfiguration(ParentRefs parentRefs, Interface interfaceNew) {
         LOG.info("adding vlan member configuration for interface {}", interfaceNew.getName());
+        EVENT_LOGGER.debug("IFM-OVSVlanMemberConfig,ADD Parent {},Child {}", parentRefs.getParentInterface(),
+                interfaceNew.getName());
         List<ListenableFuture<Void>> futures = new ArrayList<>();
         futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
             tx -> interfaceManagerCommonUtils.createInterfaceChildEntry(tx, parentRefs.getParentInterface(),

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsVlanMemberConfigUpdateHelper.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsVlanMemberConfigUpdateHelper.java
index 9e4d9c7048e53fb9365bcbc93e7df374d31296a1..a896af2dc9cc7b38ca89c63fb7794ab7d3128af6 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsVlanMemberConfigUpdateHelper.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsVlanMemberConfigUpdateHelper.java
@@ -39,6 +39,7 @@ import org.slf4j.LoggerFactory;
 @Singleton
 public class OvsVlanMemberConfigUpdateHelper {
     private static final Logger LOG = LoggerFactory.getLogger(OvsVlanMemberConfigUpdateHelper.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final ManagedNewTransactionRunner txRunner;
     private final InterfaceManagerCommonUtils interfaceManagerCommonUtils;
@@ -63,6 +64,8 @@ public class OvsVlanMemberConfigUpdateHelper {
             IfL2vlan ifL2vlanNew, Interface interfaceNew) {
         LOG.info("updating interface configuration for vlan memeber {} with parent-interface {}", interfaceNew
             .getName(), parentRefsNew.getParentInterface());
+        EVENT_LOGGER.debug("IFM-OVSVlanMemberConfig,UPDATE Parent {},Child {}", parentRefsNew.getParentInterface(),
+                interfaceNew.getName());
         List<ListenableFuture<Void>> futures = new ArrayList<>();
         ParentRefs parentRefsOld = interfaceOld.augmentation(ParentRefs.class);
 

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateAddHelper.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateAddHelper.java
index f9ca003c60b6ad28b1d9954da52b33a71f3963e3..1a3e3e854edb7bb0187398902b0aa942deed0d5e 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateAddHelper.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateAddHelper.java
@@ -49,6 +49,7 @@ import org.slf4j.LoggerFactory;
 @Singleton
 public final class OvsInterfaceStateAddHelper {
     private static final Logger LOG = LoggerFactory.getLogger(OvsInterfaceStateAddHelper.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final ManagedNewTransactionRunner txRunner;
     private final InterfaceManagerCommonUtils interfaceManagerCommonUtils;
@@ -129,9 +130,10 @@ public final class OvsInterfaceStateAddHelper {
                         ifState.getIfIndex());
                 futures.add(FlowBasedServicesUtils.bindDefaultEgressDispatcherService(txRunner, iface,
                         Long.toString(portNo), interfaceName, ifState.getIfIndex()));
+                EVENT_LOGGER.debug("IFM-OvsInterfaceState, ADD, IngressFlow {}", interfaceName);
             }
         }));
-
+        EVENT_LOGGER.debug("IFM-OvsInterfaceState,ADD {}", interfaceName);
         return futures;
     }
 
@@ -139,6 +141,7 @@ public final class OvsInterfaceStateAddHelper {
             Integer ifIndex,
             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
                     .ietf.interfaces.rev140508.interfaces.Interface interfaceInfo, String interfaceName, long portNo) {
+        EVENT_LOGGER.debug("IFM-OvsInterfaceState,ADD,TunnelIngressFlow {}", interfaceName);
         BigInteger dpId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
         ListenableFuture<Void> future = txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
             interfaceManagerCommonUtils.addTunnelIngressFlow(

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceTopologyStateUpdateHelper.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceTopologyStateUpdateHelper.java
index cd38b87d07ccc005fe9e41a6bd1c80ea32d703aa..ca6defa3b324c0a2597e59b678990d116f3b4f00 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceTopologyStateUpdateHelper.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceTopologyStateUpdateHelper.java
@@ -39,6 +39,7 @@ import org.slf4j.LoggerFactory;
 @Singleton
 public class OvsInterfaceTopologyStateUpdateHelper {
     private static final Logger LOG = LoggerFactory.getLogger(OvsInterfaceTopologyStateUpdateHelper.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final ManagedNewTransactionRunner txRunner;
     private final EntityOwnershipUtils entityOwnershipUtils;
@@ -106,6 +107,8 @@ public class OvsInterfaceTopologyStateUpdateHelper {
                     .getInterfaceStateFromOperDS(terminationPointNew.getName());
             if (interfaceState != null && interfaceState.getOperStatus() != Interface.OperStatus.Unknown
                     && interfaceState.getOperStatus() != interfaceBfdStatus) {
+                EVENT_LOGGER.debug("IFM-OvsInterfaceTopologyState,UPDATE {} to STATUS {}", interfaceName,
+                        interfaceState.getOperStatus());
                 LOG.debug("updating tunnel state for interface {} as {}", interfaceName, interfaceBfdStatus);
                 return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
                     tx -> InterfaceManagerCommonUtils.updateOpState(tx, interfaceName, interfaceBfdStatus)));

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/utilities/SouthboundUtils.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/utilities/SouthboundUtils.java
index d041cd2f99d3cb93699e0e95181ad2a90dbde8d4..e8047503851c256c1b847b3e56721ed575f5255f 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/utilities/SouthboundUtils.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/utilities/SouthboundUtils.java
@@ -82,6 +82,7 @@ import org.slf4j.LoggerFactory;
 @Singleton
 public class SouthboundUtils {
     private static final Logger LOG = LoggerFactory.getLogger(SouthboundUtils.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private static final String BFD_PARAM_ENABLE = "enable";
     private static final String BFD_PARAM_MIN_TX = "min_tx";
@@ -203,7 +204,7 @@ public class SouthboundUtils {
     private void addTunnelPortToBridge(IfTunnel ifTunnel, InstanceIdentifier<?> bridgeIid, Interface iface,
             String portName) {
         LOG.debug("adding tunnel port {} to bridge {}", portName, bridgeIid);
-
+        EVENT_LOGGER.debug("IFM-OvsInterfaceConfig,ADD Tunnelport {} Bridgeid {}", portName, bridgeIid);
         Class<? extends InterfaceTypeBase> type = TUNNEL_TYPE_MAP.get(ifTunnel.getTunnelInterfaceType());
 
         if (type == null) {

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/listeners/FlowBasedServicesConfigListener.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/listeners/FlowBasedServicesConfigListener.java
index 4058112d16de121091cf934713209b5ebb2530a7..86e39139fbf5e6e82f58954edf8a9f6ec779f099 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/listeners/FlowBasedServicesConfigListener.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/listeners/FlowBasedServicesConfigListener.java
@@ -60,6 +60,7 @@ public class FlowBasedServicesConfigListener implements ClusteredDataTreeChangeL
         RecoverableListener {
 
     private static final Logger LOG = LoggerFactory.getLogger(FlowBasedServicesConfigListener.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private ListenerRegistration<FlowBasedServicesConfigListener> listenerRegistration;
     private final DataBroker dataBroker;
@@ -258,6 +259,8 @@ public class FlowBasedServicesConfigListener implements ClusteredDataTreeChangeL
             futures.add(txRunner.callWithNewReadWriteTransactionAndSubmit(OPERATIONAL, tx -> {
                 BoundServicesState boundServicesState = FlowBasedServicesUtils
                         .getBoundServicesState(tx, interfaceName, serviceMode);
+                EVENT_LOGGER.debug("IFM-ServiceBindingConfig, BIND {}, {}", interfaceName,
+                        boundServicesNew.getServiceName());
                 // if service-binding state is not present, construct the same using ifstate
                 if (boundServicesState == null) {
                     Interface ifState = interfaceManagerCommonUtils.getInterfaceState(interfaceName);
@@ -309,6 +312,8 @@ public class FlowBasedServicesConfigListener implements ClusteredDataTreeChangeL
                 if (boundServicesList == null || boundServicesList.isEmpty()) {
                     FlowBasedServicesUtils.removeBoundServicesState(tx, interfaceName, serviceMode);
                 }
+                EVENT_LOGGER.debug("IFM-ServiceBindingConfig, UNBIND {}, {}", interfaceName,
+                        boundServicesNew.getServiceName());
                 flowBasedServicesConfigRemovable.unbindService(futures, interfaceName, boundServicesNew,
                         boundServicesList, boundServiceState);
             }));

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/utilities/FlowBasedServicesUtils.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/utilities/FlowBasedServicesUtils.java
index bdada862d300daf3e13fe727e19dad6411d51b2e..91b6416d0ddf3064044119cd851111ef7503f8c2 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/utilities/FlowBasedServicesUtils.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/servicebindings/flowbased/utilities/FlowBasedServicesUtils.java
@@ -92,6 +92,7 @@ import org.slf4j.LoggerFactory;
 
 public final class FlowBasedServicesUtils {
     private static final Logger LOG = LoggerFactory.getLogger(FlowBasedServicesUtils.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
     private static final int DEFAULT_DISPATCHER_PRIORITY = 10;
 
     private FlowBasedServicesUtils() {
@@ -252,6 +253,7 @@ public final class FlowBasedServicesUtils {
                 .child(Table.class, new TableKey(flow.getTableId())).child(Flow.class, flowKey).build();
 
         writeTransaction.put(flowInstanceId, flow, CREATE_MISSING_PARENTS);
+        EVENT_LOGGER.debug("IFM,InstallFlow {}", flow.getId());
     }
 
     private static Node buildInventoryDpnNode(BigInteger dpnId) {
@@ -546,6 +548,7 @@ public final class FlowBasedServicesUtils {
                 .build();
 
         writeTransaction.delete(flowInstanceId);
+        EVENT_LOGGER.debug("IFM,removeFlow {}", flowRef);
     }
 
     public static void removeEgressDispatcherFlows(BigInteger dpId, String iface,
@@ -568,6 +571,7 @@ public final class FlowBasedServicesUtils {
                 .build();
 
         writeTransaction.delete(flowInstanceId);
+        EVENT_LOGGER.debug("IFM,removeFlow {}", flowRef);
     }
 
     public static void removeEgressSplitHorizonDispatcherFlow(BigInteger dpId, String iface,

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java
index e921a817d1238f39a8de3d3844a590995992d5c4..07aeac110ec6adf7aeab0cffd94bea2c47b6801b 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java
@@ -45,6 +45,7 @@ import org.slf4j.LoggerFactory;
 public class DPNTEPsInfoCache extends InstanceIdDataObjectCache<DPNTEPsInfo> {
 
     private static final Logger LOG = LoggerFactory.getLogger(DPNTEPsInfoCache.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final DirectTunnelUtils directTunnelUtils;
     private final JobCoordinator coordinator;
@@ -136,6 +137,7 @@ public class DPNTEPsInfoCache extends InstanceIdDataObjectCache<DPNTEPsInfo> {
                         .setTunnelEndPointInfo(tsInfo.getTunnelEndPointInfo())
                         .setSrcDpnTepsInfo(srcDpnTepsInfo).setDstDpnTepsInfo(dstDpnTepsInfo).build();
                     LOG.debug("Queueing TunnelStateAddWorker to DJC for tunnel {}", interfaceName);
+                    EVENT_LOGGER.debug("ITM-DpnTepsInfoCache,ADD {}", interfaceName);
                     coordinator.enqueueJob(interfaceName,
                         new TunnelStateAddWorkerForNodeConnector(new TunnelStateAddWorker(directTunnelUtils, txRunner),
                             tunnelStateInfoNew), ITMConstants.JOB_MAX_RETRIES);

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DpnTepStateCache.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DpnTepStateCache.java
index f9c90972d7744cc752f4068b684ff0105cfae6f3..a6752f68f91da2e96453a0d9526618655786fb87 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DpnTepStateCache.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DpnTepStateCache.java
@@ -54,6 +54,7 @@ import org.slf4j.LoggerFactory;
 public class DpnTepStateCache extends DataObjectCache<BigInteger, DpnsTeps> {
 
     private static final Logger LOG = LoggerFactory.getLogger(DpnTepStateCache.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final DataBroker dataBroker;
     private final JobCoordinator coordinator;
@@ -152,6 +153,7 @@ public class DpnTepStateCache extends DataObjectCache<BigInteger, DpnsTeps> {
                 TunnelStateAddWorkerForNodeConnector ifStateAddWorker =
                     new TunnelStateAddWorkerForNodeConnector(new TunnelStateAddWorker(directTunnelUtils, txRunner),
                         tunnelStateInfoNew);
+                EVENT_LOGGER.debug("ITM-DpnTepStateCache,ADD {}", remoteDpns.getTunnelName());
                 coordinator.enqueueJob(remoteDpns.getTunnelName(), ifStateAddWorker, ITMConstants.JOB_MAX_RETRIES);
             }
         }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTunnelStateRemoveHelper.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTunnelStateRemoveHelper.java
index 09d1d540cca3148067f982da44d0b722ab719fea..0283f20b4415feeed6d5888ff46b00b873bd7405 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTunnelStateRemoveHelper.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/confighelpers/ItmTunnelStateRemoveHelper.java
@@ -21,6 +21,7 @@ import org.slf4j.LoggerFactory;
 
 public final class ItmTunnelStateRemoveHelper {
     private static final Logger LOG = LoggerFactory.getLogger(ItmTunnelStateRemoveHelper.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private ItmTunnelStateRemoveHelper() { }
 
@@ -29,6 +30,7 @@ public final class ItmTunnelStateRemoveHelper {
         StateTunnelListKey tlKey = ItmUtils.getTunnelStateKey(iface);
         InstanceIdentifier<StateTunnelList> stListId = ItmUtils.buildStateTunnelListId(tlKey);
         LOG.trace("Deleting tunnel_state for Id: {}", stListId);
+        EVENT_LOGGER.debug("ITM-ItmTunnelState,REMOVE {}", stListId);
         ITMBatchingUtils.delete(stListId, ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL);
         return Collections.emptyList();
     }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TerminationPointStateListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TerminationPointStateListener.java
index d5f7c852af9cc3f216520079313a8d33a571651d..e60b41aec3b067ba09cf42f92ec56103fd4ba4f9 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TerminationPointStateListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TerminationPointStateListener.java
@@ -46,6 +46,7 @@ public class TerminationPointStateListener
         extends AbstractClusteredSyncDataTreeChangeListener<OvsdbTerminationPointAugmentation> {
 
     private static final Logger LOG = LoggerFactory.getLogger(TerminationPointStateListener.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final ManagedNewTransactionRunner txRunner;
     private final EntityOwnershipUtils entityOwnershipUtils;
@@ -93,6 +94,7 @@ public class TerminationPointStateListener
             LOG.debug("Received Update DataChange Notification for ovsdb termination point {}", tpNew.getName());
             if (DirectTunnelUtils.changeInBfdMonitoringDetected(tpOld, tpNew)
                     || DirectTunnelUtils.ifBfdStatusNotEqual(tpOld, tpNew)) {
+                EVENT_LOGGER.debug("ITM-TerminationPointState,UPDATE {}", tpNew.getName());
                 LOG.info("Bfd Status changed for ovsdb termination point identifier: {},  old: {}, new: {}",
                         identifier, tpOld, tpNew);
                 RendererTunnelStateUpdateWorker rendererStateAddWorker = new RendererTunnelStateUpdateWorker(tpNew);
@@ -108,6 +110,7 @@ public class TerminationPointStateListener
                 && dpnTepStateCache.isInternal(tpNew.getName())) {
             LOG.debug("Received add DataChange Notification for ovsdb termination point {}", tpNew.getName());
             if (tpNew.getInterfaceBfdStatus() != null  && !tpNew.getInterfaceBfdStatus().isEmpty()) {
+                EVENT_LOGGER.debug("ITM-TerminationPointState,ADD {}", tpNew.getName());
                 LOG.debug("Received termination point added notification with bfd status values {}", tpNew.getName());
                 RendererTunnelStateUpdateWorker rendererStateUpdateWorker = new RendererTunnelStateUpdateWorker(tpNew);
                 coordinator.enqueueJob(tpNew.getName(), rendererStateUpdateWorker, ITMConstants.JOB_MAX_RETRIES);

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelInventoryStateListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelInventoryStateListener.java
index 7c2ec1cc241d47203029080596f041bb33a7e5d1..fb6d3864144d65192647500827528705f90aa826 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelInventoryStateListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelInventoryStateListener.java
@@ -70,6 +70,7 @@ public class TunnelInventoryStateListener extends
     AbstractClusteredSyncDataTreeChangeListener<FlowCapableNodeConnector> {
 
     private static final Logger LOG = LoggerFactory.getLogger(TunnelInventoryStateListener.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final JobCoordinator coordinator;
     private final ManagedNewTransactionRunner txRunner;
@@ -108,6 +109,8 @@ public class TunnelInventoryStateListener extends
                        @NonNull FlowCapableNodeConnector flowCapableNodeConnector) {
         String portName = flowCapableNodeConnector.getName();
         LOG.debug("InterfaceInventoryState Remove for {}", portName);
+        EVENT_LOGGER.debug("ITM-TunnelInventoryState,REMOVE DTCN received for {}",
+                flowCapableNodeConnector.getName());
         // ITM Direct Tunnels Return if its not tunnel port and if its not Internal
         if (!DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName) && !portName.startsWith("of")) {
             LOG.debug("Node Connector Remove - {} Interface is not a tunnel I/f, so no-op", portName);
@@ -134,7 +137,10 @@ public class TunnelInventoryStateListener extends
 
     private void remove(NodeConnectorId nodeConnectorId,
                         FlowCapableNodeConnector fcNodeConnectorNew, String portName) {
+        LOG.debug("TunnelInventoryState REMOVE for {}", portName);
         LOG.debug("InterfaceInventoryState REMOVE for {}", portName);
+        EVENT_LOGGER.debug("ITM-TunnelInventoryState Entity Owner, REMOVE {} {}", nodeConnectorId.getValue(),
+                portName);
         TunnelInterfaceStateRemoveWorker portStateRemoveWorker = new TunnelInterfaceStateRemoveWorker(nodeConnectorId,
                 fcNodeConnectorNew, portName);
         coordinator.enqueueJob(portName, portStateRemoveWorker, ITMConstants.JOB_MAX_RETRIES);
@@ -144,6 +150,7 @@ public class TunnelInventoryStateListener extends
     public void update(@NonNull InstanceIdentifier<FlowCapableNodeConnector> key,
                        @NonNull FlowCapableNodeConnector fcNodeConnectorOld,
                        @NonNull FlowCapableNodeConnector fcNodeConnectorNew) {
+        EVENT_LOGGER.debug("ITM-TunnelInventoryState,UPDATE DTCN received for {}", fcNodeConnectorOld.getName());
         String portName = fcNodeConnectorNew.getName();
         if (!DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName)) {
             LOG.debug("Node Connector Update - {} Interface is not a tunnel I/f, so no-op", portName);
@@ -159,6 +166,8 @@ public class TunnelInventoryStateListener extends
 
         TunnelInterfaceStateUpdateWorker portStateUpdateWorker =
                 new TunnelInterfaceStateUpdateWorker(key, fcNodeConnectorOld, fcNodeConnectorNew, portName);
+        EVENT_LOGGER.debug("ITM-TunnelInventoryState Entity Owner, UPDATE {} {} Reason {}",
+                fcNodeConnectorNew.getName(), portName, fcNodeConnectorNew.getReason());
         coordinator.enqueueJob(portName, portStateUpdateWorker, ITMConstants.JOB_MAX_RETRIES);
     }
 
@@ -166,6 +175,7 @@ public class TunnelInventoryStateListener extends
     public void add(@NonNull InstanceIdentifier<FlowCapableNodeConnector> key,
                     @NonNull FlowCapableNodeConnector fcNodeConnectorNew) {
         LOG.info("Received NodeConnector Add Event: {}, {}", key, fcNodeConnectorNew);
+        EVENT_LOGGER.debug("ITM-TunnelInventoryState,ADD DTCN received for {}", fcNodeConnectorNew.getName());
         String portName = fcNodeConnectorNew.getName();
         // Return if its not tunnel port and if its not Internal
         if (!DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName) && !portName.startsWith("of")) {
@@ -259,6 +269,7 @@ public class TunnelInventoryStateListener extends
 
         if (tunnelEndPtInfo != null && tunnelStateInfo.getSrcDpnTepsInfo() != null
             && tunnelStateInfo.getDstDpnTepsInfo() != null && directTunnelUtils.isEntityOwner()) {
+            EVENT_LOGGER.debug("ITM-TunnelInventoryState Entity Owner,ADD {}", portName);
             coordinator.enqueueJob(portName,
                 new TunnelStateAddWorkerForNodeConnector(new TunnelStateAddWorker(directTunnelUtils, txRunner),
                     tunnelStateInfo), ITMConstants.JOB_MAX_RETRIES);
@@ -308,14 +319,15 @@ public class TunnelInventoryStateListener extends
                 // modify the attributes in interface operational DS
                 handleInterfaceStateUpdates(tx, dpnTepInfo, true, interfaceName, flowCapableNodeConnectorNew.getName(),
                         operStatusNew);
-
+                EVENT_LOGGER.debug("ITM-TunnelInventoryState, UPDATE {} CHGED {} completed", interfaceName,
+                        operStatusNew.getName());
             }));
         } else {
             return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> {
                 // modify the attributes in interface operational DS
                 handleInterfaceStateUpdates(tx, dpnTepInfo, false, interfaceName,
                         flowCapableNodeConnectorNew.getName(), operStatusNew);
-
+                EVENT_LOGGER.debug("ITM-TunnelInventoryState, UPDATE {} completed", interfaceName);
             }));
         }
     }
@@ -378,6 +390,7 @@ public class TunnelInventoryStateListener extends
         if (flowCapableNodeConnector.getReason() != PortReason.Delete) {
             //Remove event is because of connection lost between controller and switch, or switch shutdown.
             // Hence, dont remove the interface but set the status as "unknown"
+
             if (interfaceName.startsWith("of")) {
                 LOG.debug("Received remove state for dpid {}", dpId.intValue());
                 for (Map.Entry<String, NodeConnectorInfo> entry : meshedMap.entrySet()) {
@@ -399,9 +412,9 @@ public class TunnelInventoryStateListener extends
                 futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL,
                     tx -> updateInterfaceStateOnNodeRemove(tx, interfaceName, flowCapableNodeConnector)));
             }
-
         } else {
             LOG.debug("removing interface state for interface: {}", interfaceName);
+            EVENT_LOGGER.debug("ITM-TunnelInventoryState,REMOVE Table 0 flow for {} completed", interfaceName);
             // removing interfaces are already done in delete worker
             meshedMap.remove(dpId.toString());
         }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelTopologyStateListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelTopologyStateListener.java
index 287a4d2d5a7211d848c73296514fae7649334736..2b3e5f36c598996ccfb91db0720967563eb547ab 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelTopologyStateListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelTopologyStateListener.java
@@ -46,6 +46,7 @@ import org.slf4j.LoggerFactory;
 public class TunnelTopologyStateListener extends AbstractClusteredSyncDataTreeChangeListener<OvsdbBridgeAugmentation> {
 
     private static final Logger LOG = LoggerFactory.getLogger(TunnelTopologyStateListener.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final JobCoordinator coordinator;
     private final ManagedNewTransactionRunner txRunner;
@@ -72,6 +73,7 @@ public class TunnelTopologyStateListener extends AbstractClusteredSyncDataTreeCh
     @Override
     public void remove(@NonNull InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
                        @NonNull OvsdbBridgeAugmentation bridgeOld) {
+        EVENT_LOGGER.debug("ITM-TunnelTopologyState, REMOVE DTCN received");
         if (directTunnelUtils.isEntityOwner()) {
             LOG.debug("Received Remove DataChange Notification for identifier: {}, ovsdbBridgeAugmentation: {}",
                     identifier, bridgeOld);
@@ -85,6 +87,7 @@ public class TunnelTopologyStateListener extends AbstractClusteredSyncDataTreeCh
     @Override
     public void update(@NonNull InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
                        @NonNull OvsdbBridgeAugmentation bridgeOld, @NonNull OvsdbBridgeAugmentation bridgeNew) {
+        EVENT_LOGGER.debug("ITM-TunnelTopologyState, UPDATE DTCN received");
 
         if (!directTunnelUtils.isEntityOwner()) {
             return;
@@ -110,6 +113,7 @@ public class TunnelTopologyStateListener extends AbstractClusteredSyncDataTreeCh
     @Override
     public void add(@NonNull InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
                     @NonNull OvsdbBridgeAugmentation bridgeNew) {
+        EVENT_LOGGER.debug("ITM-TunnelTopologyState, ADD DTCN received");
         if (directTunnelUtils.isEntityOwner()) {
             LOG.debug("Received Add DataChange Notification for identifier: {}, ovsdbBridgeAugmentation: {}",
                     identifier, bridgeNew);
@@ -159,6 +163,7 @@ public class TunnelTopologyStateListener extends AbstractClusteredSyncDataTreeCh
         }
         return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {
             LOG.debug("removing bridge references for bridge: {}, dpn: {}", bridgeOld, dpnId);
+            EVENT_LOGGER.debug("ITM-TunnelTopologyState, REMOVE {} completed", bridgeOld.getBridgeName().getValue());
             //delete bridge reference entry in interface meta operational DS
             deleteOvsBridgeRefEntry(dpnId, tx);
 
@@ -225,6 +230,7 @@ public class TunnelTopologyStateListener extends AbstractClusteredSyncDataTreeCh
                     LOG.debug("Interface {} not found in config DS", portName);
                 }
             }
+            EVENT_LOGGER.debug("ITM-TunnelTopologyState, ADD port on {} completed", bridgeName);
         }
     }
 
@@ -249,6 +255,7 @@ public class TunnelTopologyStateListener extends AbstractClusteredSyncDataTreeCh
 
             BigInteger dpnId = directTunnelUtils.getDpnId(bridgeNew.getDatapathId());
             LOG.debug("adding bridge references for bridge: {}, dpn: {}", bridgeNew, dpnId);
+            EVENT_LOGGER.debug("TunnelTopologyState, ADD bridge {} for {}", bridgeNew.getBridgeName(), dpnId);
 
             // create bridge reference entry in interface meta operational DS
             return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> {

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/workers/TunnelStateAddWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/workers/TunnelStateAddWorker.java
index 4a4348125aaa246f95fe7130a4213f229134eccd..a6da293f7193e4c5de7476aa39c769a6a9338361 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/workers/TunnelStateAddWorker.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/workers/TunnelStateAddWorker.java
@@ -46,6 +46,7 @@ import org.slf4j.LoggerFactory;
 public final class TunnelStateAddWorker {
 
     private static final Logger LOG = LoggerFactory.getLogger(TunnelStateAddWorker.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final DirectTunnelUtils directTunnelUtils;
     private final ManagedNewTransactionRunner txRunner;
@@ -70,9 +71,11 @@ public final class TunnelStateAddWorker {
         String interfaceName = tunnelName;
 
         long portNo = DirectTunnelUtils.getPortNumberFromNodeConnectorId(nodeConnectorId);
+        EVENT_LOGGER.debug("ITM-TunnelState, ADD to oper DS {}", interfaceName);
         if (portNo == ITMConstants.INVALID_PORT_NO) {
             LOG.error("Cannot derive port number, not proceeding with Interface State addition for interface: {}",
                 interfaceName);
+            EVENT_LOGGER.debug("ITM-TunnelState,ADD Table 0 flow for {} completed", interfaceName);
             return Collections.emptyList();
         }
 

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/InterfaceStateListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/InterfaceStateListener.java
index 87170ce300098b6c43d66499ab35e492396f718e..36834bd2eabc7acc748d42f735d782ba8e0a9691 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/InterfaceStateListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/InterfaceStateListener.java
@@ -45,6 +45,7 @@ import org.slf4j.LoggerFactory;
 public class InterfaceStateListener extends AbstractSyncDataTreeChangeListener<Interface> {
 
     private static final Logger LOG = LoggerFactory.getLogger(InterfaceStateListener.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final DataBroker dataBroker;
     private final JobCoordinator jobCoordinator;
@@ -70,6 +71,7 @@ public class InterfaceStateListener extends AbstractSyncDataTreeChangeListener<I
     @Override
     public void add(@NonNull InstanceIdentifier<Interface> instanceIdentifier, @NonNull Interface iface) {
         LOG.trace("Interface added: {}", iface);
+        EVENT_LOGGER.debug("ITM-InterfaceState,ADD {}", iface.getName());
         if (ItmUtils.isItmIfType(iface.getType())) {
             LOG.debug("Interface of type Tunnel added: {}", iface.getName());
             jobCoordinator.enqueueJob(ITMConstants.ITM_PREFIX + iface.getName(), () -> ItmTunnelStateAddHelper
@@ -84,6 +86,7 @@ public class InterfaceStateListener extends AbstractSyncDataTreeChangeListener<I
     @Override
     public void remove(@NonNull InstanceIdentifier<Interface> instanceIdentifier, @NonNull Interface iface) {
         LOG.trace("Interface deleted: {}", iface);
+        EVENT_LOGGER.debug("ITM-InterfaceState,REMOVE {}", iface.getName());
         if (ItmUtils.isItmIfType(iface.getType())) {
             LOG.debug("Tunnel interface deleted: {}", iface.getName());
             jobCoordinator.enqueueJob(ITMConstants.ITM_PREFIX + iface.getName(),
@@ -103,6 +106,7 @@ public class InterfaceStateListener extends AbstractSyncDataTreeChangeListener<I
          * type can't be edited on the fly
          */
         if (ItmUtils.isItmIfType(originalInterface.getType())) {
+            EVENT_LOGGER.debug("ITM-InterfaceState,UPDATE {}", updatedInterface.getName());
             LOG.trace("Interface updated. Old: {} New: {}", originalInterface, updatedInterface);
             OperStatus operStatus = updatedInterface.getOperStatus();
             if (!Objects.equals(originalInterface.getOperStatus(), updatedInterface.getOperStatus())) {

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TransportZoneListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TransportZoneListener.java
index 4b7ac014ac8e95c59bda3b673c1c60e5eb84077a..93623c06dd405763e0b26f0d68e2fcf00878890b 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TransportZoneListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TransportZoneListener.java
@@ -85,6 +85,7 @@ public class TransportZoneListener extends AbstractSyncDataTreeChangeListener<Tr
         implements RecoverableListener {
 
     private static final Logger LOG = LoggerFactory.getLogger(TransportZoneListener.class);
+    private static final Logger EVENT_LOGGER = LoggerFactory.getLogger("GeniusEventLogger");
 
     private final DataBroker dataBroker;
     private final JobCoordinator jobCoordinator;
@@ -144,15 +145,13 @@ public class TransportZoneListener extends AbstractSyncDataTreeChangeListener<Tr
     @SuppressWarnings("checkstyle:IllegalCatch")
     private void initializeTZNode() {
         InstanceIdentifier<TransportZones> path = InstanceIdentifier.create(TransportZones.class);
-        txRunner.callWithNewReadWriteTransactionAndSubmit(Datastore.CONFIGURATION,
-            tx -> {
-                FluentFuture<Optional<TransportZones>> tzones = tx.read(path);
-                if (!tzones.get().isPresent()) {
-                    TransportZonesBuilder tzb = new TransportZonesBuilder();
-                    tx.put(path, tzb.build());
-                }
+        txRunner.callWithNewReadWriteTransactionAndSubmit(Datastore.CONFIGURATION, tx -> {
+            FluentFuture<Optional<TransportZones>> tzones = tx.read(path);
+            if (!tzones.get().isPresent()) {
+                TransportZonesBuilder tzb = new TransportZonesBuilder();
+                tx.put(path, tzb.build());
             }
-        ).isDone();
+        }).isDone();
     }
 
     @Override
@@ -184,6 +183,7 @@ public class TransportZoneListener extends AbstractSyncDataTreeChangeListener<Tr
         if (allowTunnelDeletion) {
             //TODO : DPList code can be refactor with new specific class
             // which implement TransportZoneValidator
+            EVENT_LOGGER.debug("ITM-Transportzone,TunnelDeletion {}", transportZone.getZoneName());
             List<DPNTEPsInfo> opDpnList = createDPNTepInfo(transportZone);
             List<HwVtep> hwVtepList = createhWVteps(transportZone);
             LOG.trace("Delete: Invoking deleteTunnels in ItmManager with DpnList {}", opDpnList);
@@ -210,6 +210,7 @@ public class TransportZoneListener extends AbstractSyncDataTreeChangeListener<Tr
                        @NonNull TransportZone originalTransportZone, @NonNull TransportZone updatedTransportZone) {
         LOG.debug("Received Transport Zone Update Event: Old - {}, Updated - {}", originalTransportZone,
                 updatedTransportZone);
+        EVENT_LOGGER.debug("ITM-Transportzone,UPDATE {}", updatedTransportZone.getZoneName());
         List<DPNTEPsInfo> oldDpnTepsList = createDPNTepInfo(originalTransportZone);
         List<DPNTEPsInfo> newDpnTepsList = createDPNTepInfo(updatedTransportZone);
         List<DPNTEPsInfo> oldDpnTepsListcopy = new ArrayList<>();
@@ -275,6 +276,7 @@ public class TransportZoneListener extends AbstractSyncDataTreeChangeListener<Tr
     @Override
     public void add(@NonNull TransportZone transportZone) {
         LOG.debug("Received Transport Zone Add Event: {}", transportZone);
+        EVENT_LOGGER.debug("ITM-Transportzone,ADD {}", transportZone.getZoneName());
         List<DPNTEPsInfo> opDpnList = createDPNTepInfo(transportZone);
         //avoiding adding duplicates from nothosted to new dpnlist.
         List<DPNTEPsInfo> duplicateFound = new ArrayList<>();
@@ -441,6 +443,7 @@ public class TransportZoneListener extends AbstractSyncDataTreeChangeListener<Tr
                 LOG.trace("DpnID: {}, ipAddress: {}", dpnID, ipAddress);
                 TunnelEndPoints tunnelEndPoints = ItmUtils.createTunnelEndPoints(dpnID, ipAddress, portName,
                         useOfTunnel, vlanId, zones, tunnelType, tos);
+                EVENT_LOGGER.debug("ITM-createDPNTepInfo for {} {}", dpnID, ipAddress);
                 List<TunnelEndPoints> tunnelEndPointsList = mapDPNToTunnelEndpt.get(dpnID);
                 if (tunnelEndPointsList != null) {
                     LOG.trace("Existing DPN info list in the Map: {} ", dpnID);