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