Set port states in portMapping

[transportpce.git] / common / src / main / java / org / opendaylight / transportpce / common / mapping / PortMappingVersion221.java
diff --git a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java

index ace72bda9bca482e9c205d590699ad940f00bac1..6bff30368cdce312ebf56f06f9a7056f2b0e84ef 100644 (file)
--- a/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.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.rev210310.Network;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.NetworkBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.Nodes;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.NodesBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.NodesKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.CpToDegree;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.CpToDegreeBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.CpToDegreeKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.Mapping;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.MappingBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.MappingKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.McCapabilities;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.McCapabilitiesBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.McCapabilitiesKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.NodeInfo;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.NodeInfo.OpenroadmVersion;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.NodeInfoBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.SwitchingPoolLcp;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.SwitchingPoolLcpBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.SwitchingPoolLcpKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.switching.pool.lcp.NonBlockingList;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.switching.pool.lcp.NonBlockingListBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210310.network.nodes.switching.pool.lcp.NonBlockingListKey;
  import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyGHz;
  import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.Direction;
  import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PortQual;
  import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyGHz;
  import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.Direction;
  import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PortQual;
@@ -121,15 +121,15 @@ public class PortMappingVersion221 {
      }
  
      public boolean createMappingData(String nodeId) {
      }
  
      public boolean createMappingData(String nodeId) {
-        LOG.info("Create Mapping Data for node 2.2.1 {}", nodeId);
+        LOG.info("{} : OpenROADM version 2.2.1 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();
@@ -145,35 +145,35 @@ public class PortMappingVersion221 {
                  // 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) {
@@ -194,8 +194,8 @@ public class PortMappingVersion221 {
              Ports port = portObject.get();
              Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(),
                  oldMapping.getLogicalConnectionPoint());
              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);
+            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))
@@ -205,7 +205,8 @@ public class PortMappingVersion221 {
              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;
          }
      }
@@ -217,12 +218,12 @@ public class PortMappingVersion221 {
              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;
          }
  
@@ -231,7 +232,7 @@ public class PortMappingVersion221 {
          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;
@@ -240,88 +241,21 @@ public class PortMappingVersion221 {
              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;
              for (Xponder xponder : deviceObject.get().nonnullXponder().values()) {
                  // Variables to keep track of number of line ports and client ports
                  int line = 1;
@@ -336,8 +270,8 @@ public class PortMappingVersion221 {
                      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()
@@ -345,8 +279,8 @@ public class PortMappingVersion221 {
                              .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()
@@ -354,90 +288,17 @@ public class PortMappingVersion221 {
                              .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) {
@@ -446,8 +307,8 @@ public class PortMappingVersion221 {
                  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;
@@ -471,8 +332,8 @@ public class PortMappingVersion221 {
                      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 +403,7 @@ public class PortMappingVersion221 {
          for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
              List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks> srgCps
                  = new ArrayList<>();
          for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
              List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.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 +414,7 @@ public class PortMappingVersion221 {
                  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 +449,14 @@ public class PortMappingVersion221 {
                      }
  
                      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 +464,8 @@ public class PortMappingVersion221 {
  
                          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 +475,14 @@ public class PortMappingVersion221 {
                          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 +493,22 @@ public class PortMappingVersion221 {
                              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 +518,9 @@ public class PortMappingVersion221 {
                              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());
  
                      }
                  }
  
                      }
                  }
@@ -692,7 +553,7 @@ public class PortMappingVersion221 {
          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,
@@ -702,7 +563,7 @@ public class PortMappingVersion221 {
                  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;
      }
  
@@ -734,15 +595,14 @@ public class PortMappingVersion221 {
      }
  
      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<>();
@@ -772,14 +632,14 @@ public class PortMappingVersion221 {
              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))
@@ -788,20 +648,22 @@ public class PortMappingVersion221 {
          return cpToDegreeList;
      }
  
          return cpToDegreeList;
      }
  
-    private List<McCapabilities> getMcCapabilitiesList(Map<Integer, Degree> degrees, List<SharedRiskGroup> srgs,
-        String nodeId) {
-        LOG.info("Getting the MC capabilities for degrees of node {}", nodeId);
-        List<McCapabilities> mcCapabilitiesList = degrees.values().stream()
-            .map(degree -> createMcCapDegreeObject(degree, nodeId)).collect(Collectors.toList());
+    private Map<McCapabilitiesKey, McCapabilities> getMcCapabilities(Map<Integer, Degree> degrees,
+            List<SharedRiskGroup> srgs, String nodeId) {
+        LOG.info("{} : Getting the MC capabilities for degrees", nodeId);
+        Map<McCapabilitiesKey, McCapabilities> mcCapabilities = degrees.values().stream()
+            .map(degree -> createMcCapDegreeObject(degree, nodeId))
+            .collect(Collectors.toMap(McCapabilities::key, mcc -> mcc));
          // Add the SRG mc-capabilities
          // Add the SRG mc-capabilities
-        LOG.info("Getting the MC capabilities for SRGs of node {}", nodeId);
-        mcCapabilitiesList.addAll(srgs.stream().map(srg -> createMcCapSrgObject(srg, nodeId))
-            .collect(Collectors.toList()));
-        return mcCapabilitiesList;
+        LOG.info("{} : Getting the MC capabilities for SRGs", nodeId);
+        mcCapabilities.putAll(srgs.stream().map(srg -> createMcCapSrgObject(srg, nodeId))
+            .collect(Collectors.toMap(McCapabilities::key, mcCapabilities2 -> mcCapabilities2)));
+        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> mcCapabilities) {
          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);
@@ -831,8 +693,8 @@ public class PortMappingVersion221 {
              }
              nodesBldr.setSwitchingPoolLcp(splMap);
          }
              }
              nodesBldr.setSwitchingPoolLcp(splMap);
          }
-        if (mcCapList != null) {
-            nodesBldr.setMcCapabilities(mcCapList);
+        if (mcCapabilities != null) {
+            nodesBldr.setMcCapabilities(mcCapabilities);
          }
          Map<NodesKey,Nodes> nodesList = new HashMap<>();
          Nodes nodes = nodesBldr.build();
          }
          Map<NodesKey,Nodes> nodesList = new HashMap<>();
          Nodes nodes = nodesBldr.build();
@@ -848,7 +710,7 @@ public class PortMappingVersion221 {
              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;
          }
      }
@@ -868,8 +730,8 @@ public class PortMappingVersion221 {
              .withKey(new McCapabilitiesKey(mcNodeName))
              .setMcNodeName(mcNodeName);
          if (degree.getMcCapabilities() == null) {
              .withKey(new McCapabilitiesKey(mcNodeName))
              .setMcNodeName(mcNodeName);
          if (degree.getMcCapabilities() == null) {
-            LOG.warn("Media channel capabilities are not advertised for degree {} of {} - assuming fixed grid",
-                degree.getDegreeNumber(), nodeId);
+            LOG.warn("{} : Media channel capabilities are not advertised for degree {} - assuming fixed grid",
+                    nodeId, degree.getDegreeNumber());
              mcCapabilitiesBuilder
                  .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50"))
                  .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50"));
              mcCapabilitiesBuilder
                  .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50"))
                  .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50"));
@@ -889,8 +751,8 @@ public class PortMappingVersion221 {
              .withKey(new McCapabilitiesKey(mcNodeName))
              .setMcNodeName(mcNodeName);
          if (srg.getMcCapabilities() == null) {
              .withKey(new McCapabilitiesKey(mcNodeName))
              .setMcNodeName(mcNodeName);
          if (srg.getMcCapabilities() == null) {
-            LOG.warn("Media channel capabilities are not advertised for SRG {} of {} - assuming fixed grid",
-                srg.getSrgNumber(), nodeId);
+            LOG.warn("{} : Media channel capabilities are not advertised for SRG {} - assuming fixed grid",
+                    nodeId, srg.getSrgNumber());
              mcCapabilitiesBuilder
                  .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50"))
                  .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50"));
              mcCapabilitiesBuilder
                  .setCenterFreqGranularity(FrequencyGHz.getDefaultInstance("50"))
                  .setSlotWidthGranularity(FrequencyGHz.getDefaultInstance("50"));
@@ -912,6 +774,12 @@ public class PortMappingVersion221 {
                  .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)
  
          if ((port.getInterfaces() == null)
              || (!logicalConnectionPoint.contains(StringConstants.TTP_TOKEN)
@@ -924,11 +792,11 @@ public class PortMappingVersion221 {
                  Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
                      interfaces.getInterfaceName());
                  if (!openRoadmInterface.isPresent()) {
                  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
@@ -942,8 +810,8 @@ public class PortMappingVersion221 {
                      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.build();
@@ -990,9 +858,54 @@ public class PortMappingVersion221 {
              }
              mpBldr.setSupportedInterfaceCapability(supportedIntf);
          }
              }
              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,
@@ -1000,7 +913,7 @@ public class PortMappingVersion221 {
          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);
@@ -1012,11 +925,87 @@ public class PortMappingVersion221 {
          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()) {
+
+            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;
+                }
  
  
-    private boolean createMcCapabilitiesList(String nodeId, Info deviceInfo, List<McCapabilities> mcCapabilitiesList) {
+                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, nodeId));
+        mcCapabilitiesMap.putAll(getMcCapabilities(degrees, srgs, nodeId));
          return true;
      }
  
          return true;
      }
  
@@ -1025,7 +1014,7 @@ public class PortMappingVersion221 {
          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);
@@ -1038,16 +1027,18 @@ public class PortMappingVersion221 {
                              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();
@@ -1056,19 +1047,20 @@ public class PortMappingVersion221 {
                      }
                      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));
@@ -1081,9 +1073,8 @@ public class PortMappingVersion221 {
                          .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);
@@ -1091,15 +1082,16 @@ public class PortMappingVersion221 {
                          .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;
                      }
  
@@ -1110,20 +1102,20 @@ public class PortMappingVersion221 {
                      }
                      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;
                      }
  
@@ -1143,15 +1135,16 @@ public class PortMappingVersion221 {
                          .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;
              }
          }