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