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

   1 /*
   2  * Copyright © 2017 AT&T 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 package org.opendaylight.transportpce.common.mapping;
   9 import com.google.common.util.concurrent.CheckedFuture;
  10
  11 import java.util.ArrayList;
  12 import java.util.Comparator;
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Optional;
  17 import java.util.Set;
  18 import java.util.stream.Collectors;
  19
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  24 import org.opendaylight.transportpce.common.StringConstants;
  25 import org.opendaylight.transportpce.common.Timeouts;
  26 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  27 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  28 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  29 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.Network;
  30 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.NetworkBuilder;
  31 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.Nodes;
  32 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.NodesBuilder;
  33 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.NodesKey;
  34 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.CpToDegree;
  35 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.CpToDegreeBuilder;
  36 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.CpToDegreeKey;
  37 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.Mapping;
  38 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.MappingBuilder;
  39 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.MappingKey;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.CircuitPack;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.Port;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.Ports;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.PortsKey;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacks;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPorts;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Degree;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeKey;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Info;
  53 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Protocols;
  54 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
  55 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
  56 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces;
  57 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.InterfaceType;
  58 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpenROADMOpticalMultiplex;
  59 import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.OpticalTransport;
  60 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.Protocols1;
  61 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.Lldp;
  62 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfig;
  63
  64 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  65 import org.slf4j.Logger;
  66 import org.slf4j.LoggerFactory;
  67
  68
  69
  70 public class PortMappingVersion121 {
  71
  72     private static final Logger LOG = LoggerFactory.getLogger(PortMappingImpl.class);
  73
  74     private final DataBroker dataBroker;
  75     private final DeviceTransactionManager deviceTransactionManager;
  76     private final OpenRoadmInterfaces openRoadmInterfaces;
  77
  78     public PortMappingVersion121(DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager,
  79                                   OpenRoadmInterfaces openRoadmInterfaces) {
  80         this.dataBroker = dataBroker;
  81         this.deviceTransactionManager = deviceTransactionManager;
  82         this.openRoadmInterfaces = openRoadmInterfaces;
  83     }
  84
  85     public boolean createMappingData(String nodeId) {
  86
  87         LOG.info("Create Mapping Data for node 1.2.1 {}", nodeId);
  88         List<Mapping> portMapList = new ArrayList<>();
  89         InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
  90         Optional<Info> deviceInfoOptional = this.deviceTransactionManager.getDataFromDevice(nodeId,
  91             LogicalDatastoreType.OPERATIONAL, infoIID,Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
  92
  93         Info deviceInfo;
  94         if (deviceInfoOptional.isPresent()) {
  95             deviceInfo = deviceInfoOptional.get();
  96         } else {
  97             LOG.warn("Device info subtree is absent for {}", nodeId);
  98             return false;
  99         }
 100         if (deviceInfo.getNodeType() == null) {
 101             LOG.error("Node type field is missing"); // TODO make mandatory in yang
 102             return false;
 103         }
 104         switch (deviceInfo.getNodeType()) {
 105
 106             case Rdm:
 107                 // Get TTP port mapping
 108                 if (!createTtpPortMapping(nodeId, deviceInfo, portMapList)) {
 109                     // return false if mapping creation for TTP's failed
 110                     LOG.warn("Unable to create mapping for TTP's on node {}", nodeId);
 111                     return false;
 112                 }
 113
 114                 // Get PP port mapping
 115                 if (!createPpPortMapping(nodeId, deviceInfo, portMapList)) {
 116                     // return false if mapping creation for PP's failed
 117                     LOG.warn("Unable to create mapping for PP's on node {}", nodeId);
 118                     return false;
 119                 }
 120                 break;
 121             case Xpdr:
 122                 if (!createXpdrPortMapping(nodeId, portMapList)) {
 123                     LOG.warn("Unable to create mapping for Xponder on node {}", nodeId);
 124                     return false;
 125                 }
 126                 break;
 127             default:
 128                 LOG.error("Unable to create mapping for node {} : unknown nodetype ", nodeId);
 129                 break;
 130
 131         }
 132         return postPortMapping(deviceInfo, portMapList, deviceInfo.getNodeType().getIntValue(), null);
 133     }
 134
 135     private boolean postPortMapping(Info deviceInfo, List<Mapping> portMapList, Integer nodeType,
 136                                     List<CpToDegree> cp2DegreeList) {
 137         NodesBuilder nodesBldr = new NodesBuilder();
 138         nodesBldr.withKey(new NodesKey(deviceInfo.getNodeId())).setNodeId(deviceInfo.getNodeId());
 139 //        if (deviceInfo.getNodeType().getIntValue() == 1) {
 140 //            nodesBldr.setNodeType(NodeTypes.Rdm);
 141 //        }
 142
 143         if (portMapList != null) {
 144             nodesBldr.setMapping(portMapList);
 145         }
 146         if (cp2DegreeList != null) {
 147             nodesBldr.setCpToDegree(cp2DegreeList);
 148         }
 149
 150         List<Nodes> nodesList = new ArrayList<>();
 151         nodesList.add(nodesBldr.build());
 152
 153         NetworkBuilder nwBldr = new NetworkBuilder();
 154         nwBldr.setNodes(nodesList);
 155
 156         final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
 157         InstanceIdentifier<Network> nodesIID = InstanceIdentifier.builder(Network.class).build();
 158         Network network = nwBldr.build();
 159         writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, nodesIID, network);
 160         CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
 161         try {
 162             submit.checkedGet();
 163             return true;
 164
 165         } catch (TransactionCommitFailedException e) {
 166             LOG.warn("Failed to post {}", network, e);
 167             return false;
 168         }
 169     }
 170
 171     private static String getLogicalConnectionPort(Ports port, int srgCounter) {
 172         String logicalConnectionPoint = null;
 173         if (port.getLogicalConnectionPoint() != null) {
 174             switch (port.getPortDirection()) {
 175                 case Tx:
 176                     // Port direction is transmit
 177                     if (!port.getLogicalConnectionPoint().contains("SRG")) {
 178                         logicalConnectionPoint = "SRG" + srgCounter + "-" + port.getLogicalConnectionPoint() + "-TX";
 179                     } else {
 180                         logicalConnectionPoint = port.getLogicalConnectionPoint() + "-TX";
 181                     }
 182                     break;
 183                 case Rx:
 184                     // Port direction is receive
 185                     if (!port.getLogicalConnectionPoint().contains("SRG")) {
 186                         logicalConnectionPoint = "SRG" + srgCounter + "-" + port.getLogicalConnectionPoint() + "-RX";
 187                     } else {
 188                         logicalConnectionPoint = port.getLogicalConnectionPoint() + "-RX";
 189                     }
 190                     break;
 191                 case Bidirectional:
 192                     // port is bidirectional
 193                     if (!port.getLogicalConnectionPoint().contains("SRG")) {
 194                         logicalConnectionPoint = "SRG" + srgCounter + "-" + port.getLogicalConnectionPoint();
 195                     } else {
 196                         logicalConnectionPoint = port.getLogicalConnectionPoint();
 197                     }
 198                     if (!port.getLogicalConnectionPoint().endsWith("-TXRX")) {
 199                         logicalConnectionPoint = logicalConnectionPoint.concat("-TXRX");
 200                     }
 201                     break;
 202                 default:
 203                     // Unsupported Port direction
 204                     LOG.error("Unsupported port direction for port {}  {}", port, port.getPortDirection());
 205                     return null; // TODO return false or continue?
 206             }
 207             return logicalConnectionPoint;
 208         }
 209         LOG.warn("Unsupported port direction for port {} - {} - LogicalConnectionPoint is null",
 210                  port, port.getPortDirection());
 211         return null; // TODO return false or continue?
 212     }
 213
 214     private HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg
 215             .CircuitPacks>> getSrgCps(String deviceId, Info ordmInfo) {
 216         HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg
 217                 .CircuitPacks>> cpPerSrg = new HashMap<>();
 218         Integer maxSrg;
 219         // Get value for max Srg from info subtree, required for iteration
 220         // if not present assume to be 20 (temporary)
 221         if (ordmInfo.getMaxSrgs() != null) {
 222             maxSrg = ordmInfo.getMaxSrgs();
 223         } else {
 224             maxSrg = 20;
 225         }
 226         for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
 227             List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks> srgCps =
 228                     new ArrayList<>();
 229             LOG.info("Getting Circuitpacks for Srg Number {}", srgCounter);
 230             InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 231                     .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
 232             Optional<SharedRiskGroup> ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
 233                 LogicalDatastoreType.CONFIGURATION, srgIID,
 234                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 235             if (ordmSrgObject.isPresent()) {
 236                 srgCps.addAll(ordmSrgObject.get().getCircuitPacks());
 237                 cpPerSrg.put(ordmSrgObject.get().getSrgNumber(), srgCps);
 238             }
 239         }
 240         LOG.info("Device {} has {} Srg", deviceId, cpPerSrg.size());
 241         return cpPerSrg;
 242     }
 243
 244
 245     private boolean createPpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
 246         // Creating mapping data for SRG's PP
 247         HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg
 248                         .CircuitPacks>> srgCps = getSrgCps(nodeId, deviceInfo);
 249         Set<Map.Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
 250                         .srg.CircuitPacks>>> circuitPacks = srgCps.entrySet();
 251         for (Map.Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg
 252                         .CircuitPacks>> entry : circuitPacks) {
 253             Integer srgIndex = entry.getKey();
 254             for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks cp : entry
 255                     .getValue()) {
 256                 String circuitPackName = cp.getCircuitPackName();
 257                 InstanceIdentifier<CircuitPacks> cpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 258                         .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName));
 259                 Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 260                     LogicalDatastoreType.OPERATIONAL, cpIID,
 261                     Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 262
 263                 if (!circuitPackObject.isPresent() || (circuitPackObject.get().getPorts() == null)) {
 264                     LOG.warn("{} : Circuit pack {} not found or without ports.", nodeId, circuitPackName);
 265                     continue; // TODO continue or return false?
 266                 }
 267                 CircuitPacks circuitPack = circuitPackObject.get();
 268                 for (Ports port : circuitPack.getPorts()) {
 269                     if (port.getLogicalConnectionPoint() != null) {
 270                         String logicalConnectionPoint = getLogicalConnectionPort(port, srgIndex);
 271                         LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName, port
 272                                          .getPortName(),
 273                                  logicalConnectionPoint);
 274                         portMapList.add(createMappingObject(nodeId, port, circuitPackName, logicalConnectionPoint));
 275                     } else if (Port.PortQual.RoadmInternal.equals(port.getPortQual())) {
 276                         LOG.info("Port is internal, skipping Logical Connection Point missing for {} {}",
 277                                  circuitPackName,
 278                                  port.getPortName());
 279                     } else if (port.getLogicalConnectionPoint() == null) {
 280                         LOG.info("Value missing, Skipping Logical Connection Point missing for {} {}", circuitPackName,
 281                                  port.getPortName());
 282                     }
 283                 }
 284             }
 285         }
 286         return true;
 287     }
 288
 289     public boolean updateMapping(String nodeId, Mapping oldMapping) {
 290
 291
 292         LOG.info("Updating Mapping Data {} for node {}", oldMapping, nodeId);
 293         InstanceIdentifier<Ports> portIId = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
 294                 CircuitPacks.class, new CircuitPacksKey(oldMapping.getSupportingCircuitPackName())).child(Ports.class,
 295                     new PortsKey(oldMapping.getSupportingPort()));
 296         if ((oldMapping != null) && (nodeId != null)) {
 297             try {
 298                 Optional<Ports> portObject = deviceTransactionManager.getDataFromDevice(nodeId,
 299                     LogicalDatastoreType.OPERATIONAL, portIId, Timeouts.DEVICE_READ_TIMEOUT,
 300                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 301                 if (portObject.isPresent()) {
 302                     Ports port = portObject.get();
 303                     Mapping newMapping = createMappingObject(nodeId, port, oldMapping.getSupportingCircuitPackName(),
 304                                                              oldMapping.getLogicalConnectionPoint());
 305
 306                     final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
 307                     InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.create(Network.class).child(Nodes.class,
 308                         new NodesKey(nodeId)).child(Mapping.class,
 309                         new MappingKey(oldMapping.getLogicalConnectionPoint()));
 310                     writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, mapIID, newMapping);
 311                     CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
 312                     submit.checkedGet();
 313                     return true;
 314                 }
 315                 return false;
 316             } catch (TransactionCommitFailedException e) {
 317                 LOG.error("Transaction Commit Error updating Mapping {} for node {}", oldMapping
 318                         .getLogicalConnectionPoint(), nodeId, e);
 319                 return false;
 320             }
 321         } else {
 322             LOG.error("Impossible to update mapping");
 323             return false;
 324         }
 325     }
 326
 327     private Mapping createMappingObject(String nodeId, Ports port, String circuitPackName,
 328                                         String logicalConnectionPoint) {
 329         MappingBuilder mpBldr = new MappingBuilder();
 330         mpBldr.withKey(new MappingKey(logicalConnectionPoint)).setLogicalConnectionPoint(logicalConnectionPoint)
 331                 .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName());
 332
 333         // Get OMS and OTS interface provisioned on the TTP's
 334         if (logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) && (port.getInterfaces() != null)) {
 335             for (Interfaces interfaces : port.getInterfaces()) {
 336                 try {
 337                     Optional<Interface> openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
 338                         interfaces.getInterfaceName());
 339                     if (openRoadmInterface.isPresent()) {
 340                         Class<? extends InterfaceType> interfaceType = openRoadmInterface.get().getType();
 341                         // Check if interface type is OMS or OTS
 342                         if (interfaceType.equals(OpenROADMOpticalMultiplex.class)) {
 343                             mpBldr.setSupportingOms(interfaces.getInterfaceName());
 344                         }
 345                         if (interfaceType.equals(OpticalTransport.class)) {
 346                             mpBldr.setSupportingOts(interfaces.getInterfaceName());
 347                         }
 348                     } else {
 349                         LOG.warn("Interface {} from node {} was null!", interfaces.getInterfaceName(), nodeId);
 350                     }
 351                 } catch (OpenRoadmInterfaceException ex) {
 352                     LOG.warn("Error while getting interface {} from node {}!", interfaces.getInterfaceName(), nodeId,
 353                              ex);
 354                 }
 355             }
 356         }
 357         return mpBldr.build();
 358     }
 359
 360     private List<CpToDegree> getCpToDegreeList(List<Degree> degrees, String nodeId,
 361                                                Map<String, String> interfaceList) {
 362         List<CpToDegree> cpToDegreeList = new ArrayList<>();
 363         for (Degree degree : degrees) {
 364             if (degree.getCircuitPacks() != null) {
 365                 LOG.info("Inside CP to degree list");
 366                 cpToDegreeList.addAll(degree.getCircuitPacks()
 367                     .stream().map(cp -> createCpToDegreeObject(cp.getCircuitPackName() ,
 368                     degree.getDegreeNumber().toString(), nodeId ,interfaceList)).collect(Collectors.toList()));
 369             }
 370         }
 371         return cpToDegreeList;
 372     }
 373
 374     private CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber, String nodeId,
 375                                               Map<String, String> interfaceList) {
 376         String interfaceName = null;
 377         if (interfaceList.get(circuitPackName) !=  null) {
 378             interfaceName = interfaceList.get(circuitPackName);
 379         }
 380         return new CpToDegreeBuilder().withKey(new CpToDegreeKey(circuitPackName)).setCircuitPackName(circuitPackName)
 381                 .setDegreeNumber(new Long(degreeNumber)).setInterfaceName(interfaceName).build();
 382     }
 383
 384     private static List<ConnectionPorts> getDegreePorts(List<Degree> degrees) {
 385         return degrees.stream().filter(degree -> degree.getConnectionPorts() != null)
 386                 .flatMap(degree -> degree.getConnectionPorts().stream()).collect(Collectors.toList());
 387     }
 388
 389     private Map<String, String> getEthInterfaceList(String nodeId) {
 390         LOG.info("It is calling get ethernet interface");
 391         Map<String, String> cpToInterfaceMap = new HashMap<>();
 392         InstanceIdentifier<Protocols> protocolIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 393                 .child(Protocols.class);
 394         Optional<Protocols> protocolOptional = this.deviceTransactionManager.getDataFromDevice(nodeId,
 395             LogicalDatastoreType.OPERATIONAL, protocolIID,
 396             Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 397         Lldp lldp = null;
 398         if (protocolOptional.isPresent()) {
 399             lldp = protocolOptional.get().augmentation(Protocols1.class).getLldp();
 400         } else {
 401             LOG.warn("Couldnt find protocol operational data for Node : {}", nodeId);
 402         }
 403
 404         if (lldp != null && lldp.getPortConfig() != null) {
 405             for (PortConfig portConfig : lldp.getPortConfig()) {
 406                 if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) {
 407                     InstanceIdentifier<Interface> interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 408                             .child(Interface.class, new InterfaceKey(portConfig.getIfName()));
 409                     Optional<Interface> interfaceObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 410                         LogicalDatastoreType.OPERATIONAL, interfaceIID, Timeouts.DEVICE_READ_TIMEOUT,
 411                             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 412                     if (interfaceObject.isPresent() && (interfaceObject.get().getSupportingCircuitPackName() != null)) {
 413                         String supportingCircuitPackName = interfaceObject.get().getSupportingCircuitPackName();
 414                         cpToInterfaceMap.put(supportingCircuitPackName, portConfig.getIfName());
 415                         InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier.create(OrgOpenroadmDevice
 416                             .class).child(CircuitPacks.class, new CircuitPacksKey(supportingCircuitPackName));
 417                         Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(
 418                                 nodeId, LogicalDatastoreType.OPERATIONAL, circuitPacksIID, Timeouts
 419                                         .DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 420                         if (circuitPackObject.isPresent() && (circuitPackObject.get().getParentCircuitPack() != null)) {
 421                             cpToInterfaceMap.put(circuitPackObject.get().getParentCircuitPack().getCircuitPackName() ,
 422                                                  portConfig.getIfName());
 423                         }
 424                     }
 425                 }
 426             }
 427         } else {
 428             LOG.warn("Couldnt find port config under LLDP for Node : {}", nodeId);
 429         }
 430         LOG.info("Processiong is done.. now returning..");
 431         return cpToInterfaceMap;
 432     }
 433
 434     private List<Degree> getDegrees(String deviceId, Info ordmInfo) {
 435         List<Degree> degrees = new ArrayList<>();
 436         Integer maxDegree;
 437
 438         // Get value for max degree from info subtree, required for iteration
 439         // if not present assume to be 20 (temporary)
 440         if (ordmInfo.getMaxDegrees() != null) {
 441             maxDegree = ordmInfo.getMaxDegrees();
 442         } else {
 443             maxDegree = 20;
 444         }
 445
 446         for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
 447             LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
 448             InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 449                     .child(Degree.class, new DegreeKey(degreeCounter));
 450             Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
 451                 LogicalDatastoreType.CONFIGURATION, deviceIID,
 452                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 453             if (ordmDegreeObject.isPresent()) {
 454                 degrees.add(ordmDegreeObject.get());
 455             } else {
 456                 LOG.info("Device has {} degree", degreeCounter - 1);
 457                 break;
 458             }
 459         }
 460         return degrees;
 461     }
 462
 463
 464
 465
 466     private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
 467         // Creating mapping data for degree TTP's
 468
 469         List<Degree> degrees = getDegrees(nodeId, deviceInfo);
 470         List<ConnectionPorts> degreeConPorts = getDegreePorts(degrees);
 471         Map<String, String> interfaceList = getEthInterfaceList(nodeId);
 472         List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, nodeId, interfaceList);
 473         LOG.info("Map looks like this {}",interfaceList);
 474
 475         postPortMapping(deviceInfo, null, deviceInfo.getNodeType().getIntValue(), cpToDegreeList);
 476
 477         // Getting circuit-pack-name/port-name corresponding to TTP's
 478         for (ConnectionPorts cp : degreeConPorts) {
 479             String circuitPackName = cp.getCircuitPackName();
 480             String portName = cp.getPortName().toString();
 481             InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 482                     .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName))
 483                     .child(Ports.class, new PortsKey(portName));
 484
 485             LOG.info("Fetching logical Connection Point value for port {} at circuit pack {}", portName,
 486                      circuitPackName);
 487             Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 488                 LogicalDatastoreType.OPERATIONAL, portIID,
 489                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 490             if (portObject.isPresent()) {
 491                 Ports port = portObject.get();
 492                 if (port.getLogicalConnectionPoint() != null) {
 493                     LOG.info("Logical Connection Point for {} {} is {}", circuitPackName, portName,
 494                              port.getLogicalConnectionPoint());
 495                     portMapList.add(createMappingObject(nodeId, port, circuitPackName,
 496                                                         port.getLogicalConnectionPoint()));
 497                 } else {
 498                     LOG.warn("Logical Connection Point value is missing for {} {}", circuitPackName,
 499                              port.getPortName());
 500                 }
 501             } else {
 502                 LOG.warn("Port {} is not present in node {} in circuit pack {}!", portName, nodeId, circuitPackName);
 503                 continue; // TODO continue or return true?
 504             }
 505         }
 506         return true;
 507     }
 508
 509     private boolean createXpdrPortMapping(String nodeId, List<Mapping> portMapList) {
 510         // Creating for Xponder Line and Client Ports
 511         InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
 512         Optional<OrgOpenroadmDevice> deviceObject =
 513                 deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, deviceIID,
 514                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 515
 516         // Variable to keep track of number of line ports
 517         int line = 1;
 518         // Variable to keep track of number of client ports
 519         int client = 1;
 520         if (!deviceObject.isPresent() || deviceObject.get().getCircuitPacks() == null) {
 521             LOG.warn("Circuit Packs are not present for {}", nodeId);
 522             return false; // TODO return false or continue?
 523         }
 524
 525         List<CircuitPacks> circuitPackList = deviceObject.get().getCircuitPacks();
 526         circuitPackList.sort(Comparator.comparing(CircuitPack::getCircuitPackName));
 527
 528         for (CircuitPacks cp : circuitPackList) {
 529             String circuitPackName = cp.getCircuitPackName();
 530             if (cp.getPorts() == null) {
 531                 LOG.warn("Ports were not found for circuit pack: {}", circuitPackName);
 532                 continue;
 533             }
 534             for (Ports port : cp.getPorts()) {
 535                 if (port.getPortQual() == null) {
 536                     LOG.warn("PortQual was not found for port {} on circuit pack: {}", port.getPortName(),
 537                         circuitPackName);
 538                     continue;
 539                 }
 540                 if (Port.PortQual.XpdrNetwork.equals(port.getPortQual())) {
 541                     portMapList.add(createMappingObject(nodeId, port, circuitPackName,
 542                             "XPDR1-" + StringConstants.NETWORK_TOKEN + line));
 543                     line++;
 544                 } else if (Port.PortQual.XpdrClient.equals(port.getPortQual())) {
 545                     portMapList.add(createMappingObject(nodeId, port, circuitPackName,
 546                             "XPDR1-" +  StringConstants.CLIENT_TOKEN + client));
 547                     client++;
 548                 } else {
 549                     LOG.warn("Not supported type of port! Port type: {}", port.getPortQual());
 550                 }
 551             }
 552         }
 553         return true;
 554     }
 555 }