+ 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> nodes = input.getNodes();
+ AtomicBoolean success = new AtomicBoolean(true);
+ ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
+ List<String> nodesTpToUpdate = new ArrayList<>();
+ CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
+ ForkJoinPool forkJoinPool = new ForkJoinPool();
+ ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> {
+ List<String> 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.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().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 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());
+ String result = input.getServiceRate() + " is not supported";
+ results.add(result);
+ success.set(false);
+ return;
+ }
+ List<String> 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);
+ 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);
+ }
+ }
+ }
+ }
+ }
+ } else {
+ String result = nodeId + " is not mounted on the controller";
+ results.add(result);
+ success.set(false);
+ LOG.warn(result);
+ forkJoinPool.shutdown();
+ return;
+ // TODO should deletion end here?
+ }
+ for (String interfaceId : interfacesToDelete) {
+ try {
+ this.openRoadmInterfaces.deleteInterface(nodeId, interfaceId);
+ } catch (OpenRoadmInterfaceException e) {
+ String result = String.format("Failed to delete interface %s on node %s!", interfaceId, nodeId);
+ success.set(false);
+ LOG.error(result, e);
+ results.add(result);
+ }
+ }
+ List<String> 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);
+ }
+ 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()) {
+ return delServBldr.setResult("Request processed").build();
+ } 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 List<String> updateOduNodes(List<NodeInterface> nodeInterfaceList, String deLimiter) {
+ List<String> 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<String> 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;