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

   1 /*
   2  * Copyright © 2017 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 com.google.common.collect.Sets;
  11
  12 import java.util.ArrayList;
  13 import java.util.LinkedList;
  14 import java.util.List;
  15 import java.util.Optional;
  16 import java.util.Set;
  17 import java.util.concurrent.ConcurrentLinkedQueue;
  18 import java.util.concurrent.ExecutionException;
  19 import java.util.concurrent.ForkJoinPool;
  20 import java.util.concurrent.ForkJoinTask;
  21 import java.util.concurrent.Future;
  22 import java.util.concurrent.TimeUnit;
  23 import java.util.concurrent.TimeoutException;
  24 import java.util.concurrent.atomic.AtomicBoolean;
  25
  26 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  27 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  28 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  29 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  30 import org.opendaylight.transportpce.common.Timeouts;
  31 import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
  32 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  33 import org.opendaylight.transportpce.common.mapping.PortMapping;
  34 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
  35 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
  36 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl;
  37 import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
  38 import org.opendaylight.transportpce.renderer.provisiondevice.servicepath.ServiceListTopology;
  39 import org.opendaylight.transportpce.renderer.provisiondevice.servicepath.ServicePathDirection;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.service.Topology;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.get.connection.port.trail.output.Ports;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes.ModulationFormat;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.R100G;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.ServiceList;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.service.list.Services;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.service.list.ServicesBuilder;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.service.list.ServicesKey;
  51 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.node.interfaces.NodeInterface;
  52 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.node.interfaces.NodeInterfaceBuilder;
  53 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.node.interfaces.NodeInterfaceKey;
  54 import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.olm.renderer.input.Nodes;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.alarmsuppression.rev171102.ServiceNodelist;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.alarmsuppression.rev171102.service.nodelist.NodelistBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.alarmsuppression.rev171102.service.nodelist.NodelistKey;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.portmapping.rev170228.network.nodes.Mapping;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.CreateOtsOmsInput;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.CreateOtsOmsOutput;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.CreateOtsOmsOutputBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.RendererRollbackInput;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.RendererRollbackOutput;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.RendererRollbackOutputBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.ServicePathInput;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.ServicePathOutput;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.ServicePathOutputBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.renderer.rollback.output.FailedToRollback;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.renderer.rollback.output.FailedToRollbackBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.renderer.rev170228.renderer.rollback.output.FailedToRollbackKey;
  71 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  72 import org.slf4j.Logger;
  73 import org.slf4j.LoggerFactory;
  74
  75 public class DeviceRendererServiceImpl implements DeviceRendererService {
  76     private static final Logger LOG = LoggerFactory.getLogger(DeviceRendererServiceImpl.class);
  77     private final DataBroker dataBroker;
  78     private final DeviceTransactionManager deviceTransactionManager;
  79     private final OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
  80     private final OpenRoadmInterfaces openRoadmInterfaces;
  81     private final CrossConnect crossConnect;
  82     private final PortMapping portMapping;
  83     private String serviceName;
  84
  85     public DeviceRendererServiceImpl(DataBroker dataBroker, DeviceTransactionManager deviceTransactionManager,
  86             OpenRoadmInterfaceFactory openRoadmInterfaceFactory, OpenRoadmInterfaces openRoadmInterfaces,
  87             CrossConnect crossConnect, PortMapping portMapping) {
  88         this.dataBroker = dataBroker;
  89         this.deviceTransactionManager = deviceTransactionManager;
  90         this.openRoadmInterfaceFactory = openRoadmInterfaceFactory;
  91         this.openRoadmInterfaces = openRoadmInterfaces;
  92         this.crossConnect = crossConnect;
  93         this.portMapping = portMapping;
  94         serviceName = "Undefined";
  95     }
  96
  97     @Override
  98     public ServicePathOutput setupServicePath(ServicePathInput input, ServicePathDirection direction) {
  99         this.serviceName = input.getServiceName();
 100         List<Nodes> nodes = input.getNodes();
 101         // Register node for suppressing alarms
 102         if (!alarmSuppressionNodeRegistration(input)) {
 103             LOG.warn("Alarm suppresion node registration failed!!!!");
 104         }
 105         ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
 106         Set<NodeInterface> nodeInterfaces = Sets.newConcurrentHashSet();
 107         Set<String> nodesProvisioned = Sets.newConcurrentHashSet();
 108         ServiceListTopology topology = new ServiceListTopology();
 109         AtomicBoolean success = new AtomicBoolean(true);
 110         ForkJoinPool forkJoinPool = new ForkJoinPool();
 111         ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> {
 112             String nodeId = node.getNodeId();
 113             LOG.info("Starting provisioning for node : {}", nodeId);
 114             List<String> createdEthInterfaces = new ArrayList<>();
 115             List<String> createdOtuInterfaces = new ArrayList<>();
 116             List<String> createdOduInterfaces = new ArrayList<>();
 117             List<String> createdOchInterfaces = new ArrayList<>();
 118             List<String> createdConnections = new ArrayList<>();
 119             int crossConnectFlag = 0;
 120             try {
 121                 // if the node is currently mounted then proceed
 122                 if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
 123                     String srcTp = node.getSrcTp();
 124                     String destTp = node.getDestTp();
 125                     Long waveNumber = input.getWaveNumber();
 126                     if ((destTp != null) && destTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) {
 127                         crossConnectFlag++;
 128                         // create OpenRoadm Xponder Line Interfaces
 129                         String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
 130                                 nodeId, destTp, waveNumber, R100G.class, ModulationFormat.DpQpsk, serviceName);
 131                         createdOchInterfaces.add(supportingOchInterface);
 132                         String supportingOtuInterface = this.openRoadmInterfaceFactory
 133                                 .createOpenRoadmOtu4Interface(nodeId, destTp, supportingOchInterface, serviceName);
 134                         createdOtuInterfaces.add(supportingOtuInterface);
 135                         createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId,
 136                                 destTp, supportingOtuInterface, serviceName));
 137                     }
 138                     if ((srcTp != null) && srcTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) {
 139                         crossConnectFlag++;
 140                         // create OpenRoadm Xponder Client Interfaces
 141                         createdEthInterfaces.add(
 142                             this.openRoadmInterfaceFactory.createOpenRoadmEthInterface(nodeId, srcTp, serviceName));
 143                     }
 144                     if ((srcTp != null) && srcTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) {
 145                         crossConnectFlag++;
 146                         // create OpenRoadm Xponder Line Interfaces
 147                         String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
 148                                 nodeId, srcTp, waveNumber, R100G.class, ModulationFormat.DpQpsk, serviceName);
 149                         createdOchInterfaces.add(supportingOchInterface);
 150                         String supportingOtuInterface = this.openRoadmInterfaceFactory
 151                                 .createOpenRoadmOtu4Interface(nodeId, srcTp, supportingOchInterface, serviceName);
 152                         createdOtuInterfaces.add(supportingOtuInterface);
 153                         createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId,
 154                                 srcTp, supportingOtuInterface, serviceName));
 155                     }
 156                     if ((destTp != null) && destTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) {
 157                         crossConnectFlag++;
 158                         // create OpenRoadm Xponder Client Interfaces
 159                         createdEthInterfaces.add(
 160                             this.openRoadmInterfaceFactory.createOpenRoadmEthInterface(nodeId, destTp, serviceName));
 161                     }
 162                     if ((srcTp != null) && (srcTp.contains(OpenRoadmInterfacesImpl.TTP_TOKEN)
 163                             || srcTp.contains(OpenRoadmInterfacesImpl.PP_TOKEN))) {
 164                         createdOchInterfaces.add(
 165                             this.openRoadmInterfaceFactory
 166                                 .createOpenRoadmOchInterface(nodeId, srcTp, waveNumber, serviceName));
 167                     }
 168                     if ((destTp != null) && (destTp.contains(OpenRoadmInterfacesImpl.TTP_TOKEN)
 169                             || destTp.contains(OpenRoadmInterfacesImpl.PP_TOKEN))) {
 170                         createdOchInterfaces.add(
 171                             this.openRoadmInterfaceFactory
 172                                 .createOpenRoadmOchInterface(nodeId, destTp, waveNumber, serviceName));
 173                     }
 174                     if (crossConnectFlag < 1) {
 175                         LOG.info("Creating cross connect between source {} and destination {} for node {}", srcTp,
 176                                 destTp, nodeId);
 177                         Optional<String> connectionNameOpt =
 178                                 this.crossConnect.postCrossConnect(nodeId, waveNumber, srcTp, destTp);
 179                         if (connectionNameOpt.isPresent()) {
 180                             nodesProvisioned.add(nodeId);
 181                             List<Ports> ports =
 182                                     this.crossConnect.getConnectionPortTrail(nodeId, waveNumber, srcTp, destTp);
 183                             if (ServicePathDirection.A_TO_Z.equals(direction)) {
 184                                 topology.updateAtoZTopologyList(ports, nodeId);
 185                             }
 186                             if (ServicePathDirection.Z_TO_A.equals(direction)) {
 187                                 topology.updateZtoATopologyList(ports, nodeId);
 188                             }
 189                             createdConnections.add(connectionNameOpt.get());
 190                         } else {
 191                             processErrorMessage("Unable to post Roadm-connection for node " + nodeId, forkJoinPool,
 192                                     results);
 193                             success.set(false);
 194                         }
 195                     }
 196                 } else {
 197                     processErrorMessage(nodeId + " is not mounted on the controller", forkJoinPool, results);
 198                     success.set(false);
 199                 }
 200             } catch (OpenRoadmInterfaceException ex) {
 201                 processErrorMessage("Setup service path failed! Exception:" + ex.toString(), forkJoinPool, results);
 202                 success.set(false);
 203             }
 204             NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder();
 205             nodeInterfaceBuilder.withKey(new NodeInterfaceKey(nodeId));
 206             nodeInterfaceBuilder.setNodeId(nodeId);
 207             nodeInterfaceBuilder.setConnectionId(createdConnections);
 208             nodeInterfaceBuilder.setEthInterfaceId(createdEthInterfaces);
 209             nodeInterfaceBuilder.setOtuInterfaceId(createdOtuInterfaces);
 210             nodeInterfaceBuilder.setOduInterfaceId(createdOduInterfaces);
 211             nodeInterfaceBuilder.setOchInterfaceId(createdOchInterfaces);
 212             nodeInterfaces.add(nodeInterfaceBuilder.build());
 213         }));
 214         try {
 215             forkJoinTask.get();
 216         } catch (InterruptedException | ExecutionException e) {
 217             LOG.error("Error while setting up service paths!", e);
 218         }
 219         forkJoinPool.shutdown();
 220         if (success.get()) {
 221             results.add("Roadm-connection successfully created for nodes: " + String.join(", ", nodesProvisioned));
 222         }
 223         ServicePathOutputBuilder setServBldr = new ServicePathOutputBuilder();
 224         setServBldr.setNodeInterface(new ArrayList<>(nodeInterfaces));
 225         setServBldr.setSuccess(success.get());
 226         setServBldr.setResult(String.join("\n", results));
 227         // setting topology in the service list data store
 228         try {
 229             setTopologyForService(input.getServiceName(), topology.getTopology());
 230         } catch (InterruptedException | TimeoutException | ExecutionException e) {
 231             LOG.warn("Failed to write topologies for service {}.", input.getServiceName(), e);
 232         }
 233         if (!alarmSuppressionNodeRemoval(input.getServiceName())) {
 234             LOG.error("Alarm suppresion node removal failed!!!!");
 235         }
 236         return setServBldr.build();
 237     }
 238
 239     private ConcurrentLinkedQueue<String> processErrorMessage(String message, ForkJoinPool forkJoinPool,
 240             ConcurrentLinkedQueue<String> messages) {
 241         LOG.warn(message);
 242         messages.add(message);
 243         forkJoinPool.shutdown();
 244         return messages;
 245     }
 246
 247     @Override
 248     public ServicePathOutput deleteServicePath(ServicePathInput input) {
 249         List<Nodes> nodes = input.getNodes();
 250         AtomicBoolean success = new AtomicBoolean(true);
 251         ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
 252         if (!alarmSuppressionNodeRegistration(input)) {
 253             LOG.warn("Alarm suppresion node registraion failed!!!!");
 254         }
 255         ForkJoinPool forkJoinPool = new ForkJoinPool();
 256         ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> {
 257             List<String> interfacesToDelete = new LinkedList<>();
 258             String nodeId = node.getNodeId();
 259             LOG.info("Deleting service setup on node {}", nodeId);
 260             String srcTp = node.getSrcTp();
 261             String destTp = node.getDestTp();
 262             Long waveNumber = input.getWaveNumber();
 263             if ((srcTp == null) || (destTp == null)) {
 264                 LOG.error("Source ({}) or destination ({}) termination point is null.", srcTp, destTp);
 265                 return;
 266             }
 267             // if the node is currently mounted then proceed.
 268             if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
 269                 if (destTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)
 270                         || srcTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)
 271                         || srcTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)
 272                         || destTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) {
 273                     if (destTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) {
 274                         interfacesToDelete.add(destTp + "-ODU");
 275                         interfacesToDelete.add(destTp + "-OTU");
 276                         interfacesToDelete.add(
 277                                 this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(destTp, waveNumber));
 278                     }
 279                     if (srcTp.contains(OpenRoadmInterfacesImpl.NETWORK_TOKEN)) {
 280                         interfacesToDelete.add(srcTp + "-ODU");
 281                         interfacesToDelete.add(srcTp + "-OTU");
 282                         interfacesToDelete
 283                                 .add(this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(srcTp, waveNumber));
 284                     }
 285                     if (srcTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) {
 286                         interfacesToDelete.add(srcTp + "-ETHERNET");
 287                     }
 288                     if (destTp.contains(OpenRoadmInterfacesImpl.CLIENT_TOKEN)) {
 289                         interfacesToDelete.add(destTp + "-ETHERNET");
 290                     }
 291                 } else {
 292                     String connectionNumber = srcTp + "-" + destTp + "-" + waveNumber;
 293                     if (!this.crossConnect.deleteCrossConnect(nodeId, connectionNumber)) {
 294                         LOG.error("Failed to delete cross connect {}", connectionNumber);
 295                     }
 296                     connectionNumber = destTp + "-" + srcTp + "-" + waveNumber;
 297                     String interfName =
 298                             this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(srcTp, waveNumber);
 299                     if (!isUsedByXc(nodeId, interfName, connectionNumber)) {
 300                         interfacesToDelete.add(interfName);
 301                     }
 302                     interfName = this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(destTp, waveNumber);
 303                     if (!isUsedByXc(nodeId, interfName, connectionNumber)) {
 304                         interfacesToDelete.add(interfName);
 305                     }
 306                 }
 307             } else {
 308                 String result = nodeId + " is not mounted on the controller";
 309                 results.add(result);
 310                 success.set(false);
 311                 LOG.warn(result);
 312                 forkJoinPool.shutdown();
 313                 return; // TODO should deletion end here?
 314             }
 315             for (String interfaceId : interfacesToDelete) {
 316                 try {
 317                     this.openRoadmInterfaces.deleteInterface(nodeId, interfaceId);
 318                 } catch (OpenRoadmInterfaceException e) {
 319                     String result = String.format("Failed to delete interface %s on node %s!", interfaceId, nodeId);
 320                     success.set(false);
 321                     LOG.error(result, e);
 322                     results.add(result);
 323                 }
 324             }
 325         }));
 326         try {
 327             forkJoinTask.get();
 328         } catch (InterruptedException | ExecutionException e) {
 329             LOG.error("Error while deleting service paths!", e);
 330         }
 331         forkJoinPool.shutdown();
 332         if (!alarmSuppressionNodeRemoval(input.getServiceName())) {
 333             LOG.error("Alarm suppresion node removal failed!!!!");
 334         }
 335         ServicePathOutputBuilder delServBldr = new ServicePathOutputBuilder();
 336         delServBldr.setSuccess(success.get());
 337         if (results.isEmpty()) {
 338             return delServBldr.setResult("Request processed").build();
 339         } else {
 340             return delServBldr.setResult(String.join("\n", results)).build();
 341         }
 342     }
 343
 344     @Override
 345     public RendererRollbackOutput rendererRollback(RendererRollbackInput input) {
 346         boolean success = true;
 347         List<FailedToRollback> failedToRollbackList = new ArrayList<>();
 348         for (NodeInterface nodeInterfaces : input.getNodeInterface()) {
 349             List<String> failedInterfaces = new ArrayList<>();
 350             String nodeId = nodeInterfaces.getNodeId();
 351             for (String connectionId : nodeInterfaces.getConnectionId()) {
 352                 if (this.crossConnect.deleteCrossConnect(nodeId, connectionId)) {
 353                     LOG.info("Cross connect {} on node {} successfully deleted.", connectionId, nodeId);
 354                 } else {
 355                     LOG.error("Failed to delete cross connect {} on node {}!", connectionId, nodeId);
 356                     success = false;
 357                     failedInterfaces.add(connectionId);
 358                 }
 359             }
 360             // Interfaces needs to be in specific order to delete. Order is:
 361             // 1. ODU interfaces
 362             // 2. OTU interfaces
 363             // 3. OCH interfaces
 364             // 4. ETH interfaces
 365             LinkedList<String> interfacesToDelete = new LinkedList<>();
 366             if (nodeInterfaces.getOduInterfaceId() != null) {
 367                 interfacesToDelete.addAll(nodeInterfaces.getOduInterfaceId());
 368             }
 369             if (nodeInterfaces.getOtuInterfaceId() != null) {
 370                 interfacesToDelete.addAll(nodeInterfaces.getOtuInterfaceId());
 371             }
 372             if (nodeInterfaces.getOchInterfaceId() != null) {
 373                 interfacesToDelete.addAll(nodeInterfaces.getOchInterfaceId());
 374             }
 375             if (nodeInterfaces.getEthInterfaceId() != null) {
 376                 interfacesToDelete.addAll(nodeInterfaces.getEthInterfaceId());
 377             }
 378             LOG.info("Going to execute rollback on node {}. Interfaces to rollback: {}", nodeId,
 379                     String.join(", ", interfacesToDelete));
 380             for (String interfaceId : interfacesToDelete) {
 381                 try {
 382                     this.openRoadmInterfaces.deleteInterface(nodeId, interfaceId);
 383                     LOG.info("Interface {} on node {} successfully deleted.", interfaceId, nodeId);
 384                 } catch (OpenRoadmInterfaceException e) {
 385                     LOG.error("Failed to delete interface {} on node {}!", interfaceId, nodeId);
 386                     success = false;
 387                     failedInterfaces.add(interfaceId);
 388                 }
 389             }
 390             failedToRollbackList.add(new FailedToRollbackBuilder().withKey(new FailedToRollbackKey(nodeId))
 391                     .setNodeId(nodeId).setInterface(failedInterfaces).build());
 392         }
 393         return new RendererRollbackOutputBuilder().setSuccess(success).setFailedToRollback(failedToRollbackList)
 394                 .build();
 395     }
 396
 397     private boolean alarmSuppressionNodeRegistration(ServicePathInput input) {
 398         NodelistBuilder nodeListBuilder = new NodelistBuilder();
 399         nodeListBuilder.withKey(new NodelistKey(input.getServiceName()));
 400         nodeListBuilder.setServiceName(input.getServiceName());
 401         List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.alarmsuppression.rev171102.service
 402             .nodelist.nodelist.Nodes> nodeList =
 403                 new ArrayList<>();
 404         for (Nodes node : input.getNodes()) {
 405             nodeList.add(
 406                     new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.alarmsuppression.rev171102
 407                     .service.nodelist.nodelist.NodesBuilder()
 408                             .setNodeId(node.getNodeId()).build());
 409         }
 410         nodeListBuilder.setNodes(nodeList);
 411         InstanceIdentifier<
 412                 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.alarmsuppression.rev171102.service
 413                     .nodelist.Nodelist> nodeListIID =
 414                         InstanceIdentifier.create(ServiceNodelist.class).child(
 415                                 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.alarmsuppression
 416                                     .rev171102.service.nodelist.Nodelist.class,
 417                                 new NodelistKey(input.getServiceName()));
 418         final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
 419         writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, nodeListIID, nodeListBuilder.build());
 420         Future<Void> submit = writeTransaction.submit();
 421         try {
 422             submit.get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS);
 423             LOG.info("Nodes are register for alarm suppression for service: {}", input.getServiceName());
 424             return true;
 425         } catch (ExecutionException | InterruptedException | TimeoutException e) {
 426             LOG.warn("Failed to alarm suppresslist for service: {}", input.getServiceName(), e);
 427             return false;
 428         }
 429     }
 430
 431     private boolean alarmSuppressionNodeRemoval(String name) {
 432         InstanceIdentifier<
 433                 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.alarmsuppression.rev171102.service
 434                     .nodelist.Nodelist> nodeListIID =
 435                         InstanceIdentifier.create(ServiceNodelist.class).child(
 436                                 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.alarmsuppression
 437                                     .rev171102.service.nodelist.Nodelist.class,
 438                                 new NodelistKey(name));
 439         final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
 440         writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, nodeListIID);
 441         Future<Void> submit = writeTransaction.submit();
 442         try {
 443             submit.get(Timeouts.DATASTORE_DELETE, TimeUnit.MILLISECONDS);
 444             LOG.info("Nodes are unregister for alarm suppression for service: {}", name);
 445             return true;
 446         } catch (InterruptedException | TimeoutException | ExecutionException e) {
 447             LOG.warn("Failed to alarm suppresslist for service: {}", name, e);
 448             return false;
 449         }
 450     }
 451
 452     private void setTopologyForService(String name, Topology topo)
 453             throws InterruptedException, ExecutionException, TimeoutException {
 454         ServicesBuilder servicesBuilder;
 455         // Get the service from the service list inventory
 456         ServicesKey serviceKey = new ServicesKey(name);
 457         InstanceIdentifier<Services> iid =
 458                 InstanceIdentifier.create(ServiceList.class).child(Services.class, serviceKey);
 459         Optional<Services> services;
 460         try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
 461             Future<com.google.common.base.Optional<Services>> future =
 462                     readTx.read(LogicalDatastoreType.OPERATIONAL, iid);
 463             services = future.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS).toJavaUtil();
 464         } catch (InterruptedException | ExecutionException | TimeoutException e) {
 465             throw e;
 466         }
 467         if (services.isPresent()) {
 468             servicesBuilder = new ServicesBuilder(services.get());
 469         } else {
 470             servicesBuilder = new ServicesBuilder();
 471             servicesBuilder.withKey(serviceKey);
 472         }
 473         servicesBuilder.setTopology(topo);
 474         WriteTransaction writeTx = this.dataBroker.newWriteOnlyTransaction();
 475         writeTx.merge(LogicalDatastoreType.OPERATIONAL, iid, servicesBuilder.build());
 476         writeTx.submit().get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS);
 477     }
 478
 479     private boolean isUsedByXc(String nodeid, String interfaceid, String xcid) {
 480         InstanceIdentifier<RoadmConnections> xciid = InstanceIdentifier.create(OrgOpenroadmDevice.class)
 481                 .child(RoadmConnections.class, new RoadmConnectionsKey(xcid));
 482         LOG.info("reading xc {} in node {}", xcid, nodeid);
 483         Optional<RoadmConnections> crossconnection =
 484                 this.deviceTransactionManager.getDataFromDevice(nodeid, LogicalDatastoreType.CONFIGURATION, xciid,
 485                         Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
 486         if (crossconnection.isPresent()) {
 487             RoadmConnections xc = crossconnection.get();
 488             LOG.info("xd {} found", xcid);
 489             if (xc.getSource().getSrcIf().equals(interfaceid) || xc.getDestination().getDstIf().equals(interfaceid)) {
 490                 return true;
 491             }
 492         } else {
 493             LOG.info("xd {} not found !", xcid);
 494         }
 495         return false;
 496     }
 497
 498     @Override
 499     public CreateOtsOmsOutput createOtsOms(CreateOtsOmsInput input) throws OpenRoadmInterfaceException {
 500         CreateOtsOmsOutputBuilder output = new CreateOtsOmsOutputBuilder();
 501         String result = "";
 502         Boolean success = false;
 503         // if the node is currently mounted then proceed.
 504         if (this.deviceTransactionManager.isDeviceMounted(input.getNodeId())) {
 505             Mapping oldMapping = null;
 506             Mapping newMapping = null;
 507             oldMapping = this.portMapping.getMapping(input.getNodeId(), input.getLogicalConnectionPoint());
 508             if (oldMapping != null) {
 509                 String otsInterface =
 510                         this.openRoadmInterfaceFactory.createOpenRoadmOtsInterface(input.getNodeId(), oldMapping);
 511                 newMapping = this.portMapping.getMapping(input.getNodeId(), input.getLogicalConnectionPoint());
 512                 int count = 0;
 513                 Boolean isSupportingOtsPresent = isSupportingOtsPresent(newMapping);
 514                 while (!isSupportingOtsPresent && (count < 6)) {
 515                     LOG.info("waiting for post interface operation on node '{}'...", input.getNodeId());
 516                     try {
 517                         Thread.sleep(10000);
 518                         this.portMapping.updateMapping(input.getNodeId(), oldMapping);
 519                     } catch (InterruptedException e) {
 520                         LOG.error("Failed to wait for post interface operation ");
 521                     }
 522                     newMapping = this.portMapping.getMapping(input.getNodeId(), input.getLogicalConnectionPoint());
 523                     isSupportingOtsPresent = isSupportingOtsPresent(newMapping);
 524                     count++;
 525                 }
 526                 if (count < 6) {
 527                     String omsInterface =
 528                             this.openRoadmInterfaceFactory.createOpenRoadmOmsInterface(input.getNodeId(), newMapping);
 529                     if (omsInterface != null) {
 530                         result = "Interfaces " + otsInterface + " - " + omsInterface + " successfully created on node "
 531                                 + input.getNodeId();
 532                         success = true;
 533                     } else {
 534                         LOG.error("Fail to create OpenRoadmOms Interface for node '{}'", input.getNodeId());
 535                         result = "Fail to create OpenRoadmOms Interface for node : " + input.getNodeId();
 536                     }
 537                 } else {
 538                     LOG.error("Unable to get ots interface from mapping {} for node {}",
 539                             oldMapping.getLogicalConnectionPoint(), input.getNodeId());
 540                     result = String.format("Unable to get ots interface from mapping %s - %s",
 541                             oldMapping.getLogicalConnectionPoint(), input.getNodeId());
 542                 }
 543             } else {
 544                 result = "Logical Connection point " + input.getLogicalConnectionPoint() + " does not exist for "
 545                         + input.getNodeId();
 546             }
 547         } else {
 548             result = input.getNodeId() + " is not mounted on the controller";
 549             LOG.warn(result);
 550         }
 551         return output.setResult(result).setSuccess(success).build();
 552     }
 553
 554     private Boolean isSupportingOtsPresent(Mapping mapping) {
 555         Boolean result = false;
 556         if (mapping != null) {
 557             if (mapping.getSupportingOts() != null) {
 558                 LOG.info("SupportingOts info is present in mapping {}", mapping);
 559                 result = true;
 560             } else {
 561                 LOG.warn("SupportingOts info not present in mapping {}", mapping);
 562             }
 563         }
 564         return result;
 565     }
 566 }