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