networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/util/OpenRoadmTopology.java

   1 /*
   2  * Copyright © 2016 AT&T and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.transportpce.networkmodel.util;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.List;
  14 import java.util.Optional;
  15 import java.util.concurrent.ExecutionException;
  16 import java.util.concurrent.TimeUnit;
  17 import java.util.concurrent.TimeoutException;
  18
  19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  20 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.transportpce.common.NetworkUtils;
  23 import org.opendaylight.transportpce.common.Timeouts;
  24 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  25 import org.opendaylight.transportpce.networkmodel.dto.NodeData;
  26 import org.opendaylight.transportpce.networkmodel.dto.TopologyShard;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.NodeTypes;
  28 import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.node.attributes.AvailableWavelengths;
  29 import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.node.attributes.AvailableWavelengthsBuilder;
  30 import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev170929.degree.node.attributes.AvailableWavelengthsKey;
  31 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.Ports;
  32 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.PortsKey;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacks;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPorts;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Degree;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeKey;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Info;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Link1;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Link1Builder;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.NetworkTypes1;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.NetworkTypes1Builder;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Node1Builder;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.TerminationPoint1Builder;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.network.types.OpenroadmTopologyBuilder;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.DegreeAttributesBuilder;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.SrgAttributesBuilder;
  53 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrClientAttributesBuilder;
  54 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.node.termination.point.XpdrNetworkAttributesBuilder;
  55 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmLinkType;
  56 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmNodeType;
  57 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmTpType;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.Network;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkId;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkKey;
  62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NodeId;
  63 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.network.NetworkTypesBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.network.Node;
  65 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.network.NodeBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.network.NodeKey;
  67 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.network.node.SupportingNode;
  68 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.network.node.SupportingNodeBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.network.node.SupportingNodeKey;
  70 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.LinkId;
  71 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Network1;
  72 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Network1Builder;
  73 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.TpId;
  74 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.Link;
  75 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.LinkBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.LinkKey;
  77 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.link.DestinationBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.link.SourceBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.node.TerminationPoint;
  80 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.node.TerminationPointBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.node.TerminationPointKey;
  82 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  83 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  84 import org.slf4j.Logger;
  85 import org.slf4j.LoggerFactory;
  86
  87 public class OpenRoadmTopology {
  88
  89     private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmTopology.class);
  90     private static final int DEFAULT_PORT_DIRECTION = -1;
  91     private static final int MAX_DEGREE = 20;
  92     private static final int MAX_SRG = 20;
  93
  94     private final DataBroker dataBroker;
  95     private final DeviceTransactionManager deviceTransactionManager;
  96
  97     public OpenRoadmTopology(DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager) {
  98         this.dataBroker = dataBroker;
  99         this.deviceTransactionManager = deviceTransactionManager;
 100     }
 101
 102     /**
 103      * This public method creates the OpenROADM Topology Layer and posts it to the controller.
 104      */
 105     public void createTopoLayer(DataBroker controllerdb) {
 106         try {
 107             Network openRoadmTopology = createOpenRoadmTopology();
 108             InstanceIdentifierBuilder<Network> nwIID = InstanceIdentifier.builder(Network.class,
 109                     new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)));
 110             WriteTransaction wrtx = controllerdb.newWriteOnlyTransaction();
 111             wrtx.put(LogicalDatastoreType.CONFIGURATION, nwIID.build(), openRoadmTopology);
 112             wrtx.submit().get(1, TimeUnit.SECONDS);
 113             LOG.info("OpenRoadm-Topology created successfully.");
 114         } catch (ExecutionException | TimeoutException | InterruptedException e) {
 115             LOG.warn("Failed to create OpenRoadm-Topology", e);
 116         }
 117     }
 118
 119     /**
 120      * Create empty OpenROADM topology.
 121      */
 122     private Network createOpenRoadmTopology() {
 123         NetworkBuilder nwBuilder = new NetworkBuilder();
 124         NetworkId nwId = new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID);
 125         nwBuilder.setNetworkId(nwId);
 126         nwBuilder.setKey(new NetworkKey(nwId));
 127         // set network type to Transport Underlay
 128         NetworkTypes1Builder topoNetworkTypesBldr = new NetworkTypes1Builder();
 129         topoNetworkTypesBldr.setOpenroadmTopology(new OpenroadmTopologyBuilder().build());
 130         NetworkTypesBuilder nwTypeBuilder = new NetworkTypesBuilder();
 131         nwTypeBuilder.addAugmentation(NetworkTypes1.class, topoNetworkTypesBldr.build());
 132         nwBuilder.setNetworkTypes(nwTypeBuilder.build());
 133         // Array to store nodes in the topolayer of a roadm/Xponder
 134         Network1Builder nwBldr1 = new Network1Builder();
 135         // adding expressLinks
 136         nwBldr1.setLink(Collections.emptyList());
 137         nwBuilder.addAugmentation(Network1.class, nwBldr1.build());
 138         nwBuilder.setNode(Collections.emptyList());
 139         return nwBuilder.build();
 140     }
 141
 142     public TopologyShard createTopologyShard(String nodeId) {
 143         int numOfDegrees;
 144         int numOfSrgs;
 145         int portDirectionEnum = DEFAULT_PORT_DIRECTION;
 146
 147         InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
 148         java.util.Optional<Info> deviceInfoOpt =
 149                 this.deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, infoIID,
 150                         Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 151         Info deviceInfo;
 152         if (deviceInfoOpt.isPresent()) {
 153             deviceInfo = deviceInfoOpt.get();
 154         } else {
 155             LOG.error("Unable to get device info for device {}!", nodeId);
 156             return null;
 157         }
 158         List<Node> nodes = new ArrayList<>();
 159
 160         // Check if node is ROADM
 161         if (NodeTypes.Rdm.equals(deviceInfo.getNodeType())) {
 162
 163             /*
 164              * Adding Degree Node Get Degree Number -> x then get connection ports then find the port directions
 165              * to decide whether TX/RX/TXRX Get value for max degree from info subtree, required for iteration
 166              * if not present assume to be 20 (temporary)
 167              */
 168
 169             Integer maxDegree;
 170             if (deviceInfo.getMaxDegrees() != null) {
 171                 maxDegree = deviceInfo.getMaxDegrees();
 172             } else {
 173                 maxDegree = MAX_DEGREE;
 174             }
 175
 176             // Starting with degree Number = 1
 177             Integer degreeCounter = 1;
 178
 179             while (degreeCounter <= maxDegree) {
 180                 LOG.info("creating degree node {}/{}", degreeCounter, maxDegree);
 181                 NodeData nodeData = createDegreeNode(nodeId, degreeCounter);
 182                 if (nodeData != null) {
 183                     NodeBuilder tempNode = nodeData.getNodeBuilder();
 184                     portDirectionEnum = nodeData.getPortDirectionEnum();
 185                     nodes.add(tempNode.build());
 186                     degreeCounter++;
 187                 } else {
 188                 // null returned if Degree number= degreeCounter not present in the device
 189                     break;
 190                 }
 191             }
 192             numOfDegrees = degreeCounter - 1;
 193
 194             Integer maxSrg;
 195             if (deviceInfo.getMaxSrgs() != null) {
 196                 maxSrg = deviceInfo.getMaxSrgs();
 197             } else {
 198                 maxSrg = MAX_SRG;
 199             }
 200
 201             // Starting with degree Number = 1
 202             Integer srgCounter = 1;
 203
 204             while (srgCounter <= maxSrg) {
 205                 LOG.info("creating SRG node {}/{}", srgCounter, maxSrg);
 206                 NodeBuilder tempNode = createSrgNode(nodeId, srgCounter, portDirectionEnum);
 207
 208                 if (tempNode != null) {
 209                     nodes.add(tempNode.build());
 210                     srgCounter++;
 211                 } else {
 212                     // null returned if Degree number= degreeCounter not present in the device
 213                     break;
 214                 }
 215             }
 216             numOfSrgs = srgCounter - 1;
 217
 218
 219             LOG.info("adding links numOfDegrees={} numOfSrgs={}", numOfDegrees, numOfSrgs);
 220             List<Link> links = new ArrayList<>();
 221             links.addAll(createExpressLinks(nodeId, numOfDegrees, portDirectionEnum));
 222             links.addAll(createAddDropLinks(nodeId, numOfDegrees, numOfSrgs, portDirectionEnum));
 223             LOG.info("created nodes/links: {}/{}", nodes.size(), links.size());
 224             return new TopologyShard(nodes, links);
 225         } else if (NodeTypes.Xpdr.equals(deviceInfo.getNodeType())) {
 226             // Check if node is XPONDER
 227             Integer clientport = getNoOfClientPorts(nodeId);
 228             List<Link> links = new ArrayList<>();
 229             Integer clientCounter = 1;
 230             Integer lineCounter = 1;
 231             while (clientCounter <= clientport) {
 232                 NodeBuilder tempNode = createXpdr(clientCounter, lineCounter, nodeId);
 233                 if (tempNode == null) {
 234                     break;
 235                 }
 236                 nodes.add(tempNode.build());
 237                 clientCounter++;
 238                 lineCounter++;
 239                 LOG.info("Entered this loop");
 240             }
 241             return new TopologyShard(nodes, links);
 242         }
 243
 244         return null;
 245     }
 246
 247     /**
 248      * This private method gets the list of circuit packs on a xponder. For each circuit pack on a
 249      * Xponder, it does a get on circuit-pack subtree with circuit-pack-name as key in order to get the
 250      * list of ports. It then iterates over the list of ports to get ports with port-qual as
 251      * xpdr-network/xpdr-client. The line and client ports are saved as:
 252      *
 253      * <p>
 254      * 1. LINEn
 255      *
 256      * <p>
 257      * 2. CLNTn
 258      */
 259     private int getNoOfClientPorts(String deviceId) {
 260         // Creating for Xponder Line and Client Ports
 261         InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
 262         Optional<OrgOpenroadmDevice> deviceObject =
 263                 this.deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, deviceIID,
 264                         Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 265
 266         // Variable to keep track of number of client ports
 267         int client = 1;
 268         if (deviceObject.isPresent()) {
 269             for (CircuitPacks cp : deviceObject.get().getCircuitPacks()) {
 270                 if (cp.getPorts() != null) {
 271                     for (Ports port : cp.getPorts()) {
 272                         if (port.getPortQual() != null) {
 273                             if (port.getPortQual().getIntValue() == 4) {
 274                                 client++;
 275                             }
 276                         }
 277                     }
 278                 }
 279             }
 280         } else {
 281             return 0;
 282         }
 283         return client;
 284     }
 285
 286     private NodeBuilder createXpdr(Integer clientCounter, Integer lineCounter, String nodeId) {
 287         // Create a generic Topo Layer node
 288         NodeBuilder nodebldr = createTopoLayerNode(nodeId);
 289         // Create augmentation node to inorder to add degree
 290         Node1Builder node1bldr = new Node1Builder();
 291         TerminationPoint1Builder tp1Bldr = new TerminationPoint1Builder();
 292         TerminationPointBuilder tempTpBldr;
 293
 294         // set node type to Xponder
 295         node1bldr.setNodeType(OpenroadmNodeType.XPONDER);
 296         List<TerminationPoint> tpList = new ArrayList<>();
 297         String nodeIdtopo = new StringBuilder().append(nodeId).append("-XPDR1").toString();
 298         // Ad degree node specific augmentation
 299         nodebldr.setNodeId(new NodeId(nodeIdtopo));
 300         nodebldr.setKey(new NodeKey(new NodeId(nodeIdtopo)));
 301         nodebldr.addAugmentation(Node1.class, node1bldr.build());
 302         while (clientCounter != 0) {
 303             // Create CLNT-TX termination
 304             tempTpBldr = createTpBldr("XPDR1-CLIENT" + clientCounter);
 305             tp1Bldr.setTpType(OpenroadmTpType.XPONDERCLIENT);
 306             XpdrClientAttributesBuilder xpdrClntBldr = new XpdrClientAttributesBuilder();
 307             xpdrClntBldr.setTailEquipmentId("XPDR1-NETWORK" + clientCounter);
 308             tp1Bldr.setXpdrClientAttributes(xpdrClntBldr.build());
 309             tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
 310             tpList.add(tempTpBldr.build());
 311             clientCounter--;
 312         }
 313         while (lineCounter != 0) {
 314             // Create LINE-TX termination
 315             tempTpBldr = (createTpBldr("XPDR1-NETWORK" + lineCounter));
 316             tp1Bldr.setTpType(OpenroadmTpType.XPONDERNETWORK);
 317             XpdrNetworkAttributesBuilder xpdrNwAttrBldr = new XpdrNetworkAttributesBuilder();
 318             xpdrNwAttrBldr.setTailEquipmentId("XPDR1-CLIENT" + lineCounter);
 319             tp1Bldr.setXpdrNetworkAttributes(xpdrNwAttrBldr.build());
 320             tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
 321             tpList.add(tempTpBldr.build());
 322             lineCounter--;
 323         }
 324         LOG.info("printing tpList {}",tpList);
 325         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1Builder tpNode1 =
 326             new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1Builder();
 327         tpNode1.setTerminationPoint(tpList);
 328         nodebldr.addAugmentation(
 329                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1.class,
 330                 tpNode1.build());
 331         LOG.info("The nodebldr {}",nodebldr);
 332         return nodebldr;
 333     }
 334
 335
 336     private NodeData createDegreeNode(String nodeId, int degreeCounter) {
 337         // Create augmentation node to inorder to add degree
 338         Node1Builder node1bldr = new Node1Builder();
 339         // set node type to degree
 340         node1bldr.setNodeType(OpenroadmNodeType.DEGREE);
 341
 342         // Get connection ports on degree number = degreeCounter in order to get port
 343         // direction
 344         List<ConnectionPorts> degreeConPorts = getDegreePorts(nodeId, degreeCounter);
 345         if ((degreeConPorts == null) || degreeConPorts.isEmpty()) {
 346             return null;
 347         }
 348
 349         DegreeAttributesBuilder degAttBldr = new DegreeAttributesBuilder();
 350         degAttBldr.setDegreeNumber(degreeCounter);
 351         degAttBldr.setAvailableWavelengths(create96AvalWaveDegree());
 352         node1bldr.setDegreeAttributes(degAttBldr.build());
 353
 354         String nodeIdtopo = new StringBuilder(nodeId).append("-DEG").append(degreeCounter).toString();
 355         // Create a generic Topo Layer node
 356         NodeBuilder nodebldr = createTopoLayerNode(nodeId);
 357         nodebldr.setNodeId(new NodeId(nodeIdtopo));
 358         // Ad degree node specific augmentation
 359         nodebldr.addAugmentation(Node1.class, node1bldr.build());
 360         // Get Port direction
 361         int portDirectionEnum = getPortDirection(nodeId, degreeConPorts.get(0).getCircuitPackName(),
 362                                              degreeConPorts.get(0).getPortName().toString());
 363
 364         /*
 365          * if bi-directional then create 2 tp's :
 366          *
 367          * --> TTP-TXRX --> CTP-TXRX
 368          *
 369          * if uni-directional :
 370          *
 371          *     --> TTP-TX
 372          *     --> TTP-RX
 373          *     --> CTP-TX
 374          *     --> CTP-RX
 375          */
 376         TerminationPoint1Builder tp1Bldr = new TerminationPoint1Builder();
 377         TerminationPointBuilder tempTpBldr;
 378
 379         List<TerminationPoint> tpList = new ArrayList<>();
 380         if ((portDirectionEnum == 1) || (portDirectionEnum == 2)) {
 381             // ports are uni Directional on a degree, therefore 4 termination points
 382             // Create TTP-TX termination
 383
 384             tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-TX");
 385             tp1Bldr.setTpType(OpenroadmTpType.DEGREETXTTP);
 386             tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
 387             tpList.add(tempTpBldr.build());
 388
 389             // Create TTP-RX termination
 390             tp1Bldr = new TerminationPoint1Builder();
 391             tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-RX");
 392             tp1Bldr.setTpType(OpenroadmTpType.DEGREERXTTP);
 393
 394             tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
 395             tpList.add(tempTpBldr.build());
 396
 397             // Create CTP-TX termination
 398             tp1Bldr = new TerminationPoint1Builder();
 399             tempTpBldr = createTpBldr("DEG" + degreeCounter + "-CTP-TX");
 400             tp1Bldr.setTpType(OpenroadmTpType.DEGREETXCTP);
 401             tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
 402             tpList.add(tempTpBldr.build());
 403
 404             // Create CTP-RX termination
 405             tp1Bldr = new TerminationPoint1Builder();
 406             tempTpBldr = createTpBldr("DEG" + degreeCounter + "-CTP-RX");
 407             tp1Bldr.setTpType(OpenroadmTpType.DEGREERXCTP);
 408             tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
 409             tpList.add(tempTpBldr.build());
 410
 411         } else if (portDirectionEnum == 3) {
 412             // Ports are bi directional therefore 2 termination points
 413             // Create TTP-TXRX termination
 414             tp1Bldr = new TerminationPoint1Builder();
 415             tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-TXRX");
 416             tp1Bldr.setTpType(OpenroadmTpType.DEGREETXRXTTP);
 417             tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
 418             tpList.add(tempTpBldr.build());
 419
 420             // Create CTP-TXRX termination
 421             tp1Bldr = new TerminationPoint1Builder();
 422             tempTpBldr = createTpBldr("DEG" + degreeCounter + "-CTP-TXRX");
 423             tp1Bldr.setTpType(OpenroadmTpType.DEGREETXRXCTP);
 424             tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
 425             tpList.add(tempTpBldr.build());
 426
 427         }
 428
 429         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1Builder tpNode1 =
 430             new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1Builder();
 431
 432         tpNode1.setTerminationPoint(tpList);
 433
 434         nodebldr.addAugmentation(
 435                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1.class,
 436                 tpNode1.build());
 437         return new NodeData(nodebldr, portDirectionEnum);
 438     }
 439
 440
 441     private NodeBuilder createSrgNode(String nodeId, int srgCounter, int portDirectionEnum) {
 442         // Create augmentation node to inorder to add degree
 443         Node1Builder node1bldr = new Node1Builder();
 444         // set node type to degree
 445         node1bldr.setNodeType(OpenroadmNodeType.SRG);
 446
 447         node1bldr.setNodeType(OpenroadmNodeType.SRG);
 448
 449         SrgAttributesBuilder srgAttrBldr = new SrgAttributesBuilder();
 450         srgAttrBldr.setAvailableWavelengths(create96AvalWaveSrg());
 451         node1bldr.setSrgAttributes(srgAttrBldr.build());
 452
 453         // Create a generic Topo Layer node
 454         NodeBuilder nodebldr = createTopoLayerNode(nodeId);
 455         nodebldr.addAugmentation(Node1.class, node1bldr.build());
 456
 457         // Get connection ports on degree number = degreeCounter in order to get port
 458         // direction
 459         int maxPpPorts = getMaxPp(nodeId, srgCounter);
 460         if (maxPpPorts == -1) {
 461             return null;
 462         }
 463
 464
 465         String nodeIdtopo = new StringBuilder().append(nodeId).append("-SRG").append(srgCounter).toString();
 466         nodebldr.setNodeId(new NodeId(nodeIdtopo));
 467         List<TerminationPoint> tpList = new ArrayList<>();
 468
 469         TerminationPoint1Builder tp1Bldr;
 470         TerminationPointBuilder tempTpBldr;
 471
 472         for (int i = 1; i <= maxPpPorts; i++) {
 473             if ((portDirectionEnum == 1) || (portDirectionEnum == 2)) {
 474                 if (i >= (maxPpPorts / 2)) {
 475                     break;
 476                 }
 477                 // ports are uni Directional on a degree, therefore 4 termination points
 478                 // Create TTP-TX termination
 479                 tempTpBldr = createTpBldr("SRG" + srgCounter + "-PP" + i + "-TX");
 480                 tp1Bldr = new TerminationPoint1Builder();
 481                 tp1Bldr.setTpType(OpenroadmTpType.SRGTXPP);
 482                 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
 483                 tpList.add(tempTpBldr.build());
 484
 485                 // Create TTP-RX termination
 486                 tempTpBldr = createTpBldr("SRG" + srgCounter + "-PP" + i + "-RX");
 487                 tp1Bldr = new TerminationPoint1Builder();
 488                 tp1Bldr.setTpType(OpenroadmTpType.SRGRXPP);
 489                 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
 490                 tpList.add(tempTpBldr.build());
 491
 492             } else if (portDirectionEnum == 3) {
 493                 // Ports are bi directional therefore 2 termination points
 494                 // Create TTP-TXRX termination
 495                 tempTpBldr = createTpBldr("SRG" + srgCounter + "-PP" + i + "-TXRX");
 496                 tp1Bldr = new TerminationPoint1Builder();
 497                 tp1Bldr.setTpType(OpenroadmTpType.SRGTXRXPP);
 498                 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
 499                 tpList.add(tempTpBldr.build());
 500             }
 501         }
 502
 503         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1Builder tpNode1 =
 504             new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1Builder();
 505
 506         tpNode1.setTerminationPoint(tpList);
 507
 508         nodebldr.addAugmentation(
 509                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Node1.class,
 510                 tpNode1.build());
 511
 512         return nodebldr;
 513     }
 514
 515     /*
 516      * This method will return the TTP ports in the device for a given degree number to be used by the
 517      * node to create TTP and CTP termination point on the device
 518      */
 519     private List<ConnectionPorts> getDegreePorts(String deviceId, Integer degreeCounter) {
 520         List<ConnectionPorts> degreeConPorts = new ArrayList<>();
 521         LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
 522         InstanceIdentifier<Degree> deviceIID =
 523                 InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Degree.class, new DegreeKey(degreeCounter));
 524
 525         Optional<Degree> ordmDegreeObject =
 526                 this.deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.CONFIGURATION, deviceIID,
 527                         Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 528
 529         if (ordmDegreeObject.isPresent()) {
 530             degreeConPorts.addAll(new ArrayList<>(ordmDegreeObject.get().getConnectionPorts()));
 531         } else {
 532             LOG.info("Device has {} degree", (degreeCounter - 1));
 533             return Collections.emptyList();
 534         }
 535         return degreeConPorts;
 536     }
 537
 538     private int getMaxPp(String deviceId, Integer srgCounter) {
 539         int maxPpPorts;
 540         LOG.info("Getting max pp ports for Srg Number {}", srgCounter);
 541         InstanceIdentifier<SharedRiskGroup> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 542                 .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
 543         Optional<SharedRiskGroup> ordmSrgObject =
 544                 this.deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, deviceIID,
 545                         Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 546         if (ordmSrgObject.isPresent()) {
 547             if (ordmSrgObject.get().getMaxAddDropPorts() != null) {
 548                 maxPpPorts = ordmSrgObject.get().getMaxAddDropPorts();
 549             } else {
 550                 LOG.info("Max add drop ports absent");
 551                 return -1;
 552             }
 553         } else {
 554             LOG.info("SRG  absent");
 555             return -1;
 556         }
 557         return maxPpPorts;
 558     }
 559
 560     private NodeBuilder createTopoLayerNode(String nodeId) {
 561         // Sets the value of Network-ref and Node-ref as a part of the supporting node
 562         // attribute
 563         SupportingNodeBuilder supportbldr = new SupportingNodeBuilder();
 564         supportbldr.setKey(new SupportingNodeKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID), new NodeId(nodeId)));
 565         supportbldr.setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID));
 566         supportbldr.setNodeRef(new NodeId(nodeId));
 567         ArrayList<SupportingNode> supportlist = new ArrayList<>();
 568         supportlist.add(supportbldr.build());
 569         NodeBuilder nodebldr = new NodeBuilder();
 570         nodebldr.setSupportingNode(supportlist);
 571         return nodebldr;
 572     }
 573
 574     // Return 0 for null/error values
 575     // Return 1 for tx
 576     // Return 2 for rx
 577     // Return 3 for bi-directional
 578
 579     private int getPortDirection(String deviceId, String circuitPackName, String portName) {
 580         InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 581                 .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName))
 582                 .child(Ports.class, new PortsKey(portName));
 583         LOG.info("Fetching Port Direction for port {} at circuit pack {}", portName, circuitPackName);
 584         Optional<Ports> portObject =
 585                 this.deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, portIID,
 586                         Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 587         if (portObject.isPresent()) {
 588             Ports port = portObject.get();
 589             if (port.getPortDirection() != null) {
 590                 return port.getPortDirection().getIntValue();
 591             } else {
 592                 LOG.warn("Port direction value missing for {} {}", circuitPackName, port.getPortName());
 593                 return 0;
 594             }
 595         }
 596         return 0;
 597     }
 598
 599     // This method returns a generic termination point builder for a given tpid
 600     private TerminationPointBuilder createTpBldr(String tpId) {
 601         TerminationPointBuilder tpBldr = new TerminationPointBuilder();
 602         TpId tp = new TpId(tpId);
 603         TerminationPointKey tpKey = new TerminationPointKey(tp);
 604         tpBldr.setKey(tpKey);
 605         tpBldr.setTpId(tp);
 606         return tpBldr;
 607     }
 608
 609     // This method returns the linkBuilder object for given source and destination
 610     public LinkBuilder createLink(String srcNode, String dstNode, String srcTp, String destTp) {
 611         LOG.info("creating link for {}-{}", srcNode, dstNode);
 612         // Create Destination for link
 613         DestinationBuilder dstNodeBldr = new DestinationBuilder();
 614         dstNodeBldr.setDestTp(destTp);
 615         dstNodeBldr.setDestNode(new NodeId(dstNode));
 616         // Create Source for the link
 617         SourceBuilder srcNodeBldr = new SourceBuilder();
 618         srcNodeBldr.setSourceNode(new NodeId(srcNode));
 619         srcNodeBldr.setSourceTp(srcTp);
 620         LinkBuilder lnkBldr = new LinkBuilder();
 621         // set link builder attribute
 622         lnkBldr.setDestination(dstNodeBldr.build());
 623         lnkBldr.setSource(srcNodeBldr.build());
 624         lnkBldr.setLinkId(LinkIdUtil.buildLinkId(srcNode, srcTp, dstNode, destTp));
 625         lnkBldr.setKey(new LinkKey(lnkBldr.getLinkId()));
 626         org.opendaylight.yang.gen.v1.http.org.openroadm.opposite.links.rev170929.Link1Builder lnk1Bldr =
 627                 new org.opendaylight.yang.gen.v1.http.org.openroadm.opposite.links.rev170929.Link1Builder();
 628         LinkId oppositeLinkId = LinkIdUtil.getOppositeLinkId(srcNode, srcTp, dstNode, destTp);
 629         lnk1Bldr.setOppositeLink(oppositeLinkId);
 630         lnkBldr.addAugmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.opposite.links.rev170929.Link1.class,
 631                 lnk1Bldr.build());
 632         return lnkBldr;
 633     }
 634
 635     private List<Link> createExpressLinks(String nodeId, int numOfDegrees, int portDirectionEnum) {
 636         LOG.info("creating express links {} {} {}", nodeId, numOfDegrees, portDirectionEnum);
 637         List<Link> links = new ArrayList<>();
 638
 639         String srcNode;
 640         String destNode;
 641
 642         String srcTp;
 643         String destTp;
 644
 645         // ports are uni-directional
 646         if ((portDirectionEnum == 1) || (portDirectionEnum == 2)) {
 647             LOG.info("creating uni-directional express links");
 648             for (int i = 1; i <= numOfDegrees; i++) {
 649                 for (int j = i + 1; j <= numOfDegrees; j++) {
 650
 651                     srcNode = nodeId + "-DEG" + i;
 652                     destNode = nodeId + "-DEG" + j;
 653
 654                     // AtoZ direction
 655                     srcTp = "DEG" + i + "-CTP-TX";
 656                     destTp = "DEG" + j + "-CTP-RX";
 657
 658                     LinkBuilder expLinkBldr = createLink(srcNode, destNode, srcTp, destTp);
 659
 660                     Link1Builder lnk1Bldr = new Link1Builder();
 661                     lnk1Bldr.setLinkType(OpenroadmLinkType.EXPRESSLINK);
 662                     expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
 663
 664                     links.add(expLinkBldr.build());
 665
 666                     // ZtoA direction
 667                     srcTp = "DEG" + i + "-CTP-RX";
 668                     destTp = "DEG" + j + "-CTP-TX";
 669
 670                     expLinkBldr = createLink(destNode, srcNode, destTp, srcTp);
 671                     expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
 672
 673                     links.add(expLinkBldr.build());
 674
 675                 }
 676             }
 677         }
 678
 679         // ports are bi-directional
 680         if (portDirectionEnum == 3) {
 681             LOG.info("creating bi-directional express links");
 682             for (int i = 1; i <= numOfDegrees; i++) {
 683                 for (int j = i + 1; j <= numOfDegrees; j++) {
 684
 685                     srcNode = nodeId + "-DEG" + i;
 686                     destNode = nodeId + "-DEG" + j;
 687
 688                     // AtoZ direction
 689                     srcTp = "DEG" + i + "-CTP-TXRX";
 690                     destTp = "DEG" + j + "-CTP-TXRX";
 691
 692                     Link1Builder lnk1Bldr = new Link1Builder();
 693                     lnk1Bldr.setLinkType(OpenroadmLinkType.EXPRESSLINK);
 694
 695
 696                     LinkBuilder expLinkBldr = createLink(srcNode, destNode, srcTp, destTp);
 697                     expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
 698                     links.add(expLinkBldr.build());
 699
 700                     // ZtoA direction
 701                     expLinkBldr = createLink(destNode, srcNode, destTp, srcTp);
 702                     expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
 703                     links.add(expLinkBldr.build());
 704                 }
 705             }
 706         }
 707         return links;
 708     }
 709
 710     private List<Link> createAddDropLinks(String nodeId, int numOfDegrees, int numOfSrgs,
 711             int portDirectionEnum) {
 712         LOG.info("creating add-drop links {} {} {} {}", nodeId, numOfDegrees, numOfSrgs, portDirectionEnum);
 713         List<Link> links = new ArrayList<>();
 714
 715         String srcNode;
 716         String destNode;
 717
 718         String srcTp;
 719         String destTp;
 720
 721         // ports are uni-directional
 722         if ((portDirectionEnum == 1) || (portDirectionEnum == 2)) {
 723             LOG.info("creating uni-directional add-drop links");
 724             for (int i = 1; i <= numOfDegrees; i++) {
 725                 for (int j = 1; j <= numOfSrgs; j++) {
 726
 727                     srcNode = nodeId + "-DEG" + i;
 728                     destNode = nodeId + "-SRG" + j;
 729
 730                     // drop links
 731                     srcTp = "DEG" + i + "-CTP-TX";
 732                     destTp = "SRG" + j + "-CP-RX";
 733
 734                     LinkBuilder addDropLinkBldr = createLink(srcNode, destNode, srcTp, destTp);
 735                     Link1Builder lnk1Bldr = new Link1Builder();
 736                     lnk1Bldr.setLinkType(OpenroadmLinkType.DROPLINK);
 737                     addDropLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
 738                     links.add(addDropLinkBldr.build());
 739
 740                     // add links direction
 741                     srcTp = "DEG" + i + "-CTP-RX";
 742                     destTp = "SRG" + j + "-CP-TX";
 743
 744                     addDropLinkBldr = createLink(destNode, srcNode, destTp, srcTp);
 745                     lnk1Bldr.setLinkType(OpenroadmLinkType.ADDLINK);
 746                     addDropLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
 747                     links.add(addDropLinkBldr.build());
 748
 749                 }
 750             }
 751         }
 752         // ports are bi-directional
 753         if (portDirectionEnum == 3) {
 754             LOG.info("creating bi-directional add-drop links");
 755             for (int i = 1; i <= numOfDegrees; i++) {
 756                 for (int j = 1; j <= numOfSrgs; j++) {
 757
 758                     srcNode = nodeId + "-DEG" + i;
 759                     destNode = nodeId + "-SRG" + j;
 760
 761                     // drop links
 762                     srcTp = "DEG" + i + "-CTP-TXRX";
 763                     destTp = "SRG" + j + "-CP-TXRX";
 764
 765                     LinkBuilder addDropLinkBldr = createLink(srcNode, destNode, srcTp, destTp);
 766                     Link1Builder lnk1Bldr = new Link1Builder();
 767                     lnk1Bldr.setLinkType(OpenroadmLinkType.DROPLINK);
 768                     addDropLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
 769                     links.add(addDropLinkBldr.build());
 770
 771                     // add link
 772                     addDropLinkBldr = createLink(destNode, srcNode, destTp, srcTp);
 773                     lnk1Bldr.setLinkType(OpenroadmLinkType.ADDLINK);
 774                     addDropLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
 775                     links.add(addDropLinkBldr.build());
 776                 }
 777             }
 778         }
 779         return links;
 780     }
 781
 782     // This method returns the linkBuilder object for given source and destination
 783     public boolean deleteLink(String srcNode, String dstNode, String srcTp, String destTp) {
 784         LOG.info("deleting link for {}-{}", srcNode, dstNode);
 785         try {
 786             InstanceIdentifierBuilder<Link> linkIID = InstanceIdentifier
 787                     .builder(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
 788                     .augmentation(Network1.class)
 789                     .child(Link.class, new LinkKey(LinkIdUtil.buildLinkId(srcNode, srcTp, dstNode, destTp)));
 790             WriteTransaction wrtx = this.dataBroker.newWriteOnlyTransaction();
 791             wrtx.delete(LogicalDatastoreType.CONFIGURATION, linkIID.build());
 792             wrtx.submit().get(1, TimeUnit.SECONDS);
 793         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 794             LOG.error(e.getMessage(), e);
 795             return false;
 796         }
 797         return true;
 798     }
 799
 800     private List<AvailableWavelengths> create96AvalWaveDegree() {
 801         List<AvailableWavelengths> waveList = new ArrayList<>();
 802
 803         for (int i = 1; i < 97; i++) {
 804             AvailableWavelengthsBuilder avalBldr = new AvailableWavelengthsBuilder();
 805             avalBldr.setIndex((long) i);
 806             avalBldr.setKey(new AvailableWavelengthsKey((long) i));
 807             waveList.add(avalBldr.build());
 808         }
 809
 810         return waveList;
 811     }
 812
 813     private List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes.AvailableWavelengths>
 814         create96AvalWaveSrg() {
 815
 816         List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes.AvailableWavelengths>
 817             waveList = new ArrayList<>();
 818
 819         for (int i = 1; i < 97; i++) {
 820             org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes
 821                 .AvailableWavelengthsBuilder avalBldr =
 822                 new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes
 823                     .AvailableWavelengthsBuilder();
 824             avalBldr.setIndex((long) i);
 825             avalBldr.setKey(
 826                 new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev170929.srg.node.attributes
 827                     .AvailableWavelengthsKey((long) i));
 828             waveList.add(avalBldr.build());
 829         }
 830
 831         return waveList;
 832     }
 833 }