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