Bug 6388: Support of Non-unique names across OVS

Description: When two nodes connect and those two nodes have interfaces
with the same name (They all do, br-int), each time one of those
interfaces gets added to the InterfaceState, it will erase the previous
one. Changes done to check VM migration only tap/vhu/tun ports and prefix
dpnid for all other type of interfaaces

Change-Id: I9e7d930e294836b2a9be6facf5e0d5847ce1cffe
Signed-off-by: Chetan Aakere Gowdru <chetan.arakere.gowdru@ericsson.com>

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/IfmUtil.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/IfmUtil.java
index 9b7249eb08a419c131723cdddc360ed37e0626bf..b3a776c7df6f10da08c50707bfe1f0d397253d9c 100755 (executable)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/IfmUtil.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/IfmUtil.java
@@ -31,7 +31,6 @@ import org.opendaylight.genius.mdsalutil.MetaDataUtil;
 import org.opendaylight.genius.mdsalutil.NwConstants;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
@@ -433,21 +432,6 @@ public class IfmUtil {
         return null;
     }
 
-    public static boolean isTunnelType(Interface iface,org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState) {
-        boolean isTunnelInterface = InterfaceManagerCommonUtils.isTunnelInterface(iface);
-        if (!isTunnelInterface && ifState != null) {
-            isTunnelInterface = IfmUtil.isTunnelType(ifState.getType());
-        }
-        return isTunnelInterface;
-    }
-
-    public static boolean isTunnelType(Class<? extends InterfaceType> ifType) {
-        if( (ifType != null) && (ifType.isAssignableFrom(Tunnel.class)) ) {
-            return true;
-        }
-        return false;
-    }
-
     public static InterfaceInfo.InterfaceType getInterfaceType(Interface iface) {
         InterfaceInfo.InterfaceType interfaceType =
                 org.opendaylight.genius.interfacemanager.globals.InterfaceInfo.InterfaceType.UNKNOWN_INTERFACE;

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 b31bb2c0708938c1be4a7dcaa469f5c2437f01e9..f81c96dc6cd9847438d6d1c2c3f9f222f4d182d4 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
@@ -16,6 +16,9 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
@@ -62,6 +65,8 @@ public class InterfaceManagerCommonUtils {
     private static final Logger LOG = LoggerFactory.getLogger(InterfaceManagerCommonUtils.class);
     private static ConcurrentHashMap<String, Interface> interfaceConfigMap = new ConcurrentHashMap<>();
     private static ConcurrentHashMap<String, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> interfaceStateMap = new ConcurrentHashMap<>();
+    private static final String NOVA_OR_TUNNEL_PORT_REGEX = "(tap|vhu)[0-9a-f]{8}-[0-9a-f]{2}|tun[0-9a-f]{11}";
+    private static final Pattern pattern = Pattern.compile(NOVA_OR_TUNNEL_PORT_REGEX);
 
     public static NodeConnector getNodeConnectorFromInventoryOperDS(NodeConnectorId nodeConnectorId,
             DataBroker dataBroker) {
@@ -453,52 +458,10 @@ public class InterfaceManagerCommonUtils {
         interfaceStateMap.remove(iface.getName());
     }
 
-    public static List<BigInteger> getListOfDpns(DataBroker broker) {
-        List<BigInteger> dpnsList = new LinkedList<>();
-        InstanceIdentifier<Nodes> nodesInstanceIdentifier = InstanceIdentifier.builder(Nodes.class).build();
-        Optional<Nodes> nodesOptional = MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL,
-                nodesInstanceIdentifier);
-        if (!nodesOptional.isPresent()) {
-            return dpnsList;
-        }
-        Nodes nodes = nodesOptional.get();
-        List<Node> nodeList = nodes.getNode();
-        for (Node node : nodeList) {
-            NodeId nodeId = node.getId();
-            if (nodeId == null) {
-                continue;
-            }
-            BigInteger dpnId = MDSALUtil.getDpnIdFromNodeName(nodeId);
-            dpnsList.add(dpnId);
-        }
-        return dpnsList;
-    }
+    public static boolean isNovaOrTunnelPort(String portName) {
 
-    public static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface getInterfaceStateForUnknownDpn(
-            String interfaceName, DataBroker dataBroker) {
-        String parentInterface;
-        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = null;
-        List<BigInteger> listOfDpns = InterfaceManagerCommonUtils.getListOfDpns(dataBroker);
-        for (BigInteger dpnId : listOfDpns) {
-            parentInterface = new StringBuilder().append(dpnId).append(IfmConstants.OF_URI_SEPARATOR)
-                    .append(interfaceName).toString();
-            ifState = InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(parentInterface, dataBroker);
-            if (ifState != null) {
-                break;
-            }
-        }
-        return ifState;
+        Matcher matcher = pattern.matcher(portName);
+        return matcher.matches();
     }
 
-    public static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface getInterfaceStateFromDS(
-            String interfaceName) {
-        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = null;
-        for (Map.Entry<String, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> entry : interfaceStateMap
-                .entrySet()) {
-            if (entry.getKey().contains(interfaceName)) {
-                ifState = entry.getValue();
-            }
-        }
-        return ifState;
-    }
 }

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/InterfaceConfigListener.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/InterfaceConfigListener.java
index 2dceb5da8b61ae0100b732a75993f5e87bf72488..8e50e9890e2d57d03fa4aa111052624825826b24 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/InterfaceConfigListener.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/InterfaceConfigListener.java
@@ -12,6 +12,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
 import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
+import org.opendaylight.genius.interfacemanager.IfmConstants;
 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
 import org.opendaylight.genius.interfacemanager.renderer.ovs.confighelpers.OvsInterfaceConfigAddHelper;
 import org.opendaylight.genius.interfacemanager.renderer.ovs.confighelpers.OvsInterfaceConfigRemoveHelper;
@@ -22,6 +23,7 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefsBuilder;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -70,9 +72,11 @@ public class InterfaceConfigListener extends AsyncDataTreeChangeListenerBase<Int
             LOG.warn("parent refs not specified for {}",interfaceOld.getName());
             return;
         }
+        boolean isTunnelInterface  = InterfaceManagerCommonUtils.isTunnelInterface(interfaceOld);
+        parentRefs = updateParentInterface(isTunnelInterface, parentRefs);
         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
         RendererConfigRemoveWorker configWorker = new RendererConfigRemoveWorker(key, interfaceOld, ifName, parentRefs);
-        String synchronizationKey = InterfaceManagerCommonUtils.isTunnelInterface(interfaceOld) ?
+        String synchronizationKey = isTunnelInterface ?
                 parentRefs.getDatapathNodeIdentifier().toString() : parentRefs.getParentInterface();
         coordinator.enqueueJob(synchronizationKey, configWorker, MAX_RETRIES);
     }
@@ -86,9 +90,11 @@ public class InterfaceConfigListener extends AsyncDataTreeChangeListenerBase<Int
             LOG.warn("parent refs not specified for {}",interfaceNew.getName());
             return;
         }
+        boolean isTunnelInterface  = InterfaceManagerCommonUtils.isTunnelInterface(interfaceOld);
+        parentRefs = updateParentInterface(isTunnelInterface, parentRefs);
         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
         RendererConfigUpdateWorker worker = new RendererConfigUpdateWorker(key, interfaceOld, interfaceNew, ifNameNew);
-        String synchronizationKey = InterfaceManagerCommonUtils.isTunnelInterface(interfaceOld) ?
+        String synchronizationKey = isTunnelInterface ?
                 interfaceOld.getName() : parentRefs.getParentInterface();
         coordinator.enqueueJob(synchronizationKey, worker, MAX_RETRIES);
     }
@@ -102,13 +108,25 @@ public class InterfaceConfigListener extends AsyncDataTreeChangeListenerBase<Int
             LOG.warn("parent refs not specified for {}",interfaceNew.getName());
             return;
         }
+        boolean isTunnelInterface  = InterfaceManagerCommonUtils.isTunnelInterface(interfaceNew);
+        parentRefs = updateParentInterface(isTunnelInterface, parentRefs);
         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
         RendererConfigAddWorker configWorker = new RendererConfigAddWorker(key, interfaceNew, parentRefs, ifName);
-        String synchronizationKey = InterfaceManagerCommonUtils.isTunnelInterface(interfaceNew) ?
+        String synchronizationKey = isTunnelInterface ?
                 interfaceNew.getName() : parentRefs.getParentInterface();
         coordinator.enqueueJob(synchronizationKey, configWorker, MAX_RETRIES);
     }
 
+    private static ParentRefs updateParentInterface(boolean isTunnelInterface, ParentRefs parentRefs) {
+        if (!isTunnelInterface && parentRefs.getDatapathNodeIdentifier() != null) {
+            StringBuilder parentInterface = new StringBuilder(parentRefs.getDatapathNodeIdentifier().toString());
+            parentInterface.append(IfmConstants.OF_URI_SEPARATOR);
+            parentInterface.append(parentRefs.getParentInterface());
+            parentRefs = new ParentRefsBuilder(parentRefs).setParentInterface(parentInterface.toString()).build();
+        }
+        return parentRefs;
+    }
+
     private class RendererConfigAddWorker implements Callable<List<ListenableFuture<Void>>> {
         InstanceIdentifier<Interface> key;
         Interface interfaceNew;

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 e8444440179c24ed5868f0922f9dd0b0a364c9d8..ef1ca7afa6205bed9a87c6bf55ef7ae279a7ed9a 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
@@ -11,15 +11,14 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
 import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
-import org.opendaylight.genius.interfacemanager.IfmUtil;
 import org.opendaylight.genius.interfacemanager.IfmConstants;
+import org.opendaylight.genius.interfacemanager.IfmUtil;
 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
 import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
 import org.opendaylight.genius.interfacemanager.renderer.ovs.statehelpers.OvsInterfaceStateAddHelper;
 import org.opendaylight.genius.interfacemanager.renderer.ovs.statehelpers.OvsInterfaceStateRemoveHelper;
 import org.opendaylight.genius.interfacemanager.renderer.ovs.statehelpers.OvsInterfaceStateUpdateHelper;
 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
@@ -82,13 +81,16 @@ public class InterfaceInventoryStateListener extends AsyncDataTreeChangeListener
         NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
 
         //VM Migration: Skip OFPPR_DELETE event received after OFPPR_ADD for same interface from Older DPN
-        Interface ifState = InterfaceManagerCommonUtils.getInterfaceStateFromDS(portName);
-        NodeConnectorId nodeConnectorIdOld = IfmUtil.getNodeConnectorIdFromInterface(ifState);
-        if(nodeConnectorIdOld != null && !nodeConnectorId.equals(nodeConnectorIdOld)) {
-            LOG.debug("Dropping the NodeConnector Remove Event for the interface: {}, {}, {}", portName, nodeConnectorId, nodeConnectorIdOld);
-            return;
+        NodeConnectorId nodeConnectorIdOld = IfmUtil.getNodeConnectorIdFromInterface(portName, dataBroker);
+        if (InterfaceManagerCommonUtils.isNovaOrTunnelPort(portName)) {
+            if(nodeConnectorIdOld != null && !nodeConnectorId.equals(nodeConnectorIdOld)) {
+                LOG.debug("Dropping the NodeConnector Remove Event for the interface: {}, {}, {}", portName, nodeConnectorId, nodeConnectorIdOld);
+                return;
+            }
+        } else {
+            portName = getDpnPrefixedPortName(nodeConnectorId, portName);
         }
-        remove(nodeConnectorId, nodeConnectorIdOld, flowCapableNodeConnectorOld, portName, ifState);
+        remove(nodeConnectorId, nodeConnectorIdOld, flowCapableNodeConnectorOld, portName);
     }
 
     @Override
@@ -110,13 +112,15 @@ public class InterfaceInventoryStateListener extends AsyncDataTreeChangeListener
         NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
 
         //VM Migration: Delete existing interface entry for older DPN
-        Interface ifState = InterfaceManagerCommonUtils.getInterfaceStateFromDS(portName);
-        NodeConnectorId nodeConnectorIdOld = IfmUtil.getNodeConnectorIdFromInterface(ifState);
-        if (nodeConnectorIdOld != null && !nodeConnectorId.equals(nodeConnectorIdOld)) {
-            LOG.debug("Triggering NodeConnector Remove Event for the interface: {}, {}, {}", portName, nodeConnectorId, nodeConnectorIdOld);
-            remove(nodeConnectorId, nodeConnectorIdOld, fcNodeConnectorNew, portName, ifState);
+        if (InterfaceManagerCommonUtils.isNovaOrTunnelPort(portName)) {
+            NodeConnectorId nodeConnectorIdOld = IfmUtil.getNodeConnectorIdFromInterface(portName, dataBroker);
+            if (nodeConnectorIdOld != null && !nodeConnectorId.equals(nodeConnectorIdOld)) {
+                LOG.debug("Triggering NodeConnector Remove Event for the interface: {}, {}, {}", portName, nodeConnectorId, nodeConnectorIdOld);
+                remove(nodeConnectorId, nodeConnectorIdOld, fcNodeConnectorNew, portName);
+            }
+        } else {
+            portName = getDpnPrefixedPortName(nodeConnectorId, portName);
         }
-
         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
         InterfaceStateAddWorker ifStateAddWorker = new InterfaceStateAddWorker(idManager, nodeConnectorId,
                 fcNodeConnectorNew, portName);
@@ -124,13 +128,20 @@ public class InterfaceInventoryStateListener extends AsyncDataTreeChangeListener
     }
 
     private void remove(NodeConnectorId nodeConnectorIdNew, NodeConnectorId nodeConnectorIdOld,
-                        FlowCapableNodeConnector fcNodeConnectorNew, String portName, Interface ifState) {
+                        FlowCapableNodeConnector fcNodeConnectorNew, String portName) {
         DataStoreJobCoordinator coordinator = DataStoreJobCoordinator.getInstance();
         InterfaceStateRemoveWorker portStateRemoveWorker = new InterfaceStateRemoveWorker(idManager,
-                nodeConnectorIdNew, nodeConnectorIdOld, fcNodeConnectorNew, portName, ifState);
+                nodeConnectorIdNew, nodeConnectorIdOld, fcNodeConnectorNew, portName);
         coordinator.enqueueJob(portName, portStateRemoveWorker, 3);
     }
 
+    private String getDpnPrefixedPortName(NodeConnectorId nodeConnectorId, String portName) {
+        portName = new StringBuilder(
+                IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId))
+                        .append(IfmConstants.OF_URI_SEPARATOR)
+                        .append(portName).toString();
+        return portName;
+    }
     private class InterfaceStateAddWorker implements Callable {
         private final NodeConnectorId nodeConnectorId;
         private final FlowCapableNodeConnector fcNodeConnectorNew;
@@ -152,7 +163,7 @@ public class InterfaceInventoryStateListener extends AsyncDataTreeChangeListener
             // to call the respective helpers.
             List<ListenableFuture<Void>> futures = OvsInterfaceStateAddHelper.addState(dataBroker, idManager, mdsalApiManager, alivenessMonitorService, nodeConnectorId,
                     interfaceName, fcNodeConnectorNew);
-            List<InterfaceChildEntry> interfaceChildEntries = getInterfaceChildEntries(dataBroker, interfaceName, nodeConnectorId);
+            List<InterfaceChildEntry> interfaceChildEntries = getInterfaceChildEntries(dataBroker, interfaceName);
             for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
                 InterfaceStateAddWorker interfaceStateAddWorker = new InterfaceStateAddWorker(idManager, nodeConnectorId,
                         fcNodeConnectorNew, interfaceChildEntry.getChildInterface());
@@ -194,8 +205,7 @@ public class InterfaceInventoryStateListener extends AsyncDataTreeChangeListener
             // to call the respective helpers.
             List<ListenableFuture<Void>> futures = OvsInterfaceStateUpdateHelper.updateState(key, alivenessMonitorService, dataBroker, interfaceName,
                     fcNodeConnectorNew, fcNodeConnectorOld);
-            NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
-            List<InterfaceChildEntry> interfaceChildEntries = getInterfaceChildEntries(dataBroker, interfaceName, nodeConnectorId);
+            List<InterfaceChildEntry> interfaceChildEntries = getInterfaceChildEntries(dataBroker, interfaceName);
             for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
                 InterfaceStateUpdateWorker interfaceStateUpdateWorker = new InterfaceStateUpdateWorker(key, fcNodeConnectorOld,
                         fcNodeConnectorNew, interfaceChildEntry.getChildInterface());
@@ -221,18 +231,16 @@ public class InterfaceInventoryStateListener extends AsyncDataTreeChangeListener
         FlowCapableNodeConnector fcNodeConnectorOld;
         private final String interfaceName;
         private final IdManagerService idManager;
-        private final Interface ifState;
 
         public InterfaceStateRemoveWorker(IdManagerService idManager, NodeConnectorId nodeConnectorIdNew,
                                           NodeConnectorId nodeConnectorIdOld,
                                           FlowCapableNodeConnector fcNodeConnectorOld,
-                                          String portName,Interface ifState) {
+                                          String portName) {
             this.nodeConnectorIdNew = nodeConnectorIdNew;
             this.nodeConnectorIdOld = nodeConnectorIdOld;
             this.fcNodeConnectorOld = fcNodeConnectorOld;
             this.interfaceName = portName;
             this.idManager = idManager;
-            this.ifState = ifState;
         }
 
         @Override
@@ -240,14 +248,13 @@ public class InterfaceInventoryStateListener extends AsyncDataTreeChangeListener
             // If another renderer(for eg : CSS) needs to be supported, check can be performed here
             // to call the respective helpers.
             List<ListenableFuture<Void>> futures = OvsInterfaceStateRemoveHelper.removeInterfaceStateConfiguration(idManager, mdsalApiManager, alivenessMonitorService,
-                    nodeConnectorIdNew, nodeConnectorIdOld, dataBroker, interfaceName, fcNodeConnectorOld, ifState);
+                    nodeConnectorIdNew, nodeConnectorIdOld, dataBroker, interfaceName, fcNodeConnectorOld);
 
-            List<InterfaceChildEntry> interfaceChildEntries = getInterfaceChildEntries(dataBroker, interfaceName, nodeConnectorIdNew);
+            List<InterfaceChildEntry> interfaceChildEntries = getInterfaceChildEntries(dataBroker, interfaceName);
             for (InterfaceChildEntry interfaceChildEntry : interfaceChildEntries) {
                 // Fetch all interfaces on this port and trigger remove worker for each of them
                 InterfaceStateRemoveWorker interfaceStateRemoveWorker = new InterfaceStateRemoveWorker(idManager,
-                        nodeConnectorIdNew, nodeConnectorIdOld, fcNodeConnectorOld, interfaceChildEntry.getChildInterface(),
-                        InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(interfaceChildEntry.getChildInterface(), dataBroker));
+                        nodeConnectorIdNew, nodeConnectorIdOld, fcNodeConnectorOld, interfaceChildEntry.getChildInterface());
                 DataStoreJobCoordinator.getInstance().enqueueJob(interfaceName, interfaceStateRemoveWorker);
             }
             return futures;
@@ -264,19 +271,12 @@ public class InterfaceInventoryStateListener extends AsyncDataTreeChangeListener
         }
     }
 
-    public static List<InterfaceChildEntry> getInterfaceChildEntries(DataBroker dataBroker, String interfaceName, NodeConnectorId nodeConnectorId) {
+    public static List<InterfaceChildEntry> getInterfaceChildEntries(DataBroker dataBroker, String interfaceName) {
         InterfaceParentEntry interfaceParentEntry =
                 InterfaceMetaUtils.getInterfaceParentEntryFromConfigDS(interfaceName, dataBroker);
         if (interfaceParentEntry != null && interfaceParentEntry.getInterfaceChildEntry() != null) {
             return interfaceParentEntry.getInterfaceChildEntry();
         }
-        StringBuilder parentInterface = new StringBuilder(IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId));
-        parentInterface.append(IfmConstants.OF_URI_SEPARATOR);
-        parentInterface.append(interfaceName);
-        interfaceParentEntry = InterfaceMetaUtils.getInterfaceParentEntryFromConfigDS(parentInterface.toString(), dataBroker);
-        if (interfaceParentEntry != null && interfaceParentEntry.getInterfaceChildEntry() != null) {
-            return interfaceParentEntry.getInterfaceChildEntry();
-        }
         return new ArrayList<>();
     }
 }
\ No newline at end of file

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigAddHelper.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigAddHelper.java
index 70f3a5204a499307ad14c6611a10f3b599f37642..55069bd8e61b2e8c0275e82c1b3041d4699cf88a 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigAddHelper.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/confighelpers/OvsInterfaceConfigAddHelper.java
@@ -12,7 +12,6 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.interfacemanager.IfmConstants;
 import org.opendaylight.genius.interfacemanager.IfmUtil;
 import org.opendaylight.genius.interfacemanager.commons.AlivenessMonitorUtils;
 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
@@ -69,24 +68,14 @@ public class OvsInterfaceConfigAddHelper {
         if (ifL2vlan == null || (IfL2vlan.L2vlanMode.Trunk != ifL2vlan.getL2vlanMode() && IfL2vlan.L2vlanMode.Transparent != ifL2vlan.getL2vlanMode())) {
             return;
         }
-        String parentInterface = null;
-        if (parentRefs.getDatapathNodeIdentifier() != null) {
-            parentInterface = new StringBuilder().append(parentRefs.getDatapathNodeIdentifier()).append(IfmConstants.OF_URI_SEPARATOR).append(parentRefs.getParentInterface()).toString();
-        } else {
-            parentInterface = parentRefs.getParentInterface();
-        }
         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
         if(!InterfaceManagerCommonUtils.createInterfaceChildEntryIfNotPresent(dataBroker, transaction,
-                parentInterface, interfaceNew.getName())){
+                parentRefs.getParentInterface(), interfaceNew.getName())){
             return;
         }
         LOG.debug("adding vlan configuration for {}",interfaceNew.getName());
-        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState = null;
-        if (parentInterface.contains(IfmConstants.OF_URI_SEPARATOR)) {
-            ifState = InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(parentInterface, dataBroker);
-        } else {
-            ifState = InterfaceManagerCommonUtils.getInterfaceStateForUnknownDpn(parentRefs.getParentInterface(), dataBroker);
-        }
+        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState =
+                InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(parentRefs.getParentInterface(), dataBroker);
 
         InterfaceManagerCommonUtils.addStateEntry(interfaceNew.getName(), transaction, dataBroker, idManager, ifState);
 

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 229ee863f601330bca9191ab2315d6bfdd56554a..f1121754491a5a21df4d072735c56691727b29fd 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
@@ -11,7 +11,6 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.interfacemanager.IfmConstants;
 import org.opendaylight.genius.interfacemanager.IfmUtil;
 import org.opendaylight.genius.interfacemanager.commons.AlivenessMonitorUtils;
 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
@@ -36,7 +35,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.met
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfL2vlan;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefsBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
@@ -79,11 +77,6 @@ public class OvsInterfaceConfigRemoveHelper {
             return;
         }
         LOG.debug("removing vlan configuration for {}",interfaceName);
-        if (parentRefs.getDatapathNodeIdentifier() != null) {
-            parentRefs = new ParentRefsBuilder(parentRefs).setParentInterface(new StringBuilder().append(parentRefs.getDatapathNodeIdentifier())
-                            .append(IfmConstants.OF_URI_SEPARATOR).append(parentRefs.getParentInterface()).toString())
-                            .build();
-        }
         InterfaceManagerCommonUtils.deleteInterfaceStateInformation(interfaceName, transaction, idManagerService);
 
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface ifState =

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 9bf96554c1022d35a5844092351ef523e37c902e..190a755c38dff4baf8c3dbf2f7abedee237a8cd9 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
@@ -10,7 +10,6 @@ package org.opendaylight.genius.interfacemanager.renderer.ovs.statehelpers;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.genius.interfacemanager.IfmConstants;
 import org.opendaylight.genius.interfacemanager.IfmUtil;
 import org.opendaylight.genius.interfacemanager.commons.AlivenessMonitorUtils;
 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
@@ -66,15 +65,11 @@ public class OvsInterfaceStateAddHelper {
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
                 InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceKey, dataBroker);
 
-        boolean isTunnelInterface = InterfaceManagerCommonUtils.isTunnelInterface(iface);
-        if (!isTunnelInterface && fcNodeConnectorNew!=null && interfaceName.equals(fcNodeConnectorNew.getName())) {
-            interfaceName = new StringBuilder(IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId)).append(IfmConstants.OF_URI_SEPARATOR).append(interfaceName).toString();
-        }
         Interface ifState = InterfaceManagerCommonUtils.addStateEntry(iface, interfaceName, transaction, idManager,
                 physAddress, operStatus, adminStatus, nodeConnectorId);
 
         // If this interface is a tunnel interface, create the tunnel ingress flow,and start tunnel monitoring
-        if (isTunnelInterface) {
+        if (InterfaceManagerCommonUtils.isTunnelInterface(iface)) {
             handleTunnelMonitoringAddition(futures, dataBroker, mdsalApiManager, alivenessMonitorService,
                     nodeConnectorId, transaction, ifState.getIfIndex(), iface.getAugmentation(IfTunnel.class), interfaceName);
             return futures;

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateRemoveHelper.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateRemoveHelper.java
index 65cf649f3f41596e50387b677fd793d2bd790472..ab4c09d1f57ebcaa4360dec22b9108e6793ef7bf 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateRemoveHelper.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateRemoveHelper.java
@@ -10,7 +10,6 @@ package org.opendaylight.genius.interfacemanager.renderer.ovs.statehelpers;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.genius.interfacemanager.IfmConstants;
 import org.opendaylight.genius.interfacemanager.IfmUtil;
 import org.opendaylight.genius.interfacemanager.commons.AlivenessMonitorUtils;
 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
@@ -18,8 +17,6 @@ import org.opendaylight.genius.interfacemanager.commons.InterfaceMetaUtils;
 import org.opendaylight.genius.interfacemanager.servicebindings.flowbased.utilities.FlowBasedServicesUtils;
 import org.opendaylight.genius.mdsalutil.NwConstants;
 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.alivenessmonitor.rev160411.AlivenessMonitorService;
@@ -39,8 +36,7 @@ public class OvsInterfaceStateRemoveHelper {
                                                                                  AlivenessMonitorService alivenessMonitorService,
                                                                                  NodeConnectorId nodeConnectorIdNew, NodeConnectorId nodeConnectorIdOld,
                                                                                  DataBroker dataBroker, String interfaceName,
-                                                                                 FlowCapableNodeConnector fcNodeConnectorOld,
-                                                                                 Interface ifState) {
+                                                                                 FlowCapableNodeConnector fcNodeConnectorOld) {
         LOG.debug("Removing interface-state information for interface: {}", interfaceName);
         List<ListenableFuture<Void>> futures = new ArrayList<>();
         WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
@@ -56,16 +52,11 @@ public class OvsInterfaceStateRemoveHelper {
             //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"
             OvsInterfaceStateUpdateHelper.updateInterfaceStateOnNodeRemove(interfaceName, fcNodeConnectorOld, dataBroker,
-                    alivenessMonitorService, transaction, dpId.toString());
+                    alivenessMonitorService, transaction);
         }else{
-
+            InterfaceManagerCommonUtils.deleteStateEntry(interfaceName, transaction);
             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
                     InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceName, dataBroker);
-            boolean isTunnelInterface = IfmUtil.isTunnelType(iface, ifState);
-            if (!isTunnelInterface && fcNodeConnectorOld!=null && interfaceName.equals(fcNodeConnectorOld.getName())) {
-                interfaceName = new StringBuilder().append(dpId).append(IfmConstants.OF_URI_SEPARATOR).append(interfaceName).toString();
-            }
-            InterfaceManagerCommonUtils.deleteStateEntry(interfaceName, transaction);
 
             if(iface != null) {
                 // If this interface is a tunnel interface, remove the tunnel ingress flow and stop lldp monitoring

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateUpdateHelper.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateUpdateHelper.java
index b686e7d79d08f796e86529e3ad0a48858311ad0c..4bc45165bdcc0f627871d24f767b2f935148bdc2 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateUpdateHelper.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/renderer/ovs/statehelpers/OvsInterfaceStateUpdateHelper.java
@@ -11,7 +11,6 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.interfacemanager.IfmConstants;
 import org.opendaylight.genius.interfacemanager.IfmUtil;
 import org.opendaylight.genius.interfacemanager.commons.AlivenessMonitorUtils;
 import org.opendaylight.genius.interfacemanager.commons.InterfaceManagerCommonUtils;
@@ -70,12 +69,10 @@ public class OvsInterfaceStateUpdateHelper {
             PhysAddress physAddress = new PhysAddress(macAddressNew.getValue());
             ifaceBuilder.setPhysAddress(physAddress);
         }
-        NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
-        String dpnId = IfmUtil.getDpnFromNodeConnectorId(nodeConnectorId);
         // modify the attributes in interface operational DS
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
                 handleInterfaceStateUpdates(interfaceName, transaction, dataBroker,
-                        ifaceBuilder, opstateModified, flowCapableNodeConnectorNew.getName(), operStatusNew, dpnId);
+                        ifaceBuilder, opstateModified, flowCapableNodeConnectorNew.getName(), operStatusNew);
 
         // start/stop monitoring based on opState
         if(modifyTunnel(iface, opstateModified)){
@@ -89,14 +86,14 @@ public class OvsInterfaceStateUpdateHelper {
 
     public static void updateInterfaceStateOnNodeRemove(String interfaceName, FlowCapableNodeConnector flowCapableNodeConnector,
                                                         DataBroker dataBroker, AlivenessMonitorService alivenessMonitorService,
-                                                        WriteTransaction transaction, String dpnId){
+                                                        WriteTransaction transaction){
         LOG.debug("Updating interface oper-status to UNKNOWN for : {}", interfaceName);
 
         InterfaceBuilder ifaceBuilder = new InterfaceBuilder();
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
                 handleInterfaceStateUpdates(interfaceName,transaction, dataBroker,
                         ifaceBuilder, true, flowCapableNodeConnector.getName(),
-                        Interface.OperStatus.Unknown, dpnId);
+                        Interface.OperStatus.Unknown);
         if (InterfaceManagerCommonUtils.isTunnelInterface(iface)){
             handleTunnelMonitoringUpdates(alivenessMonitorService, dataBroker, iface.getAugmentation(IfTunnel.class),
                     interfaceName, Interface.OperStatus.Unknown);
@@ -115,19 +112,15 @@ public class OvsInterfaceStateUpdateHelper {
     handleInterfaceStateUpdates(String interfaceName, WriteTransaction transaction,
                                 DataBroker dataBroker, InterfaceBuilder ifaceBuilder, boolean opStateModified,
                                 String portName,
-                                org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus opState,String dpnId){
+                                org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus opState){
         LOG.debug("updating interface state entry for {}", interfaceName);
-        boolean isParentInterface = (interfaceName.equals(portName))?true:false;
-        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
-                InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceName, dataBroker);
-        if (!IfmUtil.isTunnelType(iface, null) && isParentInterface) {
-            interfaceName = new StringBuilder(dpnId).append(IfmConstants.OF_URI_SEPARATOR).append(interfaceName).toString();
-        }
         InstanceIdentifier<Interface> ifStateId = IfmUtil.buildStateInterfaceId(interfaceName);
         ifaceBuilder.setKey(new InterfaceKey(interfaceName));
+        org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface iface =
+                InterfaceManagerCommonUtils.getInterfaceFromConfigDS(interfaceName, dataBroker);
         // if interface config DS is null, do the update only for the lower-layer-interfaces
         // which have no corresponding config entries
-        if(iface == null && !isParentInterface){
+        if(iface == null && interfaceName != portName){
             return null;
         }
         if (modifyOpState(iface, opStateModified)) {

diff --git a/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/InterfaceManagerTestUtil.java b/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/InterfaceManagerTestUtil.java
index 8fe156d729c87e3f1121cb9c59beb442df49c87d..fb3b35fa5549cd4301a7bded03cad207674df026 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/InterfaceManagerTestUtil.java
+++ b/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/InterfaceManagerTestUtil.java
@@ -156,7 +156,7 @@ public class InterfaceManagerTestUtil {
                                            BigInteger dpn) {
         InterfaceBuilder builder = new InterfaceBuilder().setKey(new InterfaceKey(ifName)).setName(ifName)
                 .setDescription(desc).setEnabled(enabled).setType((Class<? extends InterfaceType>) ifType);
-        ParentRefs parentRefs = new ParentRefsBuilder().setParentInterface(ifName).build();
+        ParentRefs parentRefs = new ParentRefsBuilder().setDatapathNodeIdentifier(dpn).setParentInterface(ifName).build();
         builder.addAugmentation(ParentRefs.class, parentRefs);
         if(ifType.equals(L2vlan.class)){
             IfL2vlan l2vlan = new IfL2vlanBuilder().setVlanId(VlanId.getDefaultInstance("0"))

diff --git a/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/StateInterfaceTest.java b/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/StateInterfaceTest.java
index 277dce42f0e10f1aa5a0c0dd58db657c132b3334..7ba8e4595abfaa12c63a46ac2ab58f3cf68f062a 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/StateInterfaceTest.java
+++ b/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/StateInterfaceTest.java
@@ -252,8 +252,7 @@ public class StateInterfaceTest {
         doReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build())).when(idManager).releaseId(getIdInput);
 
         removeHelper.removeInterfaceStateConfiguration(idManager, mdsalManager, alivenessMonitorService, nodeConnectorId,
-                nodeConnectorId, dataBroker, InterfaceManagerTestUtil.interfaceName, fcNodeConnectorNew,
-                InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(InterfaceManagerTestUtil.interfaceName, dataBroker));
+                nodeConnectorId, dataBroker, InterfaceManagerTestUtil.interfaceName, fcNodeConnectorNew);
 
         verify(mockWriteTx).delete(LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
 
@@ -285,8 +284,7 @@ public class StateInterfaceTest {
                 LogicalDatastoreType.OPERATIONAL, nodeInstanceIdentifier);
 
         removeHelper.removeInterfaceStateConfiguration(idManager, mdsalManager, alivenessMonitorService, nodeConnectorId,
-                nodeConnectorId, dataBroker, InterfaceManagerTestUtil.interfaceName, fcNodeConnectorNew,
-                InterfaceManagerCommonUtils.getInterfaceStateFromOperDS(InterfaceManagerTestUtil.interfaceName, dataBroker));
+                nodeConnectorId, dataBroker, InterfaceManagerTestUtil.interfaceName, fcNodeConnectorNew);
 
     }
 

diff --git a/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/VlanInterfaceConfigurationTest.java b/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/VlanInterfaceConfigurationTest.java
index 8ca4bddd0c5593134b7e52ca41733d4b9a2602c5..6e24c00187e014f62a8811c9f4c9f1caf89d5701 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/VlanInterfaceConfigurationTest.java
+++ b/interfacemanager/interfacemanager-impl/src/test/java/org/opendaylight/genius/interfacemanager/test/VlanInterfaceConfigurationTest.java
@@ -92,23 +92,16 @@ public class VlanInterfaceConfigurationTest {
     OvsVlanMemberConfigUpdateHelper memberConfigUpdateHelper;
 
     NodeConnectorId nodeConnectorId;
-    Nodes nodes;
-    Node node;
-    List<Node>  nodeList = new ArrayList<>();
-    List<NodeConnector> nodeConnectorList = new ArrayList<>();
     NodeConnector nodeConnector;
     Interface vlanInterfaceEnabled;
     Interface vlanInterfaceDisabled;
     InstanceIdentifier<Interface> interfaceInstanceIdentifier;
     InstanceIdentifier<NodeConnector> nodeConnectorInstanceIdentifier;
-    InstanceIdentifier<Nodes> nodesInstanceIdentifier = InstanceIdentifier.builder(Nodes.class).build();
     InstanceIdentifier<InterfaceParentEntry> interfaceParentEntryIdentifier = null;
     InterfaceParentEntry interfaceParentEntry;
     InterfaceChildEntry interfaceChildEntry = null;
     InstanceIdentifier<InterfaceChildEntry> interfaceChildEntryInstanceIdentifier;
     InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> interfaceStateIdentifier;
-    InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
-            .state.Interface> interfaceStateIdentifierNew;
     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface stateInterface;
 
     @Before
@@ -126,17 +119,11 @@ public class VlanInterfaceConfigurationTest {
     private void setupMocks() {
         nodeConnectorId = InterfaceManagerTestUtil.buildNodeConnectorId(BigInteger.valueOf(1), 1);
         nodeConnector = InterfaceManagerTestUtil.buildNodeConnector(nodeConnectorId);
-        nodeConnectorList.add(nodeConnector);
-        node = new NodeBuilder().setId(NodeId.getDefaultInstance("openflow:1:1")).setKey(new NodeKey(NodeId
-                .getDefaultInstance("openflow:1:1"))).build();
-        nodeList.add(node);
-        nodes = new NodesBuilder().setNode(nodeList).build();
         vlanInterfaceEnabled = InterfaceManagerTestUtil.buildInterface(InterfaceManagerTestUtil.interfaceName, "Test Vlan Interface1", true, L2vlan.class, BigInteger.valueOf(1));
         vlanInterfaceDisabled = InterfaceManagerTestUtil.buildInterface(InterfaceManagerTestUtil.interfaceName, "Test Vlan Interface1", false, L2vlan.class, BigInteger.valueOf(1));
         interfaceInstanceIdentifier = IfmUtil.buildId(InterfaceManagerTestUtil.interfaceName);
         nodeConnectorInstanceIdentifier = InterfaceManagerTestUtil.getNcIdent("openflow:1", nodeConnectorId);
         interfaceStateIdentifier = IfmUtil.buildStateInterfaceId(vlanInterfaceEnabled.getName());
-        interfaceStateIdentifierNew = IfmUtil.buildStateInterfaceId("1:s1-eth1");
         stateInterface = InterfaceManagerTestUtil.buildStateInterface(InterfaceManagerTestUtil.interfaceName, nodeConnectorId);
         AllocateIdOutput output = new AllocateIdOutputBuilder().setIdValue((long)1).build();
         RpcResultBuilder<AllocateIdOutput> allocateIdRpcBuilder = RpcResultBuilder.success();
@@ -163,17 +150,13 @@ public class VlanInterfaceConfigurationTest {
 
     @Test
     public void testAddVlanInterfaceWhenSwitchIsNotConnected() {
-
-        Optional<Nodes> nodesOptional = Optional.of(nodes);
         Optional<Interface> expectedInterface = Optional.of(vlanInterfaceEnabled);
-        Optional.of(stateInterface);
+        Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> expectedStateInterface = Optional.of(stateInterface);
 
-        doReturn(Futures.immediateCheckedFuture(nodesOptional)).when(mockReadTx).read(LogicalDatastoreType
-                .OPERATIONAL, nodesInstanceIdentifier);
         doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
-                LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
+                        LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
-                LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifierNew);
+               LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
                 LogicalDatastoreType.CONFIGURATION, interfaceParentEntryIdentifier);
 
@@ -186,17 +169,14 @@ public class VlanInterfaceConfigurationTest {
 
     @Test
     public void testAddVlanInterfaceWhenSwitchIsConnected() {
-        Optional<Nodes> nodesOptional = Optional.of(nodes);
         Optional<Interface> expectedInterface = Optional.of(vlanInterfaceEnabled);
         Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface>
                 expectedStateInterface = Optional.of(stateInterface);
 
-        doReturn(Futures.immediateCheckedFuture(nodesOptional)).when(mockReadTx).read(LogicalDatastoreType
-                .OPERATIONAL, nodesInstanceIdentifier);
         doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
                 LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
         doReturn(Futures.immediateCheckedFuture(expectedStateInterface)).when(mockReadTx).read(
-                LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifierNew);
+                LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
                 LogicalDatastoreType.CONFIGURATION, interfaceParentEntryIdentifier);
 
@@ -209,17 +189,14 @@ public class VlanInterfaceConfigurationTest {
 
     @Test
     public void testAddVlanInterfaceWhenAdminStateDisabled() {
-        Optional<Nodes> nodesOptional = Optional.of(nodes);
         Optional<Interface> expectedInterface = Optional.of(vlanInterfaceEnabled);
         Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> expectedStateInterface =
                 Optional.of(stateInterface);
 
-        doReturn(Futures.immediateCheckedFuture(nodesOptional)).when(mockReadTx).read(LogicalDatastoreType
-                .OPERATIONAL, nodesInstanceIdentifier);
         doReturn(Futures.immediateCheckedFuture(expectedInterface)).when(mockReadTx).read(
                 LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
         doReturn(Futures.immediateCheckedFuture(expectedStateInterface)).when(mockReadTx).read(
-                LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifierNew);
+                LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
                 LogicalDatastoreType.CONFIGURATION, interfaceParentEntryIdentifier);
 
@@ -242,11 +219,11 @@ public class VlanInterfaceConfigurationTest {
         Optional<NodeConnector> expectedNc = Optional.of(nodeConnector);
         Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> expectedStateIf = Optional.of(stateInterface);
         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
-                LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
+                        LogicalDatastoreType.CONFIGURATION, interfaceInstanceIdentifier);
         doReturn(Futures.immediateCheckedFuture(expectedNc)).when(mockReadTx).read(
-                LogicalDatastoreType.OPERATIONAL, nodeConnectorInstanceIdentifier);
+                        LogicalDatastoreType.OPERATIONAL, nodeConnectorInstanceIdentifier);
         doReturn(Futures.immediateCheckedFuture(expectedStateIf)).when(mockReadTx).read(
-                LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
+                        LogicalDatastoreType.OPERATIONAL, interfaceStateIdentifier);
         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
                 LogicalDatastoreType.CONFIGURATION, interfaceParentEntryIdentifier);