X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=networkmodel%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Fnetworkmodel%2FNetConfTopologyListener.java;h=367388f8d7ea5515324901041b24ff5a61b0ba81;hb=HEAD;hp=34d2a1ea8f38f3b377c4c28d2d031dc8d30e0a68;hpb=bb4b275b90fad3b9c03d6eda2c657ff7eefdeaca;p=transportpce.git diff --git a/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/NetConfTopologyListener.java b/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/NetConfTopologyListener.java index 34d2a1ea8..367388f8d 100644 --- a/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/NetConfTopologyListener.java +++ b/networkmodel/src/main/java/org/opendaylight/transportpce/networkmodel/NetConfTopologyListener.java @@ -7,47 +7,40 @@ */ package org.opendaylight.transportpce.networkmodel; +import com.google.common.annotations.VisibleForTesting; import com.google.common.util.concurrent.ListenableFuture; -import java.util.Collection; +import java.util.ArrayList; +import java.util.List; import java.util.Map; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutionException; -import javax.annotation.Nonnull; import org.opendaylight.mdsal.binding.api.DataBroker; import org.opendaylight.mdsal.binding.api.DataObjectModification; import org.opendaylight.mdsal.binding.api.DataTreeChangeListener; import org.opendaylight.mdsal.binding.api.DataTreeModification; import org.opendaylight.mdsal.binding.api.MountPoint; import org.opendaylight.mdsal.binding.api.NotificationService; -import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry; +import org.opendaylight.mdsal.binding.api.RpcService; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.transportpce.common.StringConstants; +import org.opendaylight.transportpce.common.Timeouts; import org.opendaylight.transportpce.common.device.DeviceTransactionManager; import org.opendaylight.transportpce.common.mapping.PortMapping; import org.opendaylight.transportpce.networkmodel.dto.NodeRegistration; -import org.opendaylight.transportpce.networkmodel.dto.NodeRegistration22; -import org.opendaylight.transportpce.networkmodel.listeners.AlarmNotificationListener; -import org.opendaylight.transportpce.networkmodel.listeners.AlarmNotificationListener221; -import org.opendaylight.transportpce.networkmodel.listeners.DeOperationsListener; -import org.opendaylight.transportpce.networkmodel.listeners.DeOperationsListener221; -import org.opendaylight.transportpce.networkmodel.listeners.DeviceListener121; -import org.opendaylight.transportpce.networkmodel.listeners.DeviceListener221; -import org.opendaylight.transportpce.networkmodel.listeners.TcaListener; -import org.opendaylight.transportpce.networkmodel.listeners.TcaListener221; import org.opendaylight.transportpce.networkmodel.service.NetworkModelService; -import org.opendaylight.yang.gen.v1.http.org.openroadm.alarm.rev161014.OrgOpenroadmAlarmListener; -import org.opendaylight.yang.gen.v1.http.org.openroadm.de.operations.rev161014.OrgOpenroadmDeOperationsListener; -import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.OrgOpenroadmDeviceListener; -import org.opendaylight.yang.gen.v1.http.org.openroadm.tca.rev161014.OrgOpenroadmTcaListener; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.CreateSubscription; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.CreateSubscriptionInputBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.CreateSubscriptionOutput; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.NotificationsService; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.StreamNameType; -import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode; -import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus; -import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.Netconf; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.netconf.Streams; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.netconf.streams.Stream; +import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev240120.ConnectionOper.ConnectionStatus; +import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.device.rev240120.connection.oper.available.capabilities.AvailableCapability; +import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev231121.NetconfNode; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node; -import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -60,66 +53,63 @@ public class NetConfTopologyListener implements DataTreeChangeListener { private final DataBroker dataBroker; private final DeviceTransactionManager deviceTransactionManager; private final Map registrations; - private final Map registrations22; private final PortMapping portMapping; - public NetConfTopologyListener(final NetworkModelService networkModelService, final DataBroker dataBroker, - DeviceTransactionManager deviceTransactionManager, PortMapping portMapping) { + public NetConfTopologyListener( + final NetworkModelService networkModelService, + final DataBroker dataBroker, + DeviceTransactionManager deviceTransactionManager, + PortMapping portMapping) { this.networkModelService = networkModelService; this.dataBroker = dataBroker; this.deviceTransactionManager = deviceTransactionManager; this.registrations = new ConcurrentHashMap<>(); - this.registrations22 = new ConcurrentHashMap<>(); this.portMapping = portMapping; } - public void onDataTreeChanged(@Nonnull Collection> changes) { + @Override + public void onDataTreeChanged(List> changes) { LOG.info("onDataTreeChanged - {}", this.getClass().getSimpleName()); for (DataTreeModification change : changes) { DataObjectModification rootNode = change.getRootNode(); - if (rootNode.getDataBefore() == null) { + if (rootNode.dataBefore() == null) { continue; } - String nodeId = rootNode.getDataBefore().key().getNodeId().getValue(); - NetconfNode netconfNodeBefore = rootNode.getDataBefore().augmentation(NetconfNode.class); - switch (rootNode.getModificationType()) { + String nodeId = rootNode.dataBefore().key().getNodeId().getValue(); + NetconfNode netconfNodeBefore = rootNode.dataBefore().augmentation(NetconfNode.class); + switch (rootNode.modificationType()) { case DELETE: - this.networkModelService.deleteOpenRoadmnode(nodeId); - String deviceVersion = netconfNodeBefore - .getAvailableCapabilities().getAvailableCapability().stream() - .filter(cp -> cp.getCapability().contains(StringConstants.OPENROADM_DEVICE_MODEL_NAME)) - .sorted((c1, c2) -> c1.getCapability().compareTo(c2.getCapability())) - .findFirst() - .get().getCapability(); - onDeviceDisConnected(nodeId, deviceVersion); - LOG.info("Device {} correctly disconnected from controller", nodeId); + if (this.networkModelService.deleteOpenRoadmnode(nodeId)) { + onDeviceDisConnected(nodeId); + LOG.info("Device {} correctly disconnected from controller", nodeId); + } break; case WRITE: - NetconfNode netconfNodeAfter = rootNode.getDataAfter().augmentation(NetconfNode.class); + NetconfNode netconfNodeAfter = rootNode.dataAfter().augmentation(NetconfNode.class); if (ConnectionStatus.Connecting.equals(netconfNodeBefore.getConnectionStatus()) - && ConnectionStatus.Connected.equals(netconfNodeAfter.getConnectionStatus())) { + && ConnectionStatus.Connected.equals(netconfNodeAfter.getConnectionStatus())) { LOG.info("Connecting Node: {}", nodeId); - Optional deviceCapabilityOpt = netconfNodeAfter - .getAvailableCapabilities().getAvailableCapability().stream() - .filter(cp -> cp.getCapability().contains(StringConstants.OPENROADM_DEVICE_MODEL_NAME)) - .sorted((c1, c2) -> c1.getCapability().compareTo(c2.getCapability())) - .findFirst(); + Optional deviceCapabilityOpt = + netconfNodeAfter.getAvailableCapabilities().getAvailableCapability().stream() + .filter(cp -> cp.getCapability().contains(StringConstants.OPENROADM_DEVICE_MODEL_NAME)) + .sorted((c1, c2) -> c2.getCapability().compareTo(c1.getCapability())) + .findFirst(); if (deviceCapabilityOpt.isEmpty()) { LOG.error("Unable to get openroadm-device-capability"); return; } this.networkModelService - .createOpenRoadmNode(nodeId, deviceCapabilityOpt.get().getCapability()); - onDeviceConnected(nodeId,deviceCapabilityOpt.get().getCapability()); + .createOpenRoadmNode(nodeId, deviceCapabilityOpt.orElseThrow().getCapability()); + onDeviceConnected(nodeId, deviceCapabilityOpt.orElseThrow().getCapability()); LOG.info("Device {} correctly connected to controller", nodeId); } if (ConnectionStatus.Connected.equals(netconfNodeBefore.getConnectionStatus()) - && ConnectionStatus.Connecting.equals(netconfNodeAfter.getConnectionStatus())) { + && ConnectionStatus.Connecting.equals(netconfNodeAfter.getConnectionStatus())) { LOG.warn("Node: {} is being disconnected", nodeId); } break; default: - LOG.debug("Unknown modification type {}", rootNode.getModificationType().name()); + LOG.debug("Unknown modification type {}", rootNode.modificationType().name()); break; } } @@ -128,139 +118,105 @@ public class NetConfTopologyListener implements DataTreeChangeListener { private void onDeviceConnected(final String nodeId, String openRoadmVersion) { LOG.info("onDeviceConnected: {}", nodeId); Optional mountPointOpt = this.deviceTransactionManager.getDeviceMountPoint(nodeId); - MountPoint mountPoint; - if (mountPointOpt.isPresent()) { - mountPoint = mountPointOpt.get(); - } else { + if (mountPointOpt.isEmpty()) { LOG.error("Failed to get mount point for node {}", nodeId); return; } + MountPoint mountPoint = mountPointOpt.orElseThrow(); final Optional notificationService = mountPoint.getService(NotificationService.class); - if (!notificationService.isPresent()) { + if (notificationService.isEmpty()) { LOG.error(RPC_SERVICE_FAILED, nodeId); return; } - switch (openRoadmVersion) { - case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: - NodeRegistration node121Registration = registrateNode121Listeners(nodeId, notificationService.get()); - registrations.put(nodeId, node121Registration); - break; - case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: - NodeRegistration22 node221Registration = registrateNode221Listeners(nodeId, notificationService.get()); - registrations22.put(nodeId, node221Registration); - break; - default: - break; - } - String streamName = "NETCONF"; - subscribeStream(mountPoint, streamName, nodeId); - } + NodeRegistration nodeRegistration = + new NodeRegistration( + nodeId, openRoadmVersion, notificationService.orElseThrow(), this.dataBroker, this.portMapping); + nodeRegistration.registerListeners(); + registrations.put(nodeId, nodeRegistration); - private void onDeviceDisConnected(final String nodeId, String openRoadmVersion) { - LOG.info("onDeviceDisConnected: {}", nodeId); - switch (openRoadmVersion) { - case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1: - NodeRegistration nodeRegistration = this.registrations.remove(nodeId); - if (nodeRegistration != null) { - nodeRegistration.getAccessAlarmNotificationListenerRegistration().close(); - nodeRegistration.getAccessDeOperationasNotificationListenerRegistration().close(); - nodeRegistration.getAccessDeviceNotificationListenerRegistration().close(); - nodeRegistration.getAccessTcaNotificationListenerRegistration().close(); - } - break; - case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1: - NodeRegistration22 nodeRegistration221 = this.registrations22.remove(nodeId); - if (nodeRegistration221 != null) { - nodeRegistration221.getAccessAlarmNotificationListenerRegistration().close(); - nodeRegistration221.getAccessDeOperationasNotificationListenerRegistration().close(); - nodeRegistration221.getAccessDeviceNotificationListenerRegistration().close(); - nodeRegistration221.getAccessTcaNotificationListenerRegistration().close(); - } - break; - default: - break; - } + subscribeStream(mountPoint, nodeId); } - private NodeRegistration registrateNode121Listeners(String nodeId, NotificationService notificationService) { - final OrgOpenroadmAlarmListener alarmListener = new AlarmNotificationListener(this.dataBroker); - LOG.info("Registering notification listener on OrgOpenroadmAlarmListener for node: {}", nodeId); - final ListenerRegistration accessAlarmNotificationListenerRegistration = - notificationService.registerNotificationListener(alarmListener); - - final OrgOpenroadmDeOperationsListener deOperationsListener = new DeOperationsListener(); - LOG.info("Registering notification listener on OrgOpenroadmDeOperationsListener for node: {}", nodeId); - final ListenerRegistration - accessDeOperationasNotificationListenerRegistration = - notificationService.registerNotificationListener(deOperationsListener); - - final OrgOpenroadmDeviceListener deviceListener = new DeviceListener121(nodeId, this.portMapping); - LOG.info("Registering notification listener on OrgOpenroadmDeviceListener for node: {}", nodeId); - final ListenerRegistration accessDeviceNotificationListenerRegistration = - notificationService.registerNotificationListener(deviceListener); - - TcaListener tcaListener = new TcaListener(); - LOG.info("Registering notification listener on OrgOpenroadmTcaListener for node: {}", nodeId); - final ListenerRegistration accessTcaNotificationListenerRegistration = - notificationService.registerNotificationListener(tcaListener); - return new NodeRegistration(nodeId, accessAlarmNotificationListenerRegistration, - accessDeOperationasNotificationListenerRegistration, accessDeviceNotificationListenerRegistration, - null, accessTcaNotificationListenerRegistration); - } - - private NodeRegistration22 registrateNode221Listeners(String nodeId, NotificationService notificationService) { - final org.opendaylight.yang.gen.v1.http.org.openroadm.alarm.rev181019.OrgOpenroadmAlarmListener - alarmListener = new AlarmNotificationListener221(dataBroker); - LOG.info("Registering notification listener on OrgOpenroadmAlarmListener for node: {}", nodeId); - final ListenerRegistration accessAlarmNotificationListenerRegistration = - notificationService.registerNotificationListener(alarmListener); - - final org.opendaylight.yang.gen.v1.http.org.openroadm.de.operations.rev181019 - .OrgOpenroadmDeOperationsListener deOperationsListener = new DeOperationsListener221(); - LOG.info("Registering notification listener on OrgOpenroadmDeOperationsListener for node: {}", nodeId); - final ListenerRegistration accessDeOperationasNotificationListenerRegistration = - notificationService.registerNotificationListener(deOperationsListener); - - final org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.OrgOpenroadmDeviceListener - deviceListener = new DeviceListener221(nodeId, this.portMapping); - LOG.info("Registering notification listener on OrgOpenroadmDeviceListener for node: {}", nodeId); - final ListenerRegistration accessDeviceNotificationListenerRegistration = - notificationService.registerNotificationListener(deviceListener); - - final org.opendaylight.yang.gen.v1.http.org.openroadm.tca.rev181019.OrgOpenroadmTcaListener - tcaListener = new TcaListener221(); - LOG.info("Registering notification listener on OrgOpenroadmTcaListener for node: {}", nodeId); - final ListenerRegistration accessTcaNotificationListenerRegistration = - notificationService.registerNotificationListener(tcaListener); - return new NodeRegistration22(nodeId, accessAlarmNotificationListenerRegistration, - accessDeOperationasNotificationListenerRegistration, accessDeviceNotificationListenerRegistration, - null, accessTcaNotificationListenerRegistration); + private void onDeviceDisConnected(final String nodeId) { + LOG.info("onDeviceDisConnected: {}", nodeId); + this.registrations.remove(nodeId).unregisterListeners(); } - private boolean subscribeStream(MountPoint mountPoint, String streamName, String nodeId) { - final Optional service = mountPoint.getService(RpcConsumerRegistry.class); - if (!service.isPresent()) { + private boolean subscribeStream(MountPoint mountPoint, String nodeId) { + final Optional service = mountPoint.getService(RpcService.class); + if (service.isEmpty()) { return false; } - final NotificationsService rpcService = service.get().getRpcService(NotificationsService.class); + final CreateSubscription rpcService = service.orElseThrow().getRpc(CreateSubscription.class); if (rpcService == null) { LOG.error(RPC_SERVICE_FAILED, nodeId); return false; } - final CreateSubscriptionInputBuilder createSubscriptionInputBuilder = new CreateSubscriptionInputBuilder() - .setStream(new StreamNameType(streamName)); - LOG.info("Triggering notification stream {} for node {}", streamName, nodeId); - ListenableFuture> subscription = rpcService - .createSubscription(createSubscriptionInputBuilder.build()); + // Set the default stream as OPENROADM + for (String streamName : getSupportedStream(nodeId)) { + LOG.info("Triggering notification stream {} for node {}", streamName, nodeId); + ListenableFuture> subscription = rpcService.invoke( + new CreateSubscriptionInputBuilder().setStream(new StreamNameType(streamName)).build()); + if (checkSupportedStream(streamName, subscription)) { + return true; + } + } + return false; + } + + @VisibleForTesting + public NetConfTopologyListener( + final NetworkModelService networkModelService, + final DataBroker dataBroker, + DeviceTransactionManager deviceTransactionManager, + PortMapping portMapping, + Map registrations) { + this.networkModelService = networkModelService; + this.dataBroker = dataBroker; + this.deviceTransactionManager = deviceTransactionManager; + this.portMapping = portMapping; + this.registrations = registrations; + } + + private boolean checkSupportedStream( + String streamName, + ListenableFuture> subscription) { + boolean subscriptionSuccessful = false; try { - subscription.get(); + // Using if condition does not work, since we need to handle exceptions + subscriptionSuccessful = subscription.get().isSuccessful(); + LOG.info("{} subscription is {}", streamName, subscriptionSuccessful); } catch (InterruptedException | ExecutionException e) { LOG.error("Error during subscription to stream {}", streamName, e); } - return true; + return subscriptionSuccessful; } + + private List getSupportedStream(String nodeId) { + InstanceIdentifier streamsIID = InstanceIdentifier.create(Netconf.class).child(Streams.class); + Optional ordmInfoObject = + deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL, streamsIID, + Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT); + if (ordmInfoObject == null || ordmInfoObject.isEmpty() || ordmInfoObject.orElseThrow().getStream().isEmpty()) { + LOG.error("List of streams supports by device is not present"); + return List.of("OPENROADM","NETCONF"); + } + List streams = new ArrayList<>(); + List netconfStreams = new ArrayList<>(); + for (Stream strm : ordmInfoObject.orElseThrow().getStream().values()) { + LOG.debug("Streams are {}", strm); + if ("OPENROADM".equalsIgnoreCase(strm.getName().getValue())) { + streams.add(strm.getName().getValue()); + } else if ("NETCONF".equalsIgnoreCase(strm.getName().getValue())) { + netconfStreams.add(strm.getName().getValue()); + } + } + // If OpenROADM streams are not supported, try NETCONF streams subscription + streams.addAll(netconfStreams); + return + streams.isEmpty() + ? List.of("OPENROADM","NETCONF") + : streams; + } + }