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 / PortMappingVersion121.java
diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java
index 20d46a281ca384d214e6ac4715e2b9a51982d31b..5266e6a08fed8ae36b2766127dcf4c96eaff2061 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121.java
@@ -32,20 +32,20 @@ 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.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.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.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.openroadm.common.types.rev161014.Direction;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.CircuitPack;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.Port;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.Direction;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.CircuitPack;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.Port;
@@ -81,6 +81,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 PortMappingVersion121 {
 
     private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion121.class);
 public class PortMappingVersion121 {
 
     private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion121.class);
@@ -105,13 +106,13 @@ public class PortMappingVersion121 {
     }
 
     public boolean createMappingData(String nodeId) {
     }
 
     public boolean createMappingData(String nodeId) {
-        LOG.info("Create Mapping Data for node 1.2.1 {}", nodeId);
+        LOG.info("{} : OpenROADM version 1.2.1 node - Creating Mapping Data", nodeId);
         List<Mapping> portMapList = new ArrayList<>();
         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()) {
         List<Mapping> portMapList = new ArrayList<>();
         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();
@@ -127,25 +128,25 @@ public class PortMappingVersion121 {
                 // 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;
                 }
                 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 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;
 
         }
@@ -153,7 +154,7 @@ public class PortMappingVersion121 {
     }
 
     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)) {
@@ -161,17 +162,11 @@ public class PortMappingVersion121 {
             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))
@@ -181,7 +176,8 @@ public class PortMappingVersion121 {
             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;
         }
     }
@@ -193,12 +189,12 @@ public class PortMappingVersion121 {
             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;
         }
         // Variable to keep track of number of line ports
             return false;
         }
         // Variable to keep track of number of line ports
@@ -213,7 +209,7 @@ public class PortMappingVersion121 {
         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;
             }
 
                 continue;
             }
 
@@ -221,78 +217,11 @@ public class PortMappingVersion121 {
             List<Ports> portList = new ArrayList<>(cp.nonnullPorts().values());
             portList.sort(Comparator.comparing(Ports::getPortName));
             for (Ports port : portList) {
             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));
-                        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));
-                            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,
-                                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, circuitPackName, port,
+                    circuitPackList, lcpMap, mappingMap);
+                line = counters[0];
+                client = counters[1];
             }
         }
 
             }
         }
 
@@ -303,8 +232,8 @@ public class PortMappingVersion121 {
             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;
@@ -361,7 +290,7 @@ public class PortMappingVersion121 {
         for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
             List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks> srgCps
                 = new ArrayList<>();
         for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
             List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.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,
@@ -372,7 +301,7 @@ public class PortMappingVersion121 {
                 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;
     }
 
@@ -410,14 +339,14 @@ public class PortMappingVersion121 {
                     }
 
                     if (Port.PortQual.RoadmExternal.getIntValue() != port.getPortQual().getIntValue()) {
                     }
 
                     if (Port.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;
                     }
 
@@ -425,8 +354,8 @@ public class PortMappingVersion121 {
 
                         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);
@@ -436,14 +365,14 @@ public class PortMappingVersion121 {
                         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()))
@@ -454,22 +383,22 @@ public class PortMappingVersion121 {
                             if (!port2Object.isPresent()
                                 || port2Object.get().getPortQual().getIntValue()
                                     != Port.PortQual.RoadmExternal.getIntValue()) {
                             if (!port2Object.isPresent()
                                 || port2Object.get().getPortQual().getIntValue()
                                     != Port.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));
@@ -479,9 +408,9 @@ public class PortMappingVersion121 {
                             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());
 
                     }
                 }
 
                     }
                 }
@@ -513,7 +442,7 @@ public class PortMappingVersion121 {
         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,
@@ -523,7 +452,7 @@ public class PortMappingVersion121 {
                 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;
     }
 
@@ -535,15 +464,14 @@ public class PortMappingVersion121 {
     }
 
     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<>();
@@ -574,14 +502,14 @@ public class PortMappingVersion121 {
             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))
@@ -649,20 +577,55 @@ public class PortMappingVersion121 {
                 .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 (!logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) || (port.getInterfaces() == null)) {
             return mpBldr.build();
         }
         if (!logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) || (port.getInterfaces() == null)) {
             return mpBldr.build();
         }
+        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;
+    }
 
 
-        // Get OMS and OTS interface provisioned on the TTP's
+    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.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
@@ -673,11 +636,11 @@ public class PortMappingVersion121 {
                     mpBldr.setSupportingOts(interfaces.getInterfaceName());
                 }
             } catch (OpenRoadmInterfaceException ex) {
                     mpBldr.setSupportingOts(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 port, String circuitPackName,
     }
 
     private Mapping createXpdrMappingObject(String nodeId, Ports port, String circuitPackName,
@@ -703,10 +666,52 @@ public class PortMappingVersion121 {
         if (partnerLcp != null) {
             mpBldr.setPartnerLcp(partnerLcp);
         }
         if (partnerLcp != null) {
             mpBldr.setPartnerLcp(partnerLcp);
         }
-
+        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,
             String circuitPackName, String circuitPackName2, Ports port, Ports port2,
     private void putXpdrLcpsInMaps(int line, String nodeId,
             Integer xponderNb,
             String circuitPackName, String circuitPackName2, Ports port, Ports port2,
@@ -714,7 +719,7 @@ public class PortMappingVersion121 {
         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);
@@ -726,13 +731,88 @@ public class PortMappingVersion121 {
         return;
     }
 
         return;
     }
 
+    private int[] fillXpdrLcpsMaps(int line, int client, String nodeId,
+            Integer xponderNb,
+            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:
+                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));
+                client++;
+                break;
+
+            case XpdrNetwork:
+                line = fillXpdrNetworkLcpsMaps(line, nodeId,
+                        xponderNb,
+                        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,
+            String circuitPackName,  Ports port,
+            List<CircuitPacks> circuitPackList, Map<String, String> lcpMap, Map<String, Mapping> mappingMap) {
+
+        switch (port.getPortDirection()) {
+
+            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));
+                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,
+                        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 createTtpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
         // Creating mapping data for degree TTP's
         Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
         Map<String, String> interfaceList = getEthInterfaceList(nodeId);
         List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, interfaceList);
 
     private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
         // Creating mapping data for degree TTP's
         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);
 
         Map<Integer, List<ConnectionPorts>> connectionPortMap = getPerDegreePorts(nodeId, deviceInfo);
         postPortMapping(nodeId, null, null, cpToDegreeList);
 
         Map<Integer, List<ConnectionPorts>> connectionPortMap = getPerDegreePorts(nodeId, deviceInfo);
@@ -745,16 +825,18 @@ public class PortMappingVersion121 {
                             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();
@@ -763,20 +845,20 @@ public class PortMappingVersion121 {
                     }
                     if (Port.PortQual.RoadmExternal.getIntValue() != port.getPortQual().getIntValue()
                         || Direction.Bidirectional.getIntValue() != port.getPortDirection().getIntValue()) {
                     }
                     if (Port.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 {}"
-                            + " - Error in configuration with port-qual or port-direction",
-                            port.getPortName(),
-                            connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(), nodeId);
+                        LOG.error("{} : port {} on {} - Impossible to create logical connection point"
+                                + " - Error in configuration with port-qual or port-direction",
+                                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));
@@ -789,9 +871,8 @@ public class PortMappingVersion121 {
                         .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);
@@ -799,8 +880,8 @@ public class PortMappingVersion121 {
                         .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);
                     Optional<Ports> port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
                         LogicalDatastoreType.OPERATIONAL, port2ID, Timeouts.DEVICE_READ_TIMEOUT,
                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
@@ -818,20 +899,20 @@ public class PortMappingVersion121 {
                     }
                     if (Port.PortQual.RoadmExternal.getIntValue() != port1.getPortQual().getIntValue()
                         || Port.PortQual.RoadmExternal.getIntValue() != port2.getPortQual().getIntValue()) {
                     }
                     if (Port.PortQual.RoadmExternal.getIntValue() != port1.getPortQual().getIntValue()
                         || Port.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;
                     }
 
@@ -840,9 +921,10 @@ public class PortMappingVersion121 {
                         .append("-TTP-")
                         .append(port1.getPortDirection().getName().toUpperCase(Locale.getDefault()))
                         .toString();
                         .append("-TTP-")
                         .append(port1.getPortDirection().getName().toUpperCase(Locale.getDefault()))
                         .toString();
-                    LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
-                        connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
-                        port1.getPortName(), logicalConnectionPoint1);
+                    LOG.info("{} : Logical Connection Point for {} {} is {}",
+                            nodeId,
+                            connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
+                            port1.getPortName(), logicalConnectionPoint1);
                     portMapList.add(createMappingObject(nodeId, port1,
                         connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
                         logicalConnectionPoint1));
                     portMapList.add(createMappingObject(nodeId, port1,
                         connectionPortMap.get(cpMapEntry.getKey()).get(0).getCircuitPackName(),
                         logicalConnectionPoint1));
@@ -859,7 +941,7 @@ public class PortMappingVersion121 {
                         logicalConnectionPoint2));
                     break;
                 default:
                         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;
             }
         }
@@ -875,7 +957,7 @@ public class PortMappingVersion121 {
         }
 
         NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder()
         }
 
         NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder()
-                .setOpenroadmVersion(OpenroadmVersion._121);
+                .setOpenroadmVersion(OpenroadmNodeVersion._121);
         // TODO check if we can use here .setNodeType(NodeTypes.forValue(..) such as with 221
         switch (deviceInfo.getNodeType().getIntValue()) {
             case 1:
         // TODO check if we can use here .setNodeType(NodeTypes.forValue(..) such as with 221
         switch (deviceInfo.getNodeType().getIntValue()) {
             case 1:
Repository for Transport PCE project.