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