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.common.types.rev181019.PortQual;
  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
 202             for (Ports port : cp.getPorts()) {
 203                 if (port.getPortQual() == null) {
 204                     continue;
 205                 }
 206                 if (PortQual.XpdrNetwork.getName().equals(port.getPortQual().getName()))  {
 207                     portMapList.add(createMappingObject(nodeId, port, circuitPackName,
 208                             "XPDR1-" + StringConstants.NETWORK_TOKEN + line));
 209                     line++;
 210                 } else if (PortQual.XpdrClient.getName().equals(port.getPortQual().getName())) {
 211                     portMapList.add(createMappingObject(nodeId, port, circuitPackName,
 212                             "XPDR1-" + StringConstants.CLIENT_TOKEN + client));
 213                     client++;
 214                 } else {
 215                     LOG.warn("Not supported type of port! Port type: {}", port.getPortQual().getName());
 216                 }
 217                 LOG.info("portMapList Is {} {}",portMapList.size(),portMapList.get(0));
 218             }
 219         }
 220         return true;
 221     }
 222
 223
 224
 225     private HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg
 226             .CircuitPacks>> getSrgCps(String deviceId, Info ordmInfo) {
 227         HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg
 228                 .CircuitPacks>> cpPerSrg = new HashMap<>();
 229         Integer maxSrg;
 230         // Get value for max Srg from info subtree, required for iteration
 231         // if not present assume to be 20 (temporary)
 232         if (ordmInfo.getMaxSrgs() != null) {
 233             maxSrg = ordmInfo.getMaxSrgs();
 234         } else {
 235             maxSrg = 20;
 236         }
 237         for (int srgCounter = 1; srgCounter <= maxSrg; srgCounter++) {
 238             List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks> srgCps =
 239                     new ArrayList<>();
 240             LOG.info("Getting Circuitpacks for Srg Number {}", srgCounter);
 241             InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 242                     .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
 243             Optional<SharedRiskGroup> ordmSrgObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
 244                 LogicalDatastoreType.OPERATIONAL, srgIID,
 245                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 246             if (ordmSrgObject.isPresent()) {
 247                 srgCps.addAll(ordmSrgObject.get().getCircuitPacks());
 248                 cpPerSrg.put(ordmSrgObject.get().getSrgNumber(), srgCps);
 249             }
 250         }
 251         LOG.info("Device {} has {} Srg", deviceId, cpPerSrg.size());
 252         return cpPerSrg;
 253     }
 254
 255     private boolean createPpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
 256         // Creating mapping data for SRG's PP
 257         HashMap<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg
 258                 .CircuitPacks>> srgCps = getSrgCps(nodeId, deviceInfo);
 259         Set<Map.Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019
 260                 .srg.CircuitPacks>>> circuitPacks = srgCps.entrySet();
 261         for (Map.Entry<Integer, List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg
 262                 .CircuitPacks>> entry : circuitPacks) {
 263             Integer srgIndex = entry.getKey();
 264             for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.srg.CircuitPacks cp : entry
 265                     .getValue()) {
 266                 String circuitPackName = cp.getCircuitPackName();
 267                 InstanceIdentifier<CircuitPacks> cpIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 268                         .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName));
 269                 Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 270                     LogicalDatastoreType.OPERATIONAL, cpIID,
 271                     Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 272
 273                 if (!circuitPackObject.isPresent() || (circuitPackObject.get().getPorts() == null)) {
 274                     LOG.warn("{} : Circuit pack {} not found or without ports.", nodeId, circuitPackName);
 275                     continue; // TODO continue or return false?
 276                 }
 277                 CircuitPacks circuitPack = circuitPackObject.get();
 278                 for (Ports port : circuitPack.getPorts()) {
 279                     if (port.getLogicalConnectionPoint() != null) {
 280                         String logicalConnectionPoint = getLogicalConnectionPort(port, srgIndex);
 281                         LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName, port
 282                                          .getPortName(),
 283                                  logicalConnectionPoint);
 284                         portMapList.add(createMappingObject(nodeId, port, circuitPackName, logicalConnectionPoint));
 285                     } else if (PortQual.RoadmInternal.equals(port.getPortQual())) {
 286                         LOG.info("Port is internal, skipping Logical Connection Point missing for {} {}",
 287                                  circuitPackName,
 288                                  port.getPortName());
 289                     } else if (port.getLogicalConnectionPoint() == null) {
 290                         LOG.info("Value missing, Skipping Logical Connection Point missing for {} {}", circuitPackName,
 291                                  port.getPortName());
 292                     }
 293                 }
 294             }
 295         }
 296         return true;
 297     }
 298
 299     private static String getLogicalConnectionPort(Ports port, int srgCounter) {
 300         String logicalConnectionPoint = null;
 301         if (port.getLogicalConnectionPoint() != null) {
 302             switch (port.getPortDirection()) {
 303                 case Tx:
 304                     // Port direction is transmit
 305                     if (!port.getLogicalConnectionPoint().contains("SRG")) {
 306                         logicalConnectionPoint = "SRG" + srgCounter + "-" + port.getLogicalConnectionPoint() + "-TX";
 307                     } else {
 308                         logicalConnectionPoint = port.getLogicalConnectionPoint() + "-TX";
 309                     }
 310                     break;
 311                 case Rx:
 312                     // Port direction is receive
 313                     if (!port.getLogicalConnectionPoint().contains("SRG")) {
 314                         logicalConnectionPoint = "SRG" + srgCounter + "-" + port.getLogicalConnectionPoint() + "-RX";
 315                     } else {
 316                         logicalConnectionPoint = port.getLogicalConnectionPoint() + "-RX";
 317                     }
 318                     break;
 319                 case Bidirectional:
 320                     // port is bidirectional
 321                     if (!port.getLogicalConnectionPoint().contains("SRG")) {
 322                         logicalConnectionPoint = "SRG" + srgCounter + "-" + port.getLogicalConnectionPoint();
 323                     } else {
 324                         logicalConnectionPoint = port.getLogicalConnectionPoint();
 325                     }
 326                     if (!port.getLogicalConnectionPoint().endsWith("-TXRX")) {
 327                         logicalConnectionPoint = logicalConnectionPoint.concat("-TXRX");
 328                     }
 329                     break;
 330                 default:
 331                     // Unsupported Port direction
 332                     LOG.error("Unsupported port direction for port {}  {}", port, port.getPortDirection());
 333                     return null; // TODO return false or continue?
 334             }
 335             return logicalConnectionPoint;
 336         }
 337         LOG.warn("Unsupported port direction for port {} - {} - LogicalConnectionPoint is null",
 338                  port, port.getPortDirection());
 339         return null; // TODO return false or continue?
 340     }
 341
 342
 343     private List<Degree> getDegrees(String deviceId, Info ordmInfo) {
 344         List<Degree> degrees = new ArrayList<>();
 345         Integer maxDegree;
 346
 347         // Get value for max degree from info subtree, required for iteration
 348         // if not present assume to be 20 (temporary)
 349         if (ordmInfo.getMaxDegrees() != null) {
 350             maxDegree = ordmInfo.getMaxDegrees();
 351         } else {
 352             maxDegree = 20;
 353         }
 354
 355         for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
 356             LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
 357             InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 358                     .child(Degree.class, new DegreeKey(degreeCounter));
 359             Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
 360                 LogicalDatastoreType.OPERATIONAL, deviceIID,
 361                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 362             if (ordmDegreeObject.isPresent()) {
 363                 degrees.add(ordmDegreeObject.get());
 364             } else {
 365                 LOG.info("Device has {} degree", degreeCounter - 1);
 366                 break;
 367             }
 368         }
 369         return degrees;
 370     }
 371
 372     private static List<ConnectionPorts> getDegreePorts(List<Degree> degrees) {
 373         return degrees.stream().filter(degree -> degree.getConnectionPorts() != null)
 374                 .flatMap(degree -> degree.getConnectionPorts().stream()).collect(Collectors.toList());
 375     }
 376
 377     private Map<String, String> getEthInterfaceList(String nodeId) {
 378         LOG.info("It is calling get ethernet interface");
 379         Map<String, String> cpToInterfaceMap = new HashMap<>();
 380         InstanceIdentifier<Protocols> protocoliid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 381             .child(Protocols.class);
 382         Optional<Protocols> protocolObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 383             LogicalDatastoreType.OPERATIONAL, protocoliid, Timeouts.DEVICE_READ_TIMEOUT,
 384             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 385         if (protocolObject.isPresent() && protocolObject.get().augmentation(Protocols1.class).getLldp() != null) {
 386             Lldp lldp = protocolObject.get().augmentation(Protocols1.class).getLldp();
 387             for (PortConfig portConfig : lldp.getPortConfig()) {
 388                 if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) {
 389                     InstanceIdentifier<Interface> interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 390                         .child(Interface.class, new InterfaceKey(portConfig.getIfName()));
 391                     Optional<Interface> interfaceObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 392                         LogicalDatastoreType.OPERATIONAL, interfaceIID, Timeouts.DEVICE_READ_TIMEOUT,
 393                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 394                     if (interfaceObject.isPresent() && (interfaceObject.get().getSupportingCircuitPackName() != null)) {
 395                         String supportingCircuitPackName = interfaceObject.get().getSupportingCircuitPackName();
 396                         cpToInterfaceMap.put(supportingCircuitPackName, portConfig.getIfName());
 397                         InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier.create(OrgOpenroadmDevice
 398                             .class).child(CircuitPacks.class, new CircuitPacksKey(supportingCircuitPackName));
 399                         Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(
 400                                 nodeId, LogicalDatastoreType.OPERATIONAL, circuitPacksIID, Timeouts
 401                                         .DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 402                         if (circuitPackObject.isPresent() && (circuitPackObject.get().getParentCircuitPack() != null)) {
 403                             cpToInterfaceMap.put(circuitPackObject.get().getParentCircuitPack().getCircuitPackName(),
 404                                                  portConfig.getIfName());
 405                         }
 406                     }
 407                 }
 408             }
 409         } else {
 410             LOG.warn("Couldnt find port config under LLDP for Node : {}", nodeId);
 411         }
 412         LOG.info("Processiong is done.. now returning..");
 413         return cpToInterfaceMap;
 414     }
 415
 416     private List<CpToDegree> getCpToDegreeList(List<Degree> degrees, String nodeId,
 417                                                Map<String, String> interfaceList) {
 418         List<CpToDegree> cpToDegreeList = new ArrayList<>();
 419         for (Degree degree : degrees) {
 420             if (degree.getCircuitPacks() != null) {
 421                 LOG.info("Inside CP to degree list");
 422                 cpToDegreeList.addAll(degree.getCircuitPacks().stream()
 423                     .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(),
 424                     degree.getDegreeNumber().toString(), nodeId, interfaceList)).collect(Collectors.toList()));
 425             }
 426         }
 427         return cpToDegreeList;
 428     }
 429
 430     private boolean postPortMapping(Info deviceInfo, List<Mapping> portMapList, Integer nodeType,
 431                                     List<CpToDegree> cp2DegreeList) {
 432         NodesBuilder nodesBldr = new NodesBuilder();
 433         nodesBldr.withKey(new NodesKey(deviceInfo.getNodeId().getValue())).setNodeId(deviceInfo.getNodeId().getValue());
 434         nodesBldr.setNodeType(NodeTypes.forValue(nodeType));
 435         nodesBldr.setOpenroadmVersion(Nodes.OpenroadmVersion._221);
 436         if (portMapList != null) {
 437             nodesBldr.setMapping(portMapList);
 438         }
 439         if (cp2DegreeList != null) {
 440             nodesBldr.setCpToDegree(cp2DegreeList);
 441         }
 442
 443         List<Nodes> nodesList = new ArrayList<>();
 444         nodesList.add(nodesBldr.build());
 445
 446         NetworkBuilder nwBldr = new NetworkBuilder();
 447         nwBldr.setNodes(nodesList);
 448
 449         final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
 450         InstanceIdentifier<Network> nodesIID = InstanceIdentifier.builder(Network.class).build();
 451         Network network = nwBldr.build();
 452         writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, nodesIID, network);
 453         CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
 454         try {
 455             submit.checkedGet();
 456             return true;
 457
 458         } catch (TransactionCommitFailedException e) {
 459             LOG.warn("Failed to post {}", network, e);
 460             return false;
 461         }
 462     }
 463
 464     private CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber, String nodeId,
 465                                               Map<String, String> interfaceList) {
 466         String interfaceName = null;
 467         if (interfaceList.get(circuitPackName) != null) {
 468             interfaceName = interfaceList.get(circuitPackName);
 469         }
 470         return new CpToDegreeBuilder().withKey(new CpToDegreeKey(circuitPackName)).setCircuitPackName(circuitPackName)
 471                 .setDegreeNumber(new Long(degreeNumber)).setInterfaceName(interfaceName).build();
 472     }
 473
 474     private Mapping createMappingObject(String nodeId, Ports port, String circuitPackName,
 475                                         String logicalConnectionPoint) {
 476         MappingBuilder mpBldr = new MappingBuilder();
 477         mpBldr.withKey(new MappingKey(logicalConnectionPoint)).setLogicalConnectionPoint(logicalConnectionPoint)
 478                 .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName());
 479
 480         // Get OMS and OTS interface provisioned on the TTP's
 481         if (logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) && (port.getInterfaces() != null)) {
 482             for (Interfaces interfaces : port.getInterfaces()) {
 483                 try {
 484                     Optional<Interface>
 485                         openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
 486                         interfaces.getInterfaceName());
 487                     if (openRoadmInterface.isPresent()) {
 488                         Class<? extends InterfaceType> interfaceType = (Class<? extends InterfaceType>)
 489                             openRoadmInterface.get().getType();
 490                         // Check if interface type is OMS or OTS
 491                         if (interfaceType.equals(OpenROADMOpticalMultiplex.class)) {
 492                             mpBldr.setSupportingOms(interfaces.getInterfaceName());
 493                         }
 494                         if (interfaceType.equals(OpticalTransport.class)) {
 495                             mpBldr.setSupportingOts(interfaces.getInterfaceName());
 496                         }
 497                     } else {
 498                         LOG.warn("Interface {} from node {} was null!", interfaces.getInterfaceName(), nodeId);
 499                     }
 500                 } catch (OpenRoadmInterfaceException ex) {
 501                     LOG.warn("Error while getting interface {} from node {}!", interfaces.getInterfaceName(), nodeId,
 502                              ex);
 503                 }
 504             }
 505         }
 506         return mpBldr.build();
 507     }
 508
 509     private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
 510         // Creating mapping data for degree TTP's
 511
 512         List<Degree> degrees = getDegrees(nodeId, deviceInfo);
 513         List<ConnectionPorts> degreeConPorts = getDegreePorts(degrees);
 514         Map<String, String> interfaceList = getEthInterfaceList(nodeId);
 515         List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, nodeId, interfaceList);
 516         LOG.info("Map looks like this {}", interfaceList);
 517
 518         postPortMapping(deviceInfo, null, deviceInfo.getNodeType().getIntValue(), cpToDegreeList);
 519
 520         // Getting circuit-pack-name/port-name corresponding to TTP's
 521         for (ConnectionPorts cp : degreeConPorts) {
 522             String circuitPackName = cp.getCircuitPackName();
 523             String portName = cp.getPortName().toString();
 524             InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 525                     .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName))
 526                     .child(Ports.class, new PortsKey(portName));
 527
 528             LOG.info("Fetching logical Connection Point value for port {} at circuit pack {}", portName,
 529                      circuitPackName);
 530             Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 531                 LogicalDatastoreType.OPERATIONAL, portIID, Timeouts.DEVICE_READ_TIMEOUT,
 532                 Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 533             if (portObject.isPresent()) {
 534                 Ports port = portObject.get();
 535                 if (port.getLogicalConnectionPoint() != null) {
 536                     LOG.info("Logical Connection Point for {} {} is {}", circuitPackName, portName,
 537                              port.getLogicalConnectionPoint());
 538                     portMapList.add(createMappingObject(nodeId, port, circuitPackName,
 539                                                         port.getLogicalConnectionPoint()));
 540                 } else {
 541                     LOG.warn("Logical Connection Point value is missing for {} {}", circuitPackName,
 542                              port.getPortName());
 543                 }
 544             } else {
 545                 LOG.warn("Port {} is not present in node {} in circuit pack {}!", portName, nodeId, circuitPackName);
 546                 continue; // TODO continue or return true?
 547             }
 548         }
 549         return true;
 550     }
 551
 552 }