X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=renderer%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Frenderer%2Fprovisiondevice%2FOtnDeviceRendererServiceImpl.java;h=6c5cb39cbc1e5de1fc94b264483ecb6924503b68;hb=73478a3a5354a2a557520fec6314532bf0ad6a29;hp=8febfdc3d5b5cdb1a95eba8500d688c8f5441102;hpb=9f04e99bf6c53ce3218835145085fb75dc5b4590;p=transportpce.git diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java index 8febfdc3d..6c5cb39cb 100644 --- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java +++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java @@ -20,21 +20,24 @@ import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinTask; import java.util.concurrent.atomic.AtomicBoolean; import java.util.stream.Collectors; +import org.opendaylight.transportpce.common.StringConstants; import org.opendaylight.transportpce.common.crossconnect.CrossConnect; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; +import org.opendaylight.transportpce.common.service.ServiceTypes; import org.opendaylight.transportpce.networkmodel.service.NetworkModelService; import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathInput; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathOutput; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathOutputBuilder; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterface; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterfaceBuilder; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterfaceKey; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.otn.renderer.input.Nodes; -import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.OtnLinkType; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.OtnServicePathInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.OtnServicePathOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.OtnServicePathOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.link.tp.LinkTp; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.link.tp.LinkTpBuilder; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.node.interfaces.NodeInterface; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.node.interfaces.NodeInterfaceBuilder; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.node.interfaces.NodeInterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.otn.renderer.nodes.Nodes; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -66,65 +69,50 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { boolean success = true; List nodeInterfaces = new ArrayList<>(); List results = new ArrayList<>(); - if (input.getServiceType() == null || input.getServiceRate() == null) { + if (input.getServiceFormat() == null || input.getServiceRate() == null) { OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder() .setSuccess(false) .setResult("Error - service-type and service-rate must be presents"); return otnServicePathOutputBuilder.build(); } - CopyOnWriteArrayList otnNodesProvisioned = new CopyOnWriteArrayList<>(); - switch (input.getServiceType()) { - case "Ethernet": - if ("10G".equals(input.getServiceRate()) || "1G".equals(input.getServiceRate())) { - try { - LOG.info("Calling Node interfaces {} {} {} {} {} {} {}", - input.getServiceRate(), input.getEthernetEncoding(), - input.getServiceType(), input.getOperation(), input.getTribPortNumber(), - input.getTribSlot(), input.getNodes()); - nodeInterfaces = createInterface(input); + CopyOnWriteArrayList otnLinkTps = new CopyOnWriteArrayList<>(); + String serviceType = ServiceTypes.getOtnServiceType(input.getServiceFormat(), input.getServiceRate()); + switch (serviceType) { + case StringConstants.SERVICE_TYPE_1GE: + case StringConstants.SERVICE_TYPE_10GE: + case StringConstants.SERVICE_TYPE_100GE_M: + try { + LOG.info("Calling Node interfaces {} {} {} {} {} {} {}", + input.getServiceRate(), input.getEthernetEncoding(), + input.getServiceFormat(), input.getOperation(), input.getTribPortNumber(), + input.getTribSlot(), input.getNodes()); + if (input.getNodes() != null) { + createLowOrderInterfaces(input, nodeInterfaces, otnLinkTps); LOG.info("Node interfaces created just fine "); - - List nodesToUpdate = new ArrayList<>(); - if (!nodeInterfaces.isEmpty()) { - for (NodeInterface nodeInterf : nodeInterfaces) { - if (nodeInterf.getOduInterfaceId() != null) { - List interList = nodeInterf.getOduInterfaceId().stream() - .filter(id -> id.contains("NETWORK")).collect(Collectors.toList()); - if (!interList.isEmpty()) { - for (String inter : interList) { - String tp = inter.split("-ODU")[0]; - String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0]; - nodesToUpdate.add(nodeTopo + "--" + tp); - } - } - } - } - } - updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(), - input.getTribSlot(), false); - } catch (OpenRoadmInterfaceException e) { - LOG.warn("Set up service path failed", e); - success = false; } - } else { - LOG.warn("Unsupported service-rate for service-type Ethernet"); + } catch (OpenRoadmInterfaceException e) { + LOG.warn("Set up service path failed", e); + success = false; } break; - case "ODU": - if ("100G".equals(input.getServiceRate())) { - try { - createODU4TtpInterface(input, nodeInterfaces, otnNodesProvisioned); - updateOtnTopology(otnNodesProvisioned, null, null, null, null, false); - } catch (OpenRoadmInterfaceException e) { - LOG.warn("Set up service path failed", e); - success = false; - } - } else { - LOG.warn("Unsupported service-rate for service-type ODU"); + case StringConstants.SERVICE_TYPE_ODU4: + try { + createODU4TtpInterface(input, nodeInterfaces, otnLinkTps); + } catch (OpenRoadmInterfaceException e) { + LOG.warn("Set up service path failed", e); + success = false; + } + break; + case StringConstants.SERVICE_TYPE_ODUC4: + try { + createOduc4TtpInterface(input, nodeInterfaces, otnLinkTps); + } catch (OpenRoadmInterfaceException e) { + LOG.warn("Set up service path failed", e); + success = false; } break; default: - LOG.error("service-type {} not managed yet", input.getServiceType()); + LOG.error("service-type {} not managed yet", serviceType); break; } if (success) { @@ -142,49 +130,58 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder() .setSuccess(success) .setNodeInterface(nodeInterfacesMap) - .setResult(String.join("\n", results)); + .setResult(String.join("\n", results)) + .setLinkTp(otnLinkTps); return otnServicePathOutputBuilder.build(); } public OtnServicePathOutput deleteOtnServicePath(OtnServicePathInput input) { - if (input == null) { - LOG.error("Unable to delete otn service path. input = null"); - return new OtnServicePathOutputBuilder().setResult("Unable to delete otn service path. input = null") + if (input.getNodes() == null) { + LOG.error("Unable to delete otn service path. input nodes = null"); + return new OtnServicePathOutputBuilder().setResult("Unable to delete otn service path. input nodes = null") .setSuccess(false).build(); } List nodes = input.getNodes(); AtomicBoolean success = new AtomicBoolean(true); ConcurrentLinkedQueue results = new ConcurrentLinkedQueue<>(); - List nodesTpToUpdate = new ArrayList<>(); - CopyOnWriteArrayList otnNodesProvisioned = new CopyOnWriteArrayList<>(); + CopyOnWriteArrayList otnLinkTps = new CopyOnWriteArrayList<>(); ForkJoinPool forkJoinPool = new ForkJoinPool(); ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> { List interfacesToDelete = new LinkedList<>(); String nodeId = node.getNodeId(); LOG.info("Deleting service setup on node {}", nodeId); String networkTp = node.getNetworkTp(); - if (networkTp == null || input.getServiceRate() == null || input.getServiceType() == null) { - LOG.error("destination ({}) or service rate ({}) or service type ({}) is null.", networkTp, - input.getServiceRate(), input.getServiceType()); + if (networkTp == null || input.getServiceRate() == null || input.getServiceFormat() == null) { + LOG.error("destination ({}) or service-rate ({}) or service-format ({}) is null.", networkTp, + input.getServiceRate(), input.getServiceFormat()); return; } // if the node is currently mounted then proceed. if (this.deviceTransactionManager.isDeviceMounted(nodeId)) { String connectionNumber = ""; - switch (input.getServiceRate()) { - case ("100G"): - if ("ODU".equals(input.getServiceType())) { + switch (input.getServiceRate().intValue()) { + case 100: + if ("ODU".equals(input.getServiceFormat())) { interfacesToDelete.add(networkTp + "-ODU4"); - otnNodesProvisioned.add(node); if (node.getNetwork2Tp() != null) { interfacesToDelete.add(node.getNetwork2Tp() + "-ODU4"); } + } else if ("Ethernet".equals(input.getServiceFormat())) { + connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU4"); } break; - case ("10G"): + case 400: + if ("ODU".equals(input.getServiceFormat())) { + interfacesToDelete.add(networkTp + "-ODUC4"); + if (node.getNetwork2Tp() != null) { + interfacesToDelete.add(node.getNetwork2Tp() + "-ODUC4"); + } + } + break; + case 10: connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU2e"); break; - case ("1G"): + case 1: connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU0"); break; default: @@ -199,9 +196,17 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { for (String interf : intToDelete) { if (!this.openRoadmInterfaceFactory.isUsedByOtnXc(nodeId, interf, connectionNumber, this.deviceTransactionManager)) { + interfacesToDelete.add(interf); - if (!getSupportedInterface(nodeId, interf).contains("ODU4")) { - interfacesToDelete.add(getSupportedInterface(nodeId, interf)); + String supportedInterface = this.openRoadmInterfaces.getSupportedInterface(nodeId, interf); + if (input.getServiceRate().intValue() == 100) { + if (!supportedInterface.contains("ODUC4")) { + interfacesToDelete.add(supportedInterface); + } + } else { + if (!supportedInterface.contains("ODU4")) { + interfacesToDelete.add(supportedInterface); + } } } } @@ -230,8 +235,11 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { if (!interList.isEmpty()) { for (String inter : interList) { String tp = inter.split("-ODU")[0]; - String nodeTopo = nodeId + "-" + tp.split("-")[0]; - nodesTpToUpdate.add(nodeTopo + "--" + tp); + LinkTp otnLinkTp = new LinkTpBuilder() + .setNodeId(nodeId) + .setTpId(tp) + .build(); + otnLinkTps.add(otnLinkTp); } } })); @@ -239,18 +247,13 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { forkJoinTask.get(); } catch (InterruptedException | ExecutionException e) { LOG.error("Error while deleting service paths!", e); + return new OtnServicePathOutputBuilder().setResult("Error while deleting service paths!") + .setSuccess(false).build(); } forkJoinPool.shutdown(); - LOG.info("requesting otn-topology update..."); - if (!nodesTpToUpdate.isEmpty() && !"ODU".equals(input.getServiceType())) { - updateOtnTopology(null, nodesTpToUpdate, input.getServiceRate(), input.getTribPortNumber(), - input.getTribSlot(), true); - } else if (!otnNodesProvisioned.isEmpty()) { - updateOtnTopology(otnNodesProvisioned, null, null, null, null, true); - } - - OtnServicePathOutputBuilder delServBldr = new OtnServicePathOutputBuilder(); - delServBldr.setSuccess(success.get()); + OtnServicePathOutputBuilder delServBldr = new OtnServicePathOutputBuilder() + .setSuccess(success.get()) + .setLinkTp(otnLinkTps); if (results.isEmpty()) { return delServBldr.setResult("Request processed").build(); } else { @@ -268,46 +271,19 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { } } - private String getSupportedInterface(String nodeId, String interf) { - Optional supInterfOpt; - try { - supInterfOpt = this.openRoadmInterfaces.getInterface(nodeId, interf); - if (supInterfOpt.isPresent()) { - return supInterfOpt.get().getSupportingInterface(); - } else { - return null; - } - } catch (OpenRoadmInterfaceException e) { - LOG.error("error getting Supported Interface of {} - {}", interf, nodeId, e); - return null; - } - } - - private List createInterface(OtnServicePathInput input) throws OpenRoadmInterfaceException { - List nodeInterfaces = new ArrayList<>(); - LOG.info("Calling Create Interface entry for OTN service path"); - if (input.getServiceRate() == null - || !("1G".equals(input.getServiceRate()) || "10G".equals(input.getServiceRate()))) { - LOG.error("Service rate {} not managed yet", input.getServiceRate()); - } else { - createLowOrderInterfaces(input, nodeInterfaces); - } - return nodeInterfaces; - } - private Optional postCrossConnect(List createdOduInterfaces, Nodes node) throws OpenRoadmInterfaceException { return this.crossConnect.postOtnCrossConnect(createdOduInterfaces, node); } - private void createLowOrderInterfaces(OtnServicePathInput input, List nodeInterfaces) - throws OpenRoadmInterfaceException { + private void createLowOrderInterfaces(OtnServicePathInput input, List nodeInterfaces, + CopyOnWriteArrayList linkTpList) throws OpenRoadmInterfaceException { for (Nodes node : input.getNodes()) { // check if the node is mounted or not? List createdEthInterfaces = new ArrayList<>(); List createdOduInterfaces = new ArrayList<>(); - switch (input.getServiceRate()) { - case ("1G"): + switch (input.getServiceRate().intValue()) { + case 1: LOG.info("Input service is 1G"); if (node.getClientTp() != null) { createdEthInterfaces.add( @@ -321,15 +297,25 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { createdOduInterfaces.add( openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetworkTp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot())); + LinkTp otnLinkTp = new LinkTpBuilder() + .setNodeId(node.getNodeId()) + .setTpId(node.getNetworkTp()) + .build(); + linkTpList.add(otnLinkTp); if (node.getNetwork2Tp() != null) { createdOduInterfaces.add( // supporting interface? payload ? openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetwork2Tp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot())); + LinkTp otnLinkTp2 = new LinkTpBuilder() + .setNodeId(node.getNodeId()) + .setTpId(node.getNetworkTp()) + .build(); + linkTpList.add(otnLinkTp2); } break; - case ("10G"): + case 10: LOG.info("Input service is 10G"); if (node.getClientTp() != null) { createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth10GInterface( @@ -344,12 +330,63 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { // supporting interface? payload ? openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(), input.getServiceName(), PT_03, true, input.getTribPortNumber(), input.getTribSlot())); + LinkTp otnLinkTp3 = new LinkTpBuilder() + .setNodeId(node.getNodeId()) + .setTpId(node.getNetworkTp()) + .build(); + linkTpList.add(otnLinkTp3); if (node.getNetwork2Tp() != null) { createdOduInterfaces.add( // supporting interface? payload ? openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetwork2Tp(), input.getServiceName(), PT_03, true, input.getTribPortNumber(), input.getTribSlot())); + LinkTp otnLinkTp4 = new LinkTpBuilder() + .setNodeId(node.getNodeId()) + .setTpId(node.getNetworkTp()) + .build(); + linkTpList.add(otnLinkTp4); + } + break; + case 100: + LOG.info("Input service is 100G"); + // Take the first and last value in the list of OpucnTribSlot (assuming SH would provide + // min and max value only, size two) + OpucnTribSlotDef minOpucnTs = OpucnTribSlotDef.getDefaultInstance( + input.getOpucnTribSlots().get(0).getValue()); + OpucnTribSlotDef maxOpucnTs = OpucnTribSlotDef.getDefaultInstance( + input.getOpucnTribSlots().get(1).getValue()); + if (node.getClientTp() != null) { + createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth100GInterface( + node.getNodeId(), node.getClientTp())); + // OPUCn trib information is optional when creating ODU4 ethernet (client) interface + createdOduInterfaces.add( + openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(), + node.getClientTp(), input.getServiceName(), PT_07, false, minOpucnTs, + maxOpucnTs)); + } + // Here payload-type is optional and is not used for interface creation (especially for network) + createdOduInterfaces.add( + openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(), + node.getNetworkTp(), input.getServiceName(), PT_07, true, minOpucnTs, + maxOpucnTs)); + LinkTp otnLinkTp5 = new LinkTpBuilder() + .setNodeId(node.getNodeId()) + .setTpId(node.getNetworkTp()) + .build(); + linkTpList.add(otnLinkTp5); + // Here payload-type is optional and is not used for service creation + // This is needed if there is an intermediate node + if (node.getNetwork2Tp() != null) { + createdOduInterfaces.add( + openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(), + node.getNetwork2Tp(), input.getServiceName(), PT_07, true, minOpucnTs, + maxOpucnTs)); + LinkTp otnLinkTp6 = new LinkTpBuilder() + .setNodeId(node.getNodeId()) + .setTpId(node.getNetworkTp()) + .build(); + linkTpList.add(otnLinkTp6); } break; default: @@ -374,13 +411,16 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { } } - private void createODU4TtpInterface(OtnServicePathInput input, List nodeInterfaces, - CopyOnWriteArrayList otnNodesProvisioned) throws OpenRoadmInterfaceException { - + private void createOduc4TtpInterface(OtnServicePathInput input, List nodeInterfaces, + CopyOnWriteArrayList linkTpList) throws OpenRoadmInterfaceException { + if (input.getNodes() == null) { + return; + } + LOG.info("Creation of ODUC4 TTP interface in OTN service path {}", input); for (int i = 0; i < input.getNodes().size(); i++) { Nodes node = input.getNodes().get(i); - String supportingOtuInterface = node.getNetworkTp() + "-OTU"; - List createdOdu4Interfaces = new ArrayList<>(); + String supportingOtuInterface = node.getNetworkTp() + "-OTUC4"; + List createdOduc4Interfaces = new ArrayList<>(); // Adding SAPI/DAPI information to the Nodes tgtNode = null; if (i + 1 == input.getNodes().size()) { @@ -389,34 +429,47 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { } else { tgtNode = input.getNodes().get(i + 1); } - createdOdu4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOdu4Interface(node.getNodeId(), + createdOduc4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOduc4Interface(node.getNodeId(), node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp())); + NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder() .withKey(new NodeInterfaceKey(node.getNodeId())) .setNodeId(node.getNodeId()) - .setOduInterfaceId(createdOdu4Interfaces); + .setOduInterfaceId(createdOduc4Interfaces); // though this is odu, actually it has ODUC4 interfaces nodeInterfaces.add(nodeInterfaceBuilder.build()); - otnNodesProvisioned.add(node); + LinkTp otnLinkTp = new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build(); + linkTpList.add(otnLinkTp); } } - private void updateOtnTopology(CopyOnWriteArrayList nodes, List nodesTps, String serviceRate, - Short tribPortNb, Short tribSlotNb, boolean isDeletion) { - if (nodes != null && nodes.size() == 2) { - if (isDeletion) { - LOG.info("updating otn-topology removing ODU4 links"); - this.networkModelService.deleteOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getNetworkTp(), - nodes.get(1).getNodeId(), nodes.get(1).getNetworkTp(), OtnLinkType.ODTU4); + private void createODU4TtpInterface(OtnServicePathInput input, List nodeInterfaces, + CopyOnWriteArrayList linkTpList) throws OpenRoadmInterfaceException { + if (input.getNodes() == null) { + return; + } + LOG.info("Creation of ODU4 tp interface {}", input); + for (int i = 0; i < input.getNodes().size(); i++) { + Nodes node = input.getNodes().get(i); + String supportingOtuInterface = node.getNetworkTp() + "-OTU"; + List createdOdu4Interfaces = new ArrayList<>(); + // Adding SAPI/DAPI information to the + Nodes tgtNode = null; + if (i + 1 == input.getNodes().size()) { + // For the end node, tgtNode becomes the first node in the list + tgtNode = input.getNodes().get(0); } else { - LOG.info("updating otn-topology adding ODU4 links"); - this.networkModelService.createOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getNetworkTp(), - nodes.get(1).getNodeId(), nodes.get(1).getNetworkTp(), OtnLinkType.ODTU4); + tgtNode = input.getNodes().get(i + 1); } - } else if (nodesTps != null && (nodesTps.size() % 2 == 0) && serviceRate != null && tribPortNb != null - && tribSlotNb != null) { - LOG.info("updating otn-topology node tps -tps and tpn pools"); - this.networkModelService.updateOtnLinks(nodesTps, serviceRate, tribPortNb, tribSlotNb, isDeletion); + + createdOdu4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOdu4Interface(node.getNodeId(), + node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp())); + NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder() + .withKey(new NodeInterfaceKey(node.getNodeId())) + .setNodeId(node.getNodeId()) + .setOduInterfaceId(createdOdu4Interfaces); + nodeInterfaces.add(nodeInterfaceBuilder.build()); + LinkTp otnLinkTp = new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build(); + linkTpList.add(otnLinkTp); } } - }