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) && (port.getPortQual().getIntValue() == 4)) {
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;
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());
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());
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,
328 LOG.info("The nodebldr {}",nodebldr);
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);
339 // Get connection ports on degree number = degreeCounter in order to get port
341 List<ConnectionPorts> degreeConPorts = getDegreePorts(nodeId, degreeCounter);
342 if (degreeConPorts == null || degreeConPorts.isEmpty()) {
346 DegreeAttributesBuilder degAttBldr = new DegreeAttributesBuilder();
347 degAttBldr.setDegreeNumber(degreeCounter);
348 degAttBldr.setAvailableWavelengths(create96AvalWaveDegree());
349 node1bldr.setDegreeAttributes(degAttBldr.build());
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());
362 * if bi-directional then create 2 tp's :
364 * --> TTP-TXRX --> CTP-TXRX
366 * if uni-directional :
373 TerminationPoint1Builder tp1Bldr = new TerminationPoint1Builder();
374 TerminationPointBuilder tempTpBldr;
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
381 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-TX");
382 tp1Bldr.setTpType(OpenroadmTpType.DEGREETXTTP);
383 tempTpBldr.addAugmentation(TerminationPoint1.class, tp1Bldr.build());
384 tpList.add(tempTpBldr.build());
386 // Create TTP-RX termination
387 tp1Bldr = new TerminationPoint1Builder();
388 tempTpBldr = createTpBldr("DEG" + degreeCounter + "-TTP-RX");
389 tp1Bldr.setTpType(OpenroadmTpType.DEGREERXTTP);
391 tempTpBldr.addAugmentation(TerminationPoint1.class,tp1Bldr.build());
392 tpList.add(tempTpBldr.build());
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());
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());
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());
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());
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();
430 tpNode1.setTerminationPoint(tpList);
432 nodebldr.addAugmentation(
433 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class,
435 return new NodeData(nodebldr, portDirectionEnum);
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);
445 node1bldr.setNodeType(OpenroadmNodeType.SRG);
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());
455 // Get connection ports on degree number = degreeCounter in order to get port
457 int maxPpPorts = getMaxPp(nodeId, srgCounter);
458 if (maxPpPorts == -1) {
463 String nodeIdtopo = new StringBuilder().append(nodeId).append("-SRG").append(srgCounter).toString();
464 nodebldr.setNodeId(new NodeId(nodeIdtopo));
465 List<TerminationPoint> tpList = new ArrayList<>();
467 TerminationPoint1Builder tp1Bldr;
468 TerminationPointBuilder tempTpBldr;
470 for (int i = 1; i <= maxPpPorts; i++) {
471 if (portDirectionEnum == 1 || portDirectionEnum == 2) {
472 if (i >= maxPpPorts / 2) {
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());
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());
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());
501 switch (portDirectionEnum) {
502 case 1: // ports are uni Directional on a degree
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());
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());
527 LOG.error("No correponsding direction to the value: {}", portDirectionEnum);
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();
534 tpNode1.setTerminationPoint(tpList);
536 nodebldr.addAugmentation(
537 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class,
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
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));
553 Optional<Degree> ordmDegreeObject =
554 deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.CONFIGURATION, deviceIID,
555 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
557 if (ordmDegreeObject.isPresent()) {
558 degreeConPorts.addAll(new ArrayList<>(ordmDegreeObject.get().getConnectionPorts()));
560 LOG.info("Device has {} degree", (degreeCounter - 1));
561 return Collections.emptyList();
563 return degreeConPorts;
566 private int getMaxPp(String deviceId, Integer srgCounter) {
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();
578 LOG.info("Max add drop ports absent");
582 LOG.info("SRG absent");
588 private NodeBuilder createTopoLayerNode(String nodeId) {
589 // Sets the value of Network-ref and Node-ref as a part of the supporting node
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);
602 // Return 0 for null/error values
605 // Return 3 for bi-directional
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();
620 LOG.warn("Port direction value missing for {} {}", circuitPackName, port.getPortName());
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);
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<>();
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++) {
657 srcNode = nodeId + "-DEG" + i;
658 destNode = nodeId + "-DEG" + j;
661 srcTp = "DEG" + i + "-CTP-TX";
662 destTp = "DEG" + j + "-CTP-RX";
664 LinkBuilder expLinkBldr = TopologyUtils.createLink(srcNode, destNode, srcTp, destTp);
666 Link1Builder lnk1Bldr = new Link1Builder();
667 lnk1Bldr.setLinkType(OpenroadmLinkType.EXPRESSLINK);
668 expLinkBldr.addAugmentation(Link1.class, lnk1Bldr.build());
669 links.add(expLinkBldr.build());
672 srcTp = "DEG" + i + "-CTP-RX";
673 destTp = "DEG" + j + "-CTP-TX";
675 expLinkBldr = TopologyUtils.createLink(destNode, srcNode, destTp, srcTp);
676 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());
770 links.add(addDropLinkBldr.build());
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());
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");
792 LOG.debug("Link Id not found for Source {} and Dest {}", srcNode, dstNode);
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);
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);
818 LOG.error("No link found for given LinkId: {}",
823 } catch (InterruptedException | ExecutionException | TimeoutException e) {
824 LOG.error(e.getMessage(), e);
829 private List<AvailableWavelengths> create96AvalWaveDegree() {
830 List<AvailableWavelengths> waveList = new ArrayList<>();
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());
842 private List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node
843 .attributes.AvailableWavelengths> create96AvalWaveSrg() {
845 List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
846 .AvailableWavelengths> waveList =
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);
856 new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node
857 .attributes.AvailableWavelengthsKey(
859 waveList.add(avalBldr.build());