*/
package org.opendaylight.transportpce.renderer;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.renderer.listeners.AlarmNotificationListener;
import org.opendaylight.transportpce.renderer.listeners.DeOperationsListener;
import org.opendaylight.transportpce.renderer.listeners.DeviceListener;
import org.opendaylight.transportpce.renderer.listeners.LldpListener;
import org.opendaylight.transportpce.renderer.listeners.TcaListener;
-import org.opendaylight.transportpce.renderer.mapping.PortMapping;
import org.opendaylight.yang.gen.v1.http.org.openroadm.alarm.rev161014.AlarmNotification;
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.slf4j.LoggerFactory;
public class RendererNotificationsImpl implements DataTreeChangeListener<Node> {
-
private final DataBroker dataBroker;
private final MountPointService mountService;
private static final Logger LOG = LoggerFactory.getLogger(RendererNotificationsImpl.class);
private ListenerRegistration<RendererNotificationsImpl> dataTreeChangeListenerRegistration;
-
+ private final PortMapping portMapping;
+ private final DeviceTransactionManager deviceTransactionManager;
private final Set<String> currentMountedDevice;
public static final InstanceIdentifier<Topology> NETCONF_TOPO_IID = InstanceIdentifier.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(new TopologyId(TopologyNetconf.QNAME.getLocalName())));
});
public RendererNotificationsImpl(final DataBroker dataBroker, final MountPointService mountService,
- Set<String> currentMountedDevice) {
+ Set<String> currentMountedDevice, PortMapping portMapping,DeviceTransactionManager deviceTransactionManager) {
this.dataBroker = dataBroker;
this.mountService = mountService;
this.currentMountedDevice = currentMountedDevice;
+ this.portMapping = portMapping;
+ this.deviceTransactionManager = deviceTransactionManager;
+ if (portMapping == null) {
+ LOG.error("Portmapping is null !");
+ }
+ if (deviceTransactionManager == null) {
+ LOG.error("deviceTransactionManager is null");
+ }
if (mountService == null) {
LOG.error("Mount service is null");
-
}
if (dataBroker != null) {
this.dataTreeChangeListenerRegistration = dataBroker.registerDataTreeChangeListener(
}
}
- private void registerNotificationListener(final NodeId nodeId) {
+ private void registerNotificationListener(final String nodeId) {
- MountPoint mountPoint = PortMapping.getDeviceMountPoint(nodeId.getValue(), mountService);
+ LOG.info("onDeviceConnected: {}", nodeId);
+ Optional<MountPoint> mountPointOpt = this.deviceTransactionManager.getDeviceMountPoint(nodeId);
+ MountPoint mountPoint;
+ if (mountPointOpt.isPresent()) {
+ mountPoint = mountPointOpt.get();
+ } else {
+ LOG.error("Failed to get mount point for node {}", nodeId);
+ return;
+ }
- // Register notification service
- final Optional<NotificationService> notificationService = mountPoint.getService(
- NotificationService.class);
+ final Optional<NotificationService> notificationService =
+ mountPoint.getService(NotificationService.class).toJavaUtil();
if (!notificationService.isPresent()) {
- LOG.error("Failed to get RpcService for node {}", nodeId.getValue());
+ LOG.error("Failed to get RpcService for node {}", nodeId);
+ return;
}
final OrgOpenroadmAlarmListener alarmListener;
LOG.info("Registering notification listener on {} for node: {}", AlarmNotification.QNAME, nodeId);
// Register notification listener
-
final OrgOpenroadmDeOperationsListener deOperationsListener;
deOperationsListener = new DeOperationsListener();
LOG.info("Registering notification listener on OrgOpenroadmDeOperationsListener for node: {}", nodeId);
// Register notification listener
-
final OrgOpenroadmDeviceListener deviceListener;
deviceListener = new DeviceListener();
LOG.info("Registering notification listener on OrgOpenroadmDeviceListener for node: {}", nodeId);
// Register notification listener
-
final OrgOpenroadmLldpListener lldpListener;
lldpListener = new LldpListener();
LOG.info("Registering notification listener on OrgOpenroadmLldpListener for node: {}", nodeId);
// Register notification listener
-
final OrgOpenroadmTcaListener tcaListener;
tcaListener = new TcaListener();
LOG.info("Registering notification listener on OrgOpenroadmTcaListener for node: {}", nodeId);
// Register notification listener
-
// Listening to NETCONF datastream
final String streamName = "NETCONF";
- final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class);
+ final Optional<RpcConsumerRegistry> service = mountPoint.getService(RpcConsumerRegistry.class).toJavaUtil();
if (!service.isPresent()) {
- LOG.error("Failed to get RpcService for node {}", nodeId.getValue());
+ LOG.error("Failed to get RpcService for node {}", nodeId);
}
final NotificationsService rpcService = service.get().getRpcService(NotificationsService.class);
public void close() {
LOG.info("RenderernotificationsImpl Closed");
// Clean up the Data Change Listener registration
- if (dataTreeChangeListenerRegistration != null) {
- dataTreeChangeListenerRegistration.close();
+ if (this.dataTreeChangeListenerRegistration != null) {
+ this.dataTreeChangeListenerRegistration.close();
}
}
"Node not connected via Netconf protocol");
nodeId = rootNode.getDataAfter().getKey().getNodeId().getValue();
}
- if (nnode != null) {
- if (rootNode.getModificationType() == ModificationType.WRITE) {
- LOG.info("Node added " + nodeId);
- } else if (rootNode.getModificationType() == ModificationType.SUBTREE_MODIFIED) {
+ if (rootNode.getModificationType() == ModificationType.DELETE) {
+ String nodeid = rootNode.getDataBefore().getKey().getNodeId().getValue();
+ LOG.info("Node {} removed...", nodeid);
+ this.portMapping.deleteMappingData(nodeid);
+ }
- LOG.info("Node modified " + nodeId);
+ if (nnode != null) {
+ if (nodeId.equals("controller-config")) {
+ // We shouldn't process controller-config as an OpenROAM device
+ LOG.info("{} ignored: org-openroadm-device advertised but not a real ROADM device", nodeId);
+ return;
+ }
+ if ((rootNode.getModificationType() == ModificationType.WRITE) ||
+ (rootNode.getModificationType() == ModificationType.SUBTREE_MODIFIED)) {
+ LOG.info("Node added or modified {}", nodeId);
ConnectionStatus csts = nnode.getConnectionStatus();
switch (csts) {
.stream().map(cp -> cp.getCapability()).collect(Collectors.toList());
LOG.info("Capabilities: {}", capabilities);
/*
- * TODO: check for required
- * capabilities to listen for notifications
+ * TODO: check for required capabilities to listen
+ * for notifications
*/
- registerNotificationListener(rootNode.getDataAfter(). getNodeId());
- currentMountedDevice.add(nodeId);
- new PortMapping(dataBroker, mountService, nodeId).createMappingData();
+ registerNotificationListener(nodeId);
+ this.currentMountedDevice.add(nodeId);
+ this.portMapping.createMappingData(nodeId);
break;
}
case Connecting: {
- LOG.info("NETCONF Node: {} was disconnected", nodeId);
+ LOG.info("NETCONF Node: {} is (dis)connecting", nodeId);
break;
}
case UnableToConnect: {
break;
}
default:
- LOG.warn("Unexpected connection status " + csts.getName());
+ LOG.warn("Unexpected connection status {}", csts.getName());
}
- } else if (rootNode.getModificationType() == ModificationType.DELETE) {
- LOG.info("Node removed " + nodeId);
- currentMountedDevice.remove(nodeId);
}
}
}
+ LOG.info("Netconf devices currently mounted are : {}", this.currentMountedDevice.toString());
}
-}
\ No newline at end of file
+}
Code Review / transportpce.git / blobdiff