/**
* Manager for clustering service registrations of {@link DeviceMastership}.
*/
-public class DeviceMastershipManager implements ClusteredDataTreeChangeListener<FlowCapableNode>,
- OpendaylightInventoryListener, AutoCloseable{
+public class DeviceMastershipManager
+ implements ClusteredDataTreeChangeListener<FlowCapableNode>, OpendaylightInventoryListener, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(DeviceMastershipManager.class);
- private static final InstanceIdentifier<FlowCapableNode> II_TO_FLOW_CAPABLE_NODE
- = InstanceIdentifier.builder(Nodes.class)
- .child(Node.class)
- .augmentation(FlowCapableNode.class)
- .build();
+ private static final InstanceIdentifier<FlowCapableNode> II_TO_FLOW_CAPABLE_NODE = InstanceIdentifier
+ .builder(Nodes.class).child(Node.class).augmentation(FlowCapableNode.class).build();
private final ClusterSingletonServiceProvider clusterSingletonService;
private final ListenerRegistration<?> notifListenerRegistration;
private Set<InstanceIdentifier<FlowCapableNode>> activeNodes = Collections.emptySet();
public DeviceMastershipManager(final ClusterSingletonServiceProvider clusterSingletonService,
- final NotificationProviderService notificationService,
- final FlowNodeReconciliation reconcliationAgent,
- final DataBroker dataBroker) {
+ final NotificationProviderService notificationService, final FlowNodeReconciliation reconcliationAgent,
+ final DataBroker dataBroker) {
this.clusterSingletonService = clusterSingletonService;
this.notifListenerRegistration = notificationService.registerNotificationListener(this);
this.reconcliationAgent = reconcliationAgent;
}
/**
- * Temporary solution before Mastership manager from plugin.
- * Remove notification after update.
- * Update node notification should be send only when mastership in plugin was granted.
- * @param notification received notification
+ * Temporary solution before Mastership manager from plugin. Remove notification
+ * after update. Update node notification should be send only when mastership in
+ * plugin was granted.
+ *
+ * @param notification
+ * received notification
*/
@Override
public void onNodeUpdated(NodeUpdated notification) {
LOG.debug("NodeUpdate notification received : {}", notification);
- DeviceMastership membership = deviceMasterships.computeIfAbsent(notification.getId(), device ->
- new DeviceMastership(notification.getId()));
+ DeviceMastership membership = deviceMasterships.computeIfAbsent(notification.getId(),
+ device -> new DeviceMastership(notification.getId()));
membership.reconcile();
}
@Override
public void onNodeConnectorUpdated(NodeConnectorUpdated notification) {
- //Not published by plugin
+ // Not published by plugin
}
@Override
@Override
public void onNodeConnectorRemoved(NodeConnectorRemoved notification) {
- //Not published by plugin
+ // Not published by plugin
}
@Override
for (DataTreeModification<FlowCapableNode> change : changes) {
final InstanceIdentifier<FlowCapableNode> key = change.getRootPath().getRootIdentifier();
final DataObjectModification<FlowCapableNode> mod = change.getRootNode();
- final InstanceIdentifier<FlowCapableNode> nodeIdent =
- key.firstIdentifierOf(FlowCapableNode.class);
+ final InstanceIdentifier<FlowCapableNode> nodeIdent = key.firstIdentifierOf(FlowCapableNode.class);
switch (mod.getModificationType()) {
case DELETE:
}
break;
case SUBTREE_MODIFIED:
- //NO-OP since we do not need to reconcile on Node-updated
+ // NO-OP since we do not need to reconcile on Node-updated
break;
case WRITE:
if (mod.getDataBefore() == null) {
}
public void remove(InstanceIdentifier<FlowCapableNode> identifier, FlowCapableNode del,
- InstanceIdentifier<FlowCapableNode> nodeIdent) {
- if(compareInstanceIdentifierTail(identifier,II_TO_FLOW_CAPABLE_NODE)){
+ InstanceIdentifier<FlowCapableNode> nodeIdent) {
+ if (compareInstanceIdentifierTail(identifier, II_TO_FLOW_CAPABLE_NODE)) {
if (LOG.isDebugEnabled()) {
- LOG.debug("Node removed: {}",nodeIdent.firstKeyOf(Node.class).getId().getValue());
+ LOG.debug("Node removed: {}", nodeIdent.firstKeyOf(Node.class).getId().getValue());
}
- if ( ! nodeIdent.isWildcarded()) {
+ if (!nodeIdent.isWildcarded()) {
if (activeNodes.contains(nodeIdent)) {
synchronized (lockObj) {
if (activeNodes.contains(nodeIdent)) {
- Set<InstanceIdentifier<FlowCapableNode>> set =
- Sets.newHashSet(activeNodes);
+ Set<InstanceIdentifier<FlowCapableNode>> set = Sets.newHashSet(activeNodes);
set.remove(nodeIdent);
activeNodes = Collections.unmodifiableSet(set);
- setNodeOperationalStatus(nodeIdent,false);
+ setNodeOperationalStatus(nodeIdent, false);
}
}
}
}
public void add(InstanceIdentifier<FlowCapableNode> identifier, FlowCapableNode add,
- InstanceIdentifier<FlowCapableNode> nodeIdent) {
- if(compareInstanceIdentifierTail(identifier,II_TO_FLOW_CAPABLE_NODE)){
+ InstanceIdentifier<FlowCapableNode> nodeIdent) {
+ if (compareInstanceIdentifierTail(identifier, II_TO_FLOW_CAPABLE_NODE)) {
if (LOG.isDebugEnabled()) {
- LOG.debug("Node added: {}",nodeIdent.firstKeyOf(Node.class).getId().getValue());
+ LOG.debug("Node added: {}", nodeIdent.firstKeyOf(Node.class).getId().getValue());
}
- if ( ! nodeIdent.isWildcarded()) {
+ if (!nodeIdent.isWildcarded()) {
if (!activeNodes.contains(nodeIdent)) {
synchronized (lockObj) {
if (!activeNodes.contains(nodeIdent)) {
Set<InstanceIdentifier<FlowCapableNode>> set = Sets.newHashSet(activeNodes);
set.add(nodeIdent);
activeNodes = Collections.unmodifiableSet(set);
- setNodeOperationalStatus(nodeIdent,true);
+ setNodeOperationalStatus(nodeIdent, true);
}
}
}
@Override
public void close() {
if (listenerRegistration != null) {
- try {
- listenerRegistration.close();
- } catch (Exception e) {
- LOG.warn("Error occurred while closing operational Node listener: {}", e.getMessage());
- LOG.debug("Error occurred while closing operational Node listener", e);
- }
+ listenerRegistration.close();
listenerRegistration = null;
}
if (notifListenerRegistration != null) {
}
}
-
private boolean compareInstanceIdentifierTail(InstanceIdentifier<?> identifier1,
- InstanceIdentifier<?> identifier2) {
- return Iterables.getLast(identifier1.getPathArguments()).equals(Iterables.getLast(identifier2.getPathArguments()));
+ InstanceIdentifier<?> identifier2) {
+ return Iterables.getLast(identifier1.getPathArguments())
+ .equals(Iterables.getLast(identifier2.getPathArguments()));
}
private void setNodeOperationalStatus(InstanceIdentifier<FlowCapableNode> nodeIid, boolean status) {
NodeId nodeId = nodeIid.firstKeyOf(Node.class).getId();
- if (nodeId != null ) {
- if (deviceMasterships.containsKey(nodeId) ) {
+ if (nodeId != null) {
+ if (deviceMasterships.containsKey(nodeId)) {
deviceMasterships.get(nodeId).setDeviceOperationalStatus(status);
- LOG.debug("Operational status of device {} is set to {}",nodeId, status);
+ LOG.debug("Operational status of device {} is set to {}", nodeId, status);
}
}
}
- private void registerNodeListener(){
+
+ @SuppressWarnings("IllegalCatch")
+ private void registerNodeListener() {
final InstanceIdentifier<FlowCapableNode> flowNodeWildCardIdentifier = InstanceIdentifier.create(Nodes.class)
.child(Node.class).augmentation(FlowCapableNode.class);
- final DataTreeIdentifier<FlowCapableNode> treeId =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, flowNodeWildCardIdentifier);
+ final DataTreeIdentifier<FlowCapableNode> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ flowNodeWildCardIdentifier);
try {
SimpleTaskRetryLooper looper = new SimpleTaskRetryLooper(ForwardingRulesManagerImpl.STARTUP_LOOP_TICK,
ForwardingRulesManagerImpl.STARTUP_LOOP_MAX_RETRIES);
- listenerRegistration = looper.loopUntilNoException(() ->
- dataBroker.registerDataTreeChangeListener(treeId, DeviceMastershipManager.this));
+ listenerRegistration = looper.loopUntilNoException(
+ () -> dataBroker.registerDataTreeChangeListener(treeId, DeviceMastershipManager.this));
} catch (Exception e) {
LOG.warn("Data listener registration failed: {}", e.getMessage());
LOG.debug("Data listener registration failed ", e);
Code Review / openflowplugin.git / blobdiff