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=3d3e704910d0d569c2807f4eb90d455b8ffbf905;hb=b5ee86a522ce3cf5c6216f10647edb08b31c72e9;hp=fbf62e7ca840f9d14700d8537736300fa3bd4feb;hpb=2f13d2e6564596df4500eea94928bf13d4829808;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 fbf62e7ca..3d3e70491 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 @@ -8,6 +8,7 @@ package org.opendaylight.transportpce.renderer.provisiondevice; import java.util.ArrayList; +import java.util.Arrays; import java.util.HashMap; import java.util.LinkedList; import java.util.List; @@ -19,23 +20,25 @@ import java.util.concurrent.ExecutionException; 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.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.opendaylight.transportpce.device.renderer.rev211004.OtnServicePathInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.OtnServicePathOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.OtnServicePathOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.AEndApiInfo; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.ZEndApiInfo; 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.rev201211.node.interfaces.NodeInterface; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceBuilder; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceKey; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.otn.renderer.input.Nodes; -import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType; +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; @@ -61,161 +64,112 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { this.networkModelService = networkModelService; } +//TODO Align log messages and returned results messages @Override - public OtnServicePathOutput setupOtnServicePath(OtnServicePathInput input) { + public OtnServicePathOutput setupOtnServicePath(OtnServicePathInput input, String serviceType) { LOG.info("Calling setup otn-service path"); - boolean success = true; - List nodeInterfaces = new ArrayList<>(); - List results = new ArrayList<>(); - if (input.getServiceType() == null || input.getServiceRate() == null) { - OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder() + if (input.getServiceFormat() == null || input.getServiceRate() == null) { + return new OtnServicePathOutputBuilder() .setSuccess(false) - .setResult("Error - service-type and service-rate must be presents"); - return otnServicePathOutputBuilder.build(); + .setResult("Error - service-type and service-rate must be present") + .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); + List nodeInterfaces = new ArrayList<>(); + CopyOnWriteArrayList otnLinkTps = new CopyOnWriteArrayList<>(); + try { + switch (serviceType) { + case StringConstants.SERVICE_TYPE_1GE: + case StringConstants.SERVICE_TYPE_10GE: + case StringConstants.SERVICE_TYPE_100GE_M: + 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 = updateOduNodes(nodeInterfaces, "ODU"); - updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(), - input.getTribSlot(), false); - } catch (OpenRoadmInterfaceException e) { - LOG.warn("Set up service path failed", e); - success = false; - } - } else if ("100G".equals(input.getServiceRate())) { - try { - LOG.info("Calling Node interfaces {} {} {} {} {} {}", - input.getServiceRate(), input.getEthernetEncoding(), - input.getServiceType(), input.getOperation(), input.getOpucnTribSlots(), input.getNodes()); - nodeInterfaces = createInterface(input); - LOG.info("Node interfaces created just fine for 100G OTN "); - // TODO: Update the OTN topology accordingly with Opucn-Trib-slots - // List nodesToUpdate = updateOduNodes(nodeInterfaces, "ODUC4"); - // 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"); - } - 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 if ("400G".equals(input.getServiceRate())) { - try { - createOduc4TtpInterface(input, nodeInterfaces, otnNodesProvisioned); - updateOtnTopology(otnNodesProvisioned, null, null, null, null, false); - } catch (OpenRoadmInterfaceException e) { - LOG.warn("Set up service path failed", e); - success = false; + break; + case StringConstants.SERVICE_TYPE_ODU4: + createHighOrderInterfaces(input, nodeInterfaces, otnLinkTps); + break; + case StringConstants.SERVICE_TYPE_ODUC4: + createOduc4TtpInterface(input, nodeInterfaces, otnLinkTps); + break; + case StringConstants.SERVICE_TYPE_100GE_S: + LOG.info("Calling Node interface for service-type {}", serviceType); + if (input.getNodes() != null) { + createHighOrderInterfaces(input, nodeInterfaces, otnLinkTps); + LOG.info("Node interfaces created"); } - } else { - LOG.warn("Unsupported service-rate for service-type ODU"); - } - break; - default: - LOG.error("service-type {} not managed yet", input.getServiceType()); - break; - } - if (success) { - LOG.info("Result is success"); + break; + default: + LOG.error("Service-type {} not managed yet", serviceType); + return new OtnServicePathOutputBuilder() + .setSuccess(false) + .setResult("Service-type not managed") + .build(); + } + } catch (OpenRoadmInterfaceException e) { + LOG.warn("Service path set-up failed", e); + Map nodeInterfacesMap = new HashMap<>(); for (NodeInterface nodeInterface : nodeInterfaces) { - results.add("Otn Service path was set up successfully for node :" + nodeInterface.getNodeId()); + if (nodeInterface != null) { + nodeInterfacesMap.put(nodeInterface.key(), nodeInterface); + } } + //TODO check if we need to set a NodeInterface Map in the result in that case + return new OtnServicePathOutputBuilder() + .setSuccess(false) + .setNodeInterface(nodeInterfacesMap) + .setResult("Service path set-up failed") + .setLinkTp(otnLinkTps) + .build(); } + LOG.info("Service path set-up succeed"); + List results = new ArrayList<>(); Map nodeInterfacesMap = new HashMap<>(); for (NodeInterface nodeInterface : nodeInterfaces) { if (nodeInterface != null) { + results.add("Otn Service path was set up successfully for node :" + nodeInterface.getNodeId()); nodeInterfacesMap.put(nodeInterface.key(), nodeInterface); } } - OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder() - .setSuccess(success) + return new OtnServicePathOutputBuilder() + .setSuccess(true) .setNodeInterface(nodeInterfacesMap) - .setResult(String.join("\n", results)); - return otnServicePathOutputBuilder.build(); + .setResult(String.join("\n", results)) + .setLinkTp(otnLinkTps) + .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") - .setSuccess(false).build(); + @SuppressWarnings("rawtypes") + // FIXME check if the ForkJoinTask raw type can be avoided + // Raw types use are discouraged since they lack type safety. + // Resulting Problems are observed at run time and not at compile time + public OtnServicePathOutput deleteOtnServicePath(OtnServicePathInput input, String serviceType) { + 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())) { - interfacesToDelete.add(networkTp + "-ODU4"); - otnNodesProvisioned.add(node); - if (node.getNetwork2Tp() != null) { - interfacesToDelete.add(node.getNetwork2Tp() + "-ODU4"); - } - } - break; - case ("10G"): - connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU2e"); - break; - case ("1G"): - connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU0"); - break; - default: - LOG.error("service rate {} not managed yet", input.getServiceRate()); - String result = input.getServiceRate() + " is not supported"; - results.add(result); - success.set(false); - return; - } - List intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, true); - if (intToDelete != null) { - 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)); - } - } - } - } - } else { + if (!this.deviceTransactionManager.isDeviceMounted(nodeId)) { String result = nodeId + " is not mounted on the controller"; results.add(result); success.set(false); @@ -224,6 +178,85 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { return; // TODO should deletion end here? } + // if the node is currently mounted then proceed. + List interfacesToDelete = new LinkedList<>(); + String connectionNumber = ""; + switch (serviceType) { + case StringConstants.SERVICE_TYPE_100GE_S: + connectionNumber = getConnectionNumber(null, node, networkTp, "ODU4"); + break; + case StringConstants.SERVICE_TYPE_100GE_M: + connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU4"); + otnLinkTps.add(new LinkTpBuilder() + .setNodeId(nodeId) + .setTpId(networkTp) + .build()); + break; + case StringConstants.SERVICE_TYPE_ODU4: + if (node.getClientTp() == null && node.getNetwork2Tp() == null) { + interfacesToDelete.add(networkTp + "-ODU4"); + otnLinkTps.add(new LinkTpBuilder() + .setNodeId(nodeId) + .setTpId(networkTp) + .build()); + } + if (node.getClientTp() == null && node.getNetwork2Tp() != null) { + interfacesToDelete.add(networkTp + "-ODU4"); + interfacesToDelete.add(node.getNetwork2Tp() + "-ODU4"); + connectionNumber = getConnectionNumber(null, node, networkTp, "ODU4"); + } + break; + case StringConstants.SERVICE_TYPE_ODUC4: + if (node.getClientTp() == null && node.getNetwork2Tp() == null) { + interfacesToDelete.add(networkTp + "-ODUC4"); + otnLinkTps.add(new LinkTpBuilder() + .setNodeId(nodeId) + .setTpId(networkTp) + .build()); + } + if (node.getClientTp() == null && node.getNetwork2Tp() != null) { + interfacesToDelete.add(networkTp + "-ODUC4"); + interfacesToDelete.add(node.getNetwork2Tp() + "-ODUC4"); + connectionNumber = getConnectionNumber(null, node, networkTp, "ODUC4"); + } + break; + case StringConstants.SERVICE_TYPE_10GE: + connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU2e"); + otnLinkTps.add(new LinkTpBuilder() + .setNodeId(nodeId) + .setTpId(networkTp) + .build()); + break; + case StringConstants.SERVICE_TYPE_1GE: + connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU0"); + otnLinkTps.add(new LinkTpBuilder() + .setNodeId(nodeId) + .setTpId(networkTp) + .build()); + break; + default: + LOG.error("service-type {} not managed yet", serviceType); + String result = serviceType + " is not supported"; + results.add(result); + success.set(false); + return; + } + List intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, true); + for (String interf : intToDelete == null ? new ArrayList() : intToDelete) { + if (!this.openRoadmInterfaceFactory.isUsedByOtnXc(nodeId, interf, connectionNumber, + this.deviceTransactionManager)) { + interfacesToDelete.add(interf); + String supportedInterface = this.openRoadmInterfaces.getSupportedInterface(nodeId, interf); + if (supportedInterface == null) { + continue; + } + if ((input.getServiceRate().intValue() == 100 && !supportedInterface.contains("ODUC4")) + || (input.getServiceRate().intValue() != 100 && !supportedInterface.contains("ODU4"))) { + interfacesToDelete.add(supportedInterface); + } + } + } + for (String interfaceId : interfacesToDelete) { try { this.openRoadmInterfaces.deleteInterface(nodeId, interfaceId); @@ -234,100 +267,45 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { results.add(result); } } - List interList = interfacesToDelete.stream().filter(ele -> ele.contains("NETWORK")) - .collect(Collectors.toList()); - if (!interList.isEmpty()) { - for (String inter : interList) { - String tp = inter.split("-ODU")[0]; - String nodeTopo = nodeId + "-" + tp.split("-")[0]; - nodesTpToUpdate.add(nodeTopo + "--" + tp); - } - } })); try { 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()); - if (results.isEmpty()) { - return delServBldr.setResult("Request processed").build(); - } else { - return delServBldr.setResult(String.join("\n", results)).build(); - } + return new OtnServicePathOutputBuilder() + .setSuccess(success.get()) + .setLinkTp(otnLinkTps) + .setResult( + results.isEmpty() + ? "Request processed" + : String.join("\n", results)) + .build(); } private String getConnectionNumber(String serviceName, Nodes node, String networkTp, String oduType) { + List list1 = new ArrayList<>(); + List list2 = new ArrayList<>(Arrays.asList("x")); if (node.getClientTp() != null) { - return String.join("-", node.getClientTp(), oduType, serviceName, "x", networkTp, oduType, serviceName); + list1.addAll(Arrays.asList(node.getClientTp(), oduType)); + list2.addAll(Arrays.asList(networkTp, oduType)); } else if (node.getNetwork2Tp() != null) { - return String.join("-", networkTp, oduType, serviceName, "x", node.getNetwork2Tp(), oduType, serviceName); + list1.addAll(Arrays.asList(networkTp, oduType)); + list2.addAll(Arrays.asList(node.getNetwork2Tp(), oduType)); } else { return ""; } - } - - 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 updateOduNodes(List nodeInterfaceList, String deLimiter) { - List nodesToUpdate = new ArrayList<>(); - if (!(deLimiter.equals("ODU")) || !(deLimiter.equals("ODUC4"))) { - LOG.error("ODU node list update will be incorrect"); - } - - if (!nodeInterfaceList.isEmpty()) { - for (NodeInterface nodeInterf : nodeInterfaceList) { - 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("-" + deLimiter)[0]; - String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0]; - nodesToUpdate.add(nodeTopo + "--" + tp); - } - } - } - } - } - - return nodesToUpdate; - } - - 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()) - || "100G".equals(input.getServiceRate()))) { - LOG.error("Service rate {} not managed yet", input.getServiceRate()); - } else { - createLowOrderInterfaces(input, nodeInterfaces); + if (serviceName != null) { + list1.add(serviceName); + list2.add(serviceName); } - return nodeInterfaces; + list1.addAll(list2); + return String.join("-", list1); } private Optional postCrossConnect(List createdOduInterfaces, Nodes node) @@ -335,14 +313,22 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { 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()) { + AEndApiInfo apiInfoA = null; + ZEndApiInfo apiInfoZ = null; + if (input.getAEndApiInfo() != null && input.getAEndApiInfo().getNodeId().contains(node.getNodeId())) { + apiInfoA = input.getAEndApiInfo(); + } + if (input.getZEndApiInfo() != null && input.getZEndApiInfo().getNodeId().contains(node.getNodeId())) { + apiInfoZ = input.getZEndApiInfo(); + } // 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( @@ -356,15 +342,19 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { createdOduInterfaces.add( openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetworkTp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot())); + linkTpList.add( + new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build()); if (node.getNetwork2Tp() != null) { createdOduInterfaces.add( // supporting interface? payload ? openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetwork2Tp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot())); + linkTpList.add( + new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build()); } break; - case ("10G"): + case 10: LOG.info("Input service is 10G"); if (node.getClientTp() != null) { createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth10GInterface( @@ -372,22 +362,27 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { createdOduInterfaces.add( // suppporting interface?, payload ? openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), - node.getClientTp(), input.getServiceName(), PT_03, false, input.getTribPortNumber(), - input.getTribSlot())); + node.getClientTp(), input.getServiceName(), false, input.getTribPortNumber(), + input.getTribSlot(), apiInfoA, apiInfoZ)); } createdOduInterfaces.add( // supporting interface? payload ? openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(), - input.getServiceName(), PT_03, true, input.getTribPortNumber(), input.getTribSlot())); + input.getServiceName(), true, input.getTribPortNumber(), input.getTribSlot(), apiInfoA, + apiInfoZ)); + linkTpList.add( + new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build()); if (node.getNetwork2Tp() != null) { createdOduInterfaces.add( // supporting interface? payload ? openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), - node.getNetwork2Tp(), input.getServiceName(), PT_03, true, input.getTribPortNumber(), - input.getTribSlot())); + node.getNetwork2Tp(), input.getServiceName(), true, input.getTribPortNumber(), + input.getTribSlot(), apiInfoA, apiInfoZ)); + linkTpList.add( + new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build()); } break; - case ("100G"): + 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) @@ -409,6 +404,8 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(), node.getNetworkTp(), input.getServiceName(), PT_07, true, minOpucnTs, maxOpucnTs)); + linkTpList.add( + new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build()); // 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) { @@ -416,6 +413,8 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(), node.getNetwork2Tp(), input.getServiceName(), PT_07, true, minOpucnTs, maxOpucnTs)); + linkTpList.add( + new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build()); } break; default: @@ -430,92 +429,105 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { createdConnections.add(connectionNameOpt.get()); LOG.info("Created cross connects"); } - NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder() - .withKey(new NodeInterfaceKey(node.getNodeId())) - .setNodeId(node.getNodeId()) - .setConnectionId(createdConnections) - .setEthInterfaceId(createdEthInterfaces) - .setOduInterfaceId(createdOduInterfaces); - nodeInterfaces.add(nodeInterfaceBuilder.build()); + nodeInterfaces.add(new NodeInterfaceBuilder() + .withKey(new NodeInterfaceKey(node.getNodeId())) + .setNodeId(node.getNodeId()) + .setConnectionId(createdConnections) + .setEthInterfaceId(createdEthInterfaces) + .setOduInterfaceId(createdOduInterfaces) + .build()); } } - private void createOduc4TtpInterface(OtnServicePathInput input, List nodeInterfaces, - CopyOnWriteArrayList otnNodesProvisioned) 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() + "-OTUC4"; - List createdOduc4Interfaces = 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 { - tgtNode = input.getNodes().get(i + 1); + private void createHighOrderInterfaces(OtnServicePathInput input, List nodeInterfaces, + CopyOnWriteArrayList linkTpList) throws OpenRoadmInterfaceException { + for (Nodes node : input.nonnullNodes()) { + AEndApiInfo apiInfoA = null; + ZEndApiInfo apiInfoZ = null; + if (input.getAEndApiInfo() != null && input.getAEndApiInfo().getNodeId().contains(node.getNodeId())) { + apiInfoA = input.getAEndApiInfo(); + } + if (input.getZEndApiInfo() != null && input.getZEndApiInfo().getNodeId().contains(node.getNodeId())) { + apiInfoZ = input.getZEndApiInfo(); + } + // check if the node is mounted or not? + List createdEthInterfaces = new ArrayList<>(); + List createdOduInterfaces = new ArrayList<>(); + switch (input.getServiceRate().intValue()) { + case 100: + LOG.info("Input service is 100G"); + if (node.getClientTp() != null && node.getNetwork2Tp() == null) { + createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth100GInterface( + node.getNodeId(), node.getClientTp())); + createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface( + node.getNodeId(), node.getClientTp(), false, apiInfoA, apiInfoZ, "21")); + // supporting interface? payload ? + createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface( + node.getNodeId(), node.getNetworkTp(), true, null, null, "21")); + linkTpList.add(new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getClientTp()) + .build()); + } + if (node.getClientTp() == null && node.getNetwork2Tp() == null) { + createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface( + node.getNodeId(), node.getNetworkTp(), false, apiInfoA, apiInfoZ, "21")); + linkTpList.add(new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()) + .build()); + } + if (node.getClientTp() == null && node.getNetwork2Tp() != null) { + // supporting interface? payload ? + createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface( + node.getNodeId(), node.getNetworkTp(), true, null, null, "21")); + createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface( + node.getNodeId(), node.getNetwork2Tp(), true, null, null, "21")); + } + break; + default: + LOG.error("service rate {} not managed yet", input.getServiceRate()); + return; } - 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(createdOduc4Interfaces); // though this is odu, actually it has ODUC4 interfaces - nodeInterfaces.add(nodeInterfaceBuilder.build()); - otnNodesProvisioned.add(node); + // implement cross connect + List createdConnections = new ArrayList<>(); + if (createdOduInterfaces.size() == 2) { + Optional connectionNameOpt = postCrossConnect(createdOduInterfaces, node); + createdConnections.add(connectionNameOpt.get()); + LOG.info("Created cross connects"); + } + nodeInterfaces.add(new NodeInterfaceBuilder() + .withKey(new NodeInterfaceKey(node.getNodeId())) + .setNodeId(node.getNodeId()) + .setConnectionId(createdConnections) + .setEthInterfaceId(createdEthInterfaces) + .setOduInterfaceId(createdOduInterfaces) + .build()); } } - 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 ODU4 tp interface {}", input); + 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<>(); - // Adding SAPI/DAPI information to the - Nodes tgtNode = null; - if (i + 1 == input.getNodes().size()) { + String supportingOtuInterface = node.getNetworkTp() + "-OTUC4"; + + Nodes tgtNode = + i + 1 == input.getNodes().size() // For the end node, tgtNode becomes the first node in the list - tgtNode = input.getNodes().get(0); - } else { - tgtNode = input.getNodes().get(i + 1); - } - 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()); - otnNodesProvisioned.add(node); - } - } + ? input.getNodes().get(0) + : input.getNodes().get(i + 1); - 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); - } 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); - } - } 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); + nodeInterfaces.add(new NodeInterfaceBuilder() + .withKey(new NodeInterfaceKey(node.getNodeId())) + .setNodeId(node.getNodeId()) + .setOduInterfaceId(List.of( + // though this is odu, actually it has ODUC4 interfaces + openRoadmInterfaceFactory.createOpenRoadmOtnOduc4Interface(node.getNodeId(), + node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()))) + .build()); + linkTpList.add(new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build()); } } - }