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