Code Review / transportpce.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Update portmapping YANG model
[transportpce.git] / common / src / main / java / org / opendaylight / transportpce / common / mapping / PortMappingVersion710.java
diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java
index d3e75ae2f6ab209baef567f6723ace0cc5396f4b..e316532ad83187578c10d92d8f9d4e8c3e64ac29 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion710.java
@@ -31,29 +31,29 @@ 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.common.device.DeviceTransactionManager;
 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.Network;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.NetworkBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.Nodes;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.NodesBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.NodesKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.CpToDegree;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.CpToDegreeBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.CpToDegreeKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.Mapping;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.MappingBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.MappingKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.McCapabilities;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.McCapabilitiesBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.McCapabilitiesKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.NodeInfo;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.NodeInfo.OpenroadmVersion;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.NodeInfoBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.SwitchingPoolLcp;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.SwitchingPoolLcpBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.SwitchingPoolLcpKey;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.switching.pool.lcp.NonBlockingList;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.switching.pool.lcp.NonBlockingListBuilder;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.switching.pool.lcp.NonBlockingListKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.Network;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.NetworkBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.OpenroadmNodeVersion;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.cp.to.degree.CpToDegree;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.cp.to.degree.CpToDegreeBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.cp.to.degree.CpToDegreeKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.mapping.Mapping;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.mapping.MappingBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.mapping.MappingKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.mc.capabilities.McCapabilities;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.mc.capabilities.McCapabilitiesBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.mc.capabilities.McCapabilitiesKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.network.Nodes;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.network.NodesBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.network.NodesKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.network.nodes.NodeInfo;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.network.nodes.NodeInfoBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.switching.pool.lcp.SwitchingPoolLcp;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.switching.pool.lcp.SwitchingPoolLcpBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.switching.pool.lcp.SwitchingPoolLcpKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.switching.pool.lcp.switching.pool.lcp.NonBlockingList;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.switching.pool.lcp.switching.pool.lcp.NonBlockingListBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210315.switching.pool.lcp.switching.pool.lcp.NonBlockingListKey;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.alarm.pm.types.rev191129.Direction;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyGHz;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.CircuitPack;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.alarm.pm.types.rev191129.Direction;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyGHz;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.CircuitPack;
@@ -89,6 +89,9 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtnO
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.Protocols1;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.lldp.container.Lldp;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.lldp.container.lldp.PortConfig;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.Protocols1;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.lldp.container.Lldp;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.lldp.container.lldp.PortConfig;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.Ports1;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.port.capability.grp.port.capabilities.SupportedInterfaceCapability;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.port.capability.grp.port.capabilities.SupportedInterfaceCapabilityKey;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.Uint16;
 import org.opendaylight.yangtools.yang.common.Uint32;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.common.Uint16;
 import org.opendaylight.yangtools.yang.common.Uint32;
@@ -97,6 +100,7 @@ import org.slf4j.LoggerFactory;
 
 // FIXME: many common pieces of code between PortMapping Versions 121 and 221 and 710
 // some mutualization would be helpful
 
 // FIXME: many common pieces of code between PortMapping Versions 121 and 221 and 710
 // some mutualization would be helpful
+@SuppressWarnings("CPD-START")
 public class PortMappingVersion710 {
     private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion710.class);
     private static final Map<Direction, String> SUFFIX;
 public class PortMappingVersion710 {
     private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion710.class);
     private static final Map<Direction, String> SUFFIX;
@@ -120,15 +124,15 @@ public class PortMappingVersion710 {
     }
 
     public boolean createMappingData(String nodeId) {
     }
 
     public boolean createMappingData(String nodeId) {
-        LOG.info("Create Mapping Data for node 7.1.0 {}", nodeId);
+        LOG.info("{} : OpenROADM version 7.1.0 node - Creating Mapping Data", nodeId);
         List<Mapping> portMapList = new ArrayList<>();
         List<Mapping> portMapList = new ArrayList<>();
-        List<McCapabilities> mcCapabilitiesList = new ArrayList<>();
+        Map<McCapabilitiesKey, McCapabilities> mcCapabilities = new HashMap<>();
         InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
         Optional<Info> deviceInfoOptional = this.deviceTransactionManager.getDataFromDevice(
                 nodeId, LogicalDatastoreType.OPERATIONAL, infoIID,
                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
         if (!deviceInfoOptional.isPresent()) {
         InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
         Optional<Info> deviceInfoOptional = this.deviceTransactionManager.getDataFromDevice(
                 nodeId, LogicalDatastoreType.OPERATIONAL, infoIID,
                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
         if (!deviceInfoOptional.isPresent()) {
-            LOG.warn("Device info subtree is absent for {}", nodeId);
+            LOG.warn("{} : Device info subtree is absent", nodeId);
             return false;
         }
         Info deviceInfo = deviceInfoOptional.get();
             return false;
         }
         Info deviceInfo = deviceInfoOptional.get();
@@ -144,39 +148,39 @@ public class PortMappingVersion710 {
                 // Get TTP port mapping
                 if (!createTtpPortMapping(nodeId, deviceInfo, portMapList)) {
                     // return false if mapping creation for TTP's failed
                 // Get TTP port mapping
                 if (!createTtpPortMapping(nodeId, deviceInfo, portMapList)) {
                     // return false if mapping creation for TTP's failed
-                    LOG.warn("Unable to create mapping for TTP's on node {}", nodeId);
+                    LOG.warn("{} : Unable to create mapping for TTP's", nodeId);
                     return false;
                 }
 
                 // Get PP port mapping
                 if (!createPpPortMapping(nodeId, deviceInfo, portMapList)) {
                     // return false if mapping creation for PP's failed
                     return false;
                 }
 
                 // Get PP port mapping
                 if (!createPpPortMapping(nodeId, deviceInfo, portMapList)) {
                     // return false if mapping creation for PP's failed
-                    LOG.warn("Unable to create mapping for PP's on node {}", nodeId);
+                    LOG.warn("{} : Unable to create mapping for PP's", nodeId);
                     return false;
                 }
                 // Get MC capabilities
                     return false;
                 }
                 // Get MC capabilities
-                if (!createMcCapabilitiesList(nodeId, deviceInfo, mcCapabilitiesList)) {
+                if (!createMcCapabilitiesList(nodeId, deviceInfo, mcCapabilities)) {
                     // return false if MC capabilites failed
                     // return false if MC capabilites failed
-                    LOG.warn("Unable to create MC capabilities on node {}", nodeId);
+                    LOG.warn("{} : Unable to create MC capabilities", nodeId);
                     return false;
                 }
                 break;
             case Xpdr:
                 if (!createXpdrPortMapping(nodeId, portMapList)) {
                     return false;
                 }
                 break;
             case Xpdr:
                 if (!createXpdrPortMapping(nodeId, portMapList)) {
-                    LOG.warn("Unable to create mapping for Xponder on node {}", nodeId);
+                    LOG.warn("{} : Unable to create mapping for the Xponder", nodeId);
                     return false;
                 }
                 break;
             default:
                     return false;
                 }
                 break;
             default:
-                LOG.error("Unable to create mapping for node {} : unknown nodetype ", nodeId);
+                LOG.error("{} : unknown nodetype - Unable to create mapping", nodeId);
                 break;
 
         }
                 break;
 
         }
-        return postPortMapping(nodeId, nodeInfo, portMapList, null, null, mcCapabilitiesList);
+        return postPortMapping(nodeId, nodeInfo, portMapList, null, null, mcCapabilities);
     }
 
     public boolean updateMapping(String nodeId, Mapping oldMapping) {
     }
 
     public boolean updateMapping(String nodeId, Mapping oldMapping) {
-        InstanceIdentifier<Ports> portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+        InstanceIdentifier<Ports> portId = InstanceIdentifier.create(OrgOpenroadmDevice.class)
             .child(CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName()))
             .child(Ports.class, new PortsKey(oldMapping.getSupportingPort()));
         if ((oldMapping == null) || (nodeId == null)) {
             .child(CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName()))
             .child(Ports.class, new PortsKey(oldMapping.getSupportingPort()));
         if ((oldMapping == null) || (nodeId == null)) {
@@ -184,17 +188,11 @@ public class PortMappingVersion710 {
             return false;
         }
         try {
             return false;
         }
         try {
-            Optional<Ports> portObject = deviceTransactionManager.getDataFromDevice(nodeId,
-                LogicalDatastoreType.OPERATIONAL, portIId, Timeouts.DEVICE_READ_TIMEOUT,
-                Timeouts.DEVICE_READ_TIMEOUT_UNIT);
-            if (!portObject.isPresent()) {
-                return false;
-            }
-            Ports port = portObject.get();
-            Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(),
-                oldMapping.getLogicalConnectionPoint());
-            LOG.info("Updating old mapping Data {} for {} of {} by new mapping data {}",
-                    oldMapping, oldMapping.getLogicalConnectionPoint(), nodeId, newMapping);
+            Ports port = deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL,
+                portId, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT).get();
+            Mapping newMapping = updateMappingObject(nodeId, port, oldMapping);
+            LOG.debug("{} : Updating old mapping Data {} for {} by new mapping data {}",
+                    nodeId, oldMapping, oldMapping.getLogicalConnectionPoint(), newMapping);
             final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
             InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.create(Network.class)
                 .child(Nodes.class, new NodesKey(nodeId))
             final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
             InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.create(Network.class)
                 .child(Nodes.class, new NodesKey(nodeId))
@@ -204,7 +202,8 @@ public class PortMappingVersion710 {
             commit.get();
             return true;
         } catch (InterruptedException | ExecutionException e) {
             commit.get();
             return true;
         } catch (InterruptedException | ExecutionException e) {
-            LOG.error("Error updating Mapping {} for node {}", oldMapping.getLogicalConnectionPoint(), nodeId, e);
+            LOG.error("{} : exception when updating Mapping {} - ",
+                    nodeId, oldMapping.getLogicalConnectionPoint(), e);
             return false;
         }
     }
             return false;
         }
     }
@@ -216,12 +215,12 @@ public class PortMappingVersion710 {
             LogicalDatastoreType.OPERATIONAL, deviceIID,
             Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
         if (!deviceObject.isPresent()) {
             LogicalDatastoreType.OPERATIONAL, deviceIID,
             Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
         if (!deviceObject.isPresent()) {
-            LOG.error("Impossible to get device configuration for node {}", nodeId);
+            LOG.error("{} : Impossible to get device configuration", nodeId);
             return false;
         }
         OrgOpenroadmDevice device = deviceObject.get();
         if (device.getCircuitPacks() == null) {
             return false;
         }
         OrgOpenroadmDevice device = deviceObject.get();
         if (device.getCircuitPacks() == null) {
-            LOG.warn("Circuit Packs are not present for {}", nodeId);
+            LOG.warn("{} : Circuit Packs not present", nodeId);
             return false;
         }
 
             return false;
         }
 
@@ -230,7 +229,7 @@ public class PortMappingVersion710 {
         List<CircuitPacks> circuitPackList = new ArrayList<>(device.nonnullCircuitPacks().values());
         circuitPackList.sort(Comparator.comparing(CircuitPack::getCircuitPackName));
         if (device.getXponder() == null) {
         List<CircuitPacks> circuitPackList = new ArrayList<>(device.nonnullCircuitPacks().values());
         circuitPackList.sort(Comparator.comparing(CircuitPack::getCircuitPackName));
         if (device.getXponder() == null) {
-            LOG.warn("{} configuration does not contain a list of xponders", nodeId);
+            LOG.warn("{} : configuration does not contain a list of Xponders", nodeId);
             // Variables to keep track of number of line ports and client ports
             int line = 1;
             int client = 1;
             // Variables to keep track of number of line ports and client ports
             int line = 1;
             int client = 1;
@@ -239,95 +238,29 @@ public class PortMappingVersion710 {
             for (CircuitPacks cp : circuitPackList) {
                 String circuitPackName = cp.getCircuitPackName();
                 if (cp.getPorts() == null) {
             for (CircuitPacks cp : circuitPackList) {
                 String circuitPackName = cp.getCircuitPackName();
                 if (cp.getPorts() == null) {
-                    LOG.warn("Ports were not found for circuit pack: {}", circuitPackName);
+                    LOG.warn("{} : Ports were not found for circuit pack {}", nodeId, circuitPackName);
                     continue;
                 }
                 List<Ports> portList = new ArrayList<>(cp.nonnullPorts().values());
                 portList.sort(Comparator.comparing(Ports::getPortName));
                 for (Ports port : portList) {
                     continue;
                 }
                 List<Ports> portList = new ArrayList<>(cp.nonnullPorts().values());
                 portList.sort(Comparator.comparing(Ports::getPortName));
                 for (Ports port : portList) {
-                    if (port.getPortQual() == null) {
-                        LOG.warn("PortQual was not found for port {} on circuit pack: {}", port.getPortName(),
-                            circuitPackName);
-                        continue;
-                    }
-
-                    switch (port.getPortQual()) {
-
-                        case XpdrClient:
-                            String lcp0 = createXpdrLogicalConnectionPort(1, client, StringConstants.CLIENT_TOKEN);
-                            lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp0);
-                            mappingMap.put(lcp0,
-                                createXpdrMappingObject(nodeId, port, circuitPackName, lcp0, null, null, null, null));
-                            client++;
-                            //continue;
-                            break;
-
-                        case XpdrNetwork:
-                            if (port.getPortDirection().getIntValue() == Direction.Bidirectional.getIntValue()) {
-                                String lcp = createXpdrLogicalConnectionPort(1, line, StringConstants.NETWORK_TOKEN);
-                                lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
-                                mappingMap.put(lcp,
-                                    createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null, null, null)
-                                );
-                                line++;
-                                continue;
-                            }
-
-                            if (!checkPartnerPortNotNull(port)) {
-                                LOG.warn("Error in the configuration of port {} of {} for {}",
-                                    port.getPortName(), circuitPackName, nodeId);
-                                continue;
-                            }
-
-                            if (lcpMap.containsKey(circuitPackName + '+' + port.getPortName())) {
-                                continue;
-                            }
-                            Optional<CircuitPacks> cpOpt = circuitPackList.stream()
-                                .filter(
-                                    cP -> cP.getCircuitPackName().equals(port.getPartnerPort().getCircuitPackName()))
-                                .findFirst();
-                            if (!cpOpt.isPresent()) {
-                                LOG.error("Error fetching circuit-pack {} for {}",
-                                    port.getPartnerPort().getCircuitPackName(), nodeId);
-                                continue;
-                            }
-                            Optional<Ports> poOpt = cpOpt.get().nonnullPorts().values().stream()
-                                .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString()))
-                                .findFirst();
-                            if (!poOpt.isPresent()) {
-                                LOG.error("Error fetching port {} on {} for {}", port.getPartnerPort().getPortName(),
-                                    port.getPartnerPort().getCircuitPackName(), nodeId);
-                                continue;
-                            }
-                            Ports port2 = poOpt.get();
-                            if (!checkPartnerPort(circuitPackName, port, port2)) {
-                                LOG.error("port {} on {} is not a correct partner port of {} on  {}",
-                                    port2.getPortName(), cpOpt.get().getCircuitPackName(), port.getPortName(),
-                                    circuitPackName);
-                                continue;
-                            }
-                            putXpdrLcpsInMaps(line, nodeId, 1, null,
-                                    circuitPackName, cpOpt.get().getCircuitPackName(), port, port2,
-                                    lcpMap, mappingMap);
-                            line += 2;
-                            break;
-
-                        default:
-                            LOG.warn(
-                                "Error in the configuration of port {} of {} for {} - unsupported PortQual {}",
-                                port.getPortName(), circuitPackName, nodeId, port.getPortQual().getIntValue());
-                    }
+                    int[] counters = fillXpdrLcpsMaps(line, client, nodeId,
+                        1, null, circuitPackName, port,
+                        circuitPackList, lcpMap, mappingMap);
+                    line = counters[0];
+                    client = counters[1];
                 }
             }
         } else {
                 }
             }
         } else {
-            LOG.info("{} configuration contains a list of xponders", nodeId);
+            LOG.info("{} : configuration contains a list of xponders", nodeId);
             for (Xponder xponder : deviceObject.get().nonnullXponder().values()) {
                 // Variables to keep track of number of line ports and client ports
                 int line = 1;
                 int client = 1;
                 Integer xponderNb = xponder.getXpdrNumber().toJava();
                 XpdrNodeTypes xponderType = xponder.getXpdrType();
             for (Xponder xponder : deviceObject.get().nonnullXponder().values()) {
                 // Variables to keep track of number of line ports and client ports
                 int line = 1;
                 int client = 1;
                 Integer xponderNb = xponder.getXpdrNumber().toJava();
                 XpdrNodeTypes xponderType = xponder.getXpdrType();
-                for (XpdrPort xpdrPort : xponder.nonnullXpdrPort().values()) {
+                for (XpdrPort xpdrPort : xponder.nonnullXpdrPort().values().stream()
+                        .sorted((xp1, xp2) -> xp1.getIndex().compareTo(xp2.getIndex())).collect(Collectors.toList())) {
                     String circuitPackName = xpdrPort.getCircuitPackName();
                     String portName = xpdrPort.getPortName().toString();
                     // If there xponder-subtree has missing circuit-packs or ports,
                     String circuitPackName = xpdrPort.getCircuitPackName();
                     String portName = xpdrPort.getPortName().toString();
                     // If there xponder-subtree has missing circuit-packs or ports,
@@ -335,8 +268,8 @@ public class PortMappingVersion710 {
                     if (device.nonnullCircuitPacks().values().stream()
                             .filter(cp -> cp.getCircuitPackName().equals(circuitPackName))
                             .findFirst().isEmpty()) {
                     if (device.nonnullCircuitPacks().values().stream()
                             .filter(cp -> cp.getCircuitPackName().equals(circuitPackName))
                             .findFirst().isEmpty()) {
-                        LOG.warn("Circuit-pack {} is missing in the device - ignoring it in port-mapping",
-                            circuitPackName);
+                        LOG.warn("{} : Circuit-pack {} is missing in the device - ignoring it in port-mapping",
+                                nodeId, circuitPackName);
                         continue;
                     }
                     if (device.nonnullCircuitPacks().values().stream()
                         continue;
                     }
                     if (device.nonnullCircuitPacks().values().stream()
@@ -344,8 +277,8 @@ public class PortMappingVersion710 {
                             .findFirst().get().nonnullPorts().values().stream()
                             .filter(p -> p.getPortName().equals(portName))
                             .findFirst().isEmpty()) {
                             .findFirst().get().nonnullPorts().values().stream()
                             .filter(p -> p.getPortName().equals(portName))
                             .findFirst().isEmpty()) {
-                        LOG.warn("Port {} associated with CP {} is missing in the device - ignoring it in port-mapping",
-                            portName, circuitPackName);
+                        LOG.warn("{} : port {} on {} - association missing in the device - ignoring it in port-mapping",
+                                nodeId, portName, circuitPackName);
                         continue;
                     }
                     Ports port = device.nonnullCircuitPacks().values().stream()
                         continue;
                     }
                     Ports port = device.nonnullCircuitPacks().values().stream()
@@ -353,90 +286,17 @@ public class PortMappingVersion710 {
                             .findFirst().get().nonnullPorts().values().stream()
                             .filter(p -> p.getPortName().equals(portName))
                             .findFirst().get();
                             .findFirst().get().nonnullPorts().values().stream()
                             .filter(p -> p.getPortName().equals(portName))
                             .findFirst().get();
-                    if (port.getPortQual() == null) {
-                        LOG.warn("PortQual was not found for port {} on circuit pack: {}",
-                            port.getPortName(), circuitPackName);
-                        continue;
-                    }
-
-                    switch (port.getPortQual()) {
-
-                        case XpdrClient:
-                        case SwitchClient:
-                            String lcp0 =
-                                createXpdrLogicalConnectionPort(xponderNb , client, StringConstants.CLIENT_TOKEN);
-                            lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp0);
-                            mappingMap.put(lcp0,
-                                createXpdrMappingObject(nodeId, port, circuitPackName, lcp0, null, null, null, null));
-                            client++;
-                            //continue;
-                            break;
-
-                        case XpdrNetwork:
-                        case SwitchNetwork:
-                            if (port.getPortDirection().getIntValue() == Direction.Bidirectional.getIntValue()) {
-                                String lcp =
-                                    createXpdrLogicalConnectionPort(xponderNb , line, StringConstants.NETWORK_TOKEN);
-                                lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
-                                mappingMap.put(lcp,
-                                    createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null, null,
-                                        xponderType));
-                                line++;
-                                continue;
-                            }
-
-                            if (!checkPartnerPortNotNull(port)) {
-                                LOG.warn("Error in the configuration of port {} of {} for {}",
-                                    port.getPortName(), circuitPackName, nodeId);
-                                continue;
-                            }
-
-                            if (lcpMap.containsKey(circuitPackName + '+' + port.getPortName())) {
-                                continue;
-                            }
-
-                            Optional<CircuitPacks> cpOpt = circuitPackList.stream()
-                                .filter(
-                                    cP -> cP.getCircuitPackName().equals(port.getPartnerPort().getCircuitPackName()))
-                                .findFirst();
-                            if (!cpOpt.isPresent()) {
-                                LOG.error("Error fetching circuit-pack {} for {}",
-                                    port.getPartnerPort().getCircuitPackName(), nodeId);
-                                continue;
-                            }
-
-                            Optional<Ports> poOpt = cpOpt.get().nonnullPorts().values().stream()
-                                .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString()))
-                                .findFirst();
-                            if (!poOpt.isPresent()) {
-                                LOG.error("Error fetching port {} on {} for {}", port.getPartnerPort().getPortName(),
-                                    port.getPartnerPort().getCircuitPackName(), nodeId);
-                                continue;
-                            }
-                            Ports port2 = poOpt.get();
-                            if (!checkPartnerPort(circuitPackName, port, port2)) {
-                                LOG.error("port {} on {} is not a correct partner port of {} on  {}",
-                                    port2.getPortName(), cpOpt.get().getCircuitPackName(), port.getPortName(),
-                                    circuitPackName);
-                                continue;
-                            }
-                            putXpdrLcpsInMaps(line, nodeId, xponderNb, xponderType,
-                                    circuitPackName, cpOpt.get().getCircuitPackName(), port, port2,
-                                    lcpMap, mappingMap);
-                            line += 2;
-                            break;
-
-                        default:
-                            LOG.warn(
-                                "Error in the configuration of port {} of {} for {} - unsupported PortQual {}",
-                                port.getPortName(), circuitPackName, nodeId, port.getPortQual().getIntValue());
-                    }
+                    int[] counters = fillXpdrLcpsMaps(line, client, nodeId,
+                        xponderNb, xponderType, circuitPackName, port,
+                        circuitPackList, lcpMap, mappingMap);
+                    line = counters[0];
+                    client = counters[1];
                 }
             }
         }
 
         if (device.getConnectionMap() == null) {
                 }
             }
         }
 
         if (device.getConnectionMap() == null) {
-            LOG.warn("No connection-map inside device configuration");
+            LOG.warn("{} : No connection-map inside device configuration", nodeId);
         } else {
             Collection<ConnectionMap> connectionMap = deviceObject.get().nonnullConnectionMap().values();
             for (ConnectionMap cm : connectionMap) {
         } else {
             Collection<ConnectionMap> connectionMap = deviceObject.get().nonnullConnectionMap().values();
             for (ConnectionMap cm : connectionMap) {
@@ -445,8 +305,8 @@ public class PortMappingVersion710 {
                 Destination destination0 = cm.nonnullDestination().values().iterator().next();
                 String dkey = destination0.getCircuitPackName() + "+" + destination0.getPortName();
                 if (slcp == null) {
                 Destination destination0 = cm.nonnullDestination().values().iterator().next();
                 String dkey = destination0.getCircuitPackName() + "+" + destination0.getPortName();
                 if (slcp == null) {
-                    LOG.error("Error in connection-map analysis for source {} and destination (circuitpack+port) {}",
-                        skey, dkey);
+                    LOG.error("{} : Error in connection-map analysis for source {} and destination (CP+port) {}",
+                        nodeId, skey, dkey);
                     continue;
                 }
                 String dlcp = lcpMap.containsKey(dkey) ? lcpMap.get(dkey) : null;
                     continue;
                 }
                 String dlcp = lcpMap.containsKey(dkey) ? lcpMap.get(dkey) : null;
@@ -470,8 +330,8 @@ public class PortMappingVersion710 {
                     for (PortList item : nbl.nonnullPortList().values()) {
                         String key = item.getCircuitPackName() + "+" + item.getPortName();
                         if (!lcpMap.containsKey(key)) {
                     for (PortList item : nbl.nonnullPortList().values()) {
                         String key = item.getCircuitPackName() + "+" + item.getPortName();
                         if (!lcpMap.containsKey(key)) {
-                            LOG.error("error : port {} of {} is not associated to a logical connection point",
-                                item.getPortName(), item.getCircuitPackName());
+                            LOG.error("{} : port {} on {} is not associated to a logical connection point",
+                                nodeId, item.getPortName(), item.getCircuitPackName());
                             continue;
                         }
                         lcpList.add(lcpMap.get(key));
                             continue;
                         }
                         lcpList.add(lcpMap.get(key));
@@ -542,7 +402,7 @@ public class PortMappingVersion710 {
         for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
             List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks> srgCps
                 = new ArrayList<>();
         for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
             List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.srg.CircuitPacks> srgCps
                 = new ArrayList<>();
-            LOG.info("Getting Circuitpacks for Srg Number {}", srgCounter);
+            LOG.debug("{} : Getting Circuitpacks for Srg Number {}", deviceId, srgCounter);
             InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(srgCounter)));
             Optional<SharedRiskGroup> ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
             InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(srgCounter)));
             Optional<SharedRiskGroup> ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
@@ -553,7 +413,7 @@ public class PortMappingVersion710 {
                 cpPerSrg.put(ordmSrgObject.get().getSrgNumber().toJava(), srgCps);
             }
         }
                 cpPerSrg.put(ordmSrgObject.get().getSrgNumber().toJava(), srgCps);
             }
         }
-        LOG.info("Device {} has {} Srg", deviceId, cpPerSrg.size());
+        LOG.info("{} : Device has {} Srg", deviceId, cpPerSrg.size());
         return cpPerSrg;
     }
 
         return cpPerSrg;
     }
 
@@ -588,14 +448,14 @@ public class PortMappingVersion710 {
                     }
 
                     if (PortQual.RoadmExternal.getIntValue() != port.getPortQual().getIntValue()) {
                     }
 
                     if (PortQual.RoadmExternal.getIntValue() != port.getPortQual().getIntValue()) {
-                        LOG.info("{} : port {} on {} is not roadm-external - cannot assign logicalConnectionPoint.",
-                            nodeId, port.getPortName(), circuitPackName);
+                        LOG.debug("{} : port {} on {} is not roadm-external - cannot assign logicalConnectionPoint.",
+                                nodeId, port.getPortName(), circuitPackName);
                         continue;
                     }
 
                     if (keys.contains(currentKey)) {
                         continue;
                     }
 
                     if (keys.contains(currentKey)) {
-                        LOG.info("{} : port {} on {} has already been handled - cannot assign logicalConnectionPoint.",
-                            nodeId, port.getPortName(), circuitPackName);
+                        LOG.debug("{} : port {} on {} has already been handled - cannot assign logicalConnectionPoint.",
+                                nodeId, port.getPortName(), circuitPackName);
                         continue;
                     }
 
                         continue;
                     }
 
@@ -603,8 +463,8 @@ public class PortMappingVersion710 {
 
                         case Bidirectional:
                             String lcp = createLogicalConnectionPort(port, srgCpEntry.getKey(), portIndex);
 
                         case Bidirectional:
                             String lcp = createLogicalConnectionPort(port, srgCpEntry.getKey(), portIndex);
-                            LOG.info("{} : Logical Connection Point for {} {} is {}",
-                                nodeId, circuitPackName, port.getPortName(), lcp);
+                            LOG.info("{} : port {} on {} - associated Logical Connection Point is {}",
+                                    nodeId, port.getPortName(), circuitPackName, lcp);
                             portMapList.add(createMappingObject(nodeId, port, circuitPackName, lcp));
                             portIndex++;
                             keys.add(currentKey);
                             portMapList.add(createMappingObject(nodeId, port, circuitPackName, lcp));
                             portIndex++;
                             keys.add(currentKey);
@@ -614,14 +474,14 @@ public class PortMappingVersion710 {
                         case Tx:
                             if (!checkPartnerPortNotNull(port)) {
                                 LOG.info("{} : port {} on {} is unidirectional but has no valid partnerPort"
                         case Tx:
                             if (!checkPartnerPortNotNull(port)) {
                                 LOG.info("{} : port {} on {} is unidirectional but has no valid partnerPort"
-                                    + " - cannot assign  logicalConnectionPoint.",
-                                    nodeId, port.getPortName(), circuitPackName);
+                                        + " - cannot assign  logicalConnectionPoint.",
+                                        nodeId, port.getPortName(), circuitPackName);
                                 continue;
                             }
 
                             String lcp1 = createLogicalConnectionPort(port, srgCpEntry.getKey(), portIndex);
                                 continue;
                             }
 
                             String lcp1 = createLogicalConnectionPort(port, srgCpEntry.getKey(), portIndex);
-                            LOG.info("{} : Logical Connection Point for {} {} is {}",
-                                nodeId, circuitPackName, port.getPortName(), lcp1);
+                            LOG.info("{} :  port {} on {} - associated Logical Connection Point is {}",
+                                    nodeId, port.getPortName(), circuitPackName, lcp1);
                             InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                                 .child(CircuitPacks.class,
                                     new CircuitPacksKey(port.getPartnerPort().getCircuitPackName()))
                             InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                                 .child(CircuitPacks.class,
                                     new CircuitPacksKey(port.getPartnerPort().getCircuitPackName()))
@@ -632,22 +492,22 @@ public class PortMappingVersion710 {
                             if (!port2Object.isPresent()
                                 || port2Object.get().getPortQual().getIntValue()
                                     != PortQual.RoadmExternal.getIntValue()) {
                             if (!port2Object.isPresent()
                                 || port2Object.get().getPortQual().getIntValue()
                                     != PortQual.RoadmExternal.getIntValue()) {
-                                LOG.error("error getting partner port {} of  {} - {}",
-                                    port.getPartnerPort().getPortName().toString(),
-                                    port.getPartnerPort().getCircuitPackName(), nodeId);
+                                LOG.error("{} : port {} on {} - error getting partner",
+                                        nodeId, port.getPartnerPort().getPortName().toString(),
+                                        port.getPartnerPort().getCircuitPackName());
                                 continue;
                             }
 
                             Ports port2 = port2Object.get();
                             if (!checkPartnerPort(circuitPackName, port, port2)) {
                                 continue;
                             }
 
                             Ports port2 = port2Object.get();
                             if (!checkPartnerPort(circuitPackName, port, port2)) {
-                                LOG.error("Error with partner port configuration for port {} of  {} - {}",
-                                    port.getPortName(), circuitPackName, nodeId);
+                                LOG.error("{} : port {} on {} - Error with partner port configuration",
+                                        nodeId, port.getPortName(), circuitPackName);
                                 portIndex++;
                                 continue;
                             }
                             String lcp2 = createLogicalConnectionPort(port2, srgCpEntry.getKey(),portIndex);
                                 portIndex++;
                                 continue;
                             }
                             String lcp2 = createLogicalConnectionPort(port2, srgCpEntry.getKey(),portIndex);
-                            LOG.info("{} : Logical Connection Point for {} {} is {}",
-                                nodeId, circuitPackName, port2.getPortName(), lcp2);
+                            LOG.info("{} : port {} on {} - associated Logical Connection Point is {}",
+                                    nodeId, port2.getPortName(), circuitPackName, lcp2);
                             portMapList.add(createMappingObject(nodeId, port, circuitPackName, lcp1));
                             portMapList.add(
                                 createMappingObject(nodeId ,port2, port.getPartnerPort().getCircuitPackName(), lcp2));
                             portMapList.add(createMappingObject(nodeId, port, circuitPackName, lcp1));
                             portMapList.add(
                                 createMappingObject(nodeId ,port2, port.getPartnerPort().getCircuitPackName(), lcp2));
@@ -657,9 +517,9 @@ public class PortMappingVersion710 {
                             break;
 
                         default:
                             break;
 
                         default:
-                            LOG.info("{} : port {} on {} - unsupported Direction"
+                            LOG.error("{} : port {} on {} - unsupported Direction {}"
                                     + " - cannot assign  logicalConnectionPoint.",
                                     + " - cannot assign  logicalConnectionPoint.",
-                                nodeId, port.getPortName(), circuitPackName);
+                                    nodeId, port.getPortName(), circuitPackName, port.getPortDirection());
 
                     }
                 }
 
                     }
                 }
@@ -708,7 +568,7 @@ public class PortMappingVersion710 {
         Integer maxDegree = ordmInfo.getMaxDegrees() == null ? 20 : ordmInfo.getMaxDegrees().toJava();
 
         for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
         Integer maxDegree = ordmInfo.getMaxDegrees() == null ? 20 : ordmInfo.getMaxDegrees().toJava();
 
         for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
-            LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
+            LOG.debug("{} : Getting Connection ports for Degree Number {}", deviceId, degreeCounter);
             InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(Degree.class, new DegreeKey(Uint16.valueOf(degreeCounter)));
             Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
             InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
                 .child(Degree.class, new DegreeKey(Uint16.valueOf(degreeCounter)));
             Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
@@ -718,7 +578,7 @@ public class PortMappingVersion710 {
                 degrees.put(degreeCounter, ordmDegreeObject.get());
             }
         }
                 degrees.put(degreeCounter, ordmDegreeObject.get());
             }
         }
-        LOG.info("Device {} has {} degree", deviceId, degrees.size());
+        LOG.info("{} : Device has {} degree(s)", deviceId, degrees.size());
         return degrees;
     }
 
         return degrees;
     }
 
@@ -750,15 +610,14 @@ public class PortMappingVersion710 {
     }
 
     private Map<String, String> getEthInterfaceList(String nodeId) {
     }
 
     private Map<String, String> getEthInterfaceList(String nodeId) {
-        LOG.info("It is calling get ethernet interface");
+        LOG.info("{} : It is calling get ethernet interface", nodeId);
         InstanceIdentifier<Protocols> protocoliid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
             .child(Protocols.class);
         Optional<Protocols> protocolObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
             LogicalDatastoreType.OPERATIONAL, protocoliid, Timeouts.DEVICE_READ_TIMEOUT,
             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
         if (!protocolObject.isPresent() || protocolObject.get().augmentation(Protocols1.class).getLldp() == null) {
         InstanceIdentifier<Protocols> protocoliid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
             .child(Protocols.class);
         Optional<Protocols> protocolObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
             LogicalDatastoreType.OPERATIONAL, protocoliid, Timeouts.DEVICE_READ_TIMEOUT,
             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
         if (!protocolObject.isPresent() || protocolObject.get().augmentation(Protocols1.class).getLldp() == null) {
-            LOG.warn("Couldnt find port config under LLDP for Node : {} - Processiong is done.. now returning..",
-                nodeId);
+            LOG.warn("{} : Couldnt find port config under LLDP - Processiong is done.. now returning..", nodeId);
             return new HashMap<>();
         }
         Map<String, String> cpToInterfaceMap = new HashMap<>();
             return new HashMap<>();
         }
         Map<String, String> cpToInterfaceMap = new HashMap<>();
@@ -788,14 +647,14 @@ public class PortMappingVersion710 {
             cpToInterfaceMap.put(circuitPackObject.get().getParentCircuitPack().getCircuitPackName(),
                 portConfig.getIfName());
         }
             cpToInterfaceMap.put(circuitPackObject.get().getParentCircuitPack().getCircuitPackName(),
                 portConfig.getIfName());
         }
-        LOG.info("Processiong is done.. now returning..");
+        LOG.info("{} : Processiong is done.. now returning..", nodeId);
         return cpToInterfaceMap;
     }
 
     private List<CpToDegree> getCpToDegreeList(Map<Integer, Degree> degrees, Map<String, String> interfaceList) {
         List<CpToDegree> cpToDegreeList = new ArrayList<>();
         for (Degree degree : degrees.values()) {
         return cpToInterfaceMap;
     }
 
     private List<CpToDegree> getCpToDegreeList(Map<Integer, Degree> degrees, Map<String, String> interfaceList) {
         List<CpToDegree> cpToDegreeList = new ArrayList<>();
         for (Degree degree : degrees.values()) {
-            LOG.info("Inside CP to degree list");
+            LOG.debug("Inside CP to degree list");
             cpToDegreeList.addAll(degree.nonnullCircuitPacks().values().stream()
                 .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(),
                     degree.getDegreeNumber().toString(), interfaceList))
             cpToDegreeList.addAll(degree.nonnullCircuitPacks().values().stream()
                 .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(),
                     degree.getDegreeNumber().toString(), interfaceList))
@@ -804,24 +663,25 @@ public class PortMappingVersion710 {
         return cpToDegreeList;
     }
 
         return cpToDegreeList;
     }
 
-    private List<McCapabilities> getMcCapabilitiesList(Map<Integer, Degree> degrees, List<SharedRiskGroup> srgs,
-            Info deviceInfo, String nodeId) {
+    private Map<McCapabilitiesKey, McCapabilities> getMcCapabilities(Map<Integer, Degree> degrees,
+            List<SharedRiskGroup> srgs, Info deviceInfo, String nodeId) {
         //TODO some divergences with 2.2.1 here
         //TODO some divergences with 2.2.1 here
-        LOG.info("Getting the MC capabilities for degrees of node {}", nodeId);
+        LOG.info("{} : Getting the MC capabilities for degrees", nodeId);
         //Get all the mc-capability profiles from the device
         Map<McCapabilityProfileKey, McCapabilityProfile> mcCapabilityProfiles =
             getMcCapabilityProfiles(nodeId, deviceInfo);
         // Add the DEG mc-capabilities
         //Get all the mc-capability profiles from the device
         Map<McCapabilityProfileKey, McCapabilityProfile> mcCapabilityProfiles =
             getMcCapabilityProfiles(nodeId, deviceInfo);
         // Add the DEG mc-capabilities
-        List<McCapabilities> mcCapabilitiesList = createMcCapDegreeObject(degrees, mcCapabilityProfiles, nodeId);
+        Map<McCapabilitiesKey, McCapabilities> mcCapabilities = createMcCapDegreeObject(degrees, mcCapabilityProfiles,
+            nodeId);
         // Add the SRG mc-capabilities
         // Add the SRG mc-capabilities
-        LOG.info("Getting the MC capabilities for SRGs of node {}", nodeId);
-        mcCapabilitiesList.addAll(createMcCapSrgObject(srgs, mcCapabilityProfiles, nodeId));
-
-        return mcCapabilitiesList;
+        LOG.info("{} : Getting the MC capabilities for SRGs", nodeId);
+        mcCapabilities.putAll(createMcCapSrgObject(srgs, mcCapabilityProfiles, nodeId));
+        return mcCapabilities;
     }
 
     private boolean postPortMapping(String nodeId, NodeInfo nodeInfo, List<Mapping> portMapList,
     }
 
     private boolean postPortMapping(String nodeId, NodeInfo nodeInfo, List<Mapping> portMapList,
-            List<CpToDegree> cp2DegreeList, List<SwitchingPoolLcp> splList, List<McCapabilities> mcCapList) {
+            List<CpToDegree> cp2DegreeList, List<SwitchingPoolLcp> splList,
+            Map<McCapabilitiesKey, McCapabilities> mcCapMap) {
         NodesBuilder nodesBldr = new NodesBuilder().withKey(new NodesKey(nodeId)).setNodeId(nodeId);
         if (nodeInfo != null) {
             nodesBldr.setNodeInfo(nodeInfo);
         NodesBuilder nodesBldr = new NodesBuilder().withKey(new NodesKey(nodeId)).setNodeId(nodeId);
         if (nodeInfo != null) {
             nodesBldr.setNodeInfo(nodeInfo);
@@ -851,8 +711,8 @@ public class PortMappingVersion710 {
             }
             nodesBldr.setSwitchingPoolLcp(splMap);
         }
             }
             nodesBldr.setSwitchingPoolLcp(splMap);
         }
-        if (mcCapList != null) {
-            nodesBldr.setMcCapabilities(mcCapList);
+        if (mcCapMap != null) {
+            nodesBldr.setMcCapabilities(mcCapMap);
         }
         Map<NodesKey,Nodes> nodesList = new HashMap<>();
         Nodes nodes = nodesBldr.build();
         }
         Map<NodesKey,Nodes> nodesList = new HashMap<>();
         Nodes nodes = nodesBldr.build();
@@ -868,7 +728,7 @@ public class PortMappingVersion710 {
             commit.get();
             return true;
         } catch (InterruptedException | ExecutionException e) {
             commit.get();
             return true;
         } catch (InterruptedException | ExecutionException e) {
-            LOG.warn("Failed to post {}", network, e);
+            LOG.warn("{} : Failed to post {}", nodeId, network, e);
             return false;
         }
     }
             return false;
         }
     }
@@ -882,16 +742,16 @@ public class PortMappingVersion710 {
             .setInterfaceName(interfaceList.get(circuitPackName)).build();
     }
 
             .setInterfaceName(interfaceList.get(circuitPackName)).build();
     }
 
-    private List<McCapabilities> createMcCapDegreeObject(Map<Integer, Degree> degrees,
+    private Map<McCapabilitiesKey, McCapabilities> createMcCapDegreeObject(Map<Integer, Degree> degrees,
             Map<McCapabilityProfileKey, McCapabilityProfile> mcCapabilityProfileMap, String nodeId) {
         //TODO some divergences here with 2.2.1
             Map<McCapabilityProfileKey, McCapabilityProfile> mcCapabilityProfileMap, String nodeId) {
         //TODO some divergences here with 2.2.1
-        List<McCapabilities> mcCapabilitiesList = new ArrayList<>();
+        Map<McCapabilitiesKey, McCapabilities> mcCapabilitiesMap = new HashMap<>();
         for (Degree degree : degrees.values()) {
 
             if ((degree.getMcCapabilityProfileName() == null) || (degree.getMcCapabilityProfileName().isEmpty())) {
         for (Degree degree : degrees.values()) {
 
             if ((degree.getMcCapabilityProfileName() == null) || (degree.getMcCapabilityProfileName().isEmpty())) {
-                LOG.warn("No MC profiles are found for  node {} on degree {}", nodeId, degree.getDegreeNumber());
-                LOG.warn("Assuming the fixed grid capabilities for degree {}", degree.getDegreeNumber());
-                LOG.warn("Assuming a default MC profile-name for degree {}", degree.getDegreeNumber());
+                LOG.warn("{} : No MC profiles are found on degree {} - "
+                        + "assuming the fixed grid capabilities and a default profile-name",
+                    nodeId, degree.getDegreeNumber());
                 String mcNodeName = "DEG" + degree.getDegreeNumber().toString() + "-TTP-" + "default-profile";
                 McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder()
                     .withKey(new McCapabilitiesKey(mcNodeName))
                 String mcNodeName = "DEG" + degree.getDegreeNumber().toString() + "-TTP-" + "default-profile";
                 McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder()
                     .withKey(new McCapabilitiesKey(mcNodeName))
@@ -899,7 +759,7 @@ public class PortMappingVersion710 {
                 mcCapabilitiesBuilder
                     .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50"))
                     .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50"));
                 mcCapabilitiesBuilder
                     .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50"))
                     .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50"));
-                mcCapabilitiesList.add(mcCapabilitiesBuilder.build());
+                mcCapabilitiesMap.put(mcCapabilitiesBuilder.key(), mcCapabilitiesBuilder.build());
                 continue;
             }
 
                 continue;
             }
 
@@ -913,23 +773,23 @@ public class PortMappingVersion710 {
                 mcCapabilitiesBuilder
                     .setCenterFreqGranularity(mcCapabilityProfile.getCenterFreqGranularity())
                     .setSlotWidthGranularity(mcCapabilityProfile.getSlotWidthGranularity());
                 mcCapabilitiesBuilder
                     .setCenterFreqGranularity(mcCapabilityProfile.getCenterFreqGranularity())
                     .setSlotWidthGranularity(mcCapabilityProfile.getSlotWidthGranularity());
-                mcCapabilitiesList.add(mcCapabilitiesBuilder.build());
+                mcCapabilitiesMap.put(mcCapabilitiesBuilder.key(), mcCapabilitiesBuilder.build());
             }
 
         }
             }
 
         }
-        return mcCapabilitiesList;
+        return mcCapabilitiesMap;
     }
 
     }
 
-    private List<McCapabilities> createMcCapSrgObject(List<SharedRiskGroup> srgs,
+    private Map<McCapabilitiesKey, McCapabilities> createMcCapSrgObject(List<SharedRiskGroup> srgs,
             Map<McCapabilityProfileKey, McCapabilityProfile> mcCapabilityProfileMap, String nodeId) {
 
             Map<McCapabilityProfileKey, McCapabilityProfile> mcCapabilityProfileMap, String nodeId) {
 
-        List<McCapabilities> mcCapabilitiesList = new ArrayList<>();
+        Map<McCapabilitiesKey, McCapabilities> mcCapabilitiesMap = new HashMap<>();
         for (SharedRiskGroup srg : srgs) {
 
             if ((srg.getMcCapabilityProfileName() == null) || (srg.getMcCapabilityProfileName().isEmpty())) {
         for (SharedRiskGroup srg : srgs) {
 
             if ((srg.getMcCapabilityProfileName() == null) || (srg.getMcCapabilityProfileName().isEmpty())) {
-                LOG.warn("No MC profiles are found for  node {} on SRG {}", nodeId, srg.getSrgNumber());
-                LOG.warn("Assuming the fixed grid capabilities for SRG {}", srg.getSrgNumber());
-                LOG.warn("Assuming a default MC profile-name for SRG {}", srg.getSrgNumber());
+                LOG.warn("{} : No MC profiles are found on SRG {} - "
+                    + "assuming the fixed grid capabilities and a default MC profile-name",
+                    nodeId, srg.getSrgNumber());
                 String mcNodeName = "SRG" + srg.getSrgNumber().toString() + "-PP-" + "default-profile";
                 McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder()
                     .withKey(new McCapabilitiesKey(mcNodeName))
                 String mcNodeName = "SRG" + srg.getSrgNumber().toString() + "-PP-" + "default-profile";
                 McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder()
                     .withKey(new McCapabilitiesKey(mcNodeName))
@@ -937,7 +797,7 @@ public class PortMappingVersion710 {
                 mcCapabilitiesBuilder
                     .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50"))
                     .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50"));
                 mcCapabilitiesBuilder
                     .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50"))
                     .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50"));
-                mcCapabilitiesList.add(mcCapabilitiesBuilder.build());
+                mcCapabilitiesMap.put(mcCapabilitiesBuilder.key(), mcCapabilitiesBuilder.build());
                 continue;
             }
 
                 continue;
             }
 
@@ -951,10 +811,10 @@ public class PortMappingVersion710 {
                 mcCapabilitiesBuilder
                     .setCenterFreqGranularity(mcCapabilityProfile.getCenterFreqGranularity())
                     .setSlotWidthGranularity(mcCapabilityProfile.getSlotWidthGranularity());
                 mcCapabilitiesBuilder
                     .setCenterFreqGranularity(mcCapabilityProfile.getCenterFreqGranularity())
                     .setSlotWidthGranularity(mcCapabilityProfile.getSlotWidthGranularity());
-                mcCapabilitiesList.add(mcCapabilitiesBuilder.build());
+                mcCapabilitiesMap.put(mcCapabilitiesBuilder.key(), mcCapabilitiesBuilder.build());
             }
         }
             }
         }
-        return mcCapabilitiesList;
+        return mcCapabilitiesMap;
     }
 
     private Mapping createMappingObject(String nodeId, Ports port, String circuitPackName,
     }
 
     private Mapping createMappingObject(String nodeId, Ports port, String circuitPackName,
@@ -965,23 +825,58 @@ public class PortMappingVersion710 {
                 .setSupportingCircuitPackName(circuitPackName)
                 .setSupportingPort(port.getPortName())
                 .setPortDirection(port.getPortDirection().getName());
                 .setSupportingCircuitPackName(circuitPackName)
                 .setSupportingPort(port.getPortName())
                 .setPortDirection(port.getPortDirection().getName());
+        if (port.getAdministrativeState() != null) {
+            mpBldr.setPortAdminState(port.getAdministrativeState().name());
+        }
+        if (port.getOperationalState() != null) {
+            mpBldr.setPortOperState(port.getOperationalState().name());
+        }
 
         if ((port.getInterfaces() == null)
             || (!logicalConnectionPoint.contains(StringConstants.TTP_TOKEN)
                 && !logicalConnectionPoint.contains(StringConstants.NETWORK_TOKEN))) {
             return mpBldr.build();
         }
 
         if ((port.getInterfaces() == null)
             || (!logicalConnectionPoint.contains(StringConstants.TTP_TOKEN)
                 && !logicalConnectionPoint.contains(StringConstants.NETWORK_TOKEN))) {
             return mpBldr.build();
         }
-        // Get OMS and OTS interface provisioned on the TTP's
+        mpBldr = updateMappingInterfaces(nodeId, mpBldr, port);
+        return mpBldr.build();
+    }
+
+    private Mapping updateMappingObject(String nodeId, Ports port, Mapping oldmapping) {
+        MappingBuilder mpBldr = new MappingBuilder(oldmapping);
+        updateMappingStates(mpBldr, port, oldmapping);
+        if ((port.getInterfaces() == null)
+            || (!oldmapping.getLogicalConnectionPoint().contains(StringConstants.TTP_TOKEN)
+                && !oldmapping.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN))) {
+            return mpBldr.build();
+        }
+        // Get interfaces provisioned on the port
+        mpBldr = updateMappingInterfaces(nodeId, mpBldr, port);
+        return mpBldr.build();
+    }
+
+    private MappingBuilder updateMappingStates(MappingBuilder mpBldr, Ports port, Mapping oldmapping) {
+        if (port.getAdministrativeState() != null
+            && !port.getAdministrativeState().getName().equals(oldmapping.getPortAdminState())) {
+            mpBldr.setPortAdminState(port.getAdministrativeState().name());
+        }
+        if (port.getOperationalState() != null
+            && !port.getOperationalState().getName().equals(oldmapping.getPortOperState())) {
+            mpBldr.setPortOperState(port.getOperationalState().name());
+        }
+        return mpBldr;
+    }
+
+    private MappingBuilder updateMappingInterfaces(String nodeId, MappingBuilder mpBldr, Ports port) {
         for (Interfaces interfaces : port.getInterfaces()) {
             try {
                 Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
                     interfaces.getInterfaceName());
                 if (!openRoadmInterface.isPresent()) {
         for (Interfaces interfaces : port.getInterfaces()) {
             try {
                 Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
                     interfaces.getInterfaceName());
                 if (!openRoadmInterface.isPresent()) {
-                    LOG.warn("Interface {} from node {} was null!", interfaces.getInterfaceName(), nodeId);
+                    LOG.warn("{} : Interface {} was null!", nodeId, interfaces.getInterfaceName());
                     continue;
                 }
                     continue;
                 }
-                LOG.info("interface get from device is {} and of type {}",
-                    openRoadmInterface.get().getName(), openRoadmInterface.get().getType());
+                LOG.debug("{} : interface get from device is {} and of type {}",
+                    nodeId, openRoadmInterface.get().getName(), openRoadmInterface.get().getType());
                 Class<? extends InterfaceType> interfaceType
                     = (Class<? extends InterfaceType>) openRoadmInterface.get().getType();
                 // Check if interface type is OMS or OTS
                 Class<? extends InterfaceType> interfaceType
                     = (Class<? extends InterfaceType>) openRoadmInterface.get().getType();
                 // Check if interface type is OMS or OTS
@@ -995,14 +890,14 @@ public class PortMappingVersion710 {
                     mpBldr.setSupportingOdu4(interfaces.getInterfaceName());
                 }
             } catch (OpenRoadmInterfaceException ex) {
                     mpBldr.setSupportingOdu4(interfaces.getInterfaceName());
                 }
             } catch (OpenRoadmInterfaceException ex) {
-                LOG.warn("Error while getting interface {} from node {}!",
-                    interfaces.getInterfaceName(), nodeId, ex);
+                LOG.warn("{} : Error while getting interface {} - ",
+                    nodeId, interfaces.getInterfaceName(), ex);
             }
         }
             }
         }
-        return mpBldr.build();
+        return mpBldr;
     }
 
     }
 
-    private Mapping createXpdrMappingObject(String nodeId, Ports ports, String circuitPackName,
+    private Mapping createXpdrMappingObject(String nodeId, Ports port, String circuitPackName,
             String logicalConnectionPoint, String partnerLcp, Mapping mapping, String connectionMapLcp,
             XpdrNodeTypes xpdrNodeType) {
 
             String logicalConnectionPoint, String partnerLcp, Mapping mapping, String connectionMapLcp,
             XpdrNodeTypes xpdrNodeType) {
 
@@ -1018,11 +913,11 @@ public class PortMappingVersion710 {
                 .withKey(new MappingKey(logicalConnectionPoint))
                 .setLogicalConnectionPoint(logicalConnectionPoint)
                 .setSupportingCircuitPackName(circuitPackName)
                 .withKey(new MappingKey(logicalConnectionPoint))
                 .setLogicalConnectionPoint(logicalConnectionPoint)
                 .setSupportingCircuitPackName(circuitPackName)
-                .setSupportingPort(ports.getPortName())
-                .setPortDirection(ports.getPortDirection().getName())
+                .setSupportingPort(port.getPortName())
+                .setPortDirection(port.getPortDirection().getName())
                 .setLcpHashVal(FnvUtils.fnv1_64(nodeIdLcp));
                 .setLcpHashVal(FnvUtils.fnv1_64(nodeIdLcp));
-        if (ports.getPortQual() != null) {
-            mpBldr.setPortQual(ports.getPortQual().getName());
+        if (port.getPortQual() != null) {
+            mpBldr.setPortQual(port.getPortQual().getName());
         }
         if (xpdrNodeType != null) {
             mpBldr.setXponderType(xpdrNodeType);
         }
         if (xpdrNodeType != null) {
             mpBldr.setXponderType(xpdrNodeType);
@@ -1030,9 +925,64 @@ public class PortMappingVersion710 {
         if (partnerLcp != null) {
             mpBldr.setPartnerLcp(partnerLcp);
         }
         if (partnerLcp != null) {
             mpBldr.setPartnerLcp(partnerLcp);
         }
+        if (port.augmentation(Ports1.class) != null && port.augmentation(Ports1.class).getPortCapabilities() != null) {
+            List<Class<? extends org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327
+                .SupportedIfCapability>> supportedIntf = new ArrayList<>();
+            Map<SupportedInterfaceCapabilityKey, SupportedInterfaceCapability> supIfCapMap = port
+                .augmentation(Ports1.class).getPortCapabilities().nonnullSupportedInterfaceCapability();
+            for (SupportedInterfaceCapability sic : supIfCapMap.values()) {
+                supportedIntf.add(sic.getIfCapType());
+            }
+            mpBldr.setSupportedInterfaceCapability(supportedIntf);
+        }
+        if (port.getAdministrativeState() != null) {
+            mpBldr.setPortAdminState(port.getAdministrativeState().name());
+        }
+        if (port.getOperationalState() != null) {
+            mpBldr.setPortOperState(port.getOperationalState().name());
+        }
         return mpBldr.build();
     }
 
         return mpBldr.build();
     }
 
+    private Ports getPort2(Ports port, String nodeId, String circuitPackName, StringBuilder circuitPackName2,
+            //circuitPackName2 will be updated by reference contrary to circuitPackName
+            List<CircuitPacks> circuitPackList, Map<String, String> lcpMap) {
+        if (!checkPartnerPortNotNull(port)) {
+            LOG.warn("{} : port {} on {} - Error in the configuration ",
+                    nodeId, port.getPortName(), circuitPackName);
+            return null;
+        }
+        if (lcpMap.containsKey(circuitPackName + '+' + port.getPortName())) {
+            return null;
+        }
+        Optional<CircuitPacks> cpOpt = circuitPackList.stream()
+            .filter(
+                cP -> cP.getCircuitPackName().equals(port.getPartnerPort().getCircuitPackName()))
+            .findFirst();
+        if (!cpOpt.isPresent()) {
+            LOG.error("{} : Error fetching circuit-pack {}",
+                    nodeId, port.getPartnerPort().getCircuitPackName());
+            return null;
+        }
+        Optional<Ports> poOpt = cpOpt.get().nonnullPorts().values().stream()
+            .filter(p -> p.getPortName().equals(port.getPartnerPort().getPortName().toString()))
+            .findFirst();
+        if (!poOpt.isPresent()) {
+            LOG.error("{} : Error fetching port {} on {}",
+                    nodeId, port.getPartnerPort().getPortName(), port.getPartnerPort().getCircuitPackName());
+            return null;
+        }
+        Ports port2 = poOpt.get();
+        circuitPackName2.append(cpOpt.get().getCircuitPackName());
+        if (!checkPartnerPort(circuitPackName, port, port2)) {
+            LOG.error("{} : port {} on {} is not a correct partner port of {} on  {}",
+                    nodeId, port2.getPortName(), circuitPackName2, port.getPortName(), circuitPackName);
+            return null;
+        }
+        return port2;
+    }
+
+
     private void putXpdrLcpsInMaps(int line, String nodeId,
             Integer xponderNb, XpdrNodeTypes xponderType,
             String circuitPackName, String circuitPackName2, Ports port, Ports port2,
     private void putXpdrLcpsInMaps(int line, String nodeId,
             Integer xponderNb, XpdrNodeTypes xponderType,
             String circuitPackName, String circuitPackName2, Ports port, Ports port2,
@@ -1040,7 +990,7 @@ public class PortMappingVersion710 {
         String lcp1 = createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
         String lcp2 = createXpdrLogicalConnectionPort(xponderNb, line + 1, StringConstants.NETWORK_TOKEN);
         if (lcpMap.containsKey(lcp1) || lcpMap.containsKey(lcp2)) {
         String lcp1 = createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
         String lcp2 = createXpdrLogicalConnectionPort(xponderNb, line + 1, StringConstants.NETWORK_TOKEN);
         if (lcpMap.containsKey(lcp1) || lcpMap.containsKey(lcp2)) {
-            LOG.warn("mapping already exists for {} or {}", lcp1, lcp2);
+            LOG.warn("{} : mapping already exists for {} or {}", nodeId, lcp1, lcp2);
             return;
         }
         lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp1);
             return;
         }
         lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp1);
@@ -1052,11 +1002,88 @@ public class PortMappingVersion710 {
         return;
     }
 
         return;
     }
 
+    private int[] fillXpdrLcpsMaps(int line, int client, String nodeId,
+            Integer xponderNb, XpdrNodeTypes xponderType,
+            String circuitPackName,  Ports port,
+            List<CircuitPacks> circuitPackList, Map<String, String> lcpMap, Map<String, Mapping> mappingMap) {
+
+        if (port.getPortQual() == null) {
+            LOG.warn("{} : port {} on {} - PortQual was not found",
+                    nodeId, port.getPortName(), circuitPackName);
+            return new int[] {line, client};
+        }
+
+        switch (port.getPortQual()) {
+
+            case XpdrClient:
+            case SwitchClient:
+                String lcp0 = createXpdrLogicalConnectionPort(xponderNb, client, StringConstants.CLIENT_TOKEN);
+                lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp0);
+                mappingMap.put(lcp0,
+                    createXpdrMappingObject(nodeId, port, circuitPackName, lcp0, null, null, null, null));
+                client++;
+                break;
+
+            case XpdrNetwork:
+            case SwitchNetwork:
+                line = fillXpdrNetworkLcpsMaps(line, nodeId,
+                        xponderNb, xponderType,
+                        circuitPackName,  port,
+                        circuitPackList,  lcpMap, mappingMap);
+                break;
+
+            default:
+                LOG.error("{} : port {} on {} - unsupported PortQual {}",
+                        nodeId, port.getPortName(), circuitPackName, port.getPortQual());
+        }
+        return new int[] {line, client};
+    }
+
+    private int fillXpdrNetworkLcpsMaps(int line, String nodeId,
+            Integer xponderNb, XpdrNodeTypes xponderType,
+            String circuitPackName,  Ports port,
+            List<CircuitPacks> circuitPackList, Map<String, String> lcpMap, Map<String, Mapping> mappingMap) {
+
+        switch (port.getPortDirection()) {
 
 
-    private boolean createMcCapabilitiesList(String nodeId, Info deviceInfo, List<McCapabilities> mcCapabilitiesList) {
+            case Bidirectional:
+                String lcp = createXpdrLogicalConnectionPort(xponderNb, line, StringConstants.NETWORK_TOKEN);
+                lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
+                mappingMap.put(lcp,
+                    createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null, null, xponderType));
+                line++;
+                break;
+
+            case Rx:
+            case Tx:
+                StringBuilder circuitPackName2 = new StringBuilder();
+                Ports port2 = getPort2(port, nodeId, circuitPackName, circuitPackName2,
+                        circuitPackList, lcpMap);
+
+                if (port2 == null) {
+                     //key already present or an error occured and was logged
+                    return line;
+                }
+
+                putXpdrLcpsInMaps(line, nodeId, xponderNb, xponderType,
+                        circuitPackName, circuitPackName2.toString(), port, port2,
+                        lcpMap, mappingMap);
+                line += 2;
+                break;
+
+            default:
+                LOG.error("{} : port {} on {} - unsupported Direction {}",
+                     nodeId, port.getPortName(), circuitPackName, port.getPortDirection());
+        }
+
+        return line;
+    }
+
+    private boolean createMcCapabilitiesList(String nodeId, Info deviceInfo,
+            Map<McCapabilitiesKey, McCapabilities> mcCapabilitiesMap) {
         Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
         List<SharedRiskGroup> srgs = getSrgs(nodeId, deviceInfo);
         Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
         List<SharedRiskGroup> srgs = getSrgs(nodeId, deviceInfo);
-        mcCapabilitiesList.addAll(getMcCapabilitiesList(degrees, srgs, deviceInfo, nodeId));
+        mcCapabilitiesMap.putAll(getMcCapabilities(degrees, srgs, deviceInfo, nodeId));
         return true;
     }
 
         return true;
     }
 
@@ -1065,7 +1092,7 @@ public class PortMappingVersion710 {
         Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
         Map<String, String> interfaceList = getEthInterfaceList(nodeId);
         List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, interfaceList);
         Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
         Map<String, String> interfaceList = getEthInterfaceList(nodeId);
         List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, interfaceList);
-        LOG.info("Map looks like this {}", interfaceList);
+        LOG.info("{} : Map looks like this {}", nodeId, interfaceList);
         postPortMapping(nodeId, null, null, cpToDegreeList, null, null);
 
         Map<Integer, List<ConnectionPorts>> connectionPortMap = getPerDegreePorts(nodeId, deviceInfo);
         postPortMapping(nodeId, null, null, cpToDegreeList, null, null);
 
         Map<Integer, List<ConnectionPorts>> connectionPortMap = getPerDegreePorts(nodeId, deviceInfo);
@@ -1078,16 +1105,18 @@ public class PortMappingVersion710 {
                             new CircuitPacksKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName()))
                         .child(Ports.class,
                             new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString()));
                             new CircuitPacksKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName()))
                         .child(Ports.class,
                             new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString()));
-                    LOG.info("Fetching connection-port {} at circuit pack {}",
-                        connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString(),
-                        connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName());
+                    LOG.debug("{} : Fetching connection-port {} at circuit pack {}",
+                            nodeId,
+                            connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName(),
+                            connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName());
                     Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
                         LogicalDatastoreType.OPERATIONAL, portID, Timeouts.DEVICE_READ_TIMEOUT,
                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
                     if (!portObject.isPresent()) {
                     Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
                         LogicalDatastoreType.OPERATIONAL, portID, Timeouts.DEVICE_READ_TIMEOUT,
                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
                     if (!portObject.isPresent()) {
-                        LOG.error("No port {} on circuit pack {} for node {}",
-                            connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString(),
-                            connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId);
+                        LOG.error("{} : No port {} on circuit pack {}",
+                                nodeId,
+                                connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName(),
+                                connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName());
                         return false;
                     }
                     Ports port = portObject.get();
                         return false;
                     }
                     Ports port = portObject.get();
@@ -1096,19 +1125,20 @@ public class PortMappingVersion710 {
                     }
                     if (PortQual.RoadmExternal.getIntValue() != port.getPortQual().getIntValue()
                         || Direction.Bidirectional.getIntValue() != port.getPortDirection().getIntValue()) {
                     }
                     if (PortQual.RoadmExternal.getIntValue() != port.getPortQual().getIntValue()
                         || Direction.Bidirectional.getIntValue() != port.getPortDirection().getIntValue()) {
-                        LOG.error("Impossible to create logical connection point for port {} of {} on node {}"
+                        LOG.error("{} : port {} on {} - Impossible to create logical connection point"
                                 + " - Error in configuration with port-qual or port-direction",
                                 + " - Error in configuration with port-qual or port-direction",
-                            port.getPortName(),
-                            connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId);
+                                nodeId, port.getPortName(),
+                                connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName());
                         continue;
                     }
                     String logicalConnectionPoint = new StringBuilder("DEG")
                         .append(cpMapEntry.getKey())
                         .append("-TTP-TXRX")
                         .toString();
                         continue;
                     }
                     String logicalConnectionPoint = new StringBuilder("DEG")
                         .append(cpMapEntry.getKey())
                         .append("-TTP-TXRX")
                         .toString();
-                    LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
-                        connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), port.getPortName(),
-                        logicalConnectionPoint);
+                    LOG.info("{} : Logical Connection Point for {} on {} is {}",
+                            nodeId,
+                            port.getPortName(), connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
+                            logicalConnectionPoint);
                     portMapList.add(createMappingObject(nodeId, port,
                         connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
                         logicalConnectionPoint));
                     portMapList.add(createMappingObject(nodeId, port,
                         connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
                         logicalConnectionPoint));
@@ -1121,9 +1151,8 @@ public class PortMappingVersion710 {
                         .child(CircuitPacks.class, new CircuitPacksKey(cp1Name))
                         .child(Ports.class,
                             new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString()));
                         .child(CircuitPacks.class, new CircuitPacksKey(cp1Name))
                         .child(Ports.class,
                             new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString()));
-                    LOG.info("Fetching connection-port {} at circuit pack {}",
-                        connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString(),
-                        cp1Name);
+                    LOG.debug("{} : Fetching connection-port {} at circuit pack {}",
+                            nodeId, connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName(), cp1Name);
                     Optional<Ports> port1Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
                         LogicalDatastoreType.OPERATIONAL, port1ID, Timeouts.DEVICE_READ_TIMEOUT,
                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
                     Optional<Ports> port1Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
                         LogicalDatastoreType.OPERATIONAL, port1ID, Timeouts.DEVICE_READ_TIMEOUT,
                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
@@ -1131,15 +1160,16 @@ public class PortMappingVersion710 {
                         .child(CircuitPacks.class, new CircuitPacksKey(cp2Name))
                         .child(Ports.class,
                             new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName().toString()));
                         .child(CircuitPacks.class, new CircuitPacksKey(cp2Name))
                         .child(Ports.class,
                             new PortsKey(connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName().toString()));
-                    LOG.info("Fetching connection-port {} at circuit pack {}",
-                        connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName().toString(), cp2Name);
+                    LOG.debug("{} : Fetching connection-port {} at circuit pack {}",
+                            nodeId, connectionPortMap.get(cpMapEntry.getKey()).get(1).getPortName(), cp2Name);
                     Optional<Ports> port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
                         LogicalDatastoreType.OPERATIONAL, port2ID, Timeouts.DEVICE_READ_TIMEOUT,
                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
                     if (!port1Object.isPresent() || !port2Object.isPresent()) {
                     Optional<Ports> port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
                         LogicalDatastoreType.OPERATIONAL, port2ID, Timeouts.DEVICE_READ_TIMEOUT,
                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
                     if (!port1Object.isPresent() || !port2Object.isPresent()) {
-                        LOG.error("No port {} on circuit pack {} for node {}",
-                            connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName().toString(),
-                            connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId);
+                        LOG.error("{} : No port {} on circuit pack {}",
+                                nodeId,
+                                connectionPortMap.get(cpMapEntry.getKey()).get(0).getPortName(),
+                                connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName());
                         return false;
                     }
 
                         return false;
                     }
 
@@ -1150,20 +1180,20 @@ public class PortMappingVersion710 {
                     }
                     if (PortQual.RoadmExternal.getIntValue() != port1.getPortQual().getIntValue()
                         || PortQual.RoadmExternal.getIntValue() != port2.getPortQual().getIntValue()) {
                     }
                     if (PortQual.RoadmExternal.getIntValue() != port1.getPortQual().getIntValue()
                         || PortQual.RoadmExternal.getIntValue() != port2.getPortQual().getIntValue()) {
-                        LOG.error("Impossible to create logical connection point for port {} or port {} on node {}"
+                        LOG.error("{} : Impossible to create logical connection point for port {} or port {}"
                                 + " - Error in configuration with port-qual",
                                 + " - Error in configuration with port-qual",
-                            port1.getPortName(), port2.getPortName(), nodeId);
+                                nodeId, port1.getPortName(), port2.getPortName());
                         continue;
                     }
                     if (!checkPartnerPort(cp1Name, port1, port2)) {
                         continue;
                     }
                     if (!checkPartnerPort(cp1Name, port1, port2)) {
-                        LOG.error("port {} on {} is not a correct partner port of {} on  {}",
-                            port2.getPortName(), cp2Name, port1.getPortName(), cp1Name);
+                        LOG.error("{} : port {} on {} is not a correct partner port of {} on  {}",
+                                nodeId, port2.getPortName(), cp2Name, port1.getPortName(), cp1Name);
                         continue;
                     }
                     // Directions checks are the same for cp1 and cp2, no need to check them twice.
                     if (!checkPartnerPortNoDir(cp2Name, port2, port1)) {
                         continue;
                     }
                     // Directions checks are the same for cp1 and cp2, no need to check them twice.
                     if (!checkPartnerPortNoDir(cp2Name, port2, port1)) {
-                        LOG.error("port {} on {} is not a correct partner port of {} on  {}",
-                            port1.getPortName(), cp1Name, port2.getPortName(), cp2Name);
+                        LOG.error("{} : port {} on {} is not a correct partner port of {} on  {}",
+                                nodeId, port1.getPortName(), cp1Name, port2.getPortName(), cp2Name);
                         continue;
                     }
 
                         continue;
                     }
 
@@ -1183,15 +1213,16 @@ public class PortMappingVersion710 {
                         .append("-TTP-")
                         .append(port2.getPortDirection().getName().toUpperCase(Locale.getDefault()))
                         .toString();
                         .append("-TTP-")
                         .append(port2.getPortDirection().getName().toUpperCase(Locale.getDefault()))
                         .toString();
-                    LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
-                        connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(),
-                        port2.getPortName(), logicalConnectionPoint2);
+                    LOG.info("{} : Logical Connection Point for {} {} is {}",
+                            nodeId,
+                            connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(),
+                            port2.getPortName(), logicalConnectionPoint2);
                     portMapList.add(createMappingObject(nodeId, port2,
                             connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(),
                             logicalConnectionPoint2));
                     break;
                 default:
                     portMapList.add(createMappingObject(nodeId, port2,
                             connectionPortMap.get(cpMapEntry.getKey()).get(1).getCircuitPackName(),
                             logicalConnectionPoint2));
                     break;
                 default:
-                    LOG.error("Number of connection port for DEG{} on {} is incorrect", cpMapEntry.getKey(), nodeId);
+                    LOG.error("{} : Number of connection port for DEG{} is incorrect", nodeId, cpMapEntry.getKey());
                     continue;
             }
         }
                     continue;
             }
         }
@@ -1207,7 +1238,7 @@ public class PortMappingVersion710 {
         }
 
         NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder()
         }
 
         NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder()
-                .setOpenroadmVersion(OpenroadmVersion._710)
+                .setOpenroadmVersion(OpenroadmNodeVersion._710)
                 .setNodeType(deviceInfo.getNodeType());
         // TODO: 221 versions expects an int value - need to check whether it is bug or an evolution here
         if (deviceInfo.getClli() != null && !deviceInfo.getClli().isEmpty()) {
                 .setNodeType(deviceInfo.getNodeType());
         // TODO: 221 versions expects an int value - need to check whether it is bug or an evolution here
         if (deviceInfo.getClli() != null && !deviceInfo.getClli().isEmpty()) {
Repository for Transport PCE project.