common/src/main/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion221.java

   1 /*
   2  * Copyright © 2017 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.transportpce.common.mapping;
  10
  11 import com.google.common.util.concurrent.FluentFuture;
  12 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  13 import java.util.ArrayList;
  14 import java.util.Collections;
  15 import java.util.Comparator;
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Optional;
  20 import java.util.concurrent.ExecutionException;
  21 import java.util.stream.Collectors;
  22 import org.eclipse.jdt.annotation.NonNull;
  23 import org.opendaylight.mdsal.binding.api.DataBroker;
  24 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  25 import org.opendaylight.mdsal.common.api.CommitInfo;
  26 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  27 import org.opendaylight.transportpce.common.StringConstants;
  28 import org.opendaylight.transportpce.common.Timeouts;
  29 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  30 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  31 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  32 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.Network;
  33 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.NetworkBuilder;
  34 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.Nodes;
  35 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.NodesBuilder;
  36 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.NodesKey;
  37 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.CpToDegree;
  38 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.CpToDegreeBuilder;
  39 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.CpToDegreeKey;
  40 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.Mapping;
  41 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.MappingBuilder;
  42 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.MappingKey;
  43 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.NodeInfo;
  44 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.NodeInfo.OpenroadmVersion;
  45 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.NodeInfoBuilder;
  46 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.SwitchingPoolLcp;
  47 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.SwitchingPoolLcpBuilder;
  48 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.switching.pool.lcp.NonBlockingList;
  49 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200128.network.nodes.switching.pool.lcp.NonBlockingListBuilder;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.Direction;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PortQual;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.XpdrNodeTypes;
  53 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.CircuitPack;
  54 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.Ports;
  55 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.PortsKey;
  56 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs.CircuitPacks;
  57 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs.CircuitPacksKey;
  58 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.degree.ConnectionPorts;
  59 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface;
  60 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey;
  61 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice;
  62 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.ConnectionMap;
  63 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.Degree;
  64 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.DegreeKey;
  65 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.Info;
  66 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduSwitchingPools;
  67 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.Protocols;
  68 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
  69 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
  70 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.Xponder;
  71 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList;
  72 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.port.Interfaces;
  73 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.xponder.XpdrPort;
  74 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.InterfaceType;
  75 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpenROADMOpticalMultiplex;
  76 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalTransport;
  77 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OtnOdu;
  78 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev181019.Protocols1;
  79 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev181019.lldp.container.Lldp;
  80 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev181019.lldp.container.lldp.PortConfig;
  81 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  82 import org.slf4j.Logger;
  83 import org.slf4j.LoggerFactory;
  84
  85 public class PortMappingVersion221 {
  86     private static final Logger LOG = LoggerFactory.getLogger(PortMappingImpl.class);
  87
  88     private final DataBroker dataBroker;
  89     private final DeviceTransactionManager deviceTransactionManager;
  90     private final OpenRoadmInterfaces openRoadmInterfaces;
  91
  92     public PortMappingVersion221(DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager,
  93         OpenRoadmInterfaces openRoadmInterfaces) {
  94         this.dataBroker = dataBroker;
  95         this.deviceTransactionManager = deviceTransactionManager;
  96         this.openRoadmInterfaces = openRoadmInterfaces;
  97     }
  98
  99     public boolean createMappingData(String nodeId) {
 100         LOG.info("Create Mapping Data for node 2.2.1 {}", nodeId);
 101         List<Mapping> portMapList = new ArrayList<>();
 102         InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
 103         Optional<Info> deviceInfoOptional = this.deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType
 104             .OPERATIONAL, infoIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 105         Info deviceInfo;
 106         NodeInfo nodeInfo;
 107         if (deviceInfoOptional.isPresent()) {
 108             deviceInfo = deviceInfoOptional.get();
 109             nodeInfo = createNodeInfo(deviceInfo);
 110             if (nodeInfo == null) {
 111                 return false;
 112             } else {
 113                 postPortMapping(nodeId, nodeInfo, null, null, null);
 114             }
 115         } else {
 116             LOG.warn("Device info subtree is absent for {}", nodeId);
 117             return false;
 118         }
 119
 120         switch (deviceInfo.getNodeType()) {
 121
 122             case Rdm:
 123                 // Get TTP port mapping
 124                 if (!createTtpPortMapping(nodeId, deviceInfo, portMapList)) {
 125                     // return false if mapping creation for TTP's failed
 126                     LOG.warn("Unable to create mapping for TTP's on node {}", nodeId);
 127                     return false;
 128                 }
 129
 130                 // Get PP port mapping
 131                 if (!createPpPortMapping(nodeId, deviceInfo, portMapList)) {
 132                     // return false if mapping creation for PP's failed
 133                     LOG.warn("Unable to create mapping for PP's on node {}", nodeId);
 134                     return false;
 135                 }
 136                 break;
 137             case Xpdr:
 138                 if (!createXpdrPortMapping(nodeId, portMapList)) {
 139                     LOG.warn("Unable to create mapping for Xponder on node {}", nodeId);
 140                     return false;
 141                 }
 142                 break;
 143             default:
 144                 LOG.error("Unable to create mapping for node {} : unknown nodetype ", nodeId);
 145                 break;
 146
 147         }
 148         return postPortMapping(nodeId, nodeInfo, portMapList, null, null);
 149     }
 150
 151     public boolean updateMapping(String nodeId, Mapping oldMapping) {
 152         InstanceIdentifier<Ports> portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 153             .child(CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName()))
 154             .child(Ports.class, new PortsKey(oldMapping.getSupportingPort()));
 155         if ((oldMapping != null) && (nodeId != null)) {
 156             try {
 157                 Optional<Ports> portObject = deviceTransactionManager.getDataFromDevice(nodeId,
 158                     LogicalDatastoreType.OPERATIONAL, portIId, Timeouts.DEVICE_READ_TIMEOUT,
 159                     Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 160                 if (portObject.isPresent()) {
 161                     Ports port = portObject.get();
 162                     Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(),
 163                         oldMapping.getLogicalConnectionPoint());
 164                     LOG.info("Updating old mapping Data {} for {} of {} by new mapping data {}", oldMapping,
 165                         oldMapping.getLogicalConnectionPoint(), nodeId, newMapping);
 166                     final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
 167                     InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.create(Network.class)
 168                         .child(Nodes.class, new NodesKey(nodeId))
 169                         .child(Mapping.class, new MappingKey(oldMapping.getLogicalConnectionPoint()));
 170                     writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, mapIID, newMapping);
 171                     FluentFuture<? extends @NonNull CommitInfo> commit = writeTransaction.commit();
 172                     commit.get();
 173                     return true;
 174                 }
 175                 return false;
 176             } catch (InterruptedException | ExecutionException e) {
 177                 LOG.error("Error updating Mapping {} for node {}", oldMapping.getLogicalConnectionPoint(), nodeId, e);
 178                 return false;
 179             }
 180         } else {
 181             LOG.error("Impossible to update mapping");
 182             return false;
 183         }
 184     }
 185
 186     private boolean createXpdrPortMapping(String nodeId, List<Mapping> portMapList) {
 187         // Creating for Xponder Line and Client Ports
 188         InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
 189         Optional<OrgOpenroadmDevice> deviceObject = deviceTransactionManager.getDataFromDevice(nodeId,
 190             LogicalDatastoreType.OPERATIONAL, deviceIID,
 191             Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 192         OrgOpenroadmDevice device = null;
 193         if (deviceObject.isPresent()) {
 194             device = deviceObject.get();
 195         } else {
 196             LOG.error("Impossible to get device configuration for node {}", nodeId);
 197             return false;
 198         }
 199         // Variable to keep track of number of line ports
 200         int line = 1;
 201         // Variable to keep track of number of client ports
 202         int client = 1;
 203         Map<String, String> lcpMap = new HashMap<>();
 204         Map<String, Mapping> mappingMap = new HashMap<>();
 205
 206         List<CircuitPacks> circuitPackList = null;
 207         if (device.getCircuitPacks() == null) {
 208             LOG.warn("Circuit Packs are not present for {}", nodeId);
 209             return false;
 210         } else {
 211             circuitPackList = deviceObject.get().getCircuitPacks();
 212             circuitPackList.sort(Comparator.comparing(CircuitPack::getCircuitPackName));
 213         }
 214         if (device.getXponder() == null) {
 215             LOG.warn("{} configuration does not contain a list of xponders", nodeId);
 216             for (CircuitPacks cp : circuitPackList) {
 217                 String circuitPackName = cp.getCircuitPackName();
 218                 if (cp.getPorts() == null) {
 219                     LOG.warn("Ports were not found for circuit pack: {}", circuitPackName);
 220                     continue;
 221                 }
 222                 List<Ports> portList = cp.getPorts();
 223                 portList.sort(Comparator.comparing(Ports::getPortName));
 224                 for (Ports port : portList) {
 225                     if (port.getPortQual() == null) {
 226                         LOG.warn("PortQual was not found for port {} on circuit pack: {}", port.getPortName(),
 227                             circuitPackName);
 228                         continue;
 229                     }
 230                     if (PortQual.XpdrNetwork.getIntValue() == port.getPortQual().getIntValue()
 231                         && port.getPortDirection().getIntValue() == Direction.Bidirectional.getIntValue()) {
 232                         String lcp = "XPDR1-" + StringConstants.NETWORK_TOKEN + line;
 233                         lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
 234                         mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null,
 235                             null, null));
 236                         line++;
 237                     } else if (PortQual.XpdrNetwork.getIntValue() == port.getPortQual().getIntValue()
 238                         && port.getPortDirection().getIntValue() != Direction.Bidirectional.getIntValue()
 239                         && port.getPartnerPort() != null
 240                         && port.getPartnerPort().getCircuitPackName() != null
 241                         && port.getPartnerPort().getPortName() != null) {
 242                         if (lcpMap.containsKey(circuitPackName + '+' + port.getPortName())) {
 243                             continue;
 244                         }
 245                         String lcp1 = "XPDR1-" + StringConstants.NETWORK_TOKEN + line;
 246                         Optional<CircuitPacks> cpOpt = circuitPackList.stream().filter(cP -> cP.getCircuitPackName()
 247                             .equals(port.getPartnerPort().getCircuitPackName())).findFirst();
 248                         if (cpOpt.isPresent()) {
 249                             Optional<Ports> poOpt = cpOpt.get().getPorts().stream().filter(p -> p.getPortName()
 250                                 .equals(port.getPartnerPort().getPortName().toString())).findFirst();
 251                             if (poOpt.isPresent()) {
 252                                 Ports port2 = poOpt.get();
 253                                 if (checkPartnerPort(circuitPackName, port, port2)) {
 254                                     String lcp2 = new StringBuilder("XPDR1-").append(StringConstants.NETWORK_TOKEN)
 255                                         .append(line + 1).toString();
 256                                     if (!lcpMap.containsKey(lcp1) && !lcpMap.containsKey(lcp2)) {
 257                                         lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp1);
 258                                         lcpMap.put(cpOpt.get().getCircuitPackName() + '+' + port2.getPortName(), lcp2);
 259                                         mappingMap.put(lcp1, createXpdrMappingObject(nodeId, port, circuitPackName,
 260                                             lcp1, lcp2, null, null, null));
 261                                         mappingMap.put(lcp2, createXpdrMappingObject(nodeId, port2, cpOpt.get()
 262                                             .getCircuitPackName(), lcp2, lcp1, null, null, null));
 263                                     } else {
 264                                         LOG.warn("mapping already exists for {} or {}", lcp1, lcp2);
 265                                     }
 266                                     line += 2;
 267                                 } else {
 268                                     LOG.error("port {} on {} is not a correct partner port of {} on  {}",
 269                                         port2.getPortName(), cpOpt.get().getCircuitPackName(), port.getPortName(),
 270                                         circuitPackName);
 271                                 }
 272                             } else {
 273                                 LOG.error("Error fetching port {} on {} for {}", port.getPartnerPort().getPortName(),
 274                                     port.getPartnerPort().getCircuitPackName(), nodeId);
 275                             }
 276                         } else {
 277                             LOG.error("Error fetching circuit-pack {} for {}", port.getPartnerPort()
 278                                 .getCircuitPackName(), nodeId);
 279                         }
 280                     } else if (PortQual.XpdrClient.getIntValue() == port.getPortQual().getIntValue()) {
 281                         String lcp = "XPDR1-" + StringConstants.CLIENT_TOKEN + client;
 282                         lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
 283                         mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null,
 284                             null, null));
 285                         client++;
 286                     } else {
 287                         LOG.warn("Error in the configuration of port {} of {} for {}", port.getPortName(),
 288                             circuitPackName,
 289                             nodeId);
 290                     }
 291                 }
 292             }
 293         } else {
 294             LOG.info("{} configuration contains a list of xponders", nodeId);
 295             for (Xponder xponder:deviceObject.get().getXponder()) {
 296                 line = 1;
 297                 client = 1;
 298                 Integer xponderNb = xponder.getXpdrNumber().toJava();
 299                 XpdrNodeTypes xponderType = xponder.getXpdrType();
 300                 for (XpdrPort xpdrPort : xponder.getXpdrPort()) {
 301                     String circuitPackName = xpdrPort.getCircuitPackName();
 302                     String portName = xpdrPort.getPortName().toString();
 303                     Ports port = device.getCircuitPacks().stream().filter(cp -> cp.getCircuitPackName()
 304                         .equals(circuitPackName)).findFirst().get().getPorts().stream().filter(p -> p.getPortName()
 305                         .equals(portName)).findFirst().get();
 306                     if (port.getPortQual() == null) {
 307                         LOG.warn("PortQual was not found for port {} on circuit pack: {}", port.getPortName(),
 308                                 circuitPackName);
 309                         continue;
 310                     }
 311                     if ((PortQual.XpdrNetwork.getIntValue() == port.getPortQual().getIntValue()
 312                         || PortQual.SwitchNetwork.getIntValue() == port.getPortQual().getIntValue())
 313                         && port.getPortDirection().getIntValue() == Direction.Bidirectional.getIntValue()) {
 314                         String lcp = "XPDR" + xponderNb + "-" + StringConstants.NETWORK_TOKEN + line;
 315                         lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
 316                         mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null,
 317                             null, xponderType));
 318                         line++;
 319                     } else if ((PortQual.XpdrNetwork.getIntValue() == port.getPortQual().getIntValue()
 320                         || PortQual.SwitchNetwork.getIntValue() == port.getPortQual().getIntValue())
 321                         && port.getPortDirection().getIntValue() != Direction.Bidirectional.getIntValue()
 322                         && port.getPartnerPort() != null
 323                         && port.getPartnerPort().getCircuitPackName() != null
 324                         && port.getPartnerPort().getPortName() != null) {
 325                         if (lcpMap.containsKey(circuitPackName + '+' + port.getPortName())) {
 326                             continue;
 327                         }
 328                         String lcp1 = "XPDR" + xponderNb + "-" + StringConstants.NETWORK_TOKEN + line;
 329
 330                         Optional<CircuitPacks> cpOpt = circuitPackList.stream().filter(cP -> cP.getCircuitPackName()
 331                             .equals(port.getPartnerPort().getCircuitPackName())).findFirst();
 332                         if (cpOpt.isPresent()) {
 333                             Optional<Ports> poOpt = cpOpt.get().getPorts().stream().filter(p -> p.getPortName().equals(
 334                                 port.getPartnerPort().getPortName().toString())).findFirst();
 335                             if (poOpt.isPresent()) {
 336                                 Ports port2 = poOpt.get();
 337                                 if (checkPartnerPort(circuitPackName, port, port2)) {
 338                                     String lcp2 = new StringBuilder("XPDR").append(xponderNb).append("-").append(
 339                                         StringConstants.NETWORK_TOKEN).append(line + 1).toString();
 340                                     if (!lcpMap.containsKey(lcp1) && !lcpMap.containsKey(lcp2)) {
 341                                         lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp1);
 342                                         lcpMap.put(cpOpt.get().getCircuitPackName() + '+' + port2.getPortName(), lcp2);
 343                                         mappingMap.put(lcp1, createXpdrMappingObject(nodeId, port, circuitPackName,
 344                                             lcp1, lcp2, null, null, xponderType));
 345                                         mappingMap.put(lcp2, createXpdrMappingObject(nodeId, port2, cpOpt.get()
 346                                             .getCircuitPackName(), lcp2, lcp1, null, null, xponderType));
 347                                     } else {
 348                                         LOG.warn("mapping already exists for {} or {}", lcp1, lcp2);
 349                                     }
 350                                     line += 2;
 351                                 } else {
 352                                     LOG.error("port {} on {} is not a correct partner port of {} on  {}", port2
 353                                         .getPortName(), cpOpt.get().getCircuitPackName(), port.getPortName(),
 354                                         circuitPackName);
 355                                 }
 356                             } else {
 357                                 LOG.error("Error fetching port {} on {} for {}", port.getPartnerPort().getPortName(),
 358                                     port.getPartnerPort().getCircuitPackName(), nodeId);
 359                             }
 360                         } else {
 361                             LOG.error("Error fetching circuit-pack {} for {}", port.getPartnerPort()
 362                                 .getCircuitPackName(), nodeId);
 363                         }
 364                     } else if (PortQual.XpdrClient.getIntValue() == port.getPortQual().getIntValue()
 365                         || PortQual.SwitchClient.getIntValue() == port.getPortQual().getIntValue()) {
 366                         String lcp = "XPDR" + xponderNb + "-" + StringConstants.CLIENT_TOKEN + client;
 367                         lcpMap.put(circuitPackName + '+' + port.getPortName(), lcp);
 368                         mappingMap.put(lcp, createXpdrMappingObject(nodeId, port, circuitPackName, lcp, null, null,
 369                             null, null));
 370                         client++;
 371                     } else {
 372                         LOG.warn("Error in the configuration of port {} of {} for {}", port.getPortName(),
 373                             circuitPackName, nodeId);
 374                     }
 375                 }
 376             }
 377         }
 378
 379         if (device.getConnectionMap() != null) {
 380             List<ConnectionMap> connectionMap = deviceObject.get().getConnectionMap();
 381             String slcp = null;
 382             String dlcp = null;
 383             for (ConnectionMap cm : connectionMap) {
 384                 String skey = cm.getSource().getCircuitPackName() + "+" + cm.getSource().getPortName();
 385                 if (lcpMap.containsKey(skey)) {
 386                     slcp = lcpMap.get(skey);
 387                 }
 388                 String dkey = cm.getDestination().get(0).getCircuitPackName() + "+"
 389                     + cm.getDestination().get(0).getPortName();
 390                 if (lcpMap.containsKey(dkey)) {
 391                     dlcp = lcpMap.get(dkey);
 392                 }
 393                 if (slcp != null) {
 394                     Mapping mapping = mappingMap.get(slcp);
 395                     mappingMap.remove(slcp);
 396                     portMapList.add(createXpdrMappingObject(nodeId, null, null, null, null, mapping, dlcp, null));
 397                 } else {
 398                     LOG.error("Error in connection-map analysis");
 399                 }
 400             }
 401         } else {
 402             LOG.warn("No connection-map inside device configuration");
 403         }
 404         if (device.getOduSwitchingPools() != null) {
 405             List<OduSwitchingPools> oduSwithcingPools = device.getOduSwitchingPools();
 406             List<SwitchingPoolLcp> switchingPoolList = new ArrayList<>();
 407             for (OduSwitchingPools odp : oduSwithcingPools) {
 408                 List<NonBlockingList> nblList = new ArrayList<>();
 409                 for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org
 410                     .openroadm.device.odu.switching.pools.NonBlockingList nbl : odp.getNonBlockingList()) {
 411                     List<String> lcpList = new ArrayList<>();
 412                     if (nbl.getPortList() != null) {
 413                         for (PortList item : nbl.getPortList()) {
 414                             String key = item.getCircuitPackName() + "+" + item.getPortName();
 415                             if (lcpMap.containsKey(key)) {
 416                                 lcpList.add(lcpMap.get(key));
 417                             } else {
 418                                 LOG.error("error : port {} of {} is not associated to a logical connection point",
 419                                     item.getPortName(), item.getCircuitPackName());
 420                             }
 421                         }
 422                         NonBlockingList nonBlockingList = new NonBlockingListBuilder()
 423                             .setNblNumber(nbl.getNblNumber())
 424                             .setInterconnectBandwidth(nbl.getInterconnectBandwidth())
 425                             .setInterconnectBandwidthUnit(nbl.getInterconnectBandwidthUnit())
 426                             .setLcpList(lcpList)
 427                             .build();
 428                         nblList.add(nonBlockingList);
 429                     }
 430                 }
 431                 SwitchingPoolLcp splBldr = new SwitchingPoolLcpBuilder()
 432                     .setSwitchingPoolNumber(odp.getSwitchingPoolNumber())
 433                     .setSwitchingPoolType(odp.getSwitchingPoolType())
 434                     .setNonBlockingList(nblList)
 435                     .build();
 436                 switchingPoolList.add(splBldr);
 437             }
 438             postPortMapping(nodeId, null, null, null, switchingPoolList);
 439         }
 440
 441         if (!mappingMap.isEmpty()) {
 442             mappingMap.forEach((k,v) -> portMapList.add(v));
 443         }
 444         return true;
 445     }
 446
 447     private boolean checkPartnerPort(String circuitPackName, Ports port1, Ports port2) {
 448         if ((Direction.Rx.getIntValue() == port1.getPortDirection().getIntValue()
 449             && Direction.Tx.getIntValue() == port2.getPortDirection().getIntValue()
 450             && port2.getPartnerPort() != null
 451             && port2.getPartnerPort().getCircuitPackName() != null
 452             && port2.getPartnerPort().getPortName() != null
 453             && port2.getPartnerPort().getCircuitPackName().equals(circuitPackName)
 454             && port2.getPartnerPort().getPortName().equals(port1.getPortName()))
 455             ||
 456             (Direction.Tx.getIntValue() == port1.getPortDirection().getIntValue()
 457             && Direction.Rx.getIntValue() == port2.getPortDirection().getIntValue()
 458             && port2.getPartnerPort() != null
 459             && port2.getPartnerPort().getCircuitPackName() != null
 460             && port2.getPartnerPort().getPortName() != null
 461             && port2.getPartnerPort().getCircuitPackName().equals(circuitPackName)
 462             && port2.getPartnerPort().getPortName().equals(port1.getPortName()))) {
 463             return true;
 464         } else {
 465             return false;
 466         }
 467     }
 468
 469     private HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg
 470         .CircuitPacks>> getSrgCps(String deviceId, Info ordmInfo) {
 471         HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg
 472             .CircuitPacks>> cpPerSrg = new HashMap<>();
 473         Integer maxSrg;
 474         // Get value for max Srg from info subtree, required for iteration
 475         // if not present assume to be 20 (temporary)
 476         if (ordmInfo.getMaxSrgs() != null) {
 477             maxSrg = ordmInfo.getMaxSrgs().toJava();
 478         } else {
 479             maxSrg = 20;
 480         }
 481         for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
 482             List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks> srgCps
 483                 = new ArrayList<>();
 484             LOG.info("Getting Circuitpacks for Srg Number {}", srgCounter);
 485             InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 486                 .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
 487             Optional<SharedRiskGroup> ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
 488                 LogicalDatastoreType.OPERATIONAL, srgIID,
 489                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 490             if (ordmSrgObject.isPresent()) {
 491                 srgCps.addAll(ordmSrgObject.get().getCircuitPacks());
 492                 cpPerSrg.put(ordmSrgObject.get().getSrgNumber().toJava(), srgCps);
 493             }
 494         }
 495         LOG.info("Device {} has {} Srg", deviceId, cpPerSrg.size());
 496         return cpPerSrg;
 497     }
 498
 499     //last LOG info message in this method is too long
 500     @SuppressWarnings("checkstyle:linelength")
 501     private boolean createPpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
 502         // Creating mapping data for SRG's PP
 503         HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks>> srgCps
 504             = getSrgCps(nodeId, deviceInfo);
 505
 506         for (Integer k : srgCps.keySet()) {
 507             List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks> cpList =
 508                 srgCps.get(k);
 509             List<String> keys = new ArrayList<>();
 510             for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks cp : cpList) {
 511                 String circuitPackName = cp.getCircuitPackName();
 512                 InstanceIdentifier<CircuitPacks> cpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 513                     .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName));
 514                 Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 515                     LogicalDatastoreType.OPERATIONAL, cpIID,
 516                     Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 517
 518                 if (!circuitPackObject.isPresent() || (circuitPackObject.get().getPorts() == null)) {
 519                     LOG.warn("{} : Circuit pack {} not found or without ports.", nodeId, circuitPackName);
 520                     continue;
 521                 }
 522                 List<Ports> portList = circuitPackObject.get().getPorts();
 523                 Collections.sort(portList, new SortPort221ByName());
 524                 int portIndex = 1;
 525                 for (Ports port : portList) {
 526                     String currentKey = circuitPackName + "-" + port.getPortName();
 527                     if (port.getPortQual() == null) {
 528                         continue;
 529                     } else if (PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue()
 530                         && Direction.Bidirectional.getIntValue() == port.getPortDirection().getIntValue()
 531                         && !keys.contains(currentKey)) {
 532                         String logicalConnectionPoint = createLogicalConnectionPort(port, k, portIndex);
 533                         LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName,
 534                             port.getPortName(), logicalConnectionPoint);
 535                         portMapList.add(createMappingObject(nodeId, port, circuitPackName, logicalConnectionPoint));
 536                         portIndex++;
 537                         keys.add(currentKey);
 538                     } else if (PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue()
 539                         && (Direction.Rx.getIntValue() == port.getPortDirection().getIntValue()
 540                         || Direction.Tx.getIntValue() == port.getPortDirection().getIntValue())
 541                         && !keys.contains(currentKey)
 542                         && port.getPartnerPort() != null) {
 543                         String logicalConnectionPoint1 = createLogicalConnectionPort(port, k, portIndex);
 544                         LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName,
 545                             port.getPortName(), logicalConnectionPoint1);
 546                         InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 547                             .child(CircuitPacks.class, new CircuitPacksKey(port.getPartnerPort().getCircuitPackName()))
 548                             .child(Ports.class, new PortsKey(port.getPartnerPort().getPortName().toString()));
 549                         Optional<Ports> port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
 550                             LogicalDatastoreType.OPERATIONAL, port2ID,
 551                             Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 552                         if (port2Object.isPresent()
 553                             && port2Object.get().getPortQual().getIntValue()
 554                                 == PortQual.RoadmExternal.getIntValue()) {
 555                             Ports port2 = port2Object.get();
 556                             if (checkPartnerPort(circuitPackName, port, port2)) {
 557                                 String logicalConnectionPoint2 = createLogicalConnectionPort(port2, k, portIndex);
 558                                 LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName,
 559                                     port2.getPortName(), logicalConnectionPoint2);
 560                                 portMapList.add(createMappingObject(nodeId, port, circuitPackName,
 561                                     logicalConnectionPoint1));
 562                                 portMapList.add(createMappingObject(nodeId,port2,
 563                                     port.getPartnerPort().getCircuitPackName(), logicalConnectionPoint2));
 564                                 portIndex++;
 565                                 keys.add(currentKey);
 566                                 keys.add(port.getPartnerPort().getCircuitPackName() + "-" + port2.getPortName());
 567                             } else {
 568                                 LOG.error("Error with partner port configuration for port {} of  {} - {}",
 569                                     port.getPortName(), circuitPackName, nodeId);
 570                                 portIndex++;
 571                             }
 572                         } else {
 573                             LOG.error("error getting partner port {} of  {} - {}",
 574                                 port.getPartnerPort().getPortName().toString(),
 575                                 port.getPartnerPort().getCircuitPackName(), nodeId);
 576                             continue;
 577                         }
 578                     } else {
 579                         LOG.info("{} : port {} on {} is not roadm-external or has already been handled. No logicalConnectionPoint assignment for this port.",
 580                             nodeId, port.getPortName(), circuitPackName);
 581                     }
 582                 }
 583             }
 584         }
 585         return true;
 586     }
 587
 588     private String createLogicalConnectionPort(Ports port, int index, int portIndex) {
 589         String lcp = null;
 590         switch (port.getPortDirection()) {
 591             case Tx:
 592                 lcp = "SRG" + index + "-PP" + portIndex + "-TX";
 593                 break;
 594             case Rx:
 595                 lcp = "SRG" + index + "-PP" + portIndex + "-RX";
 596                 break;
 597             case Bidirectional:
 598                 lcp = "SRG" + index + "-PP" + portIndex + "-TXRX";
 599                 break;
 600             default:
 601                 LOG.error("Unsupported port direction for port {} : {}", port, port.getPortDirection());
 602         }
 603         return lcp;
 604     }
 605
 606     private List<Degree> getDegrees(String deviceId, Info ordmInfo) {
 607         List<Degree> degrees = new ArrayList<>();
 608         Integer maxDegree;
 609
 610         // Get value for max degree from info subtree, required for iteration
 611         // if not present assume to be 20 (temporary)
 612         if (ordmInfo.getMaxDegrees() != null) {
 613             maxDegree = ordmInfo.getMaxDegrees().toJava();
 614         } else {
 615             maxDegree = 20;
 616         }
 617
 618         for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
 619             LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
 620             InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 621                 .child(Degree.class, new DegreeKey(degreeCounter));
 622             Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
 623                 LogicalDatastoreType.OPERATIONAL, deviceIID,
 624                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 625             if (ordmDegreeObject.isPresent()) {
 626                 degrees.add(ordmDegreeObject.get());
 627             }
 628         }
 629         LOG.info("Device {} has {} degree", deviceId, degrees.size());
 630         return degrees;
 631     }
 632
 633     private Map<Integer, List<ConnectionPorts>> getPerDegreePorts(String deviceId, Info ordmInfo) {
 634         Map<Integer, List<ConnectionPorts>> conPortMap = new HashMap<>();
 635         Integer maxDegree;
 636
 637         if (ordmInfo.getMaxDegrees() != null) {
 638             maxDegree = ordmInfo.getMaxDegrees().toJava();
 639         } else {
 640             maxDegree = 20;
 641         }
 642         for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
 643             LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
 644             InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 645                 .child(Degree.class, new DegreeKey(degreeCounter));
 646             Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
 647                 LogicalDatastoreType.OPERATIONAL, deviceIID,
 648                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 649             if (ordmDegreeObject.isPresent()) {
 650                 conPortMap.put(degreeCounter, ordmDegreeObject.get().getConnectionPorts());
 651             }
 652         }
 653         LOG.info("Device {} has {} degree", deviceId, conPortMap.size());
 654         return conPortMap;
 655     }
 656
 657     private Map<String, String> getEthInterfaceList(String nodeId) {
 658         LOG.info("It is calling get ethernet interface");
 659         Map<String, String> cpToInterfaceMap = new HashMap<>();
 660         InstanceIdentifier<Protocols> protocoliid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 661             .child(Protocols.class);
 662         Optional<Protocols> protocolObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 663             LogicalDatastoreType.OPERATIONAL, protocoliid, Timeouts.DEVICE_READ_TIMEOUT,
 664             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 665         if (protocolObject.isPresent() && protocolObject.get().augmentation(Protocols1.class).getLldp() != null) {
 666             Lldp lldp = protocolObject.get().augmentation(Protocols1.class).getLldp();
 667             for (PortConfig portConfig : lldp.getPortConfig()) {
 668                 if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) {
 669                     InstanceIdentifier<Interface> interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 670                         .child(Interface.class, new InterfaceKey(portConfig.getIfName()));
 671                     Optional<Interface> interfaceObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 672                         LogicalDatastoreType.OPERATIONAL, interfaceIID, Timeouts.DEVICE_READ_TIMEOUT,
 673                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 674                     if (interfaceObject.isPresent() && (interfaceObject.get().getSupportingCircuitPackName() != null)) {
 675                         String supportingCircuitPackName = interfaceObject.get().getSupportingCircuitPackName();
 676                         cpToInterfaceMap.put(supportingCircuitPackName, portConfig.getIfName());
 677                         InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier
 678                             .create(OrgOpenroadmDevice.class)
 679                             .child(CircuitPacks.class, new CircuitPacksKey(supportingCircuitPackName));
 680                         Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(
 681                             nodeId, LogicalDatastoreType.OPERATIONAL, circuitPacksIID, Timeouts.DEVICE_READ_TIMEOUT,
 682                             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 683                         if (circuitPackObject.isPresent() && (circuitPackObject.get().getParentCircuitPack() != null)) {
 684                             cpToInterfaceMap.put(circuitPackObject.get().getParentCircuitPack().getCircuitPackName(),
 685                                 portConfig.getIfName());
 686                         }
 687                     }
 688                 }
 689             }
 690         } else {
 691             LOG.warn("Couldnt find port config under LLDP for Node : {}", nodeId);
 692         }
 693         LOG.info("Processiong is done.. now returning..");
 694         return cpToInterfaceMap;
 695     }
 696
 697     private List<CpToDegree> getCpToDegreeList(List<Degree> degrees, String nodeId,
 698         Map<String, String> interfaceList) {
 699         List<CpToDegree> cpToDegreeList = new ArrayList<>();
 700         for (Degree degree : degrees) {
 701             if (degree.getCircuitPacks() != null) {
 702                 LOG.info("Inside CP to degree list");
 703                 cpToDegreeList.addAll(degree.getCircuitPacks().stream()
 704                     .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(),
 705                         degree.getDegreeNumber().toString(), nodeId, interfaceList))
 706                     .collect(Collectors.toList()));
 707             }
 708         }
 709         return cpToDegreeList;
 710     }
 711
 712     private boolean postPortMapping(String nodeId, NodeInfo nodeInfo, List<Mapping> portMapList,
 713         List<CpToDegree> cp2DegreeList, List<SwitchingPoolLcp> splList) {
 714         NodesBuilder nodesBldr = new NodesBuilder().withKey(new NodesKey(nodeId)).setNodeId(nodeId);
 715         if (nodeInfo != null) {
 716             nodesBldr.setNodeInfo(nodeInfo);
 717         }
 718         if (portMapList != null) {
 719             nodesBldr.setMapping(portMapList);
 720         }
 721         if (cp2DegreeList != null) {
 722             nodesBldr.setCpToDegree(cp2DegreeList);
 723         }
 724         if (splList != null) {
 725             nodesBldr.setSwitchingPoolLcp(splList);
 726         }
 727         List<Nodes> nodesList = new ArrayList<>();
 728         nodesList.add(nodesBldr.build());
 729
 730         NetworkBuilder nwBldr = new NetworkBuilder().setNodes(nodesList);
 731
 732         final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
 733         InstanceIdentifier<Network> nodesIID = InstanceIdentifier.builder(Network.class).build();
 734         Network network = nwBldr.build();
 735         writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, nodesIID, network);
 736         FluentFuture<? extends @NonNull CommitInfo> commit = writeTransaction.commit();
 737         try {
 738             commit.get();
 739             return true;
 740         } catch (InterruptedException | ExecutionException e) {
 741             LOG.warn("Failed to post {}", network, e);
 742             return false;
 743         }
 744     }
 745
 746     private CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber, String nodeId,
 747         Map<String, String> interfaceList) {
 748         String interfaceName = null;
 749         if (interfaceList.get(circuitPackName) != null) {
 750             interfaceName = interfaceList.get(circuitPackName);
 751         }
 752         return new CpToDegreeBuilder().withKey(new CpToDegreeKey(circuitPackName)).setCircuitPackName(circuitPackName)
 753             .setDegreeNumber(Long.valueOf(degreeNumber)).setInterfaceName(interfaceName).build();
 754     }
 755
 756     private Mapping createMappingObject(String nodeId, Ports port, String circuitPackName,
 757         String logicalConnectionPoint) {
 758         MappingBuilder mpBldr = new MappingBuilder();
 759         mpBldr.withKey(new MappingKey(logicalConnectionPoint)).setLogicalConnectionPoint(logicalConnectionPoint)
 760             .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName())
 761             .setPortDirection(port.getPortDirection().getName());
 762
 763         // Get OMS and OTS interface provisioned on the TTP's
 764         if ((logicalConnectionPoint.contains(StringConstants.TTP_TOKEN)
 765             || logicalConnectionPoint.contains(StringConstants.NETWORK_TOKEN)) && (port.getInterfaces() != null)) {
 766             for (Interfaces interfaces : port.getInterfaces()) {
 767                 try {
 768                     Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
 769                         interfaces.getInterfaceName());
 770                     if (openRoadmInterface.isPresent()) {
 771                         LOG.info("interface get from device is {} and of type {}", openRoadmInterface.get().getName(),
 772                             openRoadmInterface.get().getType());
 773                         Class<? extends InterfaceType> interfaceType
 774                             = (Class<? extends InterfaceType>) openRoadmInterface.get().getType();
 775                         // Check if interface type is OMS or OTS
 776                         if (interfaceType.equals(OpenROADMOpticalMultiplex.class)) {
 777                             mpBldr.setSupportingOms(interfaces.getInterfaceName());
 778                         }
 779                         if (interfaceType.equals(OpticalTransport.class)) {
 780                             mpBldr.setSupportingOts(interfaces.getInterfaceName());
 781                         }
 782                         if (interfaceType.equals(OtnOdu.class)) {
 783                             mpBldr.setSupportingOdu4(interfaces.getInterfaceName());
 784                         }
 785                     } else {
 786                         LOG.warn("Interface {} from node {} was null!", interfaces.getInterfaceName(), nodeId);
 787                     }
 788                 } catch (OpenRoadmInterfaceException ex) {
 789                     LOG.warn("Error while getting interface {} from node {}!", interfaces.getInterfaceName(), nodeId,
 790                         ex);
 791                 }
 792             }
 793         }
 794         return mpBldr.build();
 795     }
 796
 797     private Mapping createXpdrMappingObject(String nodeId, Ports port, String circuitPackName,
 798             String logicalConnectionPoint, String partnerLcp, Mapping mapping, String connectionMapLcp,
 799             XpdrNodeTypes xpdrNodeType) {
 800         MappingBuilder mpBldr;
 801         if (mapping != null && connectionMapLcp != null) {
 802             // update existing mapping
 803             mpBldr = new MappingBuilder(mapping).setConnectionMapLcp(connectionMapLcp);
 804         } else {
 805             // create a new mapping
 806             mpBldr = new MappingBuilder()
 807                 .withKey(new MappingKey(logicalConnectionPoint))
 808                 .setLogicalConnectionPoint(logicalConnectionPoint)
 809                 .setSupportingCircuitPackName(circuitPackName)
 810                 .setSupportingPort(port.getPortName())
 811                 .setPortDirection(port.getPortDirection().getName());
 812             if (port.getPortQual() != null) {
 813                 mpBldr.setPortQual(port.getPortQual().getName());
 814             }
 815             if (port.getSupportedInterfaceCapability() != null) {
 816                 mpBldr.setSupportedInterfaceCapability(port.getSupportedInterfaceCapability());
 817             }
 818             if (xpdrNodeType != null) {
 819                 mpBldr.setXponderType(xpdrNodeType);
 820             }
 821             if (partnerLcp != null) {
 822                 mpBldr.setPartnerLcp(partnerLcp);
 823             }
 824         }
 825         return mpBldr.build();
 826     }
 827
 828     //some LOG messages are too long
 829     @SuppressWarnings("checkstyle:linelength")
 830     @SuppressFBWarnings("DM_CONVERT_CASE")
 831     private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
 832         // Creating mapping data for degree TTP's
 833         List<Degree> degrees = getDegrees(nodeId, deviceInfo);
 834         Map<String, String> interfaceList = getEthInterfaceList(nodeId);
 835         List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, nodeId, interfaceList);
 836         LOG.info("Map looks like this {}", interfaceList);
 837         postPortMapping(nodeId, null, null, cpToDegreeList, null);
 838
 839         Map<Integer, List<ConnectionPorts>> connectionPortMap = getPerDegreePorts(nodeId, deviceInfo);
 840         for (Integer k : connectionPortMap.keySet()) {
 841             switch (connectionPortMap.get(k).size()) {
 842                 case 1:
 843                     // port is bidirectional
 844                     InstanceIdentifier<Ports> portID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 845                         .child(CircuitPacks.class, new CircuitPacksKey(connectionPortMap.get(k).get(0)
 846                             .getCircuitPackName()))
 847                         .child(Ports.class, new PortsKey(connectionPortMap.get(k).get(0)
 848                             .getPortName().toString()));
 849                     LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap.get(k).get(0)
 850                         .getPortName().toString(), connectionPortMap.get(k).get(0).getCircuitPackName());
 851                     Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 852                         LogicalDatastoreType.OPERATIONAL, portID, Timeouts.DEVICE_READ_TIMEOUT,
 853                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 854                     if (portObject.isPresent()) {
 855                         Ports port = portObject.get();
 856                         if (port.getPortQual() == null) {
 857                             continue;
 858                         } else if (PortQual.RoadmExternal.getIntValue() == port.getPortQual().getIntValue()
 859                             && Direction.Bidirectional.getIntValue() == port.getPortDirection().getIntValue()) {
 860                             String logicalConnectionPoint = new StringBuilder("DEG").append(k).append("-TTP-TXRX")
 861                                 .toString();
 862                             LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
 863                                 connectionPortMap.get(k).get(0).getCircuitPackName(), port.getPortName(),
 864                                 logicalConnectionPoint);
 865                             portMapList.add(createMappingObject(nodeId, port,
 866                                 connectionPortMap.get(k).get(0).getCircuitPackName(), logicalConnectionPoint));
 867                         } else {
 868                             LOG.error(
 869                                 "Impossible to create logical connection point for port {} of {} on node {}"
 870                                 + "- Error in configuration with port-qual or port-direction",
 871                                 port.getPortName(), connectionPortMap.get(k).get(0).getCircuitPackName(), nodeId);
 872                         }
 873                     } else {
 874                         LOG.error("No port {} on circuit pack {} for node {}",
 875                             connectionPortMap.get(k).get(0).getPortName().toString(),
 876                             connectionPortMap.get(k).get(0).getCircuitPackName(), nodeId);
 877                         return false;
 878                     }
 879                     break;
 880                 case 2:
 881                     // ports are unidirectionals
 882                     String cp1Name = connectionPortMap.get(k).get(0).getCircuitPackName();
 883                     String cp2Name = connectionPortMap.get(k).get(1).getCircuitPackName();
 884                     InstanceIdentifier<Ports> port1ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 885                         .child(CircuitPacks.class, new CircuitPacksKey(cp1Name))
 886                         .child(Ports.class, new PortsKey(connectionPortMap.get(k).get(0).getPortName().toString()));
 887                     LOG.info("Fetching connection-port {} at circuit pack {}", connectionPortMap.get(k).get(0)
 888                         .getPortName().toString(), cp1Name);
 889                     Optional<Ports> port1Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
 890                         LogicalDatastoreType.OPERATIONAL, port1ID, Timeouts.DEVICE_READ_TIMEOUT,
 891                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 892                     InstanceIdentifier<Ports> port2ID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 893                         .child(CircuitPacks.class, new CircuitPacksKey(cp2Name))
 894                         .child(Ports.class, new PortsKey(connectionPortMap.get(k).get(1).getPortName().toString()));
 895                     LOG.info("Fetching connection-port {} at circuit pack {}",
 896                         connectionPortMap.get(k).get(1).getPortName().toString(), cp2Name);
 897                     Optional<Ports> port2Object = this.deviceTransactionManager.getDataFromDevice(nodeId,
 898                         LogicalDatastoreType.OPERATIONAL, port2ID, Timeouts.DEVICE_READ_TIMEOUT,
 899                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 900                     if (port1Object.isPresent() && port2Object.isPresent()) {
 901                         Ports port1 = port1Object.get();
 902                         Ports port2 = port2Object.get();
 903                         if (port1.getPortQual() == null || port2.getPortQual() == null) {
 904                             continue;
 905                         } else if ((PortQual.RoadmExternal.getIntValue() == port1.getPortQual().getIntValue()
 906                                 && PortQual.RoadmExternal.getIntValue() == port2.getPortQual().getIntValue()
 907                                 && Direction.Rx.getIntValue() == port1.getPortDirection().getIntValue()
 908                                 && Direction.Tx.getIntValue() == port2.getPortDirection().getIntValue()
 909                                 && port1.getPartnerPort() != null && port2.getPartnerPort() != null
 910                                 && port1.getPartnerPort().getCircuitPackName().equals(cp2Name)
 911                                 && port1.getPartnerPort().getPortName().equals(port2.getPortName())
 912                                 && port2.getPartnerPort().getCircuitPackName().equals(cp1Name)
 913                                 && port2.getPartnerPort().getPortName().equals(port1.getPortName()))
 914                                 ||
 915                                 (PortQual.RoadmExternal.getIntValue() == port1.getPortQual().getIntValue()
 916                                 && PortQual.RoadmExternal.getIntValue() == port2.getPortQual().getIntValue()
 917                                 && Direction.Rx.getIntValue() == port2.getPortDirection().getIntValue()
 918                                 && Direction.Tx.getIntValue() == port1.getPortDirection().getIntValue()
 919                                 && port1.getPartnerPort() != null && port2.getPartnerPort() != null
 920                                 && port1.getPartnerPort().getCircuitPackName().equals(cp2Name)
 921                                 && port1.getPartnerPort().getPortName().equals(port2.getPortName())
 922                                 && port2.getPartnerPort().getCircuitPackName().equals(cp1Name)
 923                                 && port2.getPartnerPort().getPortName().equals(port1.getPortName()))) {
 924                             String logicalConnectionPoint1 = new StringBuilder("DEG").append(k).append("-TTP-")
 925                                 .append(port1.getPortDirection().getName().toUpperCase()).toString();
 926                             LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
 927                                 connectionPortMap.get(k).get(0).getCircuitPackName(), port1.getPortName(),
 928                                 logicalConnectionPoint1);
 929                             portMapList.add(createMappingObject(nodeId, port1, connectionPortMap.get(k).get(0)
 930                                 .getCircuitPackName(), logicalConnectionPoint1));
 931                             String logicalConnectionPoint2 = new StringBuilder("DEG").append(k).append("-TTP-")
 932                                 .append(port2.getPortDirection().getName().toUpperCase()).toString();
 933                             LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId,
 934                                 connectionPortMap.get(k).get(1).getCircuitPackName(), port2.getPortName(),
 935                                 logicalConnectionPoint2);
 936                             portMapList.add(createMappingObject(nodeId, port2, connectionPortMap.get(k).get(1)
 937                                 .getCircuitPackName(), logicalConnectionPoint2));
 938                         } else {
 939                             LOG.error(
 940                                 "impossible to create logical connection point for port {} or port {} on node {} - "
 941                                 + "Error in configuration with port-qual, port-direction or partner-port configuration",
 942                                 port1.getPortName(), port2.getPortName(), nodeId);
 943                         }
 944                     } else {
 945                         LOG.error("No port {} on circuit pack {} for node {}",
 946                             connectionPortMap.get(k).get(0).getPortName().toString(),
 947                             connectionPortMap.get(k).get(0).getCircuitPackName(), nodeId);
 948                         return false;
 949                     }
 950
 951                     break;
 952                 default:
 953                     LOG.error("Number of connection port for DEG{} on {} is incorrect", k, nodeId);
 954                     continue;
 955             }
 956         }
 957         return true;
 958     }
 959
 960     private NodeInfo createNodeInfo(Info deviceInfo) {
 961         NodeInfoBuilder nodeInfoBldr = new NodeInfoBuilder();
 962         if (deviceInfo.getNodeType() != null) {
 963             nodeInfoBldr = new NodeInfoBuilder()
 964                 .setOpenroadmVersion(OpenroadmVersion._221)
 965                 .setNodeType(deviceInfo.getNodeType());
 966             if (deviceInfo.getClli() != null && !deviceInfo.getClli().isEmpty()) {
 967                 nodeInfoBldr.setNodeClli(deviceInfo.getClli());
 968             } else {
 969                 nodeInfoBldr.setNodeClli("defaultCLLI");
 970             }
 971             if (deviceInfo.getModel() != null) {
 972                 nodeInfoBldr.setNodeModel(deviceInfo.getModel());
 973             }
 974             if (deviceInfo.getVendor() != null) {
 975                 nodeInfoBldr.setNodeVendor(deviceInfo.getVendor());
 976             }
 977             if (deviceInfo.getIpAddress() != null) {
 978                 nodeInfoBldr.setNodeIpAddress(deviceInfo.getIpAddress());
 979             }
 980         } else {
 981          // TODO make mandatory in yang
 982             LOG.error("Node type field is missing");
 983             return null;
 984         }
 985         return nodeInfoBldr.build();
 986     }
 987
 988 }