renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java

   1 /*
   2  * Copyright © 2019 AT&T and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.transportpce.renderer.provisiondevice;
   9
  10 import java.util.ArrayList;
  11 import java.util.HashMap;
  12 import java.util.LinkedList;
  13 import java.util.List;
  14 import java.util.Map;
  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;
  41
  42
  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;
  52
  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;
  62     }
  63
  64     @Override
  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()
  72                 .setSuccess(false)
  73                 .setResult("Error - service-type and service-rate must be presents");
  74             return otnServicePathOutputBuilder.build();
  75         }
  76         CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
  77         switch (input.getServiceFormat()) {
  78             case "Ethernet":
  79                 if (input.getServiceRate().intValue() == 1 || input.getServiceRate().intValue() == 10) {
  80                     try {
  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 ");
  87
  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);
  93                         success = false;
  94                     }
  95                 } else if (input.getServiceRate().intValue() == 100) {
  96                     try {
  97                         LOG.info("Calling Node interfaces {} {} {} {} {} {}",
  98                             input.getServiceRate(), input.getEthernetEncoding(),
  99                             input.getServiceFormat(), input.getOperation(), input.getOpucnTribSlots(),
 100                             input.getNodes());
 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);
 109                         success = false;
 110                     }
 111                 } else {
 112                     LOG.warn("Unsupported service-rate for service-type Ethernet");
 113                 }
 114                 break;
 115             case "ODU":
 116                 if (input.getServiceRate().intValue() == 100) {
 117                     try {
 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);
 122                         success = false;
 123                     }
 124                 } else if (input.getServiceRate().intValue() == 400) {
 125                     try {
 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);
 130                         success = false;
 131                     }
 132                 } else {
 133                     LOG.warn("Unsupported service-rate for service-type ODU");
 134                 }
 135                 break;
 136             default:
 137                 LOG.error("service-type {} not managed yet", input.getServiceFormat());
 138                 break;
 139         }
 140         if (success) {
 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());
 144             }
 145         }
 146         Map<NodeInterfaceKey,NodeInterface> nodeInterfacesMap = new HashMap<>();
 147         for (NodeInterface nodeInterface : nodeInterfaces) {
 148             if (nodeInterface != null) {
 149                 nodeInterfacesMap.put(nodeInterface.key(), nodeInterface);
 150             }
 151         }
 152         OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
 153                 .setSuccess(success)
 154                 .setNodeInterface(nodeInterfacesMap)
 155                 .setResult(String.join("\n", results));
 156         return otnServicePathOutputBuilder.build();
 157     }
 158
 159     public OtnServicePathOutput deleteOtnServicePath(OtnServicePathInput input) {
 160         if (input == null) {
 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();
 164         }
 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());
 179                 return;
 180             }
 181             // if the node is currently mounted then proceed.
 182             if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
 183                 String connectionNumber = "";
 184                 switch (input.getServiceRate().intValue()) {
 185                     case 100:
 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");
 191                             }
 192                         } else if ("Ethernet".equals(input.getServiceFormat())) {
 193                             connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU4");
 194                         }
 195                         break;
 196                     case 400:
 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");
 202                             }
 203                         }
 204                         break;
 205                     case 10:
 206                         connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU2e");
 207                         break;
 208                     case 1:
 209                         connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU0");
 210                         break;
 211                     default:
 212                         LOG.error("service rate {} not managed yet", input.getServiceRate());
 213                         String result = input.getServiceRate() + " is not supported";
 214                         results.add(result);
 215                         success.set(false);
 216                         return;
 217                 }
 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)) {
 223
 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);
 229                                 }
 230                             } else {
 231                                 if (!supportedInterface.contains("ODU4")) {
 232                                     interfacesToDelete.add(supportedInterface);
 233                                 }
 234                             }
 235                         }
 236                     }
 237                 }
 238             } else {
 239                 String result = nodeId + " is not mounted on the controller";
 240                 results.add(result);
 241                 success.set(false);
 242                 LOG.warn(result);
 243                 forkJoinPool.shutdown();
 244                 return;
 245                 // TODO should deletion end here?
 246             }
 247             for (String interfaceId : interfacesToDelete) {
 248                 try {
 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);
 252                     success.set(false);
 253                     LOG.error(result, e);
 254                     results.add(result);
 255                 }
 256             }
 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);
 264                 }
 265             }
 266         }));
 267         try {
 268             forkJoinTask.get();
 269         } catch (InterruptedException | ExecutionException e) {
 270             LOG.error("Error while deleting service paths!", e);
 271         }
 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);
 279         }
 280
 281         OtnServicePathOutputBuilder delServBldr = new OtnServicePathOutputBuilder();
 282         delServBldr.setSuccess(success.get());
 283         if (results.isEmpty()) {
 284             return delServBldr.setResult("Request processed").build();
 285         } else {
 286             return delServBldr.setResult(String.join("\n", results)).build();
 287         }
 288     }
 289
 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);
 295         } else {
 296             return "";
 297         }
 298     }
 299
 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");
 304         }
 305
 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);
 316                         }
 317                     }
 318                 }
 319             }
 320         }
 321
 322         return nodesToUpdate;
 323     }
 324
 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());
 332         } else {
 333             createLowOrderInterfaces(input, nodeInterfaces);
 334         }
 335         return nodeInterfaces;
 336     }
 337
 338     private Optional<String> postCrossConnect(List<String> createdOduInterfaces, Nodes node)
 339             throws OpenRoadmInterfaceException {
 340         return this.crossConnect.postOtnCrossConnect(createdOduInterfaces, node);
 341     }
 342
 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()) {
 350                 case 1:
 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()));
 360                     }
 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()));
 370                     }
 371                     break;
 372                 case 10:
 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()));
 382                     }
 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()));
 393                     }
 394                     break;
 395                 case 100:
 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,
 410                                 maxOpucnTs));
 411                     }
 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,
 416                             maxOpucnTs));
 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,
 423                                 maxOpucnTs));
 424                     }
 425                     break;
 426                 default:
 427                     LOG.error("service rate {} not managed yet", input.getServiceRate());
 428                     return;
 429             }
 430
 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");
 437             }
 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());
 445         }
 446     }
 447
 448     private void createOduc4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
 449         CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
 450         if (input.getNodes() == null) {
 451             return;
 452         }
 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);
 463             } else {
 464                 tgtNode = input.getNodes().get(i + 1);
 465             }
 466             createdOduc4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOduc4Interface(node.getNodeId(),
 467                 node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()));
 468
 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);
 475         }
 476     }
 477
 478     private void createODU4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
 479         CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
 480         if (input.getNodes() == null) {
 481             return;
 482         }
 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);
 493             } else {
 494                 tgtNode = input.getNodes().get(i + 1);
 495             }
 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);
 504         }
 505     }
 506
 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) {
 510             if (isDeletion) {
 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);
 514             } else {
 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);
 518             }
 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);
 523         }
 524     }
 525
 526 }