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