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.rev200128.OtnServicePathInput;
30 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathOutput;
31 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.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.rev201211.node.interfaces.NodeInterface;
34 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceBuilder;
35 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceKey;
36 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.otn.renderer.input.Nodes;
37 import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
38 import org.slf4j.Logger;
39 import org.slf4j.LoggerFactory;
42 public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
43 private static final Logger LOG = LoggerFactory.getLogger(OtnDeviceRendererServiceImpl.class);
44 private static final String PT_03 = "03";
45 private static final String PT_07 = "07";
46 private final OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
47 private final CrossConnect crossConnect;
48 private final OpenRoadmInterfaces openRoadmInterfaces;
49 private final DeviceTransactionManager deviceTransactionManager;
50 private final NetworkModelService networkModelService;
52 public OtnDeviceRendererServiceImpl(OpenRoadmInterfaceFactory openRoadmInterfaceFactory, CrossConnect crossConnect,
53 OpenRoadmInterfaces openRoadmInterfaces,
54 DeviceTransactionManager deviceTransactionManager,
55 NetworkModelService networkModelService) {
56 this.openRoadmInterfaceFactory = openRoadmInterfaceFactory;
57 this.crossConnect = crossConnect;
58 this.openRoadmInterfaces = openRoadmInterfaces;
59 this.deviceTransactionManager = deviceTransactionManager;
60 this.networkModelService = networkModelService;
64 public OtnServicePathOutput setupOtnServicePath(OtnServicePathInput input) {
65 LOG.info("Calling setup otn-service path");
66 boolean success = true;
67 List<NodeInterface> nodeInterfaces = new ArrayList<>();
68 List<String> results = new ArrayList<>();
69 if (input.getServiceType() == null || input.getServiceRate() == null) {
70 OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
72 .setResult("Error - service-type and service-rate must be presents");
73 return otnServicePathOutputBuilder.build();
75 CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
76 switch (input.getServiceType()) {
78 if ("10G".equals(input.getServiceRate()) || "1G".equals(input.getServiceRate())) {
80 LOG.info("Calling Node interfaces {} {} {} {} {} {} {}",
81 input.getServiceRate(), input.getEthernetEncoding(),
82 input.getServiceType(), input.getOperation(), input.getTribPortNumber(),
83 input.getTribSlot(), input.getNodes());
84 nodeInterfaces = createInterface(input);
85 LOG.info("Node interfaces created just fine ");
87 List<String> nodesToUpdate = updateOduNodes(nodeInterfaces, "ODU");
88 updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(),
89 input.getTribSlot(), false);
90 } catch (OpenRoadmInterfaceException e) {
91 LOG.warn("Set up service path failed", e);
94 } else if ("100G".equals(input.getServiceRate())) {
96 LOG.info("Calling Node interfaces {} {} {} {} {} {}",
97 input.getServiceRate(), input.getEthernetEncoding(),
98 input.getServiceType(), input.getOperation(), input.getOpucnTribSlots(), input.getNodes());
99 nodeInterfaces = createInterface(input);
100 LOG.info("Node interfaces created just fine for 100G OTN ");
101 // TODO: Update the OTN topology accordingly with Opucn-Trib-slots
102 // List<String> nodesToUpdate = updateOduNodes(nodeInterfaces, "ODUC4");
103 // updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(),
104 // input.getTribSlot(), false);
105 } catch (OpenRoadmInterfaceException e) {
106 LOG.warn("Set up service path failed", e);
110 LOG.warn("Unsupported service-rate for service-type Ethernet");
114 if ("100G".equals(input.getServiceRate())) {
116 createODU4TtpInterface(input, nodeInterfaces, otnNodesProvisioned);
117 updateOtnTopology(otnNodesProvisioned, null, null, null, null, false);
118 } catch (OpenRoadmInterfaceException e) {
119 LOG.warn("Set up service path failed", e);
122 } else if ("400G".equals(input.getServiceRate())) {
124 createOduc4TtpInterface(input, nodeInterfaces, otnNodesProvisioned);
125 updateOtnTopology(otnNodesProvisioned, null, null, null, null, false);
126 } catch (OpenRoadmInterfaceException e) {
127 LOG.warn("Set up service path failed", e);
131 LOG.warn("Unsupported service-rate for service-type ODU");
135 LOG.error("service-type {} not managed yet", input.getServiceType());
139 LOG.info("Result is success");
140 for (NodeInterface nodeInterface : nodeInterfaces) {
141 results.add("Otn Service path was set up successfully for node :" + nodeInterface.getNodeId());
144 Map<NodeInterfaceKey,NodeInterface> nodeInterfacesMap = new HashMap<>();
145 for (NodeInterface nodeInterface : nodeInterfaces) {
146 if (nodeInterface != null) {
147 nodeInterfacesMap.put(nodeInterface.key(), nodeInterface);
150 OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
152 .setNodeInterface(nodeInterfacesMap)
153 .setResult(String.join("\n", results));
154 return otnServicePathOutputBuilder.build();
157 public OtnServicePathOutput deleteOtnServicePath(OtnServicePathInput input) {
159 LOG.error("Unable to delete otn service path. input = null");
160 return new OtnServicePathOutputBuilder().setResult("Unable to delete otn service path. input = null")
161 .setSuccess(false).build();
163 List<Nodes> nodes = input.getNodes();
164 AtomicBoolean success = new AtomicBoolean(true);
165 ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
166 List<String> nodesTpToUpdate = new ArrayList<>();
167 CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
168 ForkJoinPool forkJoinPool = new ForkJoinPool();
169 ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> {
170 List<String> interfacesToDelete = new LinkedList<>();
171 String nodeId = node.getNodeId();
172 LOG.info("Deleting service setup on node {}", nodeId);
173 String networkTp = node.getNetworkTp();
174 if (networkTp == null || input.getServiceRate() == null || input.getServiceType() == null) {
175 LOG.error("destination ({}) or service rate ({}) or service type ({}) is null.", networkTp,
176 input.getServiceRate(), input.getServiceType());
179 // if the node is currently mounted then proceed.
180 if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
181 String connectionNumber = "";
182 switch (input.getServiceRate()) {
184 if ("ODU".equals(input.getServiceType())) {
185 interfacesToDelete.add(networkTp + "-ODU4");
186 otnNodesProvisioned.add(node);
187 if (node.getNetwork2Tp() != null) {
188 interfacesToDelete.add(node.getNetwork2Tp() + "-ODU4");
190 } else if ("Ethernet".equals(input.getServiceType())) {
191 connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU4");
195 LOG.info("Service Rate is 400G");
196 if ("ODU".equals(input.getServiceType())) {
197 interfacesToDelete.add(networkTp + "-ODUC4");
198 otnNodesProvisioned.add(node);
199 if (node.getNetwork2Tp() != null) {
200 interfacesToDelete.add(node.getNetwork2Tp() + "-ODUC4");
205 connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU2e");
208 connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU0");
211 LOG.error("service rate {} not managed yet", input.getServiceRate());
212 String result = input.getServiceRate() + " is not supported";
217 List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, true);
218 if (intToDelete != null) {
219 for (String interf : intToDelete) {
220 if (!this.openRoadmInterfaceFactory.isUsedByOtnXc(nodeId, interf, connectionNumber,
221 this.deviceTransactionManager)) {
223 interfacesToDelete.add(interf);
224 String supportedInterface = this.openRoadmInterfaces.getSupportedInterface(nodeId, interf);
225 if (input.getServiceRate().equals("100G")) {
226 if (!supportedInterface.contains("ODUC4")) {
227 interfacesToDelete.add(supportedInterface);
230 if (!supportedInterface.contains("ODU4")) {
231 interfacesToDelete.add(supportedInterface);
238 String result = nodeId + " is not mounted on the controller";
242 forkJoinPool.shutdown();
244 // TODO should deletion end here?
246 for (String interfaceId : interfacesToDelete) {
248 this.openRoadmInterfaces.deleteInterface(nodeId, interfaceId);
249 } catch (OpenRoadmInterfaceException e) {
250 String result = String.format("Failed to delete interface %s on node %s!", interfaceId, nodeId);
252 LOG.error(result, e);
256 List<String> interList = interfacesToDelete.stream().filter(ele -> ele.contains("NETWORK"))
257 .collect(Collectors.toList());
258 if (!interList.isEmpty()) {
259 for (String inter : interList) {
260 String tp = inter.split("-ODU")[0];
261 String nodeTopo = nodeId + "-" + tp.split("-")[0];
262 nodesTpToUpdate.add(nodeTopo + "--" + tp);
268 } catch (InterruptedException | ExecutionException e) {
269 LOG.error("Error while deleting service paths!", e);
271 forkJoinPool.shutdown();
272 LOG.info("requesting otn-topology update...");
273 if (!nodesTpToUpdate.isEmpty() && !"ODU".equals(input.getServiceType())) {
274 updateOtnTopology(null, nodesTpToUpdate, input.getServiceRate(), input.getTribPortNumber(),
275 input.getTribSlot(), true);
276 } else if (!otnNodesProvisioned.isEmpty()) {
277 updateOtnTopology(otnNodesProvisioned, null, null, null, null, true);
280 OtnServicePathOutputBuilder delServBldr = new OtnServicePathOutputBuilder();
281 delServBldr.setSuccess(success.get());
282 if (results.isEmpty()) {
283 return delServBldr.setResult("Request processed").build();
285 return delServBldr.setResult(String.join("\n", results)).build();
289 private String getConnectionNumber(String serviceName, Nodes node, String networkTp, String oduType) {
290 if (node.getClientTp() != null) {
291 return String.join("-", node.getClientTp(), oduType, serviceName, "x", networkTp, oduType, serviceName);
292 } else if (node.getNetwork2Tp() != null) {
293 return String.join("-", networkTp, oduType, serviceName, "x", node.getNetwork2Tp(), oduType, serviceName);
299 private List<String> updateOduNodes(List<NodeInterface> nodeInterfaceList, String deLimiter) {
300 List<String> nodesToUpdate = new ArrayList<>();
301 if (!(deLimiter.equals("ODU")) || !(deLimiter.equals("ODUC4"))) {
302 LOG.error("ODU node list update will be incorrect");
305 if (!nodeInterfaceList.isEmpty()) {
306 for (NodeInterface nodeInterf : nodeInterfaceList) {
307 if (nodeInterf.getOduInterfaceId() != null) {
308 List<String> interList = nodeInterf.getOduInterfaceId().stream()
309 .filter(id -> id.contains("NETWORK")).collect(Collectors.toList());
310 if (!interList.isEmpty()) {
311 for (String inter : interList) {
312 String tp = inter.split("-" + deLimiter)[0];
313 String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0];
314 nodesToUpdate.add(nodeTopo + "--" + tp);
321 return nodesToUpdate;
324 private List<NodeInterface> createInterface(OtnServicePathInput input) throws OpenRoadmInterfaceException {
325 List<NodeInterface> nodeInterfaces = new ArrayList<>();
326 LOG.info("Calling Create Interface entry for OTN service path");
327 if (input.getServiceRate() == null
328 || !("1G".equals(input.getServiceRate()) || "10G".equals(input.getServiceRate())
329 || "100G".equals(input.getServiceRate()))) {
330 LOG.error("Service rate {} not managed yet", input.getServiceRate());
332 createLowOrderInterfaces(input, nodeInterfaces);
334 return nodeInterfaces;
337 private Optional<String> postCrossConnect(List<String> createdOduInterfaces, Nodes node)
338 throws OpenRoadmInterfaceException {
339 return this.crossConnect.postOtnCrossConnect(createdOduInterfaces, node);
342 private void createLowOrderInterfaces(OtnServicePathInput input, List<NodeInterface> nodeInterfaces)
343 throws OpenRoadmInterfaceException {
344 for (Nodes node : input.getNodes()) {
345 // check if the node is mounted or not?
346 List<String> createdEthInterfaces = new ArrayList<>();
347 List<String> createdOduInterfaces = new ArrayList<>();
348 switch (input.getServiceRate()) {
350 LOG.info("Input service is 1G");
351 if (node.getClientTp() != null) {
352 createdEthInterfaces.add(
353 openRoadmInterfaceFactory.createOpenRoadmEth1GInterface(node.getNodeId(),
354 node.getClientTp()));
355 createdOduInterfaces.add(
356 // suppporting interface?, payload ?
357 openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getClientTp(),
358 input.getServiceName(), PT_07, false, input.getTribPortNumber(), input.getTribSlot()));
360 createdOduInterfaces.add(
361 openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetworkTp(),
362 input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot()));
363 if (node.getNetwork2Tp() != null) {
364 createdOduInterfaces.add(
365 // supporting interface? payload ?
366 openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(),
367 node.getNetwork2Tp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(),
368 input.getTribSlot()));
372 LOG.info("Input service is 10G");
373 if (node.getClientTp() != null) {
374 createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth10GInterface(
375 node.getNodeId(), node.getClientTp()));
376 createdOduInterfaces.add(
377 // suppporting interface?, payload ?
378 openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
379 node.getClientTp(), input.getServiceName(), PT_03, false, input.getTribPortNumber(),
380 input.getTribSlot()));
382 createdOduInterfaces.add(
383 // supporting interface? payload ?
384 openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(),
385 input.getServiceName(), PT_03, true, input.getTribPortNumber(), input.getTribSlot()));
386 if (node.getNetwork2Tp() != null) {
387 createdOduInterfaces.add(
388 // supporting interface? payload ?
389 openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
390 node.getNetwork2Tp(), input.getServiceName(), PT_03, true, input.getTribPortNumber(),
391 input.getTribSlot()));
395 LOG.info("Input service is 100G");
396 // Take the first and last value in the list of OpucnTribSlot (assuming SH would provide
397 // min and max value only, size two)
398 OpucnTribSlotDef minOpucnTs = OpucnTribSlotDef.getDefaultInstance(
399 input.getOpucnTribSlots().get(0).getValue());
400 OpucnTribSlotDef maxOpucnTs = OpucnTribSlotDef.getDefaultInstance(
401 input.getOpucnTribSlots().get(1).getValue());
402 if (node.getClientTp() != null) {
403 createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth100GInterface(
404 node.getNodeId(), node.getClientTp()));
405 // OPUCn trib information is optional when creating ODU4 ethernet (client) interface
406 createdOduInterfaces.add(
407 openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
408 node.getClientTp(), input.getServiceName(), PT_07, false, minOpucnTs,
411 // Here payload-type is optional and is not used for interface creation (especially for network)
412 createdOduInterfaces.add(
413 openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
414 node.getNetworkTp(), input.getServiceName(), PT_07, true, minOpucnTs,
416 // Here payload-type is optional and is not used for service creation
417 // This is needed if there is an intermediate node
418 if (node.getNetwork2Tp() != null) {
419 createdOduInterfaces.add(
420 openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
421 node.getNetwork2Tp(), input.getServiceName(), PT_07, true, minOpucnTs,
426 LOG.error("service rate {} not managed yet", input.getServiceRate());
430 // implement cross connect
431 List<String> createdConnections = new ArrayList<>();
432 if (!createdOduInterfaces.isEmpty()) {
433 Optional<String> connectionNameOpt = postCrossConnect(createdOduInterfaces, node);
434 createdConnections.add(connectionNameOpt.get());
435 LOG.info("Created cross connects");
437 NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
438 .withKey(new NodeInterfaceKey(node.getNodeId()))
439 .setNodeId(node.getNodeId())
440 .setConnectionId(createdConnections)
441 .setEthInterfaceId(createdEthInterfaces)
442 .setOduInterfaceId(createdOduInterfaces);
443 nodeInterfaces.add(nodeInterfaceBuilder.build());
447 private void createOduc4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
448 CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
449 if (input.getNodes() == null) {
452 LOG.info("Creation of ODUC4 TTP interface in OTN service path {}", input);
453 for (int i = 0; i < input.getNodes().size(); i++) {
454 Nodes node = input.getNodes().get(i);
455 String supportingOtuInterface = node.getNetworkTp() + "-OTUC4";
456 List<String> createdOduc4Interfaces = new ArrayList<>();
457 // Adding SAPI/DAPI information to the
458 Nodes tgtNode = null;
459 if (i + 1 == input.getNodes().size()) {
460 // For the end node, tgtNode becomes the first node in the list
461 tgtNode = input.getNodes().get(0);
463 tgtNode = input.getNodes().get(i + 1);
465 createdOduc4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOduc4Interface(node.getNodeId(),
466 node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()));
468 NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
469 .withKey(new NodeInterfaceKey(node.getNodeId()))
470 .setNodeId(node.getNodeId())
471 .setOduInterfaceId(createdOduc4Interfaces); // though this is odu, actually it has ODUC4 interfaces
472 nodeInterfaces.add(nodeInterfaceBuilder.build());
473 otnNodesProvisioned.add(node);
477 private void createODU4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
478 CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
479 if (input.getNodes() == null) {
482 LOG.info("Creation of ODU4 tp interface {}", input);
483 for (int i = 0; i < input.getNodes().size(); i++) {
484 Nodes node = input.getNodes().get(i);
485 String supportingOtuInterface = node.getNetworkTp() + "-OTU";
486 List<String> createdOdu4Interfaces = new ArrayList<>();
487 // Adding SAPI/DAPI information to the
488 Nodes tgtNode = null;
489 if (i + 1 == input.getNodes().size()) {
490 // For the end node, tgtNode becomes the first node in the list
491 tgtNode = input.getNodes().get(0);
493 tgtNode = input.getNodes().get(i + 1);
495 createdOdu4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOdu4Interface(node.getNodeId(),
496 node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()));
497 NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
498 .withKey(new NodeInterfaceKey(node.getNodeId()))
499 .setNodeId(node.getNodeId())
500 .setOduInterfaceId(createdOdu4Interfaces);
501 nodeInterfaces.add(nodeInterfaceBuilder.build());
502 otnNodesProvisioned.add(node);
506 private void updateOtnTopology(CopyOnWriteArrayList<Nodes> nodes, List<String> nodesTps, String serviceRate,
507 Short tribPortNb, Short tribSlotNb, boolean isDeletion) {
508 if (nodes != null && nodes.size() == 2) {
510 LOG.info("updating otn-topology removing ODU4 links");
511 this.networkModelService.deleteOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getNetworkTp(),
512 nodes.get(1).getNodeId(), nodes.get(1).getNetworkTp(), OtnLinkType.ODTU4);
514 LOG.info("updating otn-topology adding ODU4 links");
515 this.networkModelService.createOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getNetworkTp(),
516 nodes.get(1).getNodeId(), nodes.get(1).getNetworkTp(), OtnLinkType.ODTU4);
518 } else if (nodesTps != null && (nodesTps.size() % 2 == 0) && serviceRate != null && tribPortNb != null
519 && tribSlotNb != null) {
520 LOG.info("updating otn-topology node tps -tps and tpn pools");
521 this.networkModelService.updateOtnLinks(nodesTps, serviceRate, tribPortNb, tribSlotNb, isDeletion);