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.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;
86 public class OpenRoadmTopology22 {
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;
93 private NetworkTransactionService networkTransactionService;
94 private final DeviceTransactionManager deviceTransactionManager;
96 public OpenRoadmTopology22(NetworkTransactionService networkTransactionService,
97 DeviceTransactionManager deviceTransactionManager) {
98 this.networkTransactionService = networkTransactionService;
99 this.deviceTransactionManager = deviceTransactionManager;
103 * This public method creates the OpenROADM Topology
104 * Layer and posts it to the controller.
106 public void createTopoLayer() {
108 Network openRoadmTopology = createOpenRoadmTopology();
109 InstanceIdentifierBuilder<Network> nwIID = InstanceIdentifier.builder(Networks.class).child(Network.class,
110 new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)));
112 this.networkTransactionService.put(LogicalDatastoreType.CONFIGURATION, nwIID.build(), openRoadmTopology);
113 this.networkTransactionService.submit().get(1, TimeUnit.SECONDS);
114 LOG.info("OpenRoadm-Topology created successfully.");
115 } catch (ExecutionException | TimeoutException | InterruptedException e) {
116 LOG.warn("Failed to create OpenRoadm-Topology", e);
121 * Create empty OpenROADM topology.
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();
142 public TopologyShard createTopologyShard(String nodeId) {
145 int portDirectionEnum = DEFAULT_PORT_DIRECTION;
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);
152 if (deviceInfoOpt.isPresent()) {
153 deviceInfo = deviceInfoOpt.get();
155 LOG.error("Unable to get device info for device {}!", nodeId);
158 List<Node> nodes = new ArrayList<>();
159 // Check if node is ROADM
160 if (NodeTypes.Rdm.getName().equals(deviceInfo.getNodeType().getName())) {
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)
169 if (deviceInfo.getMaxDegrees() != null) {
170 maxDegree = deviceInfo.getMaxDegrees();
172 maxDegree = MAX_DEGREE;
175 // Starting with degree Number = 1
176 Integer degreeCounter = 1;
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());
187 // null returned if Degree number= degreeCounter not present in the device
192 numOfDegrees = degreeCounter - 1;
195 if (deviceInfo.getMaxSrgs() != null) {
196 maxSrg = deviceInfo.getMaxSrgs();
201 // Starting with degree Number = 1
202 Integer srgCounter = 1;
204 while (srgCounter <= maxSrg) {
205 LOG.info("creating SRG node {}/{}", srgCounter, maxSrg);
206 NodeBuilder tempNode = createSrgNode(nodeId, srgCounter, portDirectionEnum);
208 if (tempNode != null) {
209 nodes.add(tempNode.build());
212 // null returned if Degree number= degreeCounter not present in the device
216 numOfSrgs = srgCounter - 1;
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) {
236 nodes.add(tempNode.build());
239 LOG.info("Entered this loop");
241 return new TopologyShard(nodes, links);
243 LOG.error("Device node Type not managed yet");
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:
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);
266 // Variable to keep track of number of client ports
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) {
273 if (port.getPortQual().getIntValue() == 4) {
286 private NodeBuilder createXpdr(Integer clientCounter, Integer lineCounter, String nodeId) {
287 // Create a generic Topo Layer node
288 NodeBuilder nodebldr = createTopoLayerNode(nodeId);
289 // Create augmentation node to inorder to add degree
290 Node1Builder node1bldr = new Node1Builder();
291 TerminationPoint1Builder tp1Bldr = new TerminationPoint1Builder();
292 TerminationPointBuilder tempTpBldr;
294 // set node type to Xponder
295 node1bldr.setNodeType(OpenroadmNodeType.XPONDER);
296 List<TerminationPoint> tpList = new ArrayList<>();
297 String nodeIdtopo = new StringBuilder().append(nodeId).append("-XPDR1").toString();
298 // Ad degree node specific augmentation
299 nodebldr.setNodeId(new NodeId(nodeIdtopo));
300 nodebldr.withKey((new NodeKey(new NodeId(nodeIdtopo))));
301 nodebldr.addAugmentation(Node1.class, node1bldr.build());
302 while (clientCounter != 0) {
303 // Create CLNT-TX termination
304 tempTpBldr = createTpBldr("XPDR1-CLIENT" + clientCounter);
305 tp1Bldr.setTpType(OpenroadmTpType.XPONDERCLIENT);
306 XpdrClientAttributesBuilder xpdrClntBldr = new XpdrClientAttributesBuilder();
307 xpdrClntBldr.setTailEquipmentId("XPDR1-NETWORK" + clientCounter);
308 tp1Bldr.setXpdrClientAttributes(xpdrClntBldr.build());
309 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
310 tpList.add(tempTpBldr.build());
312 while (lineCounter != 0) {
313 // Create LINE-TX termination
314 tempTpBldr = (createTpBldr("XPDR1-NETWORK" + lineCounter));
315 tp1Bldr.setTpType(OpenroadmTpType.XPONDERNETWORK);
316 XpdrNetworkAttributesBuilder xpdrNwAttrBldr = new XpdrNetworkAttributesBuilder();
317 xpdrNwAttrBldr.setTailEquipmentId("XPDR1-CLIENT" + lineCounter);
318 tp1Bldr.setXpdrNetworkAttributes(xpdrNwAttrBldr.build());
319 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
320 tpList.add(tempTpBldr.build());
322 LOG.info("printing tpList {}",tpList);
323 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
324 .Node1Builder tpNode1 = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang
325 .ietf.network.topology.rev180226.Node1Builder();
326 tpNode1.setTerminationPoint(tpList);
327 nodebldr.addAugmentation(
328 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class,
330 LOG.info("The nodebldr {}",nodebldr);
335 private NodeData createDegreeNode(String nodeId, int degreeCounter) {
336 // Create augmentation node to inorder to add degree
337 Node1Builder node1bldr = new Node1Builder();
338 // set node type to degree
339 node1bldr.setNodeType(OpenroadmNodeType.DEGREE);
341 // Get connection ports on degree number = degreeCounter in order to get port
343 List<ConnectionPorts> degreeConPorts = getDegreePorts(nodeId, degreeCounter);
344 if (degreeConPorts == null || degreeConPorts.isEmpty()) {
348 DegreeAttributesBuilder degAttBldr = new DegreeAttributesBuilder();
349 degAttBldr.setDegreeNumber(degreeCounter);
350 degAttBldr.setAvailableWavelengths(create96AvalWaveDegree());
351 node1bldr.setDegreeAttributes(degAttBldr.build());
353 String nodeIdtopo = new StringBuilder(nodeId).append("-DEG").append(degreeCounter).toString();
354 // Create a generic Topo Layer node
355 NodeBuilder nodebldr = createTopoLayerNode(nodeId);
356 nodebldr.setNodeId(new NodeId(nodeIdtopo));
357 // Ad degree node specific augmentation
358 nodebldr.addAugmentation(Node1.class, node1bldr.build());
359 // Get Port direction
360 int portDirectionEnum = getPortDirection(nodeId, degreeConPorts.get(0).getCircuitPackName(),
361 degreeConPorts.get(0).getPortName().toString());
364 * if bi-directional then create 2 tp's :
366 * --> TTP-TXRX --> CTP-TXRX
368 * if uni-directional :
375 TerminationPoint1Builder tp1Bldr = new TerminationPoint1Builder();
376 TerminationPointBuilder tempTpBldr;
378 List<TerminationPoint> tpList = new ArrayList<>();
379 if (portDirectionEnum == 1 || portDirectionEnum == 2) {
380 // ports are uni Directional on a degree, therefore 4 termination points
381 // Create TTP-TX termination
383 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-TX");
384 tp1Bldr.setTpType(OpenroadmTpType.DEGREETXTTP);
385 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
386 tpList.add(tempTpBldr.build());
388 // Create TTP-RX termination
389 tp1Bldr = new TerminationPoint1Builder();
390 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-RX");
391 tp1Bldr.setTpType(OpenroadmTpType.DEGREERXTTP);
393 tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
394 tpList.add(tempTpBldr.build());
396 // Create CTP-TX termination
397 tp1Bldr = new TerminationPoint1Builder();
398 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-CTP-TX");
399 tp1Bldr.setTpType(OpenroadmTpType.DEGREETXCTP);
400 tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
401 tpList.add(tempTpBldr.build());
403 // Create CTP-RX termination
404 tp1Bldr = new TerminationPoint1Builder();
405 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-CTP-RX");
406 tp1Bldr.setTpType(OpenroadmTpType.DEGREERXCTP);
407 tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
408 tpList.add(tempTpBldr.build());
410 } else if (portDirectionEnum == 3) {
411 // Ports are bi directional therefore 2 termination points
412 // Create TTP-TXRX termination
413 tp1Bldr = new TerminationPoint1Builder();
414 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-TXRX");
415 tp1Bldr.setTpType(OpenroadmTpType.DEGREETXRXTTP);
416 tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
417 tpList.add(tempTpBldr.build());
419 // Create CTP-TXRX termination
420 tp1Bldr = new TerminationPoint1Builder();
421 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-CTP-TXRX");
422 tp1Bldr.setTpType(OpenroadmTpType.DEGREETXRXCTP);
423 tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
424 tpList.add(tempTpBldr.build());
428 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder tpNode1
429 = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology
430 .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());
452 // Create a generic Topo Layer node
453 NodeBuilder nodebldr = createTopoLayerNode(nodeId);
454 nodebldr.addAugmentation(Node1.class, node1bldr.build());
457 // Get connection ports on degree number = degreeCounter in order to get port
459 int maxPpPorts = getMaxPp(nodeId, srgCounter);
460 if (maxPpPorts == -1) {
465 String nodeIdtopo = new StringBuilder().append(nodeId).append("-SRG").append(srgCounter).toString();
466 nodebldr.setNodeId(new NodeId(nodeIdtopo));
467 List<TerminationPoint> tpList = new ArrayList<>();
469 TerminationPoint1Builder tp1Bldr;
470 TerminationPointBuilder tempTpBldr;
472 for (int i = 1; i <= maxPpPorts; i++) {
473 if (portDirectionEnum == 1 || portDirectionEnum == 2) {
474 if (i >= maxPpPorts / 2) {
477 // ports are uni Directional on a degree, therefore 4 termination points
478 // Create PP-TX termination
479 tempTpBldr = createTpBldr("SRG" + srgCounter + "-PP" + i + "-TX");
480 tp1Bldr = new TerminationPoint1Builder();
481 tp1Bldr.setTpType(OpenroadmTpType.SRGTXPP);
482 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
483 tpList.add(tempTpBldr.build());
485 // Create PP-RX termination
486 tempTpBldr = createTpBldr("SRG" + srgCounter + "-PP" + i + "-RX");
487 tp1Bldr = new TerminationPoint1Builder();
488 tp1Bldr.setTpType(OpenroadmTpType.SRGRXPP);
489 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
490 tpList.add(tempTpBldr.build());
492 } else if (portDirectionEnum == 3) {
493 // Ports are bi directional therefore 2 termination points
494 // Create PP-TXRX termination
495 tempTpBldr = createTpBldr("SRG" + srgCounter + "-PP" + i + "-TXRX");
496 tp1Bldr = new TerminationPoint1Builder();
497 tp1Bldr.setTpType(OpenroadmTpType.SRGTXRXPP);
498 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
499 tpList.add(tempTpBldr.build());
503 switch (portDirectionEnum) {
504 case 1: // ports are uni Directional on a degree
506 // Create CP-TX termination
507 tempTpBldr = createTpBldr("SRG" + srgCounter + "-CP" + "-TX");
508 tp1Bldr = new TerminationPoint1Builder();
509 tp1Bldr.setTpType(OpenroadmTpType.SRGTXCP);
510 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
511 tpList.add(tempTpBldr.build());
512 // Create CP-RX termination
513 tempTpBldr = createTpBldr("SRG" + srgCounter + "-CP" + "-RX");
514 tp1Bldr = new TerminationPoint1Builder();
515 tp1Bldr.setTpType(OpenroadmTpType.SRGRXCP);
516 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
517 tpList.add(tempTpBldr.build());
520 // Ports are bi directional therefore 2 termination points
521 // Create CP-TXRX termination
522 tempTpBldr = createTpBldr("SRG" + srgCounter + "-CP" + "-TXRX");
523 tp1Bldr = new TerminationPoint1Builder();
524 tp1Bldr.setTpType(OpenroadmTpType.SRGTXRXCP);
525 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
526 tpList.add(tempTpBldr.build());
529 LOG.error("No correponsding direction to the value: {}", portDirectionEnum);
533 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder tpNode1 =
534 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder();
536 tpNode1.setTerminationPoint(tpList);
538 nodebldr.addAugmentation(
539 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class,
546 * This method will return the TTP ports in the device for a given degree number to be used by the
547 * node to create TTP and CTP termination point on the device
549 private List<ConnectionPorts> getDegreePorts(String deviceId, Integer degreeCounter) {
550 List<ConnectionPorts> degreeConPorts = new ArrayList<>();
551 LOG.info("Getting Connection ports for Degree Number {}", degreeCounter);
552 InstanceIdentifier<Degree> deviceIID =
553 InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Degree.class, new DegreeKey(degreeCounter));
555 Optional<Degree> ordmDegreeObject =
556 deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.CONFIGURATION, deviceIID,
557 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
559 if (ordmDegreeObject.isPresent()) {
560 degreeConPorts.addAll(new ArrayList<>(ordmDegreeObject.get().getConnectionPorts()));
562 LOG.info("Device has {} degree", (degreeCounter - 1));
563 return Collections.emptyList();
565 return degreeConPorts;
568 private int getMaxPp(String deviceId, Integer srgCounter) {
570 LOG.info("Getting max pp ports for Srg Number {}", srgCounter);
571 InstanceIdentifier<SharedRiskGroup> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
572 .child(SharedRiskGroup.class, new SharedRiskGroupKey(srgCounter));
573 Optional<SharedRiskGroup> ordmSrgObject =
574 deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, deviceIID,
575 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
576 if (ordmSrgObject.isPresent()) {
577 if (ordmSrgObject.get().getMaxAddDropPorts() != null) {
578 maxPpPorts = ordmSrgObject.get().getMaxAddDropPorts();
580 LOG.info("Max add drop ports absent");
584 LOG.info("SRG absent");
590 private NodeBuilder createTopoLayerNode(String nodeId) {
591 // Sets the value of Network-ref and Node-ref as a part of the supporting node
593 SupportingNodeBuilder supportbldr = new SupportingNodeBuilder();
594 supportbldr.withKey(new SupportingNodeKey(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID), new NodeId(nodeId)));
595 supportbldr.setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID));
596 supportbldr.setNodeRef(new NodeId(nodeId));
597 ArrayList<SupportingNode> supportlist = new ArrayList<>();
598 supportlist.add(supportbldr.build());
599 NodeBuilder nodebldr = new NodeBuilder();
600 nodebldr.setSupportingNode(supportlist);
604 // Return 0 for null/error values
607 // Return 3 for bi-directional
609 private int getPortDirection(String deviceId, String circuitPackName, String portName) {
610 InstanceIdentifier<Ports> portIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
611 .child(CircuitPacks.class, new CircuitPacksKey(circuitPackName))
612 .child(Ports.class, new PortsKey(portName));
613 LOG.info("Fetching Port Direction for port {} at circuit pack {}", portName, circuitPackName);
614 Optional<Ports> portObject =
615 deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL, portIID,
616 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
617 if (portObject.isPresent()) {
618 Ports port = portObject.get();
619 if (port.getPortDirection() != null) {
620 return port.getPortDirection().getIntValue();
622 LOG.warn("Port direction value missing for {} {}", circuitPackName, port.getPortName());
629 // This method returns a generic termination point builder for a given tpid
630 private TerminationPointBuilder createTpBldr(String tpId) {
631 TerminationPointBuilder tpBldr = new TerminationPointBuilder();
632 TpId tp = new TpId(tpId);
633 TerminationPointKey tpKey = new TerminationPointKey(tp);
634 tpBldr.withKey(tpKey);
643 private List<Link> createExpressLinks(String nodeId, int numOfDegrees, int portDirectionEnum) {
644 LOG.info("creating express links {} {} {}", nodeId, numOfDegrees, portDirectionEnum);
645 List<Link> links = new ArrayList<>();
653 // ports are uni-directional
654 if (portDirectionEnum == 1 || portDirectionEnum == 2) {
655 LOG.info("creating uni-directional express links");
656 for (int i = 1; i <= numOfDegrees; i++) {
657 for (int j = i + 1; j <= numOfDegrees; j++) {
659 srcNode = nodeId + "-DEG" + i;
660 destNode = nodeId + "-DEG" + j;
663 srcTp = "DEG" + i + "-CTP-TX";
664 destTp = "DEG" + j + "-CTP-RX";
666 LinkBuilder expLinkBldr = TopologyUtils.createLink(srcNode, destNode, srcTp, destTp);
668 Link1Builder lnk1Bldr = new Link1Builder();
669 lnk1Bldr.setLinkType(OpenroadmLinkType.EXPRESSLINK);
670 expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
671 links.add(expLinkBldr.build());
674 srcTp = "DEG" + i + "-CTP-RX";
675 destTp = "DEG" + j + "-CTP-TX";
677 expLinkBldr = TopologyUtils.createLink(destNode, srcNode, destTp, srcTp);
678 expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
679 links.add(expLinkBldr.build());
685 // ports are bi-directional
686 if (portDirectionEnum == 3) {
687 LOG.info("creating bi-directional express links");
688 for (int i = 1; i <= numOfDegrees; i++) {
689 for (int j = i + 1; j <= numOfDegrees; j++) {
691 srcNode = nodeId + "-DEG" + i;
692 destNode = nodeId + "-DEG" + j;
695 srcTp = "DEG" + i + "-CTP-TXRX";
696 destTp = "DEG" + j + "-CTP-TXRX";
698 Link1Builder lnk1Bldr = new Link1Builder();
699 lnk1Bldr.setLinkType(OpenroadmLinkType.EXPRESSLINK);
700 LinkBuilder expLinkBldr = TopologyUtils.createLink(srcNode, destNode, srcTp, destTp);
701 expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
702 links.add(expLinkBldr.build());
705 expLinkBldr = TopologyUtils.createLink(destNode, srcNode, destTp, srcTp);
706 expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
707 links.add(expLinkBldr.build());
714 private List<Link> createAddDropLinks(String nodeId, int numOfDegrees, int numOfSrgs, int portDirectionEnum) {
715 LOG.info("creating add-drop links {} {} {} {}", nodeId, numOfDegrees, numOfSrgs, portDirectionEnum);
716 List<Link> links = new ArrayList<>();
724 // ports are uni-directional
725 if (portDirectionEnum == 1 || portDirectionEnum == 2) {
726 LOG.info("creating uni-directional add-drop links");
727 for (int i = 1; i <= numOfDegrees; i++) {
728 for (int j = 1; j <= numOfSrgs; j++) {
730 srcNode = nodeId + "-DEG" + i;
731 destNode = nodeId + "-SRG" + j;
734 srcTp = "DEG" + i + "-CTP-TX";
735 destTp = "SRG" + j + "-CP-RX";
737 LinkBuilder addDropLinkBldr = TopologyUtils.createLink(srcNode, destNode, srcTp, destTp);
738 Link1Builder lnk1Bldr = new Link1Builder();
739 lnk1Bldr.setLinkType(OpenroadmLinkType.DROPLINK);
740 addDropLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
741 links.add(addDropLinkBldr.build());
743 // add links direction
744 srcTp = "DEG" + i + "-CTP-RX";
745 destTp = "SRG" + j + "-CP-TX";
747 addDropLinkBldr = TopologyUtils.createLink(destNode, srcNode, destTp, srcTp);
748 lnk1Bldr.setLinkType(OpenroadmLinkType.ADDLINK);
749 addDropLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
750 links.add(addDropLinkBldr.build());
755 // ports are bi-directional
756 if (portDirectionEnum == 3) {
757 LOG.info("creating bi-directional add-drop links");
758 for (int i = 1; i <= numOfDegrees; i++) {
759 for (int j = 1; j <= numOfSrgs; j++) {
761 srcNode = nodeId + "-DEG" + i;
762 destNode = nodeId + "-SRG" + j;
765 srcTp = "DEG" + i + "-CTP-TXRX";
766 destTp = "SRG" + j + "-CP-TXRX";
768 LinkBuilder addDropLinkBldr = TopologyUtils.createLink(srcNode, destNode, srcTp, destTp);
769 Link1Builder lnk1Bldr = new Link1Builder();
770 lnk1Bldr.setLinkType(OpenroadmLinkType.DROPLINK);
771 addDropLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
772 links.add(addDropLinkBldr.build());
775 addDropLinkBldr = TopologyUtils.createLink(destNode, srcNode, destTp, srcTp);
776 lnk1Bldr.setLinkType(OpenroadmLinkType.ADDLINK);
777 addDropLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
778 links.add(addDropLinkBldr.build());
785 // This method returns the linkBuilder object for given source and destination
786 public static boolean deleteLink(String srcNode, String dstNode, String srcTp, String destTp,
787 NetworkTransactionService networkTransactionService) {
788 LOG.info("deleting link for {}-{}", srcNode, dstNode);
789 LinkId linkId = LinkIdUtil.buildLinkId(srcNode, srcTp, dstNode, destTp);
790 if (deleteLinkLinkId(linkId, networkTransactionService)) {
791 LOG.debug("Link Id {} updated to have admin state down");
794 LOG.debug("Link Id not found for Source {} and Dest {}", srcNode, dstNode);
799 // This method returns the linkBuilder object for given source and destination
800 public static boolean deleteLinkLinkId(LinkId linkId , NetworkTransactionService networkTransactionService) {
801 LOG.info("deleting link for LinkId: {}", linkId);
803 InstanceIdentifierBuilder<Link> linkIID = InstanceIdentifier.builder(Networks.class).child(Network.class,
804 new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).augmentation(Network1.class)
805 .child(Link.class, new LinkKey(linkId));
806 com.google.common.base.Optional<Link> link =
807 networkTransactionService.read(LogicalDatastoreType.CONFIGURATION,linkIID.build()).get();
808 if (link.isPresent()) {
809 LinkBuilder linkBuilder = new LinkBuilder(link.get());
810 Link1Builder link1Builder = new Link1Builder(linkBuilder.augmentation(org.opendaylight
811 .yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1.class));
812 link1Builder.setAdministrativeState(State.OutOfService);
813 linkBuilder.removeAugmentation(Link1.class);
814 linkBuilder.addAugmentation(Link1.class,link1Builder.build());
815 networkTransactionService.merge(LogicalDatastoreType.CONFIGURATION, linkIID.build(),
816 linkBuilder.build());
817 networkTransactionService.submit().get(1, TimeUnit.SECONDS);
820 LOG.error("No link found for given LinkId: {}",
825 } catch (InterruptedException | ExecutionException | TimeoutException e) {
826 LOG.error(e.getMessage(), e);
831 private List<AvailableWavelengths> create96AvalWaveDegree() {
832 List<AvailableWavelengths> waveList = new ArrayList<>();
834 for (int i = 1; i < 97; i++) {
835 AvailableWavelengthsBuilder avalBldr = new AvailableWavelengthsBuilder();
836 avalBldr.setIndex((long) i);
837 avalBldr.withKey(new AvailableWavelengthsKey((long) i));
838 waveList.add(avalBldr.build());
844 private List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node
845 .attributes.AvailableWavelengths> create96AvalWaveSrg() {
847 List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
848 .AvailableWavelengths> waveList =
851 for (int i = 1; i < 97; i++) {
852 org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
853 .AvailableWavelengthsBuilder avalBldr =
854 new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node
855 .attributes.AvailableWavelengthsBuilder();
856 avalBldr.setIndex((long) i);
858 new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node
859 .attributes.AvailableWavelengthsKey(
861 waveList.add(avalBldr.build());