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