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=f9606e3b3f96698c3728af138b39cb1facb097e5;hb=c725528fb8a0b09ce24adac744c888a10cf90f72;hp=191b1998a7540808c02083786908236426e964a3;hpb=8e16a471eadb0e9e8fb9a4c745f5e64ffeffa702;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 191b1998a..f9606e3b3 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,112 +8,205 @@ package org.opendaylight.transportpce.renderer.provisiondevice; import java.util.ArrayList; +import java.util.HashMap; import java.util.LinkedList; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.CopyOnWriteArrayList; 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.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.renderer.device.rev200128.OtnServicePathInput; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathOutput; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.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.rev200128.node.interfaces.NodeInterface; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.node.interfaces.NodeInterfaceBuilder; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.node.interfaces.NodeInterfaceKey; -import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200128.otn.renderer.input.Nodes; +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.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.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType; +import org.opendaylight.yangtools.yang.common.Uint32; import org.slf4j.Logger; import org.slf4j.LoggerFactory; + public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { - private static final String ODU2E = "-ODU2e-"; private static final Logger LOG = LoggerFactory.getLogger(OtnDeviceRendererServiceImpl.class); + private static final String PT_03 = "03"; + private static final String PT_07 = "07"; private final OpenRoadmInterfaceFactory openRoadmInterfaceFactory; private final CrossConnect crossConnect; private final OpenRoadmInterfaces openRoadmInterfaces; private final DeviceTransactionManager deviceTransactionManager; - + private final NetworkModelService networkModelService; public OtnDeviceRendererServiceImpl(OpenRoadmInterfaceFactory openRoadmInterfaceFactory, CrossConnect crossConnect, OpenRoadmInterfaces openRoadmInterfaces, - DeviceTransactionManager deviceTransactionManager) { + DeviceTransactionManager deviceTransactionManager, + NetworkModelService networkModelService) { this.openRoadmInterfaceFactory = openRoadmInterfaceFactory; this.crossConnect = crossConnect; this.openRoadmInterfaces = openRoadmInterfaces; this.deviceTransactionManager = deviceTransactionManager; + this.networkModelService = networkModelService; } @Override public OtnServicePathOutput setupOtnServicePath(OtnServicePathInput input) { - LOG.info("Calling setup service path"); + LOG.info("Calling setup otn-service path"); boolean success = true; List nodeInterfaces = new ArrayList<>(); List results = new ArrayList<>(); - if (input.getServiceType().equals("Ethernet")) { - try { - LOG.info("Calling Node interfaces {} {} {} {} {} {} {}", - input.getServiceRate(),input.getEthernetEncoding(), - input.getServiceType(),input.getOperation(),input.getTribPortNumber(), - input.getTribSlot(),input.getNodes()); - nodeInterfaces = createInterface(input); - LOG.info("Node interfaces created just fine "); - } - catch (OpenRoadmInterfaceException e) { - //handle exception - LOG.warn("Set up service path failed {}", e.toString()); - success = false; - } + 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.getServiceFormat()) { + case "Ethernet": + if (input.getServiceRate().intValue() == 1 || input.getServiceRate().intValue() == 10) { + try { + LOG.info("Calling Node interfaces {} {} {} {} {} {} {}", + input.getServiceRate(), input.getEthernetEncoding(), + input.getServiceFormat(), input.getOperation(), input.getTribPortNumber(), + input.getTribSlot(), input.getNodes()); + nodeInterfaces = createInterface(input); + 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 (input.getServiceRate().intValue() == 100) { + try { + LOG.info("Calling Node interfaces {} {} {} {} {} {}", + input.getServiceRate(), input.getEthernetEncoding(), + input.getServiceFormat(), 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 (input.getServiceRate().intValue() == 100) { + 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 (input.getServiceRate().intValue() == 400) { + 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; + } + } else { + LOG.warn("Unsupported service-rate for service-type ODU"); + } + break; + default: + LOG.error("service-type {} not managed yet", input.getServiceFormat()); + break; } if (success) { LOG.info("Result is success"); - for (NodeInterface nodeInterface: nodeInterfaces) { + for (NodeInterface nodeInterface : nodeInterfaces) { results.add("Otn Service path was set up successfully for node :" + nodeInterface.getNodeId()); } - //TODO Add otn topology links + } + Map nodeInterfacesMap = new HashMap<>(); + for (NodeInterface nodeInterface : nodeInterfaces) { + if (nodeInterface != null) { + nodeInterfacesMap.put(nodeInterface.key(), nodeInterface); + } } OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder() .setSuccess(success) - .setNodeInterface(nodeInterfaces) + .setNodeInterface(nodeInterfacesMap) .setResult(String.join("\n", results)); return otnServicePathOutputBuilder.build(); } - @Override 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(); + } List nodes = input.getNodes(); AtomicBoolean success = new AtomicBoolean(true); ConcurrentLinkedQueue results = new ConcurrentLinkedQueue<>(); + List nodesTpToUpdate = new ArrayList<>(); + CopyOnWriteArrayList otnNodesProvisioned = 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 srcTp = node.getClientTp(); - String destTp = node.getNetworkTp(); - if ((srcTp == null) || (destTp == null) || input.getServiceRate() == null) { - LOG.error("Source ({}) or destination ({}) termination point is null.", srcTp, destTp); + String networkTp = node.getNetworkTp(); + 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("10G"): - connectionNumber = srcTp + ODU2E + input.getServiceName() + "-x-" + destTp - + ODU2E + input.getServiceName(); + 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("1G"): - connectionNumber = srcTp + "-ODU0-" + input.getServiceName() + "-x-" + destTp - + ODU2E + input.getServiceName(); + case 400: + if ("ODU".equals(input.getServiceFormat())) { + interfacesToDelete.add(networkTp + "-ODUC4"); + otnNodesProvisioned.add(node); + if (node.getNetwork2Tp() != null) { + interfacesToDelete.add(node.getNetwork2Tp() + "-ODUC4"); + } + } + break; + case 10: + connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU2e"); + break; + case 1: + connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU0"); break; default: LOG.error("service rate {} not managed yet", input.getServiceRate()); @@ -127,9 +220,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); + } } } } @@ -141,7 +242,7 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { LOG.warn(result); forkJoinPool.shutdown(); return; - //TODO should deletion end here? + // TODO should deletion end here? } for (String interfaceId : interfacesToDelete) { try { @@ -153,6 +254,15 @@ 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(); @@ -160,6 +270,14 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { LOG.error("Error while deleting service paths!", e); } forkJoinPool.shutdown(); + LOG.info("requesting otn-topology update..."); + if (!nodesTpToUpdate.isEmpty() && !"ODU".equals(input.getServiceFormat())) { + 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()) { @@ -167,29 +285,49 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { } else { return delServBldr.setResult(String.join("\n", results)).build(); } + } + private String getConnectionNumber(String serviceName, Nodes node, String networkTp, String oduType) { + if (node.getClientTp() != null) { + return String.join("-", node.getClientTp(), oduType, serviceName, "x", networkTp, oduType, serviceName); + } else if (node.getNetwork2Tp() != null) { + return String.join("-", networkTp, oduType, serviceName, "x", node.getNetwork2Tp(), oduType, serviceName); + } 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; + 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); + } + } + } } - } catch (OpenRoadmInterfaceException e) { - LOG.error("error getting Supported Interface of {} - {}", interf, nodeId, e); - return null; } + + 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()))) { + || !(input.getServiceRate().intValue() == 1 || input.getServiceRate().intValue() == 10 + || input.getServiceRate().intValue() == 100)) { LOG.error("Service rate {} not managed yet", input.getServiceRate()); } else { createLowOrderInterfaces(input, nodeInterfaces); @@ -199,47 +337,98 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { private Optional postCrossConnect(List createdOduInterfaces, Nodes node) throws OpenRoadmInterfaceException { - return this.crossConnect.postOtnCrossConnect(createdOduInterfaces,node); + return this.crossConnect.postOtnCrossConnect(createdOduInterfaces, node); } private void createLowOrderInterfaces(OtnServicePathInput input, List nodeInterfaces) throws OpenRoadmInterfaceException { - for (Nodes node: input.getNodes()) { - //check if the node is mounted or not? + 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"); - createdEthInterfaces.add( - openRoadmInterfaceFactory.createOpenRoadmEth1GInterface(node.getNodeId(), node.getClientTp())); - createdOduInterfaces.add( - //suppporting interface?, payload ? - openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getClientTp(), - input.getServiceName(), "07", false, input.getTribPortNumber(), input.getTribSlot())); + if (node.getClientTp() != null) { + createdEthInterfaces.add( + openRoadmInterfaceFactory.createOpenRoadmEth1GInterface(node.getNodeId(), + node.getClientTp())); + createdOduInterfaces.add( + // suppporting interface?, payload ? + openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getClientTp(), + input.getServiceName(), PT_07, false, input.getTribPortNumber(), input.getTribSlot())); + } createdOduInterfaces.add( openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetworkTp(), - input.getServiceName(), "07", true, input.getTribPortNumber(), input.getTribSlot())); + input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot())); + if (node.getNetwork2Tp() != null) { + createdOduInterfaces.add( + // supporting interface? payload ? + openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), + node.getNetwork2Tp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(), + input.getTribSlot())); + } break; - case("10G"): + case 10: LOG.info("Input service is 10G"); - createdEthInterfaces.add( - openRoadmInterfaceFactory.createOpenRoadmEth10GInterface(node.getNodeId(), node.getClientTp())); - createdOduInterfaces.add( - //suppporting interface?, payload ? - openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getClientTp(), - input.getServiceName(),"03", false ,input.getTribPortNumber(),input.getTribSlot())); + if (node.getClientTp() != null) { + createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth10GInterface( + node.getNodeId(), node.getClientTp())); + createdOduInterfaces.add( + // suppporting interface?, payload ? + openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), + node.getClientTp(), input.getServiceName(), PT_03, false, input.getTribPortNumber(), + input.getTribSlot())); + } createdOduInterfaces.add( // supporting interface? payload ? openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(), - input.getServiceName(),"03" , true ,input.getTribPortNumber(),input.getTribSlot())); + input.getServiceName(), PT_03, true, input.getTribPortNumber(), input.getTribSlot())); + if (node.getNetwork2Tp() != null) { + createdOduInterfaces.add( + // supporting interface? payload ? + openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), + node.getNetwork2Tp(), input.getServiceName(), PT_03, true, input.getTribPortNumber(), + input.getTribSlot())); + } + 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)); + // 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)); + } break; default: LOG.error("service rate {} not managed yet", input.getServiceRate()); return; } - //implement cross connect + // implement cross connect List createdConnections = new ArrayList<>(); if (!createdOduInterfaces.isEmpty()) { Optional connectionNameOpt = postCrossConnect(createdOduInterfaces, node); @@ -247,12 +436,91 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService { LOG.info("Created cross connects"); } NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder() - .withKey(new NodeInterfaceKey(input.getServiceName() + "-" + node.getNodeId())) - .setNodeId(input.getServiceName() + "-" + node.getNodeId()) - .setConnectionId(createdConnections) - .setEthInterfaceId(createdEthInterfaces) - .setOduInterfaceId(createdOduInterfaces); + .withKey(new NodeInterfaceKey(node.getNodeId())) + .setNodeId(node.getNodeId()) + .setConnectionId(createdConnections) + .setEthInterfaceId(createdEthInterfaces) + .setOduInterfaceId(createdOduInterfaces); nodeInterfaces.add(nodeInterfaceBuilder.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); + } + 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); + } + } + + private void createODU4TtpInterface(OtnServicePathInput input, List nodeInterfaces, + CopyOnWriteArrayList otnNodesProvisioned) 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 { + 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); + } + } + + private void updateOtnTopology(CopyOnWriteArrayList nodes, List nodesTps, Uint32 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); + } + } + }