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