networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/NetConfTopologyListener.java

   1 /*
   2  * Copyright © 2016 Orange 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.networkmodel;
   9
  10 import com.google.common.util.concurrent.ListenableFuture;
  11 import java.util.Collection;
  12 import java.util.Map;
  13 import java.util.Optional;
  14 import java.util.concurrent.ConcurrentHashMap;
  15 import java.util.concurrent.ExecutionException;
  16 import javax.annotation.Nonnull;
  17 import org.opendaylight.mdsal.binding.api.DataBroker;
  18 import org.opendaylight.mdsal.binding.api.DataObjectModification;
  19 import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
  20 import org.opendaylight.mdsal.binding.api.DataTreeModification;
  21 import org.opendaylight.mdsal.binding.api.MountPoint;
  22 import org.opendaylight.mdsal.binding.api.NotificationService;
  23 import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
  24 import org.opendaylight.transportpce.common.StringConstants;
  25 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  26 import org.opendaylight.transportpce.common.mapping.PortMapping;
  27 import org.opendaylight.transportpce.networkmodel.dto.NodeRegistration;
  28 import org.opendaylight.transportpce.networkmodel.dto.NodeRegistration22;
  29 import org.opendaylight.transportpce.networkmodel.listeners.AlarmNotificationListener;
  30 import org.opendaylight.transportpce.networkmodel.listeners.AlarmNotificationListener221;
  31 import org.opendaylight.transportpce.networkmodel.listeners.DeOperationsListener;
  32 import org.opendaylight.transportpce.networkmodel.listeners.DeOperationsListener221;
  33 import org.opendaylight.transportpce.networkmodel.listeners.DeviceListener121;
  34 import org.opendaylight.transportpce.networkmodel.listeners.DeviceListener221;
  35 import org.opendaylight.transportpce.networkmodel.listeners.TcaListener;
  36 import org.opendaylight.transportpce.networkmodel.listeners.TcaListener221;
  37 import org.opendaylight.transportpce.networkmodel.service.NetworkModelService;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.alarm.rev161014.OrgOpenroadmAlarmListener;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.de.operations.rev161014.OrgOpenroadmDeOperationsListener;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.OrgOpenroadmDeviceListener;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.tca.rev161014.OrgOpenroadmTcaListener;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.CreateSubscriptionInputBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.CreateSubscriptionOutput;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.NotificationsService;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.StreamNameType;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
  49 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  50 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  51 import org.opendaylight.yangtools.yang.common.RpcResult;
  52 import org.slf4j.Logger;
  53 import org.slf4j.LoggerFactory;
  54
  55 public class NetConfTopologyListener implements DataTreeChangeListener<Node> {
  56
  57     private static final Logger LOG = LoggerFactory.getLogger(NetConfTopologyListener.class);
  58     private static final String RPC_SERVICE_FAILED = "Failed to get RpcService for node {}";
  59     private final NetworkModelService networkModelService;
  60     private final DataBroker dataBroker;
  61     private final DeviceTransactionManager deviceTransactionManager;
  62     private final Map<String, NodeRegistration> registrations;
  63     private final Map<String, NodeRegistration22> registrations22;
  64     private final PortMapping portMapping;
  65
  66     public NetConfTopologyListener(final NetworkModelService networkModelService, final DataBroker dataBroker,
  67              DeviceTransactionManager deviceTransactionManager, PortMapping portMapping) {
  68         this.networkModelService = networkModelService;
  69         this.dataBroker = dataBroker;
  70         this.deviceTransactionManager = deviceTransactionManager;
  71         this.registrations = new ConcurrentHashMap<>();
  72         this.registrations22 = new ConcurrentHashMap<>();
  73         this.portMapping = portMapping;
  74     }
  75
  76     public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Node>> changes) {
  77         LOG.info("onDataTreeChanged - {}", this.getClass().getSimpleName());
  78         for (DataTreeModification<Node> change : changes) {
  79             DataObjectModification<Node> rootNode = change.getRootNode();
  80             if (rootNode.getDataBefore() == null) {
  81                 continue;
  82             }
  83             String nodeId = rootNode.getDataBefore().key().getNodeId().getValue();
  84             NetconfNode netconfNodeBefore = rootNode.getDataBefore().augmentation(NetconfNode.class);
  85             switch (rootNode.getModificationType()) {
  86                 case DELETE:
  87                     this.networkModelService.deleteOpenRoadmnode(nodeId);
  88                     String deviceVersion = netconfNodeBefore
  89                         .getAvailableCapabilities().getAvailableCapability().stream()
  90                         .filter(cp -> cp.getCapability().contains(StringConstants.OPENROADM_DEVICE_MODEL_NAME))
  91                         .sorted((c1, c2) -> c1.getCapability().compareTo(c2.getCapability()))
  92                         .findFirst()
  93                         .get().getCapability();
  94                     onDeviceDisConnected(nodeId, deviceVersion);
  95                     LOG.info("Device {} correctly disconnected from controller", nodeId);
  96                     break;
  97                 case WRITE:
  98                     NetconfNode netconfNodeAfter = rootNode.getDataAfter().augmentation(NetconfNode.class);
  99                     if (ConnectionStatus.Connecting.equals(netconfNodeBefore.getConnectionStatus())
 100                         && ConnectionStatus.Connected.equals(netconfNodeAfter.getConnectionStatus())) {
 101                         LOG.info("Connecting Node: {}", nodeId);
 102                         Optional<AvailableCapability> deviceCapabilityOpt = netconfNodeAfter
 103                             .getAvailableCapabilities().getAvailableCapability().stream()
 104                             .filter(cp -> cp.getCapability().contains(StringConstants.OPENROADM_DEVICE_MODEL_NAME))
 105                             .sorted((c1, c2) -> c1.getCapability().compareTo(c2.getCapability()))
 106                             .findFirst();
 107                         if (deviceCapabilityOpt.isEmpty()) {
 108                             LOG.error("Unable to get openroadm-device-capability");
 109                             return;
 110                         }
 111                         this.networkModelService
 112                             .createOpenRoadmNode(nodeId, deviceCapabilityOpt.get().getCapability());
 113                         onDeviceConnected(nodeId,deviceCapabilityOpt.get().getCapability());
 114                         LOG.info("Device {} correctly connected to controller", nodeId);
 115                     }
 116                     if (ConnectionStatus.Connected.equals(netconfNodeBefore.getConnectionStatus())
 117                         && ConnectionStatus.Connecting.equals(netconfNodeAfter.getConnectionStatus())) {
 118                         LOG.warn("Node: {} is being disconnected", nodeId);
 119                     }
 120                     break;
 121                 default:
 122                     LOG.debug("Unknown modification type {}", rootNode.getModificationType().name());
 123                     break;
 124             }
 125         }
 126     }
 127
 128     private void onDeviceConnected(final String nodeId, String openRoadmVersion) {
 129         LOG.info("onDeviceConnected: {}", nodeId);
 130         Optional<MountPoint> mountPointOpt = this.deviceTransactionManager.getDeviceMountPoint(nodeId);
 131         MountPoint mountPoint;
 132         if (mountPointOpt.isPresent()) {
 133             mountPoint = mountPointOpt.get();
 134         } else {
 135             LOG.error("Failed to get mount point for node {}", nodeId);
 136             return;
 137         }
 138         final Optional<NotificationService> notificationService = mountPoint.getService(NotificationService.class);
 139         if (!notificationService.isPresent()) {
 140             LOG.error(RPC_SERVICE_FAILED, nodeId);
 141             return;
 142         }
 143         switch (openRoadmVersion) {
 144             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 145                 NodeRegistration node121Registration = registrateNode121Listeners(nodeId, notificationService.get());
 146                 registrations.put(nodeId, node121Registration);
 147                 break;
 148             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 149                 NodeRegistration22 node221Registration = registrateNode221Listeners(nodeId, notificationService.get());
 150                 registrations22.put(nodeId, node221Registration);
 151                 break;
 152             default:
 153                 break;
 154         }
 155         String streamName = "NETCONF";
 156         subscribeStream(mountPoint, streamName, nodeId);
 157     }
 158
 159     private void onDeviceDisConnected(final String nodeId, String openRoadmVersion) {
 160         LOG.info("onDeviceDisConnected: {}", nodeId);
 161         switch (openRoadmVersion) {
 162             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
 163                 NodeRegistration nodeRegistration = this.registrations.remove(nodeId);
 164                 if (nodeRegistration != null) {
 165                     nodeRegistration.getAccessAlarmNotificationListenerRegistration().close();
 166                     nodeRegistration.getAccessDeOperationasNotificationListenerRegistration().close();
 167                     nodeRegistration.getAccessDeviceNotificationListenerRegistration().close();
 168                     nodeRegistration.getAccessTcaNotificationListenerRegistration().close();
 169                 }
 170                 break;
 171             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
 172                 NodeRegistration22 nodeRegistration221 = this.registrations22.remove(nodeId);
 173                 if (nodeRegistration221 != null) {
 174                     nodeRegistration221.getAccessAlarmNotificationListenerRegistration().close();
 175                     nodeRegistration221.getAccessDeOperationasNotificationListenerRegistration().close();
 176                     nodeRegistration221.getAccessDeviceNotificationListenerRegistration().close();
 177                     nodeRegistration221.getAccessTcaNotificationListenerRegistration().close();
 178                 }
 179                 break;
 180             default:
 181                 break;
 182         }
 183     }
 184
 185     private NodeRegistration registrateNode121Listeners(String nodeId, NotificationService notificationService) {
 186         final OrgOpenroadmAlarmListener alarmListener = new AlarmNotificationListener(this.dataBroker);
 187         LOG.info("Registering notification listener on OrgOpenroadmAlarmListener for node: {}", nodeId);
 188         final ListenerRegistration<OrgOpenroadmAlarmListener> accessAlarmNotificationListenerRegistration =
 189             notificationService.registerNotificationListener(alarmListener);
 190
 191         final OrgOpenroadmDeOperationsListener deOperationsListener = new DeOperationsListener();
 192         LOG.info("Registering notification listener on OrgOpenroadmDeOperationsListener for node: {}", nodeId);
 193         final ListenerRegistration<OrgOpenroadmDeOperationsListener>
 194             accessDeOperationasNotificationListenerRegistration =
 195             notificationService.registerNotificationListener(deOperationsListener);
 196
 197         final OrgOpenroadmDeviceListener deviceListener = new DeviceListener121(nodeId, this.portMapping);
 198         LOG.info("Registering notification listener on OrgOpenroadmDeviceListener for node: {}", nodeId);
 199         final ListenerRegistration<OrgOpenroadmDeviceListener> accessDeviceNotificationListenerRegistration =
 200             notificationService.registerNotificationListener(deviceListener);
 201
 202         TcaListener tcaListener = new TcaListener();
 203         LOG.info("Registering notification listener on OrgOpenroadmTcaListener for node: {}", nodeId);
 204         final ListenerRegistration<OrgOpenroadmTcaListener> accessTcaNotificationListenerRegistration =
 205             notificationService.registerNotificationListener(tcaListener);
 206         return new NodeRegistration(nodeId, accessAlarmNotificationListenerRegistration,
 207             accessDeOperationasNotificationListenerRegistration, accessDeviceNotificationListenerRegistration,
 208             null, accessTcaNotificationListenerRegistration);
 209     }
 210
 211     private NodeRegistration22 registrateNode221Listeners(String nodeId, NotificationService notificationService) {
 212         final org.opendaylight.yang.gen.v1.http.org.openroadm.alarm.rev181019.OrgOpenroadmAlarmListener
 213             alarmListener = new AlarmNotificationListener221(dataBroker);
 214         LOG.info("Registering notification listener on OrgOpenroadmAlarmListener for node: {}", nodeId);
 215         final ListenerRegistration<org.opendaylight.yang.gen.v1.http.org.openroadm.alarm.rev181019
 216             .OrgOpenroadmAlarmListener> accessAlarmNotificationListenerRegistration =
 217             notificationService.registerNotificationListener(alarmListener);
 218
 219         final org.opendaylight.yang.gen.v1.http.org.openroadm.de.operations.rev181019
 220             .OrgOpenroadmDeOperationsListener deOperationsListener = new DeOperationsListener221();
 221         LOG.info("Registering notification listener on OrgOpenroadmDeOperationsListener for node: {}", nodeId);
 222         final ListenerRegistration<org.opendaylight.yang.gen.v1.http.org.openroadm.de.operations.rev181019
 223             .OrgOpenroadmDeOperationsListener> accessDeOperationasNotificationListenerRegistration =
 224             notificationService.registerNotificationListener(deOperationsListener);
 225
 226         final org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.OrgOpenroadmDeviceListener
 227             deviceListener = new DeviceListener221(nodeId, this.portMapping);
 228         LOG.info("Registering notification listener on OrgOpenroadmDeviceListener for node: {}", nodeId);
 229         final ListenerRegistration<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019
 230             .OrgOpenroadmDeviceListener> accessDeviceNotificationListenerRegistration =
 231             notificationService.registerNotificationListener(deviceListener);
 232
 233         final org.opendaylight.yang.gen.v1.http.org.openroadm.tca.rev181019.OrgOpenroadmTcaListener
 234             tcaListener = new TcaListener221();
 235         LOG.info("Registering notification listener on OrgOpenroadmTcaListener for node: {}", nodeId);
 236         final ListenerRegistration<org.opendaylight.yang.gen.v1.http.org.openroadm.tca.rev181019
 237             .OrgOpenroadmTcaListener> accessTcaNotificationListenerRegistration =
 238             notificationService.registerNotificationListener(tcaListener);
 239         return new NodeRegistration22(nodeId, accessAlarmNotificationListenerRegistration,
 240             accessDeOperationasNotificationListenerRegistration, accessDeviceNotificationListenerRegistration,
 241             null, accessTcaNotificationListenerRegistration);
 242     }
 243
 244     private boolean subscribeStream(MountPoint mountPoint, String streamName, String nodeId) {
 245         final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class);
 246         if (!service.isPresent()) {
 247             return false;
 248         }
 249         final NotificationsService rpcService = service.get().getRpcService(NotificationsService.class);
 250         if (rpcService == null) {
 251             LOG.error(RPC_SERVICE_FAILED, nodeId);
 252             return false;
 253         }
 254         final CreateSubscriptionInputBuilder createSubscriptionInputBuilder = new CreateSubscriptionInputBuilder()
 255             .setStream(new StreamNameType(streamName));
 256         LOG.info("Triggering notification stream {} for node {}", streamName, nodeId);
 257         ListenableFuture<RpcResult<CreateSubscriptionOutput>> subscription = rpcService
 258             .createSubscription(createSubscriptionInputBuilder.build());
 259         try {
 260             subscription.get();
 261         } catch (InterruptedException | ExecutionException e) {
 262             LOG.error("Error during subscription to stream {}", streamName, e);
 263         }
 264         return true;
 265     }
 266 }