2 * Copyright © 2019 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
8 package org.opendaylight.transportpce.renderer.provisiondevice;
10 import java.util.ArrayList;
11 import java.util.HashMap;
12 import java.util.LinkedList;
13 import java.util.List;
15 import java.util.Optional;
16 import java.util.concurrent.ConcurrentLinkedQueue;
17 import java.util.concurrent.CopyOnWriteArrayList;
18 import java.util.concurrent.ExecutionException;
19 import java.util.concurrent.ForkJoinPool;
20 import java.util.concurrent.ForkJoinTask;
21 import java.util.concurrent.atomic.AtomicBoolean;
22 import java.util.stream.Collectors;
23 import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
24 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
25 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
26 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
27 import org.opendaylight.transportpce.networkmodel.service.NetworkModelService;
28 import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
29 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.OtnServicePathInput;
30 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.OtnServicePathOutput;
31 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.OtnServicePathOutputBuilder;
32 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef;
33 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.node.interfaces.NodeInterface;
34 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.node.interfaces.NodeInterfaceBuilder;
35 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.node.interfaces.NodeInterfaceKey;
36 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.otn.renderer.nodes.Nodes;
37 import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
38 import org.opendaylight.yangtools.yang.common.Uint32;
39 import org.slf4j.Logger;
40 import org.slf4j.LoggerFactory;
43 public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
44 private static final Logger LOG = LoggerFactory.getLogger(OtnDeviceRendererServiceImpl.class);
45 private static final String PT_03 = "03";
46 private static final String PT_07 = "07";
47 private final OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
48 private final CrossConnect crossConnect;
49 private final OpenRoadmInterfaces openRoadmInterfaces;
50 private final DeviceTransactionManager deviceTransactionManager;
51 private final NetworkModelService networkModelService;
53 public OtnDeviceRendererServiceImpl(OpenRoadmInterfaceFactory openRoadmInterfaceFactory, CrossConnect crossConnect,
54 OpenRoadmInterfaces openRoadmInterfaces,
55 DeviceTransactionManager deviceTransactionManager,
56 NetworkModelService networkModelService) {
57 this.openRoadmInterfaceFactory = openRoadmInterfaceFactory;
58 this.crossConnect = crossConnect;
59 this.openRoadmInterfaces = openRoadmInterfaces;
60 this.deviceTransactionManager = deviceTransactionManager;
61 this.networkModelService = networkModelService;
65 public OtnServicePathOutput setupOtnServicePath(OtnServicePathInput input) {
66 LOG.info("Calling setup otn-service path");
67 boolean success = true;
68 List<NodeInterface> nodeInterfaces = new ArrayList<>();
69 List<String> results = new ArrayList<>();
70 if (input.getServiceFormat() == null || input.getServiceRate() == null) {
71 OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
73 .setResult("Error - service-type and service-rate must be presents");
74 return otnServicePathOutputBuilder.build();
76 CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
77 switch (input.getServiceFormat()) {
79 if (input.getServiceRate().intValue() == 1 || input.getServiceRate().intValue() == 10) {
81 LOG.info("Calling Node interfaces {} {} {} {} {} {} {}",
82 input.getServiceRate(), input.getEthernetEncoding(),
83 input.getServiceFormat(), input.getOperation(), input.getTribPortNumber(),
84 input.getTribSlot(), input.getNodes());
85 nodeInterfaces = createInterface(input);
86 LOG.info("Node interfaces created just fine ");
88 List<String> nodesToUpdate = updateOduNodes(nodeInterfaces, "ODU");
89 updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(),
90 input.getTribSlot(), false);
91 } catch (OpenRoadmInterfaceException e) {
92 LOG.warn("Set up service path failed", e);
95 } else if (input.getServiceRate().intValue() == 100) {
97 LOG.info("Calling Node interfaces {} {} {} {} {} {}",
98 input.getServiceRate(), input.getEthernetEncoding(),
99 input.getServiceFormat(), input.getOperation(), input.getOpucnTribSlots(),
101 nodeInterfaces = createInterface(input);
102 LOG.info("Node interfaces created just fine for 100G OTN ");
103 // TODO: Update the OTN topology accordingly with Opucn-Trib-slots
104 // List<String> nodesToUpdate = updateOduNodes(nodeInterfaces, "ODUC4");
105 // updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(),
106 // input.getTribSlot(), false);
107 } catch (OpenRoadmInterfaceException e) {
108 LOG.warn("Set up service path failed", e);
112 LOG.warn("Unsupported service-rate for service-type Ethernet");
116 if (input.getServiceRate().intValue() == 100) {
118 createODU4TtpInterface(input, nodeInterfaces, otnNodesProvisioned);
119 updateOtnTopology(otnNodesProvisioned, null, null, null, null, false);
120 } catch (OpenRoadmInterfaceException e) {
121 LOG.warn("Set up service path failed", e);
124 } else if (input.getServiceRate().intValue() == 400) {
126 createOduc4TtpInterface(input, nodeInterfaces, otnNodesProvisioned);
127 updateOtnTopology(otnNodesProvisioned, null, null, null, null, false);
128 } catch (OpenRoadmInterfaceException e) {
129 LOG.warn("Set up service path failed", e);
133 LOG.warn("Unsupported service-rate for service-type ODU");
137 LOG.error("service-type {} not managed yet", input.getServiceFormat());
141 LOG.info("Result is success");
142 for (NodeInterface nodeInterface : nodeInterfaces) {
143 results.add("Otn Service path was set up successfully for node :" + nodeInterface.getNodeId());
146 Map<NodeInterfaceKey,NodeInterface> nodeInterfacesMap = new HashMap<>();
147 for (NodeInterface nodeInterface : nodeInterfaces) {
148 if (nodeInterface != null) {
149 nodeInterfacesMap.put(nodeInterface.key(), nodeInterface);
152 OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
154 .setNodeInterface(nodeInterfacesMap)
155 .setResult(String.join("\n", results));
156 return otnServicePathOutputBuilder.build();
159 public OtnServicePathOutput deleteOtnServicePath(OtnServicePathInput input) {
161 LOG.error("Unable to delete otn service path. input = null");
162 return new OtnServicePathOutputBuilder().setResult("Unable to delete otn service path. input = null")
163 .setSuccess(false).build();
165 List<Nodes> nodes = input.getNodes();
166 AtomicBoolean success = new AtomicBoolean(true);
167 ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
168 List<String> nodesTpToUpdate = new ArrayList<>();
169 CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
170 ForkJoinPool forkJoinPool = new ForkJoinPool();
171 ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> {
172 List<String> interfacesToDelete = new LinkedList<>();
173 String nodeId = node.getNodeId();
174 LOG.info("Deleting service setup on node {}", nodeId);
175 String networkTp = node.getNetworkTp();
176 if (networkTp == null || input.getServiceRate() == null || input.getServiceFormat() == null) {
177 LOG.error("destination ({}) or service-rate ({}) or service-format ({}) is null.", networkTp,
178 input.getServiceRate(), input.getServiceFormat());
181 // if the node is currently mounted then proceed.
182 if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
183 String connectionNumber = "";
184 switch (input.getServiceRate().intValue()) {
186 if ("ODU".equals(input.getServiceFormat())) {
187 interfacesToDelete.add(networkTp + "-ODU4");
188 otnNodesProvisioned.add(node);
189 if (node.getNetwork2Tp() != null) {
190 interfacesToDelete.add(node.getNetwork2Tp() + "-ODU4");
192 } else if ("Ethernet".equals(input.getServiceFormat())) {
193 connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU4");
197 if ("ODU".equals(input.getServiceFormat())) {
198 interfacesToDelete.add(networkTp + "-ODUC4");
199 otnNodesProvisioned.add(node);
200 if (node.getNetwork2Tp() != null) {
201 interfacesToDelete.add(node.getNetwork2Tp() + "-ODUC4");
206 connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU2e");
209 connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU0");
212 LOG.error("service rate {} not managed yet", input.getServiceRate());
213 String result = input.getServiceRate() + " is not supported";
218 List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, true);
219 if (intToDelete != null) {
220 for (String interf : intToDelete) {
221 if (!this.openRoadmInterfaceFactory.isUsedByOtnXc(nodeId, interf, connectionNumber,
222 this.deviceTransactionManager)) {
224 interfacesToDelete.add(interf);
225 String supportedInterface = this.openRoadmInterfaces.getSupportedInterface(nodeId, interf);
226 if (input.getServiceRate().intValue() == 100) {
227 if (!supportedInterface.contains("ODUC4")) {
228 interfacesToDelete.add(supportedInterface);
231 if (!supportedInterface.contains("ODU4")) {
232 interfacesToDelete.add(supportedInterface);
239 String result = nodeId + " is not mounted on the controller";
243 forkJoinPool.shutdown();
245 // TODO should deletion end here?
247 for (String interfaceId : interfacesToDelete) {
249 this.openRoadmInterfaces.deleteInterface(nodeId, interfaceId);
250 } catch (OpenRoadmInterfaceException e) {
251 String result = String.format("Failed to delete interface %s on node %s!", interfaceId, nodeId);
253 LOG.error(result, e);
257 List<String> interList = interfacesToDelete.stream().filter(ele -> ele.contains("NETWORK"))
258 .collect(Collectors.toList());
259 if (!interList.isEmpty()) {
260 for (String inter : interList) {
261 String tp = inter.split("-ODU")[0];
262 String nodeTopo = nodeId + "-" + tp.split("-")[0];
263 nodesTpToUpdate.add(nodeTopo + "--" + tp);
269 } catch (InterruptedException | ExecutionException e) {
270 LOG.error("Error while deleting service paths!", e);
272 forkJoinPool.shutdown();
273 LOG.info("requesting otn-topology update...");
274 if (!nodesTpToUpdate.isEmpty() && !"ODU".equals(input.getServiceFormat())) {
275 updateOtnTopology(null, nodesTpToUpdate, input.getServiceRate(), input.getTribPortNumber(),
276 input.getTribSlot(), true);
277 } else if (!otnNodesProvisioned.isEmpty()) {
278 updateOtnTopology(otnNodesProvisioned, null, null, null, null, true);
281 OtnServicePathOutputBuilder delServBldr = new OtnServicePathOutputBuilder();
282 delServBldr.setSuccess(success.get());
283 if (results.isEmpty()) {
284 return delServBldr.setResult("Request processed").build();
286 return delServBldr.setResult(String.join("\n", results)).build();
290 private String getConnectionNumber(String serviceName, Nodes node, String networkTp, String oduType) {
291 if (node.getClientTp() != null) {
292 return String.join("-", node.getClientTp(), oduType, serviceName, "x", networkTp, oduType, serviceName);
293 } else if (node.getNetwork2Tp() != null) {
294 return String.join("-", networkTp, oduType, serviceName, "x", node.getNetwork2Tp(), oduType, serviceName);
300 private List<String> updateOduNodes(List<NodeInterface> nodeInterfaceList, String deLimiter) {
301 List<String> nodesToUpdate = new ArrayList<>();
302 if (!(deLimiter.equals("ODU")) || !(deLimiter.equals("ODUC4"))) {
303 LOG.error("ODU node list update will be incorrect");
306 if (!nodeInterfaceList.isEmpty()) {
307 for (NodeInterface nodeInterf : nodeInterfaceList) {
308 if (nodeInterf.getOduInterfaceId() != null) {
309 List<String> interList = nodeInterf.getOduInterfaceId().stream()
310 .filter(id -> id.contains("NETWORK")).collect(Collectors.toList());
311 if (!interList.isEmpty()) {
312 for (String inter : interList) {
313 String tp = inter.split("-" + deLimiter)[0];
314 String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0];
315 nodesToUpdate.add(nodeTopo + "--" + tp);
322 return nodesToUpdate;
325 private List<NodeInterface> createInterface(OtnServicePathInput input) throws OpenRoadmInterfaceException {
326 List<NodeInterface> nodeInterfaces = new ArrayList<>();
327 LOG.info("Calling Create Interface entry for OTN service path");
328 if (input.getServiceRate() == null
329 || !(input.getServiceRate().intValue() == 1 || input.getServiceRate().intValue() == 10
330 || input.getServiceRate().intValue() == 100)) {
331 LOG.error("Service rate {} not managed yet", input.getServiceRate());
333 createLowOrderInterfaces(input, nodeInterfaces);
335 return nodeInterfaces;
338 private Optional<String> postCrossConnect(List<String> createdOduInterfaces, Nodes node)
339 throws OpenRoadmInterfaceException {
340 return this.crossConnect.postOtnCrossConnect(createdOduInterfaces, node);
343 private void createLowOrderInterfaces(OtnServicePathInput input, List<NodeInterface> nodeInterfaces)
344 throws OpenRoadmInterfaceException {
345 for (Nodes node : input.getNodes()) {
346 // check if the node is mounted or not?
347 List<String> createdEthInterfaces = new ArrayList<>();
348 List<String> createdOduInterfaces = new ArrayList<>();
349 switch (input.getServiceRate().intValue()) {
351 LOG.info("Input service is 1G");
352 if (node.getClientTp() != null) {
353 createdEthInterfaces.add(
354 openRoadmInterfaceFactory.createOpenRoadmEth1GInterface(node.getNodeId(),
355 node.getClientTp()));
356 createdOduInterfaces.add(
357 // suppporting interface?, payload ?
358 openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getClientTp(),
359 input.getServiceName(), PT_07, false, input.getTribPortNumber(), input.getTribSlot()));
361 createdOduInterfaces.add(
362 openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetworkTp(),
363 input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot()));
364 if (node.getNetwork2Tp() != null) {
365 createdOduInterfaces.add(
366 // supporting interface? payload ?
367 openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(),
368 node.getNetwork2Tp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(),
369 input.getTribSlot()));
373 LOG.info("Input service is 10G");
374 if (node.getClientTp() != null) {
375 createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth10GInterface(
376 node.getNodeId(), node.getClientTp()));
377 createdOduInterfaces.add(
378 // suppporting interface?, payload ?
379 openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
380 node.getClientTp(), input.getServiceName(), PT_03, false, input.getTribPortNumber(),
381 input.getTribSlot()));
383 createdOduInterfaces.add(
384 // supporting interface? payload ?
385 openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(),
386 input.getServiceName(), PT_03, true, input.getTribPortNumber(), input.getTribSlot()));
387 if (node.getNetwork2Tp() != null) {
388 createdOduInterfaces.add(
389 // supporting interface? payload ?
390 openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
391 node.getNetwork2Tp(), input.getServiceName(), PT_03, true, input.getTribPortNumber(),
392 input.getTribSlot()));
396 LOG.info("Input service is 100G");
397 // Take the first and last value in the list of OpucnTribSlot (assuming SH would provide
398 // min and max value only, size two)
399 OpucnTribSlotDef minOpucnTs = OpucnTribSlotDef.getDefaultInstance(
400 input.getOpucnTribSlots().get(0).getValue());
401 OpucnTribSlotDef maxOpucnTs = OpucnTribSlotDef.getDefaultInstance(
402 input.getOpucnTribSlots().get(1).getValue());
403 if (node.getClientTp() != null) {
404 createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth100GInterface(
405 node.getNodeId(), node.getClientTp()));
406 // OPUCn trib information is optional when creating ODU4 ethernet (client) interface
407 createdOduInterfaces.add(
408 openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
409 node.getClientTp(), input.getServiceName(), PT_07, false, minOpucnTs,
412 // Here payload-type is optional and is not used for interface creation (especially for network)
413 createdOduInterfaces.add(
414 openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
415 node.getNetworkTp(), input.getServiceName(), PT_07, true, minOpucnTs,
417 // Here payload-type is optional and is not used for service creation
418 // This is needed if there is an intermediate node
419 if (node.getNetwork2Tp() != null) {
420 createdOduInterfaces.add(
421 openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
422 node.getNetwork2Tp(), input.getServiceName(), PT_07, true, minOpucnTs,
427 LOG.error("service rate {} not managed yet", input.getServiceRate());
431 // implement cross connect
432 List<String> createdConnections = new ArrayList<>();
433 if (!createdOduInterfaces.isEmpty()) {
434 Optional<String> connectionNameOpt = postCrossConnect(createdOduInterfaces, node);
435 createdConnections.add(connectionNameOpt.get());
436 LOG.info("Created cross connects");
438 NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
439 .withKey(new NodeInterfaceKey(node.getNodeId()))
440 .setNodeId(node.getNodeId())
441 .setConnectionId(createdConnections)
442 .setEthInterfaceId(createdEthInterfaces)
443 .setOduInterfaceId(createdOduInterfaces);
444 nodeInterfaces.add(nodeInterfaceBuilder.build());
448 private void createOduc4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
449 CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
450 if (input.getNodes() == null) {
453 LOG.info("Creation of ODUC4 TTP interface in OTN service path {}", input);
454 for (int i = 0; i < input.getNodes().size(); i++) {
455 Nodes node = input.getNodes().get(i);
456 String supportingOtuInterface = node.getNetworkTp() + "-OTUC4";
457 List<String> createdOduc4Interfaces = new ArrayList<>();
458 // Adding SAPI/DAPI information to the
459 Nodes tgtNode = null;
460 if (i + 1 == input.getNodes().size()) {
461 // For the end node, tgtNode becomes the first node in the list
462 tgtNode = input.getNodes().get(0);
464 tgtNode = input.getNodes().get(i + 1);
466 createdOduc4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOduc4Interface(node.getNodeId(),
467 node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()));
469 NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
470 .withKey(new NodeInterfaceKey(node.getNodeId()))
471 .setNodeId(node.getNodeId())
472 .setOduInterfaceId(createdOduc4Interfaces); // though this is odu, actually it has ODUC4 interfaces
473 nodeInterfaces.add(nodeInterfaceBuilder.build());
474 otnNodesProvisioned.add(node);
478 private void createODU4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
479 CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
480 if (input.getNodes() == null) {
483 LOG.info("Creation of ODU4 tp interface {}", input);
484 for (int i = 0; i < input.getNodes().size(); i++) {
485 Nodes node = input.getNodes().get(i);
486 String supportingOtuInterface = node.getNetworkTp() + "-OTU";
487 List<String> createdOdu4Interfaces = new ArrayList<>();
488 // Adding SAPI/DAPI information to the
489 Nodes tgtNode = null;
490 if (i + 1 == input.getNodes().size()) {
491 // For the end node, tgtNode becomes the first node in the list
492 tgtNode = input.getNodes().get(0);
494 tgtNode = input.getNodes().get(i + 1);
496 createdOdu4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOdu4Interface(node.getNodeId(),
497 node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()));
498 NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
499 .withKey(new NodeInterfaceKey(node.getNodeId()))
500 .setNodeId(node.getNodeId())
501 .setOduInterfaceId(createdOdu4Interfaces);
502 nodeInterfaces.add(nodeInterfaceBuilder.build());
503 otnNodesProvisioned.add(node);
507 private void updateOtnTopology(CopyOnWriteArrayList<Nodes> nodes, List<String> nodesTps, Uint32 serviceRate,
508 Short tribPortNb, Short tribSlotNb, boolean isDeletion) {
509 if (nodes != null && nodes.size() == 2) {
511 LOG.info("updating otn-topology removing ODU4 links");
512 this.networkModelService.deleteOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getNetworkTp(),
513 nodes.get(1).getNodeId(), nodes.get(1).getNetworkTp(), OtnLinkType.ODTU4);
515 LOG.info("updating otn-topology adding ODU4 links");
516 this.networkModelService.createOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getNetworkTp(),
517 nodes.get(1).getNodeId(), nodes.get(1).getNetworkTp(), OtnLinkType.ODTU4);
519 } else if (nodesTps != null && (nodesTps.size() % 2 == 0) && serviceRate != null && tribPortNb != null
520 && tribSlotNb != null) {
521 LOG.info("updating otn-topology node tps -tps and tpn pools");
522 this.networkModelService.updateOtnLinks(nodesTps, serviceRate, tribPortNb, tribSlotNb, isDeletion);