2 * Copyright © 2016 AT&T and others. All rights reserved.
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
9 package org.opendaylight.transportpce.networkmodel.util;
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;
19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
20 import org.opendaylight.transportpce.common.NetworkUtils;
21 import org.opendaylight.transportpce.common.Timeouts;
22 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
23 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
24 import org.opendaylight.transportpce.networkmodel.dto.NodeData;
25 import org.opendaylight.transportpce.networkmodel.dto.TopologyShard;
26 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.NetworkTypes1;
27 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.NetworkTypes1Builder;
28 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.networks.network.network.types.OpenroadmCommonNetworkBuilder;
29 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.NodeTypes;
30 import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes.AvailableWavelengths;
31 import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes.AvailableWavelengthsBuilder;
32 import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes.AvailableWavelengthsKey;
33 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.Ports;
34 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.PortsKey;
35 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacks;
36 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
37 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPorts;
38 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
39 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Degree;
40 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeKey;
41 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Info;
42 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
43 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
44 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1;
45 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1Builder;
46 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1;
47 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1Builder;
48 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.TerminationPoint1;
49 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.TerminationPoint1Builder;
50 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.node.DegreeAttributesBuilder;
51 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.node.SrgAttributesBuilder;
52 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.node.termination.point.XpdrClientAttributesBuilder;
53 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.node.termination.point.XpdrNetworkAttributesBuilder;
54 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmLinkType;
55 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmNodeType;
56 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmTpType;
57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkBuilder;
62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
63 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NetworkTypesBuilder;
64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
65 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeBuilder;
66 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeKey;
67 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
68 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeBuilder;
69 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeKey;
70 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1;
71 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1Builder;
72 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
73 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
74 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkBuilder;
75 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
76 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointBuilder;
77 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPointKey;
78 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
79 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
80 import org.slf4j.Logger;
81 import org.slf4j.LoggerFactory;
83 public class OpenRoadmTopology121 {
85 private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmTopology121.class);
86 private static final int DEFAULT_PORT_DIRECTION = -1;
87 private static final int MAX_DEGREE = 20;
88 private static final int MAX_SRG = 20;
90 private NetworkTransactionService networkTransactionService;
91 private final DeviceTransactionManager deviceTransactionManager;
93 public OpenRoadmTopology121(NetworkTransactionService networkTransactionService,
94 DeviceTransactionManager deviceTransactionManager) {
95 this.networkTransactionService = networkTransactionService;
96 this.deviceTransactionManager = deviceTransactionManager;
100 * This public method creates the OpenROADM Topology Layer and posts it to
103 public void createTopoLayer() {
105 Network openRoadmTopology = createOpenRoadmTopology();
106 InstanceIdentifierBuilder<Network> nwIID = InstanceIdentifier.builder(Networks.class).child(Network.class,
107 new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)));
108 this.networkTransactionService.put(LogicalDatastoreType.CONFIGURATION, nwIID.build(), openRoadmTopology);
109 this.networkTransactionService.submit().get(1, TimeUnit.SECONDS);
110 LOG.info("OpenRoadm-Topology created successfully.");
111 } catch (ExecutionException | TimeoutException | InterruptedException e) {
112 LOG.warn("Failed to create OpenRoadm-Topology", e);
117 * Create empty OpenROADM topology.
119 private Network createOpenRoadmTopology() {
120 NetworkBuilder nwBuilder = new NetworkBuilder();
121 NetworkId nwId = new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID);
122 nwBuilder.setNetworkId(nwId);
123 nwBuilder.withKey(new NetworkKey(nwId));
124 // set network type to Transport Underlay
125 NetworkTypes1Builder topoNetworkTypesBldr = new NetworkTypes1Builder();
126 topoNetworkTypesBldr.setOpenroadmCommonNetwork(new OpenroadmCommonNetworkBuilder().build());
127 NetworkTypesBuilder nwTypeBuilder = new NetworkTypesBuilder();
128 nwTypeBuilder.addAugmentation(NetworkTypes1.class, topoNetworkTypesBldr.build());
129 nwBuilder.setNetworkTypes(nwTypeBuilder.build());
130 // Array to store nodes in the topolayer of a roadm/Xponder
131 Network1Builder nwBldr1 = new Network1Builder();
132 // adding expressLinks
133 nwBldr1.setLink(Collections.emptyList());
134 nwBuilder.addAugmentation(Network1.class, nwBldr1.build());
135 nwBuilder.setNode(Collections.emptyList());
136 return nwBuilder.build();
139 public TopologyShard createTopologyShard(String nodeId) {
142 int portDirectionEnum = DEFAULT_PORT_DIRECTION;
144 InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
145 java.util.Optional<Info> deviceInfoOpt =
146 deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, infoIID,
147 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
149 if (deviceInfoOpt.isPresent()) {
150 deviceInfo = deviceInfoOpt.get();
152 LOG.error("Unable to get device info for device {}!", nodeId);
155 List<Node> nodes = new ArrayList<>();
157 // Check if node is ROADM
158 if (NodeTypes.Rdm.equals(deviceInfo.getNodeType())) {
161 * Adding Degree Node Get Degree Number -> x then get connection ports then find the port directions
162 * to decide whether TX/RX/TXRX Get value for max degree from info subtree, required for iteration
163 * if not present assume to be 20 (temporary)
167 if (deviceInfo.getMaxDegrees() != null) {
168 maxDegree = deviceInfo.getMaxDegrees();
170 maxDegree = MAX_DEGREE;
173 // Starting with degree Number = 1
174 Integer degreeCounter = 1;
176 while (degreeCounter <= maxDegree) {
177 LOG.info("creating degree node {}/{}", degreeCounter, maxDegree);
178 NodeData nodeData = createDegreeNode(nodeId, degreeCounter);
179 if (nodeData != null) {
180 NodeBuilder tempNode = nodeData.getNodeBuilder();
181 portDirectionEnum = nodeData.getPortDirectionEnum();
182 nodes.add(tempNode.build());
185 // null returned if Degree number= degreeCounter not present in the device
190 numOfDegrees = degreeCounter - 1;
193 if (deviceInfo.getMaxSrgs() != null) {
194 maxSrg = deviceInfo.getMaxSrgs();
199 // Starting with degree Number = 1
200 Integer srgCounter = 1;
202 while (srgCounter <= maxSrg) {
203 LOG.info("creating SRG node {}/{}", srgCounter, maxSrg);
204 NodeBuilder tempNode = createSrgNode(nodeId, srgCounter, portDirectionEnum);
206 if (tempNode != null) {
207 nodes.add(tempNode.build());
210 // null returned if Degree number= degreeCounter not present in the device
214 numOfSrgs = srgCounter - 1;
217 LOG.info("adding links numOfDegrees={} numOfSrgs={}", numOfDegrees, numOfSrgs);
218 List<Link> links = new ArrayList<>();
219 links.addAll(createExpressLinks(nodeId, numOfDegrees, portDirectionEnum));
220 links.addAll(createAddDropLinks(nodeId, numOfDegrees, numOfSrgs, portDirectionEnum));
221 LOG.info("created nodes/links: {}/{}", nodes.size(), links.size());
222 return new TopologyShard(nodes, links);
223 } else if (NodeTypes.Xpdr.equals(deviceInfo.getNodeType())) {
224 // Check if node is XPONDER
225 Integer clientport = getNoOfClientPorts(nodeId);
226 List<Link> links = new ArrayList<>();
227 Integer clientCounter = 1;
228 Integer lineCounter = 1;
229 while (clientCounter <= clientport) {
230 NodeBuilder tempNode = createXpdr(clientCounter, lineCounter, nodeId);
231 if (tempNode == null) {
234 nodes.add(tempNode.build());
237 LOG.info("Entered this loop");
239 return new TopologyShard(nodes, links);
246 * This private method gets the list of circuit packs on a xponder. For each circuit pack on a
247 * Xponder, it does a get on circuit-pack subtree with circuit-pack-name as key in order to get the
248 * list of ports. It then iterates over the list of ports to get ports with port-qual as
249 * xpdr-network/xpdr-client. The line and client ports are saved as:
257 private int getNoOfClientPorts(String deviceId) {
258 // Creating for Xponder Line and Client Ports
259 InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
260 Optional<OrgOpenroadmDevice> deviceObject =
261 deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, deviceIID,
262 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
264 // Variable to keep track of number of client ports
266 if (deviceObject.isPresent()) {
267 for (CircuitPacks cp : deviceObject.get().getCircuitPacks()) {
268 if (cp.getPorts() != null) {
269 for (Ports port : cp.getPorts()) {
270 if ((port.getPortQual() != null) && (port.getPortQual().getIntValue() == 4)) {
282 private NodeBuilder createXpdr(Integer clientCounter, Integer lineCounter, String nodeId) {
283 // Create a generic Topo Layer node
284 NodeBuilder nodebldr = createTopoLayerNode(nodeId);
285 // Create augmentation node to inorder to add degree
286 Node1Builder node1bldr = new Node1Builder();
287 TerminationPoint1Builder tp1Bldr = new TerminationPoint1Builder();
288 TerminationPointBuilder tempTpBldr;
290 // set node type to Xponder
291 node1bldr.setNodeType(OpenroadmNodeType.XPONDER);
292 List<TerminationPoint> tpList = new ArrayList<>();
293 String nodeIdtopo = new StringBuilder().append(nodeId).append("-XPDR1").toString();
296 nodebldr.setNodeId(new NodeId(nodeIdtopo));
297 nodebldr.withKey(new NodeKey(new NodeId(nodeIdtopo)));
298 nodebldr.addAugmentation(Node1.class, node1bldr.build());
299 while (clientCounter != 0) {
300 // Create CLNT-TX termination
301 tempTpBldr = createTpBldr("XPDR1-CLIENT" + clientCounter);
302 tp1Bldr.setTpType(OpenroadmTpType.XPONDERCLIENT);
303 XpdrClientAttributesBuilder xpdrClntBldr = new XpdrClientAttributesBuilder();
304 xpdrClntBldr.setTailEquipmentId("XPDR1-NETWORK" + clientCounter);
305 tp1Bldr.setXpdrClientAttributes(xpdrClntBldr.build());
306 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
307 tpList.add(tempTpBldr.build());
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());
321 LOG.info("printing tpList {}",tpList);
322 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
323 .Node1Builder tpNode1 = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf
324 .network.topology.rev180226.Node1Builder();
325 tpNode1.setTerminationPoint(tpList);
326 nodebldr.addAugmentation(
327 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class,
329 LOG.info("The nodebldr {}",nodebldr);
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);
340 // Get connection ports on degree number = degreeCounter in order to get port
342 List<ConnectionPorts> degreeConPorts = getDegreePorts(nodeId, degreeCounter);
343 if (degreeConPorts == null || degreeConPorts.isEmpty()) {
347 DegreeAttributesBuilder degAttBldr = new DegreeAttributesBuilder();
348 degAttBldr.setDegreeNumber(degreeCounter);
349 degAttBldr.setAvailableWavelengths(create96AvalWaveDegree());
350 node1bldr.setDegreeAttributes(degAttBldr.build());
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());
363 * if bi-directional then create 2 tp's :
365 * --> TTP-TXRX --> CTP-TXRX
367 * if uni-directional :
374 TerminationPoint1Builder tp1Bldr = new TerminationPoint1Builder();
375 TerminationPointBuilder tempTpBldr;
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
382 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-TX");
383 tp1Bldr.setTpType(OpenroadmTpType.DEGREETXTTP);
384 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
385 tpList.add(tempTpBldr.build());
387 // Create TTP-RX termination
388 tp1Bldr = new TerminationPoint1Builder();
389 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-RX");
390 tp1Bldr.setTpType(OpenroadmTpType.DEGREERXTTP);
392 tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
393 tpList.add(tempTpBldr.build());
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());
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());
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());
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());
427 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
428 .Node1Builder tpNode1
429 = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network
430 .topology.rev180226.Node1Builder();
432 tpNode1.setTerminationPoint(tpList);
434 nodebldr.addAugmentation(
435 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class,
437 return new NodeData(nodebldr, portDirectionEnum);
441 private NodeBuilder createSrgNode(String nodeId, int srgCounter, int portDirectionEnum) {
442 // Create augmentation node to in order to add srg
443 Node1Builder node1bldr = new Node1Builder();
444 // set node type to SRG
445 node1bldr.setNodeType(OpenroadmNodeType.SRG);
447 node1bldr.setNodeType(OpenroadmNodeType.SRG);
449 SrgAttributesBuilder srgAttrBldr = new SrgAttributesBuilder();
450 srgAttrBldr.setAvailableWavelengths(create96AvalWaveSrg());
451 node1bldr.setSrgAttributes(srgAttrBldr.build());
453 // Create a generic Topo Layer node
454 NodeBuilder nodebldr = createTopoLayerNode(nodeId);
455 nodebldr.addAugmentation(Node1.class, node1bldr.build());
458 // Get connection ports on degree number = degreeCounter in order to get port
460 int maxPpPorts = getMaxPp(nodeId, srgCounter);
461 if (maxPpPorts == -1) {
466 String nodeIdtopo = new StringBuilder().append(nodeId).append("-SRG").append(srgCounter).toString();
467 nodebldr.setNodeId(new NodeId(nodeIdtopo));
468 List<TerminationPoint> tpList = new ArrayList<>();
470 TerminationPoint1Builder tp1Bldr;
471 TerminationPointBuilder tempTpBldr;
473 for (int i = 1; i <= maxPpPorts; i++) {
474 if (portDirectionEnum == 1 || portDirectionEnum == 2) {
475 if (i >= maxPpPorts / 2) {
478 // ports are uni Directional on a degree, therefore 4 termination points
479 // Create PP-TX termination
480 tempTpBldr = createTpBldr("SRG" + srgCounter + "-PP" + i + "-TX");
481 tp1Bldr = new TerminationPoint1Builder();
482 tp1Bldr.setTpType(OpenroadmTpType.SRGTXPP);
483 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
484 tpList.add(tempTpBldr.build());
486 // Create PP-RX termination
487 tempTpBldr = createTpBldr("SRG" + srgCounter + "-PP" + i + "-RX");
488 tp1Bldr = new TerminationPoint1Builder();
489 tp1Bldr.setTpType(OpenroadmTpType.SRGRXPP);
490 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
491 tpList.add(tempTpBldr.build());
493 } else if (portDirectionEnum == 3) {
494 // Ports are bi directional therefore 2 termination points
495 // Create PP-TXRX termination
496 tempTpBldr = createTpBldr("SRG" + srgCounter + "-PP" + i + "-TXRX");
497 tp1Bldr = new TerminationPoint1Builder();
498 tp1Bldr.setTpType(OpenroadmTpType.SRGTXRXPP);
499 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
500 tpList.add(tempTpBldr.build());
504 switch (portDirectionEnum) {
505 case 1: // ports are uni Directional on a degree
507 // Create CP-TX termination
508 tempTpBldr = createTpBldr("SRG" + srgCounter + "-CP" + "-TX");
509 tp1Bldr = new TerminationPoint1Builder();
510 tp1Bldr.setTpType(OpenroadmTpType.SRGTXCP);
511 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
512 tpList.add(tempTpBldr.build());
513 // Create CP-RX termination
514 tempTpBldr = createTpBldr("SRG" + srgCounter + "-CP" + "-RX");
515 tp1Bldr = new TerminationPoint1Builder();
516 tp1Bldr.setTpType(OpenroadmTpType.SRGRXCP);
517 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
518 tpList.add(tempTpBldr.build());
521 // Ports are bi directional therefore 2 termination points
522 // Create CP-TXRX termination
523 tempTpBldr = createTpBldr("SRG" + srgCounter + "-CP" + "-TXRX");
524 tp1Bldr = new TerminationPoint1Builder();
525 tp1Bldr.setTpType(OpenroadmTpType.SRGTXRXCP);
526 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
527 tpList.add(tempTpBldr.build());
530 LOG.error("No correponsding direction to the value: {}", portDirectionEnum);
534 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder tpNode1 =
535 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder();
537 tpNode1.setTerminationPoint(tpList);
539 nodebldr.addAugmentation(
540 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class,
547 * This method will return the TTP ports in the device for a given degree number to be used by the
548 * node to create TTP and CTP termination point on the device
550 private List<ConnectionPorts> getDegreePorts(String deviceId, Integer degreeCounter) {
551 List<ConnectionPorts> degreeConPorts = new ArrayList<>();
552 LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
553 InstanceIdentifier<Degree> deviceIID =
554 InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Degree.class, new DegreeKey(degreeCounter));
556 Optional<Degree> ordmDegreeObject =
557 deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.CONFIGURATION, deviceIID,
558 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
560 if (ordmDegreeObject.isPresent()) {
561 degreeConPorts.addAll(new ArrayList<>(ordmDegreeObject.get().getConnectionPorts()));
563 LOG.info("Device has {} degree", (degreeCounter - 1));
564 return Collections.emptyList();
566 return degreeConPorts;
569 private int getMaxPp(String deviceId, Integer srgCounter) {
571 LOG.info("Getting max pp ports for Srg Number {}", srgCounter);
572 InstanceIdentifier<SharedRiskGroup> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
573 .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
574 Optional<SharedRiskGroup> ordmSrgObject =
575 deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, deviceIID,
576 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
577 if (ordmSrgObject.isPresent()) {
578 if (ordmSrgObject.get().getMaxAddDropPorts() != null) {
579 maxPpPorts = ordmSrgObject.get().getMaxAddDropPorts();
581 LOG.info("Max add drop ports absent");
585 LOG.info("SRG absent");
591 private NodeBuilder createTopoLayerNode(String nodeId) {
592 // Sets the value of Network-ref and Node-ref as a part of the supporting node
594 SupportingNodeBuilder supportbldr = new SupportingNodeBuilder();
595 supportbldr.withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID), new NodeId(nodeId)));
596 supportbldr.setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID));
597 supportbldr.setNodeRef(new NodeId(nodeId));
598 ArrayList<SupportingNode> supportlist = new ArrayList<>();
599 supportlist.add(supportbldr.build());
600 NodeBuilder nodebldr = new NodeBuilder();
601 nodebldr.setSupportingNode(supportlist);
605 // Return 0 for null/error values
608 // Return 3 for bi-directional
610 private int getPortDirection(String deviceId, String circuitPackName, String portName) {
611 InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
612 .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName))
613 .child(Ports.class, new PortsKey(portName));
614 LOG.info("Fetching Port Direction for port {} at circuit pack {}", portName, circuitPackName);
615 Optional<Ports> portObject =
616 deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, portIID,
617 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
618 if (portObject.isPresent()) {
619 Ports port = portObject.get();
620 if (port.getPortDirection() != null) {
621 return port.getPortDirection().getIntValue();
623 LOG.warn("Port direction value missing for {} {}", circuitPackName, port.getPortName());
630 // This method returns a generic termination point builder for a given tpid
631 private TerminationPointBuilder createTpBldr(String tpId) {
632 TerminationPointBuilder tpBldr = new TerminationPointBuilder();
633 TpId tp = new TpId(tpId);
634 TerminationPointKey tpKey = new TerminationPointKey(tp);
635 tpBldr.withKey(tpKey);
640 private List<Link> createExpressLinks(String nodeId, int numOfDegrees, int portDirectionEnum) {
641 LOG.info("creating express links {} {} {}", nodeId, numOfDegrees, portDirectionEnum);
642 List<Link> links = new ArrayList<>();
650 // ports are uni-directional
651 if (portDirectionEnum == 1 || portDirectionEnum == 2) {
652 LOG.info("creating uni-directional express links");
653 for (int i = 1; i <= numOfDegrees; i++) {
654 for (int j = i + 1; j <= numOfDegrees; j++) {
656 srcNode = nodeId + "-DEG" + i;
657 destNode = nodeId + "-DEG" + j;
660 srcTp = "DEG" + i + "-CTP-TX";
661 destTp = "DEG" + j + "-CTP-RX";
663 LinkBuilder expLinkBldr = TopologyUtils.createLink(srcNode, destNode, srcTp, destTp);
665 Link1Builder lnk1Bldr = new Link1Builder();
666 lnk1Bldr.setLinkType(OpenroadmLinkType.EXPRESSLINK);
667 expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
668 links.add(expLinkBldr.build());
671 srcTp = "DEG" + i + "-CTP-RX";
672 destTp = "DEG" + j + "-CTP-TX";
674 expLinkBldr = TopologyUtils.createLink(destNode, srcNode, destTp, srcTp);
675 expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
677 links.add(expLinkBldr.build());
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++) {
689 srcNode = nodeId + "-DEG" + i;
690 destNode = nodeId + "-DEG" + j;
693 srcTp = "DEG" + i + "-CTP-TXRX";
694 destTp = "DEG" + j + "-CTP-TXRX";
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());
703 expLinkBldr = TopologyUtils.createLink(destNode, srcNode, destTp, srcTp);
704 expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
705 links.add(expLinkBldr.build());
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<>();
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++) {
728 srcNode = nodeId + "-DEG" + i;
729 destNode = nodeId + "-SRG" + j;
732 srcTp = "DEG" + i + "-CTP-TX";
733 destTp = "SRG" + j + "-CP-RX";
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());
741 // add links direction
742 srcTp = "DEG" + i + "-CTP-RX";
743 destTp = "SRG" + j + "-CP-TX";
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());
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++) {
759 srcNode = nodeId + "-DEG" + i;
760 destNode = nodeId + "-SRG" + j;
763 srcTp = "DEG" + i + "-CTP-TXRX";
764 destTp = "SRG" + j + "-CP-TXRX";
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());
771 links.add(addDropLinkBldr.build());
774 addDropLinkBldr = TopologyUtils.createLink(destNode, srcNode, destTp, srcTp);
775 lnk1Bldr.setLinkType(OpenroadmLinkType.ADDLINK);
776 addDropLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
777 links.add(addDropLinkBldr.build());
785 private List<AvailableWavelengths> create96AvalWaveDegree() {
786 List<AvailableWavelengths> waveList = new ArrayList<>();
788 for (int i = 1; i < 97; i++) {
789 AvailableWavelengthsBuilder avalBldr = new AvailableWavelengthsBuilder();
790 avalBldr.setIndex((long) i);
791 avalBldr.withKey(new AvailableWavelengthsKey((long) i));
792 waveList.add(avalBldr.build());
798 private List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
799 .AvailableWavelengths> create96AvalWaveSrg() {
801 List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
802 .AvailableWavelengths> waveList = new ArrayList<>();
804 for (int i = 1; i < 97; i++) {
805 org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
806 .AvailableWavelengthsBuilder avalBldr =
807 new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
808 .AvailableWavelengthsBuilder();
809 avalBldr.setIndex((long) i);
811 new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
812 .AvailableWavelengthsKey((long) i));
813 waveList.add(avalBldr.build());