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                 CircuitPacks circuitPack = circuitPackObject.get();
 301                 for (Ports port : circuitPack.getPorts()) {
 302                     if (port.getLogicalConnectionPoint() != null) {
 303                         String logicalConnectionPoint = getLogicalConnectionPort(port, srgIndex);
 304                         LOG.info("{} : Logical Connection Point for {} {} is {}", nodeId, circuitPackName, port
 305                                          .getPortName(),
 306                                  logicalConnectionPoint);
 307                         portMapList.add(createMappingObject(nodeId, port, circuitPackName, logicalConnectionPoint));
 308                     } else if (PortQual.RoadmInternal.equals(port.getPortQual())) {
 309                         LOG.info("Port is internal, skipping Logical Connection Point missing for {} {}",
 310                                  circuitPackName,
 311                                  port.getPortName());
 312                     } else if (port.getLogicalConnectionPoint() == null) {
 313                         LOG.info("Value missing, Skipping Logical Connection Point missing for {} {}", circuitPackName,
 314                                  port.getPortName());
 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
 366     private List<Degree> getDegrees(String deviceId, Info ordmInfo) {
 367         List<Degree> degrees = new ArrayList<>();
 368         Integer maxDegree;
 369
 370         // Get value for max degree from info subtree, required for iteration
 371         // if not present assume to be 20 (temporary)
 372         if (ordmInfo.getMaxDegrees() != null) {
 373             maxDegree = ordmInfo.getMaxDegrees();
 374         } else {
 375             maxDegree = 20;
 376         }
 377
 378         for (int degreeCounter = 1; degreeCounter <= maxDegree; degreeCounter++) {
 379             LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
 380             InstanceIdentifier<Degree> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 381                     .child(Degree.class, new DegreeKey(degreeCounter));
 382             Optional<Degree> ordmDegreeObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
 383                 LogicalDatastoreType.OPERATIONAL, deviceIID,
 384                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 385             if (ordmDegreeObject.isPresent()) {
 386                 degrees.add(ordmDegreeObject.get());
 387             } else {
 388                 LOG.info("Device has {} degree", degreeCounter - 1);
 389                 break;
 390             }
 391         }
 392         return degrees;
 393     }
 394
 395     private static List<ConnectionPorts> getDegreePorts(List<Degree> degrees) {
 396         return degrees.stream().filter(degree -> degree.getConnectionPorts() != null)
 397                 .flatMap(degree -> degree.getConnectionPorts().stream()).collect(Collectors.toList());
 398     }
 399
 400     private Map<String, String> getEthInterfaceList(String nodeId) {
 401         LOG.info("It is calling get ethernet interface");
 402         Map<String, String> cpToInterfaceMap = new HashMap<>();
 403         InstanceIdentifier<Protocols> protocoliid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 404             .child(Protocols.class);
 405         Optional<Protocols> protocolObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 406             LogicalDatastoreType.OPERATIONAL, protocoliid, Timeouts.DEVICE_READ_TIMEOUT,
 407             Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 408         if (protocolObject.isPresent() && protocolObject.get().augmentation(Protocols1.class).getLldp() != null) {
 409             Lldp lldp = protocolObject.get().augmentation(Protocols1.class).getLldp();
 410             for (PortConfig portConfig : lldp.getPortConfig()) {
 411                 if (portConfig.getAdminStatus().equals(PortConfig.AdminStatus.Txandrx)) {
 412                     InstanceIdentifier<Interface> interfaceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 413                         .child(Interface.class, new InterfaceKey(portConfig.getIfName()));
 414                     Optional<Interface> interfaceObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 415                         LogicalDatastoreType.OPERATIONAL, interfaceIID, Timeouts.DEVICE_READ_TIMEOUT,
 416                         Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 417                     if (interfaceObject.isPresent() && (interfaceObject.get().getSupportingCircuitPackName() != null)) {
 418                         String supportingCircuitPackName = interfaceObject.get().getSupportingCircuitPackName();
 419                         cpToInterfaceMap.put(supportingCircuitPackName, portConfig.getIfName());
 420                         InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier.create(OrgOpenroadmDevice
 421                             .class).child(CircuitPacks.class, new CircuitPacksKey(supportingCircuitPackName));
 422                         Optional<CircuitPacks> circuitPackObject = this.deviceTransactionManager.getDataFromDevice(
 423                                 nodeId, LogicalDatastoreType.OPERATIONAL, circuitPacksIID, Timeouts
 424                                         .DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 425                         if (circuitPackObject.isPresent() && (circuitPackObject.get().getParentCircuitPack() != null)) {
 426                             cpToInterfaceMap.put(circuitPackObject.get().getParentCircuitPack().getCircuitPackName(),
 427                                                  portConfig.getIfName());
 428                         }
 429                     }
 430                 }
 431             }
 432         } else {
 433             LOG.warn("Couldnt find port config under LLDP for Node : {}", nodeId);
 434         }
 435         LOG.info("Processiong is done.. now returning..");
 436         return cpToInterfaceMap;
 437     }
 438
 439     private List<CpToDegree> getCpToDegreeList(List<Degree> degrees, String nodeId,
 440                                                Map<String, String> interfaceList) {
 441         List<CpToDegree> cpToDegreeList = new ArrayList<>();
 442         for (Degree degree : degrees) {
 443             if (degree.getCircuitPacks() != null) {
 444                 LOG.info("Inside CP to degree list");
 445                 cpToDegreeList.addAll(degree.getCircuitPacks().stream()
 446                     .map(cp -> createCpToDegreeObject(cp.getCircuitPackName(),
 447                     degree.getDegreeNumber().toString(), nodeId, interfaceList)).collect(Collectors.toList()));
 448             }
 449         }
 450         return cpToDegreeList;
 451     }
 452
 453     private boolean postPortMapping(Info deviceInfo, List<Mapping> portMapList, Integer nodeType,
 454                                     List<CpToDegree> cp2DegreeList) {
 455         NodesBuilder nodesBldr = new NodesBuilder();
 456         nodesBldr.withKey(new NodesKey(deviceInfo.getNodeId().getValue())).setNodeId(deviceInfo.getNodeId().getValue());
 457         nodesBldr.setNodeType(NodeTypes.forValue(nodeType));
 458         nodesBldr.setOpenroadmVersion(Nodes.OpenroadmVersion._221);
 459         if (portMapList != null) {
 460             nodesBldr.setMapping(portMapList);
 461         }
 462         if (cp2DegreeList != null) {
 463             nodesBldr.setCpToDegree(cp2DegreeList);
 464         }
 465
 466         List<Nodes> nodesList = new ArrayList<>();
 467         nodesList.add(nodesBldr.build());
 468
 469         NetworkBuilder nwBldr = new NetworkBuilder();
 470         nwBldr.setNodes(nodesList);
 471
 472         final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
 473         InstanceIdentifier<Network> nodesIID = InstanceIdentifier.builder(Network.class).build();
 474         Network network = nwBldr.build();
 475         writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, nodesIID, network);
 476         CheckedFuture<Void, TransactionCommitFailedException> submit = writeTransaction.submit();
 477         try {
 478             submit.checkedGet();
 479             return true;
 480
 481         } catch (TransactionCommitFailedException e) {
 482             LOG.warn("Failed to post {}", network, e);
 483             return false;
 484         }
 485     }
 486
 487     private CpToDegree createCpToDegreeObject(String circuitPackName, String degreeNumber, String nodeId,
 488                                               Map<String, String> interfaceList) {
 489         String interfaceName = null;
 490         if (interfaceList.get(circuitPackName) != null) {
 491             interfaceName = interfaceList.get(circuitPackName);
 492         }
 493         return new CpToDegreeBuilder().withKey(new CpToDegreeKey(circuitPackName)).setCircuitPackName(circuitPackName)
 494                 .setDegreeNumber(new Long(degreeNumber)).setInterfaceName(interfaceName).build();
 495     }
 496
 497     private Mapping createMappingObject(String nodeId, Ports port, String circuitPackName,
 498         String logicalConnectionPoint) {
 499         MappingBuilder mpBldr = new MappingBuilder();
 500         mpBldr.withKey(new MappingKey(logicalConnectionPoint)).setLogicalConnectionPoint(logicalConnectionPoint)
 501                 .setSupportingCircuitPackName(circuitPackName).setSupportingPort(port.getPortName());
 502
 503         // Get OMS and OTS interface provisioned on the TTP's
 504         if (logicalConnectionPoint.contains(StringConstants.TTP_TOKEN) && (port.getInterfaces() != null)) {
 505             for (Interfaces interfaces : port.getInterfaces()) {
 506                 try {
 507                     Optional<Interface>
 508                         openRoadmInterface = this.openRoadmInterfaces.getInterface(nodeId,
 509                         interfaces.getInterfaceName());
 510                     if (openRoadmInterface.isPresent()) {
 511                         Class<? extends InterfaceType> interfaceType = (Class<? extends InterfaceType>)
 512                             openRoadmInterface.get().getType();
 513                         // Check if interface type is OMS or OTS
 514                         if (interfaceType.equals(OpenROADMOpticalMultiplex.class)) {
 515                             mpBldr.setSupportingOms(interfaces.getInterfaceName());
 516                         }
 517                         if (interfaceType.equals(OpticalTransport.class)) {
 518                             mpBldr.setSupportingOts(interfaces.getInterfaceName());
 519                         }
 520                     } else {
 521                         LOG.warn("Interface {} from node {} was null!", interfaces.getInterfaceName(), nodeId);
 522                     }
 523                 } catch (OpenRoadmInterfaceException ex) {
 524                     LOG.warn("Error while getting interface {} from node {}!", interfaces.getInterfaceName(), nodeId,
 525                              ex);
 526                 }
 527             }
 528         }
 529         return mpBldr.build();
 530     }
 531
 532     private Mapping createXpdrMappingObject(String nodeId, Ports port, String circuitPackName,
 533         String logicalConnectionPoint, Mapping mapping, String assoLcp) {
 534         MappingBuilder mpBldr;
 535         if (mapping != null && assoLcp != null) {
 536             mpBldr = new MappingBuilder(mapping);
 537             mpBldr.setAssociatedLcp(assoLcp);
 538         } else {
 539             mpBldr = new MappingBuilder();
 540             mpBldr.withKey(new MappingKey(logicalConnectionPoint))
 541                 .setLogicalConnectionPoint(logicalConnectionPoint)
 542                 .setSupportingCircuitPackName(circuitPackName)
 543                 .setSupportingPort(port.getPortName())
 544                 .setPortDirection(port.getPortDirection().getName());
 545             if (port.getPortQual() != null) {
 546                 mpBldr.setPortQual(port.getPortQual().getName());
 547             }
 548         }
 549         return mpBldr.build();
 550     }
 551
 552     private boolean createTtpPortMapping(String nodeId, Info deviceInfo, List<Mapping> portMapList) {
 553         // Creating mapping data for degree TTP's
 554
 555         List<Degree> degrees = getDegrees(nodeId, deviceInfo);
 556         List<ConnectionPorts> degreeConPorts = getDegreePorts(degrees);
 557         Map<String, String> interfaceList = getEthInterfaceList(nodeId);
 558         List<CpToDegree> cpToDegreeList = getCpToDegreeList(degrees, nodeId, interfaceList);
 559         LOG.info("Map looks like this {}", interfaceList);
 560
 561         postPortMapping(deviceInfo, null, deviceInfo.getNodeType().getIntValue(), cpToDegreeList);
 562
 563         // Getting circuit-pack-name/port-name corresponding to TTP's
 564         for (ConnectionPorts cp : degreeConPorts) {
 565             String circuitPackName = cp.getCircuitPackName();
 566             String portName = cp.getPortName().toString();
 567             InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 568                     .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName))
 569                     .child(Ports.class, new PortsKey(portName));
 570
 571             LOG.info("Fetching logical Connection Point value for port {} at circuit pack {}", portName,
 572                      circuitPackName);
 573             Optional<Ports> portObject = this.deviceTransactionManager.getDataFromDevice(nodeId,
 574                 LogicalDatastoreType.OPERATIONAL, portIID, Timeouts.DEVICE_READ_TIMEOUT,
 575                 Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 576             if (portObject.isPresent()) {
 577                 Ports port = portObject.get();
 578                 if (port.getLogicalConnectionPoint() != null) {
 579                     LOG.info("Logical Connection Point for {} {} is {}", circuitPackName, portName,
 580                              port.getLogicalConnectionPoint());
 581                     portMapList.add(createMappingObject(nodeId, port, circuitPackName,
 582                                                         port.getLogicalConnectionPoint()));
 583                 } else {
 584                     LOG.warn("Logical Connection Point value is missing for {} {}", circuitPackName,
 585                              port.getPortName());
 586                 }
 587             } else {
 588                 LOG.warn("Port {} is not present in node {} in circuit pack {}!", portName, nodeId, circuitPackName);
 589                 continue; // TODO continue or return true?
 590             }
 591         }
 592         return true;
 593     }
 594
 595 }