Fix R2R link deletion problem

JIRA: TRNSPRTPCE-4
JIRA: TRNSPRTPCE-13
Signed-off-by: shweta <sv111y@att.com>
Change-Id: Ic48e2aa148b12f51d9380d34f890c96346ab018d

diff --git a/api/src/main/yang/portmapping@2017-02-28.yang b/api/src/main/yang/portmapping@2017-02-28.yang
index 9daec9e681eeacc608228d958b485c61d2778769..7f683fa772d2d7816dcd7b1f95ebedde9072416c 100644 (file)
--- a/api/src/main/yang/portmapping@2017-02-28.yang
+++ b/api/src/main/yang/portmapping@2017-02-28.yang
@@ -73,7 +73,10 @@ module portmapping {
        }
        leaf degree-number{
             type uint32;
-        }
+       }
+       leaf interface-name{
+          type string;
+       }
       }
     }
   }

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingImpl.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingImpl.java
index 7bf21e29d56c62b7b0f09e3d7848f300874685f1..66752cea539836485e2bb42bc7914536accc5ab0 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingImpl.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingImpl.java
@@ -40,16 +40,21 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPorts;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Degree;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Info;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Protocols;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.InterfaceType;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpenROADMOpticalMultiplex;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalTransport;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.Protocols1;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.Lldp;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfig;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.Network;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.NetworkBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.Nodes;
@@ -151,7 +156,9 @@ public class PortMappingImpl implements PortMapping {
 
         List<Degree> degrees = getDegrees(nodeId, deviceInfo);
         List<ConnectionPorts> degreeConPorts = getDegreePorts(degrees);
-        List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees);
+        Map<String, String> interfaceList = getEthInterfaceList(nodeId);
+        List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, nodeId, interfaceList);
+        LOG.info("Map looks like this {}",interfaceList);
 
         postPortMapping(deviceInfo, null, deviceInfo.getNodeType().getIntValue(), cpToDegreeList);
 
@@ -433,9 +440,14 @@ public class PortMappingImpl implements PortMapping {
         return mpBldr.build();
     }
 
-    private static CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber) {
+    private CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber, String nodeId,
+                                                     Map<String, String> interfaceList) {
+        String interfaceName = null;
+        if (interfaceList.get(circuitPackName) !=  null) {
+            interfaceName = interfaceList.get(circuitPackName);
+        }
         return new CpToDegreeBuilder().withKey(new CpToDegreeKey(circuitPackName)).setCircuitPackName(circuitPackName)
-            .setDegreeNumber(new Long(degreeNumber)).build();
+            .setDegreeNumber(new Long(degreeNumber)).setInterfaceName(interfaceName).build();
     }
 
     private static List<ConnectionPorts> getDegreePorts(List<Degree> degrees) {
@@ -443,12 +455,15 @@ public class PortMappingImpl implements PortMapping {
             .flatMap(degree -> degree.getConnectionPorts().stream()).collect(Collectors.toList());
     }
 
-    private List<CpToDegree> getCpToDegreeList(List<Degree> degrees) {
+    private List<CpToDegree> getCpToDegreeList(List<Degree> degrees, String nodeId,
+                                               Map<String, String> interfaceList) {
         List<CpToDegree> cpToDegreeList = new ArrayList<>();
         for (Degree degree : degrees) {
             if (degree.getCircuitPacks() != null) {
+                LOG.info("Inside CP to degree list");
                 cpToDegreeList.addAll(degree.getCircuitPacks().stream()
-                    .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(), degree.getDegreeNumber().toString()))
+                    .map(cp -> createCpToDegreeObject(cp.getCircuitPackName() ,
+                            degree.getDegreeNumber().toString(), nodeId ,interfaceList))
                     .collect(Collectors.toList()));
             }
         }
@@ -627,4 +642,42 @@ public class PortMappingImpl implements PortMapping {
 
     }
 
-}
\ No newline at end of file
+    private Map<String, String> getEthInterfaceList(String nodeId) {
+        LOG.info("It is calling get ethernet interface");
+        Map<String, String> cpToInterfaceMap = new HashMap<>();
+        InstanceIdentifier<Lldp> lldpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+                .child(Protocols.class).augmentation(Protocols1.class).child(Lldp.class);
+        Optional<Lldp> lldpObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
+                LogicalDatastoreType.OPERATIONAL, lldpIID, Timeouts.DEVICE_READ_TIMEOUT,
+                Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+        if (lldpObject.isPresent() && (lldpObject.get().getPortConfig() != null)) {
+            for (PortConfig portConfig : lldpObject.get().getPortConfig()) {
+                if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) {
+                    InstanceIdentifier<Interface> interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+                            .child(Interface.class, new InterfaceKey(portConfig.getIfName()));
+                    Optional<Interface> interfaceObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
+                            LogicalDatastoreType.OPERATIONAL, interfaceIID, Timeouts.DEVICE_READ_TIMEOUT,
+                            Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+                    if (interfaceObject.isPresent() && (interfaceObject.get().getSupportingCircuitPackName() != null)) {
+                        String supportingCircuitPackName = interfaceObject.get().getSupportingCircuitPackName();
+                        cpToInterfaceMap.put(supportingCircuitPackName, portConfig.getIfName());
+                        InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier.create(OrgOpenroadmDevice
+                                .class).child(CircuitPacks.class, new CircuitPacksKey(supportingCircuitPackName));
+                        Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(
+                                nodeId, LogicalDatastoreType.OPERATIONAL, circuitPacksIID, Timeouts
+                                                .DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+                        if (circuitPackObject.isPresent() && (circuitPackObject.get().getParentCircuitPack() != null)) {
+                            cpToInterfaceMap.put(circuitPackObject.get().getParentCircuitPack().getCircuitPackName() ,
+                                    portConfig.getIfName());
+                        }
+                    }
+                }
+            }
+        } else {
+            LOG.warn("Couldnt find port config under LLDP for Node : {}", nodeId);
+        }
+        LOG.info("Processiong is done.. now returning..");
+        return cpToInterfaceMap;
+    }
+
+}

diff --git a/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/R2RLinkDiscovery.java b/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/R2RLinkDiscovery.java
index 40ae84c062bf48438ad0a4d2993bbbaed8d9474e..78b76f2d29111a3119e60648edc1e8b35d8c400e 100644 (file)
--- a/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/R2RLinkDiscovery.java
+++ b/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/R2RLinkDiscovery.java
@@ -7,24 +7,22 @@
  */
 package org.opendaylight.transportpce.networkmodel;
 
+import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.MountPoint;
 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.transportpce.common.Timeouts;
 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
-import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
 import org.opendaylight.transportpce.networkmodel.util.OpenRoadmTopology;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev170929.Direction;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacks;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Degree;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Protocols;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.Protocols1;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.NbrList;
@@ -35,7 +33,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapp
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.Nodes;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.NodesKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.nodes.CpToDegree;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.nodes.CpToDegreeKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.nodes.Mapping;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -50,7 +48,7 @@ public class R2RLinkDiscovery {
     private final OpenRoadmInterfaces openRoadmInterfaces;
 
     public R2RLinkDiscovery(final DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager,
-            OpenRoadmTopology openRoadmTopology, OpenRoadmInterfaces openRoadmInterfaces) {
+                            OpenRoadmTopology openRoadmTopology, OpenRoadmInterfaces openRoadmInterfaces) {
         this.dataBroker = dataBroker;
         this.deviceTransactionManager = deviceTransactionManager;
         this.openRoadmTopology = openRoadmTopology;
@@ -71,19 +69,21 @@ public class R2RLinkDiscovery {
         LOG.info("LLDP subtree is present. Device has {} neighbours", nbrList.getIfName().size());
         for (IfName ifName : nbrList.getIfName()) {
             if (ifName.getRemoteSysName() == null) {
-                LOG.error("LLDP subtree is empty in the device for nodeId: {}", nodeId.getValue());
-                return false;
-            }
-            Optional<MountPoint> mps = this.deviceTransactionManager.getDeviceMountPoint(ifName.getRemoteSysName());
-            if (!mps.isPresent()) {
-                LOG.warn("Neighbouring nodeId: {} is not mounted yet", ifName.getRemoteSysName());
-                // The controller raises a warning rather than an error because the first node to
-                // mount cannot see its neighbors yet. The link will be detected when processing
-                // the neighbor node.
+                LOG.warn("LLDP subtree neighbour is empty for nodeId: {}, ifName: {}",
+                        nodeId.getValue(),ifName.getIfName());
             } else {
-                if (!createR2RLink(nodeId, ifName.getIfName(), ifName.getRemoteSysName(), ifName.getRemotePortId())) {
-                    LOG.error("Link Creation failed between {} and {} nodes.", nodeId, ifName.getRemoteSysName());
-                    return false;
+                Optional<MountPoint> mps = this.deviceTransactionManager.getDeviceMountPoint(ifName.getRemoteSysName());
+                if (!mps.isPresent()) {
+                    LOG.warn("Neighbouring nodeId: {} is not mounted yet", ifName.getRemoteSysName());
+                    // The controller raises a warning rather than an error because the first node to
+                    // mount cannot see its neighbors yet. The link will be detected when processing
+                    // the neighbor node.
+                } else {
+                    if (!createR2RLink(nodeId, ifName.getIfName(), ifName.getRemoteSysName(),
+                            ifName.getRemotePortId())) {
+                        LOG.error("Link Creation failed between {} and {} nodes.", nodeId, ifName.getRemoteSysName());
+                        return false;
+                    }
                 }
             }
         }
@@ -91,36 +91,37 @@ public class R2RLinkDiscovery {
     }
 
     public Direction getDegreeDirection(Integer degreeCounter, NodeId nodeId) {
-        InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Degree.class,
-                new DegreeKey(degreeCounter));
-        Optional<Degree> degreeObject = this.deviceTransactionManager.getDataFromDevice(nodeId.getValue(),
-                LogicalDatastoreType.OPERATIONAL, deviceIID, Timeouts.DEVICE_READ_TIMEOUT,
-                Timeouts.DEVICE_READ_TIMEOUT_UNIT);
-        if (degreeObject.isPresent()) {
-            Integer connectionPortCount = degreeObject.get().getConnectionPorts().size();
-            if (connectionPortCount == 1) {
-                return Direction.Bidirectional;
-            } else if (connectionPortCount > 1) {
-                return Direction.Tx;
-            } else {
-                return Direction.NotApplicable;
+        InstanceIdentifier<Nodes> nodesIID = InstanceIdentifier.builder(Network.class)
+                .child(Nodes.class, new NodesKey(nodeId.getValue())).build();
+        try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+            Optional<Nodes> nodesObject = readTx.read(LogicalDatastoreType.CONFIGURATION, nodesIID)
+                    .get().toJavaUtil();
+            if (nodesObject.isPresent() && nodesObject.get().getMapping() != null) {
+                List<Mapping> mappingList = nodesObject.get().getMapping();
+                mappingList = mappingList.stream().filter(mp -> mp.getLogicalConnectionPoint().contains("DEG"
+                        + degreeCounter)).collect(Collectors.toList());
+                if (mappingList.size() == 1) {
+                    return Direction.Bidirectional;
+                } else if (mappingList.size() > 1) {
+                    return Direction.Tx;
+                } else {
+                    return Direction.NotApplicable;
+                }
             }
-        } else {
-            LOG.error("Couldnt retrieve Degree object for nodeId: {} and DegreeNumbner: {}", nodeId.getValue(),
-                    degreeCounter);
-            return Direction.NotApplicable;
+        } catch (InterruptedException | ExecutionException e) {
+            LOG.error("Failed getting Mapping data from portMapping",e);
         }
+        return Direction.NotApplicable;
     }
 
     public boolean createR2RLink(NodeId nodeId, String interfaceName, String remoteSystemName,
-            String remoteInterfaceName) {
+                                 String remoteInterfaceName) {
         String srcTpTx = null;
         String srcTpRx = null;
         String destTpTx = null;
         String destTpRx = null;
         // Find which degree is associated with ethernet interface
-        // portmapping.getDegFromCP(nodeId,interfaceName);
-        Integer srcDegId = getDegFromCP(nodeId, interfaceName);
+        Integer srcDegId = getDegFromInterface(nodeId, interfaceName);
         if (srcDegId == null) {
             LOG.error("Couldnt find degree connected to Ethernet interface for nodeId: {}", nodeId);
             return false;
@@ -141,8 +142,7 @@ public class R2RLinkDiscovery {
         }
         // Find degree for which Ethernet interface is created on other end
         NodeId destNodeId = new NodeId(remoteSystemName);
-        Integer destDegId = getDegFromCP(destNodeId, remoteInterfaceName);
-        // portmapping.getDegFromCP(nodeId,interfaceName);
+        Integer destDegId = getDegFromInterface(destNodeId, remoteInterfaceName);
         if (destDegId == null) {
             LOG.error("Couldnt find degree connected to Ethernet interface for nodeId: {}", nodeId);
             return false;
@@ -164,7 +164,7 @@ public class R2RLinkDiscovery {
         // A->Z
         LOG.debug(
             "Found a neighbor SrcNodeId: {} , SrcDegId: {} , SrcTPId: {}, DestNodeId:{} , DestDegId: {}, DestTPId: {}",
-                nodeId.getValue(), srcDegId, srcTpTx, destNodeId, destDegId, destTpRx);
+            nodeId.getValue(), srcDegId, srcTpTx, destNodeId, destDegId, destTpRx);
         InitRoadmNodesInputBuilder r2rlinkBuilderAToZ = new InitRoadmNodesInputBuilder();
         r2rlinkBuilderAToZ.setRdmANode(nodeId.getValue()).setDegANum(srcDegId.shortValue())
                 .setTerminationPointA(srcTpTx).setRdmZNode(destNodeId.getValue()).setDegZNum(destDegId.shortValue())
@@ -193,14 +193,13 @@ public class R2RLinkDiscovery {
     }
 
     public boolean deleteR2RLink(NodeId nodeId, String interfaceName, String remoteSystemName,
-            String remoteInterfaceName) {
+                                 String remoteInterfaceName) {
         String srcTpTx = null;
         String srcTpRx = null;
         String destTpTx = null;
         String destTpRx = null;
         // Find which degree is associated with ethernet interface
-        // portmapping.getDegFromCP(nodeId,interfaceName);
-        Integer srcDegId = getDegFromCP(nodeId, interfaceName);
+        Integer srcDegId = getDegFromInterface(nodeId, interfaceName);
         if (srcDegId == null) {
             LOG.error("Couldnt find degree connected to Ethernet interface for nodeId: {}", nodeId);
             return false;
@@ -220,8 +219,7 @@ public class R2RLinkDiscovery {
         }
         // Find degree for which Ethernet interface is created on other end
         NodeId destNodeId = new NodeId(remoteSystemName);
-        // portmapping.getDegFromCP(nodeId,interfaceName);
-        Integer destDegId = getDegFromCP(destNodeId, remoteInterfaceName);
+        Integer destDegId = getDegFromInterface(destNodeId, remoteInterfaceName);
         if (destDegId == null) {
             LOG.error("Couldnt find degree connected to Ethernet interface for nodeId: {}", nodeId);
             return false;
@@ -239,78 +237,42 @@ public class R2RLinkDiscovery {
             destTpTx = "DEG" + destDegId + "-TTP-TX";
             destTpRx = "DEG" + destDegId + "-TTP-RX";
         }
-        return this.openRoadmTopology.deleteLink(nodeId.getValue(), destNodeId.getValue(), srcTpTx, destTpRx)
-                && this.openRoadmTopology.deleteLink(destNodeId.getValue(), nodeId.getValue(), destTpTx, srcTpRx);
+        return this.openRoadmTopology.deleteLink(nodeId.getValue(), destNodeId.getValue(),
+                srcDegId, destDegId, srcTpTx, destTpRx)
+                && this.openRoadmTopology.deleteLink(destNodeId.getValue(), nodeId.getValue(),
+                destDegId, srcDegId, destTpTx, srcTpRx);
     }
 
-    private CpToDegree getCPtoDegreeMapping(NodeId nodeId, String circuitPackName) {
-        InstanceIdentifier<CpToDegree> cptoDegMappingIID = InstanceIdentifier.builder(Network.class)
-                .child(Nodes.class, new NodesKey(nodeId.getValue()))
-                .child(CpToDegree.class, new CpToDegreeKey(circuitPackName)).build();
-        LOG.debug("Input parameters are {},{}", nodeId.getValue(), circuitPackName);
+    private Integer getDegFromInterface(NodeId nodeId, String interfaceName) {
+        InstanceIdentifier<Nodes> nodesIID = InstanceIdentifier.builder(Network.class)
+                .child(Nodes.class, new NodesKey(nodeId.getValue())).build();
         try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
-            Optional<CpToDegree> cptpDegObject = readTx.read(LogicalDatastoreType.CONFIGURATION, cptoDegMappingIID)
+            Optional<Nodes> nodesObject = readTx.read(LogicalDatastoreType.CONFIGURATION, nodesIID)
                     .get().toJavaUtil();
-            if (cptpDegObject.isPresent()) {
-                CpToDegree cpToDeg = cptpDegObject.get();
-                LOG.debug("Found mapping for the Circuit Pack {}. Degree: {}", circuitPackName, cpToDeg);
-                return cpToDeg;
+            if (nodesObject.isPresent() && nodesObject.get().getCpToDegree() != null) {
+                List<CpToDegree> cpToDeg = nodesObject.get().getCpToDegree();
+                Stream cpToDegStream = cpToDeg.stream().filter(cp -> cp.getInterfaceName() != null)
+                        .filter(cp -> cp.getInterfaceName().equals(interfaceName));
+                if (cpToDegStream != null) {
+                    Optional<CpToDegree> firstCpToDegree = cpToDegStream.findFirst();
+                    if (firstCpToDegree.isPresent() && firstCpToDegree != null) {
+                        LOG.debug("Found and returning {}",firstCpToDegree.get().getDegreeNumber().intValue());
+                        return firstCpToDegree.get().getDegreeNumber().intValue();
+                    } else {
+                        LOG.debug("Not found so returning nothing");
+                        return null;
+                    }
+                } else {
+                    LOG.warn("CircuitPack stream couldnt find anything for nodeId: {} and interfaceName: {}",
+                            nodeId.getValue(),interfaceName);
+                }
             } else {
-                LOG.warn("Could not find mapping for Circuit Pack {} for nodeId {}", circuitPackName,
-                        nodeId.getValue());
+                LOG.warn("Could not find mapping for Interface {} for nodeId {}", interfaceName,
+                            nodeId.getValue());
             }
         } catch (InterruptedException | ExecutionException ex) {
-            LOG.error("Unable to read mapping for circuit pack : {} for nodeId {}", circuitPackName, nodeId, ex);
+            LOG.error("Unable to read mapping for Interface : {} for nodeId {}", interfaceName, nodeId, ex);
         }
         return null;
     }
-
-    private Integer getDegFromParentCP(NodeId nodeId, String interfaceName, String supportingCircuitPack) {
-        InstanceIdentifier<CircuitPacks> circuitPackIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
-                .child(CircuitPacks.class, new CircuitPacksKey(supportingCircuitPack));
-        Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(nodeId.getValue(),
-                LogicalDatastoreType.OPERATIONAL, circuitPackIID, Timeouts.DEVICE_READ_TIMEOUT,
-                Timeouts.DEVICE_READ_TIMEOUT_UNIT);
-        if (!circuitPackObject.isPresent()
-                || (circuitPackObject.get().getParentCircuitPack().getCircuitPackName() == null)) {
-            LOG.warn("Parent circuitpack not found for NodeId: {} and Interface: {}", nodeId, interfaceName);
-            return null;
-        }
-        String parentCP = circuitPackObject.get().getParentCircuitPack().getCircuitPackName();
-        CpToDegree cpToDegree = getCPtoDegreeMapping(nodeId, parentCP);
-        if (cpToDegree == null) {
-            LOG.error("CP to Degree mapping not found even with parent circuitpack for NodeID: {}" + "and Interface {}",
-                    nodeId, interfaceName);
-            return null;
-        } else {
-            LOG.debug("CP to degree is {}", cpToDegree.getDegreeNumber());
-            return cpToDegree.getDegreeNumber().intValue();
-        }
-    }
-
-    private Integer getDegFromCP(NodeId nodeId, String interfaceName) {
-        try {
-            java.util.Optional<Interface> interfaceOpt = this.openRoadmInterfaces.getInterface(nodeId.getValue(),
-                    interfaceName);
-            if (!interfaceOpt.isPresent()) {
-                LOG.warn("Interface with {} on node {} was not found!", interfaceName, nodeId.getValue());
-                return null;
-            }
-            String supportingCircuitPack = interfaceOpt.get().getSupportingCircuitPackName();
-            LOG.debug("Supporting circuitpack name is :{}", interfaceOpt.get().getSupportingCircuitPackName());
-            CpToDegree cpToDegree = getCPtoDegreeMapping(nodeId, supportingCircuitPack);
-            // Currently devices have different ways to represent connection to Ethernet port
-            // and degree port.
-            // If Circuit pack is not present under degree tree then read parent CP of given
-            // CP (Circuit pack).
-            if (cpToDegree != null) {
-                return cpToDegree.getDegreeNumber().intValue();
-            } else {
-                return getDegFromParentCP(nodeId, interfaceName, supportingCircuitPack);
-            }
-        } catch (OpenRoadmInterfaceException ex) {
-            LOG.error("Failed to get source interface {} from node {}!", interfaceName, nodeId, ex);
-            return null;
-        }
-    }
 }

diff --git a/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmTopology.java b/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmTopology.java
index 950e821aed8f149e2a87f3145ec5477a9f2464a5..a447f5fd4c4ea027eb50aeec1cfc4cceeee30a72 100644 (file)
--- a/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmTopology.java
+++ b/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmTopology.java
@@ -804,16 +804,21 @@ public class OpenRoadmTopology {
     }
 
     // This method returns the linkBuilder object for given source and destination.
-    public boolean deleteLink(String srcNode, String dstNode, String srcTp, String destTp) {
+    public boolean deleteLink(String srcNode, String dstNode, Integer srcDegId,
+            Integer destDegId ,String srcTp, String destTp) {
         LOG.info("deleting link for {}-{}", srcNode, dstNode);
         try {
+            LinkId linkId = LinkIdUtil.buildLinkId(srcNode + "-DEG" + srcDegId,
+                    srcTp, dstNode + "-DEG" + destDegId, destTp);
+            LOG.info("Link is for the link is {}", linkId.getValue());
             InstanceIdentifierBuilder<Link> linkIID = InstanceIdentifier
                     .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
-                    .augmentation(Network1.class)
-                    .child(Link.class, new LinkKey(LinkIdUtil.buildLinkId(srcNode, srcTp, dstNode, destTp)));
+                    .augmentation(Network1.class).child(Link.class, new LinkKey(linkId));
             WriteTransaction wrtx = this.dataBroker.newWriteOnlyTransaction();
             wrtx.delete(LogicalDatastoreType.CONFIGURATION, linkIID.build());
+            LOG.info("Deleted");
             wrtx.submit().get(1, TimeUnit.SECONDS);
+            LOG.info("Submitted");
         } catch (InterruptedException | ExecutionException | TimeoutException e) {
             LOG.error(e.getMessage(), e);
             return false;