Fix warnings/javadocs in sal-distributed-datastore 92/46692/2
authorTom Pantelis <tpanteli@brocade.com>
Fri, 7 Oct 2016 21:36:42 +0000 (17:36 -0400)
committerTom Pantelis <tpanteli@brocade.com>
Wed, 12 Oct 2016 16:29:29 +0000 (12:29 -0400)
Fixed checkstyle warnings in the entity ownershiop classes. Most of the
warnings/changes were for:
 - white space before if/for/while/catch
 - white space before beginning brace
 - line too long
 - illegal catching of Exception (suppressed)
 - variable name too short
 - indentation
 - missing period after first sentence in javadoc
 - missing first sentence in javadoc
 - missing <p/> in javadoc

Change-Id: I34d130d5f50751222d89a0b36c132bd270aba156
Signed-off-by: Tom Pantelis <tpanteli@brocade.com>
18 files changed:
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/AbstractEntityOwnerChangeListener.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/CandidateListChangeListener.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/DistributedEntityOwnershipService.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/EntityOwnerChangeListener.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/EntityOwnersModel.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/EntityOwnershipListenerActor.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/EntityOwnershipListenerSupport.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/EntityOwnershipShard.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/EntityOwnershipShardCommitCoordinator.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/EntityOwnershipStatistics.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/messages/CandidateRemoved.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/messages/RemoveAllCandidates.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/messages/SelectOwner.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/selectionstrategy/EntityOwnerSelectionStrategy.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/selectionstrategy/EntityOwnerSelectionStrategyConfig.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/selectionstrategy/EntityOwnerSelectionStrategyConfigReader.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/selectionstrategy/FirstCandidateSelectionStrategy.java
opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/entityownership/selectionstrategy/LeastLoadedCandidateSelectionStrategy.java

index eeda4f9..1989bad 100644 (file)
@@ -11,6 +11,7 @@ package org.opendaylight.controller.cluster.datastore.entityownership;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.ENTITY_OWNERS_PATH;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.ENTITY_OWNER_QNAME;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.ENTITY_QNAME;
+
 import org.opendaylight.controller.cluster.datastore.ShardDataTree;
 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeListener;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.clustering.entity.owners.rev150804.entity.owners.EntityType;
index 833ca30..3b4f2d9 100644 (file)
@@ -12,6 +12,7 @@ import static org.opendaylight.controller.cluster.datastore.entityownership.Enti
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.ENTITY_ID_QNAME;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.ENTITY_OWNERS_PATH;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.ENTITY_QNAME;
+
 import akka.actor.ActorRef;
 import com.google.common.base.Preconditions;
 import java.util.ArrayList;
@@ -57,14 +58,14 @@ class CandidateListChangeListener implements DOMDataTreeChangeListener {
     }
 
     void init(ShardDataTree shardDataTree) {
-        shardDataTree.registerTreeChangeListener(YangInstanceIdentifier.builder(ENTITY_OWNERS_PATH).
-                node(EntityType.QNAME).node(EntityType.QNAME).node(ENTITY_QNAME).node(ENTITY_QNAME).
-                        node(Candidate.QNAME).node(Candidate.QNAME).build(), this);
+        shardDataTree.registerTreeChangeListener(YangInstanceIdentifier.builder(ENTITY_OWNERS_PATH)
+                .node(EntityType.QNAME).node(EntityType.QNAME).node(ENTITY_QNAME).node(ENTITY_QNAME)
+                    .node(Candidate.QNAME).node(Candidate.QNAME).build(), this);
     }
 
     @Override
     public void onDataTreeChanged(Collection<DataTreeCandidate> changes) {
-        for(DataTreeCandidate change: changes) {
+        for (DataTreeCandidate change: changes) {
             DataTreeCandidateNode changeRoot = change.getRootNode();
             ModificationType type = changeRoot.getModificationType();
 
@@ -76,23 +77,23 @@ class CandidateListChangeListener implements DOMDataTreeChangeListener {
 
             YangInstanceIdentifier entityId = extractEntityPath(change.getRootPath());
 
-            if(type == ModificationType.WRITE || type == ModificationType.APPEARED) {
+            if (type == ModificationType.WRITE || type == ModificationType.APPEARED) {
                 LOG.debug("{}: Candidate {} was added for entity {}", logId, candidate, entityId);
 
-                Collection<String> currentCandidates = addToCurrentCandidates(entityId, candidate);
-                shard.tell(new CandidateAdded(entityId, candidate, new ArrayList<>(currentCandidates)), shard);
-            } else if(type == ModificationType.DELETE || type == ModificationType.DISAPPEARED) {
+                Collection<String> newCandidates = addToCurrentCandidates(entityId, candidate);
+                shard.tell(new CandidateAdded(entityId, candidate, new ArrayList<>(newCandidates)), shard);
+            } else if (type == ModificationType.DELETE || type == ModificationType.DISAPPEARED) {
                 LOG.debug("{}: Candidate {} was removed for entity {}", logId, candidate, entityId);
 
-                Collection<String> currentCandidates = removeFromCurrentCandidates(entityId, candidate);
-                shard.tell(new CandidateRemoved(entityId, candidate, new ArrayList<>(currentCandidates)), shard);
+                Collection<String> newCandidates = removeFromCurrentCandidates(entityId, candidate);
+                shard.tell(new CandidateRemoved(entityId, candidate, new ArrayList<>(newCandidates)), shard);
             }
         }
     }
 
     private Collection<String> addToCurrentCandidates(YangInstanceIdentifier entityId, String newCandidate) {
         Collection<String> candidates = currentCandidates.get(entityId);
-        if(candidates == null) {
+        if (candidates == null) {
             candidates = new LinkedHashSet<>();
             currentCandidates.put(entityId, candidates);
         }
@@ -103,7 +104,7 @@ class CandidateListChangeListener implements DOMDataTreeChangeListener {
 
     private Collection<String> removeFromCurrentCandidates(YangInstanceIdentifier entityId, String candidateToRemove) {
         Collection<String> candidates = currentCandidates.get(entityId);
-        if(candidates != null) {
+        if (candidates != null) {
             candidates.remove(candidateToRemove);
             return candidates;
         }
@@ -114,12 +115,12 @@ class CandidateListChangeListener implements DOMDataTreeChangeListener {
 
     private static YangInstanceIdentifier extractEntityPath(YangInstanceIdentifier candidatePath) {
         List<PathArgument> newPathArgs = new ArrayList<>();
-        for(PathArgument pathArg: candidatePath.getPathArguments()) {
+        for (PathArgument pathArg: candidatePath.getPathArguments()) {
             newPathArgs.add(pathArg);
-            if(pathArg instanceof NodeIdentifierWithPredicates) {
+            if (pathArg instanceof NodeIdentifierWithPredicates) {
                 NodeIdentifierWithPredicates nodeKey = (NodeIdentifierWithPredicates) pathArg;
                 Entry<QName, Object> key = nodeKey.getKeyValues().entrySet().iterator().next();
-                if(ENTITY_ID_QNAME.equals(key.getKey())) {
+                if (ENTITY_ID_QNAME.equals(key.getKey())) {
                     break;
                 }
             }
index 48c68e7..a2c7601 100644 (file)
@@ -10,6 +10,7 @@ package org.opendaylight.controller.cluster.datastore.entityownership;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.CANDIDATE_NODE_ID;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.ENTITY_OWNER_NODE_ID;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.entityPath;
+
 import akka.actor.ActorRef;
 import akka.dispatch.OnComplete;
 import akka.pattern.Patterns;
@@ -109,7 +110,7 @@ public class DistributedEntityOwnershipService implements DOMEntityOwnershipServ
         future.onComplete(new OnComplete<Object>() {
             @Override
             public void onComplete(final Throwable failure, final Object response) {
-                if(failure != null) {
+                if (failure != null) {
                     LOG.debug("Error sending message {} to {}", message, shardActor, failure);
                 } else {
                     LOG.debug("{} message to {} succeeded", message, shardActor, failure);
@@ -120,12 +121,12 @@ public class DistributedEntityOwnershipService implements DOMEntityOwnershipServ
 
     @VisibleForTesting
     void executeLocalEntityOwnershipShardOperation(final Object message) {
-        if(localEntityOwnershipShard == null) {
+        if (localEntityOwnershipShard == null) {
             Future<ActorRef> future = context.findLocalShardAsync(ENTITY_OWNERSHIP_SHARD_NAME);
             future.onComplete(new OnComplete<ActorRef>() {
                 @Override
                 public void onComplete(final Throwable failure, final ActorRef shardActor) {
-                    if(failure != null) {
+                    if (failure != null) {
                         LOG.error("Failed to find local {} shard", ENTITY_OWNERSHIP_SHARD_NAME, failure);
                     } else {
                         localEntityOwnershipShard = shardActor;
@@ -144,7 +145,7 @@ public class DistributedEntityOwnershipService implements DOMEntityOwnershipServ
             throws CandidateAlreadyRegisteredException {
         Preconditions.checkNotNull(entity, "entity cannot be null");
 
-        if(registeredEntities.putIfAbsent(entity, entity) != null) {
+        if (registeredEntities.putIfAbsent(entity, entity) != null) {
             throw new CandidateAlreadyRegisteredException(entity);
         }
 
@@ -194,9 +195,11 @@ public class DistributedEntityOwnershipService implements DOMEntityOwnershipServ
 
         // Check if there are any candidates, if there are none we do not really have ownership state
         final MapEntryNode entity = (MapEntryNode) entityNode.get();
-        final Optional<DataContainerChild<? extends PathArgument, ?>> optionalCandidates = entity.getChild(CANDIDATE_NODE_ID);
-        final boolean hasCandidates = optionalCandidates.isPresent() && ((MapNode) optionalCandidates.get()).getValue().size() > 0;
-        if(!hasCandidates){
+        final Optional<DataContainerChild<? extends PathArgument, ?>> optionalCandidates =
+                entity.getChild(CANDIDATE_NODE_ID);
+        final boolean hasCandidates = optionalCandidates.isPresent()
+                && ((MapNode) optionalCandidates.get()).getValue().size() > 0;
+        if (!hasCandidates) {
             return Optional.absent();
         }
 
@@ -215,10 +218,11 @@ public class DistributedEntityOwnershipService implements DOMEntityOwnershipServ
     }
 
     @VisibleForTesting
+    @SuppressWarnings("checkstyle:IllegalCatch")
     DataTree getLocalEntityOwnershipShardDataTree() {
         if (localEntityOwnershipShardDataTree == null) {
             try {
-                if(localEntityOwnershipShard == null) {
+                if (localEntityOwnershipShard == null) {
                     localEntityOwnershipShard = Await.result(context.findLocalShardAsync(
                             ENTITY_OWNERSHIP_SHARD_NAME), Duration.Inf());
                 }
index 050ee5d..428c428 100644 (file)
@@ -8,6 +8,7 @@
 package org.opendaylight.controller.cluster.datastore.entityownership;
 
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.createEntity;
+
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Strings;
@@ -41,17 +42,18 @@ class EntityOwnerChangeListener extends AbstractEntityOwnerChangeListener {
 
     @Override
     public void onDataTreeChanged(final Collection<DataTreeCandidate> changes) {
-        for(DataTreeCandidate change: changes) {
+        for (DataTreeCandidate change: changes) {
             DataTreeCandidateNode changeRoot = change.getRootNode();
             LeafNode<?> ownerLeaf = (LeafNode<?>) changeRoot.getDataAfter().get();
 
-            LOG.debug("{}: Entity node changed: {}, {}", logId(), changeRoot.getModificationType(), change.getRootPath());
+            LOG.debug("{}: Entity node changed: {}, {}", logId(), changeRoot.getModificationType(),
+                    change.getRootPath());
 
             String newOwner = extractOwner(ownerLeaf);
 
             String origOwner = null;
             Optional<NormalizedNode<?, ?>> dataBefore = changeRoot.getDataBefore();
-            if(dataBefore.isPresent()) {
+            if (dataBefore.isPresent()) {
                 origOwner = extractOwner((LeafNode<?>) changeRoot.getDataBefore().get());
             }
 
@@ -64,8 +66,9 @@ class EntityOwnerChangeListener extends AbstractEntityOwnerChangeListener {
 
                 DOMEntity entity = createEntity(change.getRootPath());
 
-                LOG.debug("{}: Calling notifyEntityOwnershipListeners: entity: {}, wasOwner: {}, isOwner: {}, hasOwner: {}",
-                        logId(), entity, wasOwner, isOwner, hasOwner);
+                LOG.debug(
+                    "{}: Calling notifyEntityOwnershipListeners: entity: {}, wasOwner: {}, isOwner: {}, hasOwner: {}",
+                    logId(), entity, wasOwner, isOwner, hasOwner);
 
                 listenerSupport.notifyEntityOwnershipListeners(entity, wasOwner, isOwner, hasOwner);
             }
index 57433ba..1b5e512 100644 (file)
@@ -11,6 +11,7 @@ import java.util.Map.Entry;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.clustering.entity.owners.rev150804.EntityOwners;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.clustering.entity.owners.rev150804.entity.owners.EntityType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.clustering.entity.owners.rev150804.entity.owners.entity.type.Entity;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.clustering.entity.owners.rev150804.entity.owners.entity.type.entity.Candidate;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@@ -31,8 +32,7 @@ import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOr
  * @author Thomas Pantelis
  */
 public final class EntityOwnersModel {
-    static final  QName ENTITY_QNAME = org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.
-            md.sal.clustering.entity.owners.rev150804.entity.owners.entity.type.Entity.QNAME;
+    static final QName ENTITY_QNAME = Entity.QNAME;
     static final QName CANDIDATE_NAME_QNAME = QName.create(Candidate.QNAME, "name");
     static final QName ENTITY_ID_QNAME = QName.create(ENTITY_QNAME, "id");
     static final QName ENTITY_OWNER_QNAME = QName.create(ENTITY_QNAME, "owner");
@@ -50,18 +50,18 @@ public final class EntityOwnersModel {
             YangInstanceIdentifier.of(EntityOwners.QNAME).node(EntityType.QNAME);
 
     static YangInstanceIdentifier entityPath(String entityType, YangInstanceIdentifier entityId) {
-        return YangInstanceIdentifier.builder(ENTITY_OWNERS_PATH).node(EntityType.QNAME).
-                nodeWithKey(EntityType.QNAME, ENTITY_TYPE_QNAME, entityType).node(ENTITY_QNAME).
-                        nodeWithKey(ENTITY_QNAME, ENTITY_ID_QNAME, entityId).build();
+        return YangInstanceIdentifier.builder(ENTITY_OWNERS_PATH).node(EntityType.QNAME)
+                .nodeWithKey(EntityType.QNAME, ENTITY_TYPE_QNAME, entityType).node(ENTITY_QNAME)
+                        .nodeWithKey(ENTITY_QNAME, ENTITY_ID_QNAME, entityId).build();
 
     }
 
     static YangInstanceIdentifier candidatePath(String entityType, YangInstanceIdentifier entityId,
             String candidateName) {
-        return YangInstanceIdentifier.builder(ENTITY_OWNERS_PATH).node(EntityType.QNAME).
-                nodeWithKey(EntityType.QNAME, ENTITY_TYPE_QNAME, entityType).node(ENTITY_QNAME).
-                        nodeWithKey(ENTITY_QNAME, ENTITY_ID_QNAME, entityId).node(Candidate.QNAME).
-                                nodeWithKey(Candidate.QNAME, CANDIDATE_NAME_QNAME, candidateName).build();
+        return YangInstanceIdentifier.builder(ENTITY_OWNERS_PATH).node(EntityType.QNAME)
+                .nodeWithKey(EntityType.QNAME, ENTITY_TYPE_QNAME, entityType).node(ENTITY_QNAME)
+                        .nodeWithKey(ENTITY_QNAME, ENTITY_ID_QNAME, entityId).node(Candidate.QNAME)
+                                .nodeWithKey(Candidate.QNAME, CANDIDATE_NAME_QNAME, candidateName).build();
 
     }
 
@@ -82,8 +82,8 @@ public final class EntityOwnersModel {
 
     static ContainerNode entityOwnersWithEntityTypeEntry(MapEntryNode entityTypeNode) {
         return ImmutableContainerNodeBuilder.create().withNodeIdentifier(
-                ENTITY_OWNERS_NODE_ID).addChild(ImmutableNodes.mapNodeBuilder(EntityType.QNAME).
-                        addChild(entityTypeNode).build()).build();
+                ENTITY_OWNERS_NODE_ID).addChild(ImmutableNodes.mapNodeBuilder(EntityType.QNAME)
+                        .addChild(entityTypeNode).build()).build();
     }
 
     static MapEntryNode entityTypeEntryWithEntityEntry(String entityType, MapEntryNode entityNode) {
@@ -98,8 +98,8 @@ public final class EntityOwnersModel {
     }
 
     static MapNode candidateEntry(String candidateName) {
-        return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(Candidate.QNAME)).
-                addChild(candidateMapEntry(candidateName)).build();
+        return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(Candidate.QNAME))
+                .addChild(candidateMapEntry(candidateName)).build();
     }
 
     static MapEntryNode candidateMapEntry(String candidateName) {
@@ -111,11 +111,12 @@ public final class EntityOwnersModel {
                 ImmutableNodes.leafNode(ENTITY_OWNER_QNAME, owner)).build();
     }
 
-    public static String entityTypeFromEntityPath(YangInstanceIdentifier entityPath){
+    public static String entityTypeFromEntityPath(YangInstanceIdentifier entityPath) {
         YangInstanceIdentifier parent = entityPath;
-        while(!parent.isEmpty()) {
+        while (!parent.isEmpty()) {
             if (EntityType.QNAME.equals(parent.getLastPathArgument().getNodeType())) {
-                YangInstanceIdentifier.NodeIdentifierWithPredicates entityTypeLastPathArgument = (YangInstanceIdentifier.NodeIdentifierWithPredicates) parent.getLastPathArgument();
+                YangInstanceIdentifier.NodeIdentifierWithPredicates entityTypeLastPathArgument =
+                        (YangInstanceIdentifier.NodeIdentifierWithPredicates) parent.getLastPathArgument();
                 return (String) entityTypeLastPathArgument.getKeyValues().get(ENTITY_TYPE_QNAME);
             }
             parent = parent.getParent();
@@ -126,13 +127,13 @@ public final class EntityOwnersModel {
     static DOMEntity createEntity(YangInstanceIdentifier entityPath) {
         String entityType = null;
         YangInstanceIdentifier entityId = null;
-        for(PathArgument pathArg: entityPath.getPathArguments()) {
-            if(pathArg instanceof NodeIdentifierWithPredicates) {
+        for (PathArgument pathArg: entityPath.getPathArguments()) {
+            if (pathArg instanceof NodeIdentifierWithPredicates) {
                 NodeIdentifierWithPredicates nodeKey = (NodeIdentifierWithPredicates) pathArg;
                 Entry<QName, Object> key = nodeKey.getKeyValues().entrySet().iterator().next();
-                if(ENTITY_TYPE_QNAME.equals(key.getKey())) {
+                if (ENTITY_TYPE_QNAME.equals(key.getKey())) {
                     entityType = key.getValue().toString();
-                } else if(ENTITY_ID_QNAME.equals(key.getKey())) {
+                } else if (ENTITY_ID_QNAME.equals(key.getKey())) {
                     entityId = (YangInstanceIdentifier) key.getValue();
                 }
             }
index df0b1ae..450a675 100644 (file)
@@ -13,8 +13,6 @@ import com.google.common.base.Preconditions;
 import org.opendaylight.controller.cluster.common.actor.AbstractUntypedActor;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipChange;
 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListener;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * An actor which is responsible for notifying an EntityOwnershipListener of changes.
@@ -22,8 +20,6 @@ import org.slf4j.LoggerFactory;
  * @author Thomas Pantelis
  */
 class EntityOwnershipListenerActor extends AbstractUntypedActor {
-    private static final Logger LOG = LoggerFactory.getLogger(EntityOwnershipListenerActor.class);
-
     private final DOMEntityOwnershipListener listener;
 
     private EntityOwnershipListenerActor(DOMEntityOwnershipListener listener) {
@@ -39,6 +35,7 @@ class EntityOwnershipListenerActor extends AbstractUntypedActor {
         }
     }
 
+    @SuppressWarnings("checkstyle:IllegalCatch")
     private void onEntityOwnershipChanged(DOMEntityOwnershipChange change) {
         LOG.debug("Notifying EntityOwnershipListener {}: {}", listener, change);
 
index 26e6ab7..be82582 100644 (file)
@@ -96,7 +96,7 @@ class EntityOwnershipListenerSupport {
 
     private void notifyListeners(DOMEntity entity, String mapKey, boolean wasOwner, boolean isOwner, boolean hasOwner) {
         Collection<DOMEntityOwnershipListener> listeners = entityTypeListenerMap.get(mapKey);
-        if(!listeners.isEmpty()) {
+        if (!listeners.isEmpty()) {
             notifyListeners(entity, wasOwner, isOwner, hasOwner, listeners);
         }
     }
@@ -105,7 +105,7 @@ class EntityOwnershipListenerSupport {
             Collection<DOMEntityOwnershipListener> listeners) {
         DOMEntityOwnershipChange changed = new DOMEntityOwnershipChange(entity,
                 EntityOwnershipChangeState.from(wasOwner, isOwner, hasOwner), inJeopardy);
-        for(DOMEntityOwnershipListener listener: listeners) {
+        for (DOMEntityOwnershipListener listener: listeners) {
             ActorRef listenerActor = listenerActorFor(listener);
 
             LOG.debug("{}: Notifying EntityOwnershipListenerActor {} with {}", logId, listenerActor, changed);
@@ -117,7 +117,7 @@ class EntityOwnershipListenerSupport {
     private void addListener(DOMEntityOwnershipListener listener, String mapKey) {
         if (entityTypeListenerMap.put(mapKey, listener)) {
             ListenerActorRefEntry listenerEntry = listenerActorMap.get(listener);
-            if(listenerEntry == null) {
+            if (listenerEntry == null) {
                 listenerActorMap.put(listener, new ListenerActorRefEntry());
             } else {
                 listenerEntry.referenceCount++;
@@ -132,10 +132,10 @@ class EntityOwnershipListenerSupport {
             LOG.debug("{}: Found {}", logId, listenerEntry);
 
             listenerEntry.referenceCount--;
-            if(listenerEntry.referenceCount <= 0) {
+            if (listenerEntry.referenceCount <= 0) {
                 listenerActorMap.remove(listener);
 
-                if(listenerEntry.actorRef != null) {
+                if (listenerEntry.actorRef != null) {
                     LOG.debug("Killing EntityOwnershipListenerActor {}", listenerEntry.actorRef);
                     listenerEntry.actorRef.tell(PoisonPill.getInstance(), ActorRef.noSender());
                 }
@@ -152,7 +152,7 @@ class EntityOwnershipListenerSupport {
         int referenceCount = 1;
 
         ActorRef actorFor(DOMEntityOwnershipListener listener) {
-            if(actorRef == null) {
+            if (actorRef == null) {
                 actorRef = actorContext.actorOf(EntityOwnershipListenerActor.props(listener));
 
                 LOG.debug("{}: Created EntityOwnershipListenerActor {} for listener {}", logId, actorRef, listener);
index db71da6..e0bd7f1 100644 (file)
@@ -21,13 +21,14 @@ import static org.opendaylight.controller.cluster.datastore.entityownership.Enti
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.candidateNodeKey;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.candidatePath;
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.entityOwnersWithCandidate;
+
 import akka.actor.ActorRef;
 import akka.actor.ActorSelection;
 import akka.actor.Cancellable;
 import akka.cluster.Cluster;
+import akka.cluster.ClusterEvent.CurrentClusterState;
 import akka.cluster.Member;
 import akka.cluster.MemberStatus;
-import akka.cluster.ClusterEvent.CurrentClusterState;
 import akka.pattern.Patterns;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
@@ -87,10 +88,6 @@ class EntityOwnershipShard extends Shard {
     private final EntityOwnershipStatistics entityOwnershipStatistics;
     private boolean removeAllInitialCandidates = true;
 
-    private static DatastoreContext noPersistenceDatastoreContext(DatastoreContext datastoreContext) {
-        return DatastoreContext.newBuilderFrom(datastoreContext).persistent(false).build();
-    }
-
     protected EntityOwnershipShard(Builder builder) {
         super(builder);
         this.localMemberName = builder.localMemberName;
@@ -101,6 +98,10 @@ class EntityOwnershipShard extends Shard {
         this.entityOwnershipStatistics.init(getDataStore());
     }
 
+    private static DatastoreContext noPersistenceDatastoreContext(DatastoreContext datastoreContext) {
+        return DatastoreContext.newBuilderFrom(datastoreContext).persistent(false).build();
+    }
+
     @Override
     protected void onDatastoreContext(DatastoreContext context) {
         super.onDatastoreContext(noPersistenceDatastoreContext(context));
@@ -116,27 +117,27 @@ class EntityOwnershipShard extends Shard {
 
     @Override
     public void handleNonRaftCommand(final Object message) {
-        if(message instanceof RegisterCandidateLocal) {
+        if (message instanceof RegisterCandidateLocal) {
             onRegisterCandidateLocal((RegisterCandidateLocal) message);
-        } else if(message instanceof UnregisterCandidateLocal) {
-            onUnregisterCandidateLocal((UnregisterCandidateLocal)message);
-        } else if(message instanceof CandidateAdded){
+        } else if (message instanceof UnregisterCandidateLocal) {
+            onUnregisterCandidateLocal((UnregisterCandidateLocal) message);
+        } else if (message instanceof CandidateAdded) {
             onCandidateAdded((CandidateAdded) message);
-        } else if(message instanceof CandidateRemoved){
+        } else if (message instanceof CandidateRemoved) {
             onCandidateRemoved((CandidateRemoved) message);
-        } else if(message instanceof PeerDown) {
+        } else if (message instanceof PeerDown) {
             onPeerDown((PeerDown) message);
-        } else if(message instanceof PeerUp) {
+        } else if (message instanceof PeerUp) {
             onPeerUp((PeerUp) message);
-        } else if(message instanceof RegisterListenerLocal) {
-            onRegisterListenerLocal((RegisterListenerLocal)message);
-        } else if(message instanceof UnregisterListenerLocal) {
+        } else if (message instanceof RegisterListenerLocal) {
+            onRegisterListenerLocal((RegisterListenerLocal) message);
+        } else if (message instanceof UnregisterListenerLocal) {
             onUnregisterListenerLocal((UnregisterListenerLocal) message);
-        } else if(message instanceof SelectOwner) {
+        } else if (message instanceof SelectOwner) {
             onSelectOwner((SelectOwner) message);
-        } else if(message instanceof RemoveAllCandidates) {
+        } else if (message instanceof RemoveAllCandidates) {
             onRemoveAllCandidates((RemoveAllCandidates) message);
-        } else if(!commitCoordinator.handleMessage(message, this)) {
+        } else if (!commitCoordinator.handleMessage(message, this)) {
             super.handleNonRaftCommand(message);
         }
     }
@@ -151,13 +152,13 @@ class EntityOwnershipShard extends Shard {
         LOG.debug("{}: onSelectOwner: {}", persistenceId(), selectOwner);
 
         String currentOwner = getCurrentOwner(selectOwner.getEntityPath());
-        if(Strings.isNullOrEmpty(currentOwner)) {
+        if (Strings.isNullOrEmpty(currentOwner)) {
             writeNewOwner(selectOwner.getEntityPath(), newOwner(currentOwner, selectOwner.getAllCandidates(),
                     selectOwner.getOwnerSelectionStrategy()));
 
             Cancellable cancellable = entityToScheduledOwnershipTask.get(selectOwner.getEntityPath());
-            if(cancellable != null){
-                if(!cancellable.isCancelled()){
+            if (cancellable != null) {
+                if (!cancellable.isCancelled()) {
                     cancellable.cancel();
                 }
                 entityToScheduledOwnershipTask.remove(selectOwner.getEntityPath());
@@ -183,7 +184,8 @@ class EntityOwnershipShard extends Shard {
         DOMEntity entity = unregisterCandidate.getEntity();
         listenerSupport.unsetHasCandidateForEntity(entity);
 
-        YangInstanceIdentifier candidatePath = candidatePath(entity.getType(), entity.getIdentifier(), localMemberName.getName());
+        YangInstanceIdentifier candidatePath = candidatePath(entity.getType(), entity.getIdentifier(),
+                localMemberName.getName());
         commitCoordinator.commitModification(new DeleteModification(candidatePath), this);
 
         getSender().tell(SuccessReply.INSTANCE, getSelf());
@@ -224,14 +226,16 @@ class EntityOwnershipShard extends Shard {
     private void onUnregisterListenerLocal(UnregisterListenerLocal unregisterListener) {
         LOG.debug("{}: onUnregisterListenerLocal: {}", persistenceId(), unregisterListener);
 
-        listenerSupport.removeEntityOwnershipListener(unregisterListener.getEntityType(), unregisterListener.getListener());
+        listenerSupport.removeEntityOwnershipListener(unregisterListener.getEntityType(),
+                unregisterListener.getListener());
 
         getSender().tell(SuccessReply.INSTANCE, getSelf());
     }
 
     void tryCommitModifications(final BatchedModifications modifications) {
-        if(isLeader()) {
-            LOG.debug("{}: Committing BatchedModifications {} locally", persistenceId(), modifications.getTransactionID());
+        if (isLeader()) {
+            LOG.debug("{}: Committing BatchedModifications {} locally", persistenceId(),
+                    modifications.getTransactionID());
 
             // Note that it's possible the commit won't get consensus and will timeout and not be applied
             // to the state. However we don't need to retry it in that case b/c it will be committed to
@@ -243,10 +247,8 @@ class EntityOwnershipShard extends Shard {
             if (leader != null) {
                 possiblyRemoveAllInitialCandidates(leader);
 
-                if(LOG.isDebugEnabled()) {
-                    LOG.debug("{}: Sending BatchedModifications {} to leader {}", persistenceId(),
-                            modifications.getTransactionID(), leader);
-                }
+                LOG.debug("{}: Sending BatchedModifications {} to leader {}", persistenceId(),
+                        modifications.getTransactionID(), leader);
 
                 Future<Object> future = Patterns.ask(leader, modifications, TimeUnit.SECONDS.toMillis(
                         getDatastoreContext().getShardTransactionCommitTimeoutInSeconds()));
@@ -264,9 +266,9 @@ class EntityOwnershipShard extends Shard {
         // potential stale candidates we had previously registered, as it's possible a candidate may not be
         // registered by a client in the new incarnation. We have to send the RemoveAllCandidates message prior to any
         // pending registrations.
-        if(removeAllInitialCandidates && leader != null) {
+        if (removeAllInitialCandidates && leader != null) {
             removeAllInitialCandidates = false;
-            if(!isLeader()) {
+            if (!isLeader()) {
                 LOG.debug("{} - got new leader {} on startup - sending RemoveAllCandidates", persistenceId(), leader);
 
                 leader.tell(new RemoveAllCandidates(localMemberName), ActorRef.noSender());
@@ -290,8 +292,9 @@ class EntityOwnershipShard extends Shard {
                 return false;
             case IsolatedLeader:
                 return true;
+            default:
+                throw new IllegalStateException("Unsupported RAFT state " + state);
         }
-        throw new IllegalStateException("Unsupported RAFT state " + state);
     }
 
     private void notifyAllListeners() {
@@ -377,23 +380,24 @@ class EntityOwnershipShard extends Shard {
 
     private void initializeDownPeerMemberNamesFromClusterState() {
         java.util.Optional<Cluster> cluster = getRaftActorContext().getCluster();
-        if(!cluster.isPresent()) {
+        if (!cluster.isPresent()) {
             return;
         }
 
         CurrentClusterState state = cluster.get().state();
         Set<Member> unreachable = state.getUnreachable();
 
-        LOG.debug("{}: initializeDownPeerMemberNamesFromClusterState - current downPeerMemberNames: {}, unreachable: {}",
-                persistenceId(), downPeerMemberNames, unreachable);
+        LOG.debug(
+            "{}: initializeDownPeerMemberNamesFromClusterState - current downPeerMemberNames: {}, unreachable: {}",
+            persistenceId(), downPeerMemberNames, unreachable);
 
         downPeerMemberNames.clear();
-        for(Member m: unreachable) {
+        for (Member m: unreachable) {
             downPeerMemberNames.add(MemberName.forName(m.getRoles().iterator().next()));
         }
 
-        for(Member m: state.getMembers()) {
-            if(m.status() != MemberStatus.up() && m.status() != MemberStatus.weaklyUp()) {
+        for (Member m: state.getMembers()) {
+            if (m.status() != MemberStatus.up() && m.status() != MemberStatus.weaklyUp()) {
                 LOG.debug("{}: Adding down member with status {}", persistenceId(), m.status());
                 downPeerMemberNames.add(MemberName.forName(m.getRoles().iterator().next()));
             }
@@ -405,10 +409,11 @@ class EntityOwnershipShard extends Shard {
     private void onCandidateRemoved(CandidateRemoved message) {
         LOG.debug("{}: onCandidateRemoved: {}", persistenceId(), message);
 
-        if(isLeader()) {
+        if (isLeader()) {
             String currentOwner = getCurrentOwner(message.getEntityPath());
             writeNewOwner(message.getEntityPath(),
-                    newOwner(currentOwner, message.getRemainingCandidates(), getEntityOwnerElectionStrategy(message.getEntityPath())));
+                    newOwner(currentOwner, message.getRemainingCandidates(),
+                            getEntityOwnerElectionStrategy(message.getEntityPath())));
         }
     }
 
@@ -418,7 +423,7 @@ class EntityOwnershipShard extends Shard {
     }
 
     private void onCandidateAdded(CandidateAdded message) {
-        if(!isLeader()){
+        if (!isLeader()) {
             return;
         }
 
@@ -437,10 +442,10 @@ class EntityOwnershipShard extends Shard {
 
         LOG.debug("{}: Using strategy {} to select owner, currentOwner = {}", persistenceId(), strategy, currentOwner);
 
-        if(strategy.getSelectionDelayInMillis() == 0L) {
+        if (strategy.getSelectionDelayInMillis() == 0L) {
             writeNewOwner(message.getEntityPath(), newOwner(currentOwner, message.getAllCandidates(),
                     strategy));
-        } else if(message.getAllCandidates().size() == availableMembers) {
+        } else if (message.getAllCandidates().size() == availableMembers) {
             LOG.debug("{}: Received the maximum candidates requests : {} writing new owner",
                     persistenceId(), availableMembers);
             cancelOwnerSelectionTask(message.getEntityPath());
@@ -455,7 +460,7 @@ class EntityOwnershipShard extends Shard {
         LOG.info("{}: onPeerDown: {}", persistenceId(), peerDown);
 
         MemberName downMemberName = peerDown.getMemberName();
-        if(downPeerMemberNames.add(downMemberName) && isLeader()) {
+        if (downPeerMemberNames.add(downMemberName) && isLeader()) {
             // Select new owners for entities owned by the down peer and which have other candidates. For an entity for
             // which the down peer is the only candidate, we leave it as the owner and don't clear it. This is done to
             // handle the case where the peer member process is actually still running but the node is partitioned.
@@ -470,13 +475,13 @@ class EntityOwnershipShard extends Shard {
     private void selectNewOwnerForEntitiesOwnedBy(Set<String> ownedBy) {
         final BatchedModifications modifications = commitCoordinator.newBatchedModifications();
         searchForEntitiesOwnedBy(ownedBy, (entityTypeNode, entityNode) -> {
-            YangInstanceIdentifier entityPath = YangInstanceIdentifier.builder(ENTITY_TYPES_PATH).
-                    node(entityTypeNode.getIdentifier()).node(ENTITY_NODE_ID).node(entityNode.getIdentifier()).
-                    node(ENTITY_OWNER_NODE_ID).build();
+            YangInstanceIdentifier entityPath = YangInstanceIdentifier.builder(ENTITY_TYPES_PATH)
+                    .node(entityTypeNode.getIdentifier()).node(ENTITY_NODE_ID).node(entityNode.getIdentifier())
+                    .node(ENTITY_OWNER_NODE_ID).build();
             String newOwner = newOwner(getCurrentOwner(entityPath), getCandidateNames(entityNode),
                     getEntityOwnerElectionStrategy(entityPath));
 
-            if(!newOwner.isEmpty()) {
+            if (!newOwner.isEmpty()) {
                 LOG.debug("{}: Found entity {}, writing new owner {}", persistenceId(), entityPath, newOwner);
 
                 modifications.addModification(new WriteModification(entityPath,
@@ -501,7 +506,7 @@ class EntityOwnershipShard extends Shard {
         // leader change occurred.
         commitCoordinator.onStateChanged(this, isLeader());
 
-        if(isLeader()) {
+        if (isLeader()) {
             // Try to assign owners for entities that have no current owner. It's possible the peer that is now up
             // had previously registered as a candidate and was the only candidate but the owner write tx couldn't be
             // committed due to a leader change. Eg, the leader is able to successfully commit the candidate add tx but
@@ -516,7 +521,7 @@ class EntityOwnershipShard extends Shard {
     private Collection<String> getCandidateNames(MapEntryNode entity) {
         Collection<MapEntryNode> candidates = ((MapNode)entity.getChild(CANDIDATE_NODE_ID).get()).getValue();
         Collection<String> candidateNames = new ArrayList<>(candidates.size());
-        for(MapEntryNode candidate: candidates) {
+        for (MapEntryNode candidate: candidates) {
             candidateNames.add(candidate.getChild(CANDIDATE_NAME_NODE_ID).get().getValue().toString());
         }
 
@@ -530,7 +535,7 @@ class EntityOwnershipShard extends Shard {
             Optional<DataContainerChild<? extends PathArgument, ?>> possibleOwner =
                     entityNode.getChild(ENTITY_OWNER_NODE_ID);
             String currentOwner = possibleOwner.isPresent() ? possibleOwner.get().getValue().toString() : "";
-            if(ownedBy.contains(currentOwner)) {
+            if (ownedBy.contains(currentOwner)) {
                 walker.onEntity(entityTypeNode, entityNode);
             }
         });
@@ -563,18 +568,18 @@ class EntityOwnershipShard extends Shard {
 
     private void searchForEntities(EntityWalker walker) {
         Optional<NormalizedNode<?, ?>> possibleEntityTypes = getDataStore().readNode(ENTITY_TYPES_PATH);
-        if(!possibleEntityTypes.isPresent()) {
+        if (!possibleEntityTypes.isPresent()) {
             return;
         }
 
-        for(MapEntryNode entityType:  ((MapNode) possibleEntityTypes.get()).getValue()) {
+        for (MapEntryNode entityType:  ((MapNode) possibleEntityTypes.get()).getValue()) {
             Optional<DataContainerChild<?, ?>> possibleEntities = entityType.getChild(ENTITY_NODE_ID);
-            if(!possibleEntities.isPresent()) {
+            if (!possibleEntities.isPresent()) {
                 // shouldn't happen but handle anyway
                 continue;
             }
 
-            for(MapEntryNode entity:  ((MapNode) possibleEntities.get()).getValue()) {
+            for (MapEntryNode entity:  ((MapNode) possibleEntities.get()).getValue()) {
                 walker.onEntity(entityType, entity);
             }
         }
@@ -589,34 +594,31 @@ class EntityOwnershipShard extends Shard {
 
     /**
      * Schedule a new owner selection job. Cancelling any outstanding job if it has not been cancelled.
-     *
-     * @param entityPath
-     * @param allCandidates
      */
-    public void scheduleOwnerSelection(YangInstanceIdentifier entityPath, Collection<String> allCandidates,
-                                       EntityOwnerSelectionStrategy strategy){
+    private void scheduleOwnerSelection(YangInstanceIdentifier entityPath, Collection<String> allCandidates,
+                                       EntityOwnerSelectionStrategy strategy) {
         cancelOwnerSelectionTask(entityPath);
 
         LOG.debug("{}: Scheduling owner selection after {} ms", persistenceId(), strategy.getSelectionDelayInMillis());
 
         final Cancellable lastScheduledTask = context().system().scheduler().scheduleOnce(
-                FiniteDuration.apply(strategy.getSelectionDelayInMillis(), TimeUnit.MILLISECONDS)
-                , self(), new SelectOwner(entityPath, allCandidates, strategy)
-                , context().system().dispatcher(), self());
+                FiniteDuration.apply(strategy.getSelectionDelayInMillis(), TimeUnit.MILLISECONDS), self(),
+                new SelectOwner(entityPath, allCandidates, strategy), context().system().dispatcher(), self());
 
         entityToScheduledOwnershipTask.put(entityPath, lastScheduledTask);
     }
 
-    private void cancelOwnerSelectionTask(YangInstanceIdentifier entityPath){
+    private void cancelOwnerSelectionTask(YangInstanceIdentifier entityPath) {
         final Cancellable lastScheduledTask = entityToScheduledOwnershipTask.get(entityPath);
-        if(lastScheduledTask != null && !lastScheduledTask.isCancelled()){
+        if (lastScheduledTask != null && !lastScheduledTask.isCancelled()) {
             lastScheduledTask.cancel();
         }
     }
 
-    private String newOwner(String currentOwner, Collection<String> candidates, EntityOwnerSelectionStrategy ownerSelectionStrategy) {
+    private String newOwner(String currentOwner, Collection<String> candidates,
+            EntityOwnerSelectionStrategy ownerSelectionStrategy) {
         Collection<String> viableCandidates = getViableCandidates(candidates);
-        if(viableCandidates.isEmpty()){
+        if (viableCandidates.isEmpty()) {
             return "";
         }
         return ownerSelectionStrategy.newOwner(currentOwner, viableCandidates);
@@ -635,7 +637,7 @@ class EntityOwnershipShard extends Shard {
 
     private String getCurrentOwner(YangInstanceIdentifier entityId) {
         Optional<NormalizedNode<?, ?>> optionalEntityOwner = getDataStore().readNode(entityId.node(ENTITY_OWNER_QNAME));
-        if(optionalEntityOwner.isPresent()){
+        if (optionalEntityOwner.isPresent()) {
             return optionalEntityOwner.get().getValue().toString();
         }
         return null;
@@ -658,15 +660,15 @@ class EntityOwnershipShard extends Shard {
             super(EntityOwnershipShard.class);
         }
 
-        Builder localMemberName(MemberName localMemberName) {
+        Builder localMemberName(MemberName newLocalMemberName) {
             checkSealed();
-            this.localMemberName = localMemberName;
+            this.localMemberName = newLocalMemberName;
             return this;
         }
 
-        Builder ownerSelectionStrategyConfig(EntityOwnerSelectionStrategyConfig ownerSelectionStrategyConfig){
+        Builder ownerSelectionStrategyConfig(EntityOwnerSelectionStrategyConfig newOwnerSelectionStrategyConfig) {
             checkSealed();
-            this.ownerSelectionStrategyConfig = ownerSelectionStrategyConfig;
+            this.ownerSelectionStrategyConfig = newOwnerSelectionStrategyConfig;
             return this;
         }
 
index c792cf1..621354d 100644 (file)
@@ -62,13 +62,13 @@ class EntityOwnershipShardCommitCoordinator {
 
     boolean handleMessage(Object message, EntityOwnershipShard shard) {
         boolean handled = true;
-        if(CommitTransactionReply.isSerializedType(message)) {
+        if (CommitTransactionReply.isSerializedType(message)) {
             // Successful reply from a local commit.
             inflightCommitSucceeded(shard);
-        } else if(message instanceof akka.actor.Status.Failure) {
+        } else if (message instanceof akka.actor.Status.Failure) {
             // Failure reply from a local commit.
-            inflightCommitFailure(((Failure)message).cause(), shard);
-        } else if(COMMIT_RETRY_MESSAGE.equals(message)) {
+            inflightCommitFailure(((Failure) message).cause(), shard);
+        } else if (COMMIT_RETRY_MESSAGE.equals(message)) {
             retryInflightCommit(shard);
         } else {
             handled = false;
@@ -79,11 +79,11 @@ class EntityOwnershipShardCommitCoordinator {
 
     private void retryInflightCommit(EntityOwnershipShard shard) {
         // Shouldn't be null happen but verify anyway
-        if(inflightCommit == null) {
+        if (inflightCommit == null) {
             return;
         }
 
-        if(shard.hasLeader()) {
+        if (shard.hasLeader()) {
             log.debug("Retrying commit for BatchedModifications {}", inflightCommit.getTransactionID());
 
             shard.tryCommitModifications(inflightCommit);
@@ -94,13 +94,13 @@ class EntityOwnershipShardCommitCoordinator {
 
     void inflightCommitFailure(Throwable cause, EntityOwnershipShard shard) {
         // This should've originated from a failed inflight commit but verify anyway
-        if(inflightCommit == null) {
+        if (inflightCommit == null) {
             return;
         }
 
         log.debug("Inflight BatchedModifications {} commit failed", inflightCommit.getTransactionID(), cause);
 
-        if(!(cause instanceof NoShardLeaderException)) {
+        if (!(cause instanceof NoShardLeaderException)) {
             // If the failure is other than NoShardLeaderException the commit may have been partially
             // processed so retry with a new transaction ID to be safe.
             newInflightCommitWithDifferentTransactionID();
@@ -121,11 +121,11 @@ class EntityOwnershipShardCommitCoordinator {
 
     void inflightCommitSucceeded(EntityOwnershipShard shard) {
         // Shouldn't be null but verify anyway
-        if(inflightCommit == null) {
+        if (inflightCommit == null) {
             return;
         }
 
-        if(retryCommitSchedule != null) {
+        if (retryCommitSchedule != null) {
             retryCommitSchedule.cancel();
         }
 
@@ -136,17 +136,17 @@ class EntityOwnershipShardCommitCoordinator {
     }
 
     void commitNextBatch(EntityOwnershipShard shard) {
-        if(inflightCommit != null || pendingModifications.isEmpty() || !shard.hasLeader()) {
+        if (inflightCommit != null || pendingModifications.isEmpty() || !shard.hasLeader()) {
             return;
         }
 
         inflightCommit = newBatchedModifications();
         Iterator<Modification> iter = pendingModifications.iterator();
-        while(iter.hasNext()) {
+        while (iter.hasNext()) {
             inflightCommit.addModification(iter.next());
             iter.remove();
-            if(inflightCommit.getModifications().size() >=
-                    shard.getDatastoreContext().getShardBatchedModificationCount()) {
+            if (inflightCommit.getModifications().size()
+                    >= shard.getDatastoreContext().getShardBatchedModificationCount()) {
                 break;
             }
         }
@@ -164,13 +164,13 @@ class EntityOwnershipShardCommitCoordinator {
     }
 
     void commitModifications(BatchedModifications modifications, EntityOwnershipShard shard) {
-        if(modifications.getModifications().isEmpty()) {
+        if (modifications.getModifications().isEmpty()) {
             return;
         }
 
         boolean hasLeader = shard.hasLeader();
-        if(inflightCommit != null || !hasLeader) {
-            if(log.isDebugEnabled()) {
+        if (inflightCommit != null || !hasLeader) {
+            if (log.isDebugEnabled()) {
                 log.debug("{} - adding modifications to pending",
                         inflightCommit != null ? "A commit is inflight" : "No shard leader");
             }
@@ -187,12 +187,12 @@ class EntityOwnershipShardCommitCoordinator {
 
         possiblyPrunePendingCommits(shard, isLeader);
 
-        if(!isLeader && inflightCommit != null) {
+        if (!isLeader && inflightCommit != null) {
             // We're no longer the leader but we have an inflight local commit. This likely means we didn't get
             // consensus for the commit and switched to follower due to another node with a higher term. We
             // can't be sure if the commit was replicated to any node so we retry it here with a new
             // transaction ID.
-            if(retryCommitSchedule != null) {
+            if (retryCommitSchedule != null) {
                 retryCommitSchedule.cancel();
             }
 
@@ -216,15 +216,15 @@ class EntityOwnershipShardCommitCoordinator {
             shard.convertPendingTransactionsToMessages();
 
             // Prune the inflightCommit.
-            if(inflightCommit != null) {
+            if (inflightCommit != null) {
                 inflightCommit = pruneModifications(inflightCommit);
             }
 
             // Prune the subsequent pending modifications.
             Iterator<Modification> iter = pendingModifications.iterator();
-            while(iter.hasNext()) {
+            while (iter.hasNext()) {
                 Modification mod = iter.next();
-                if(!canForwardModificationToNewLeader(mod)) {
+                if (!canForwardModificationToNewLeader(mod)) {
                     iter.remove();
                 }
             }
@@ -233,12 +233,13 @@ class EntityOwnershipShardCommitCoordinator {
 
     @Nullable
     private BatchedModifications pruneModifications(BatchedModifications toPrune) {
-        BatchedModifications prunedModifications = new BatchedModifications(toPrune.getTransactionID(), toPrune.getVersion());
+        BatchedModifications prunedModifications = new BatchedModifications(toPrune.getTransactionID(),
+                toPrune.getVersion());
         prunedModifications.setDoCommitOnReady(toPrune.isDoCommitOnReady());
         prunedModifications.setReady(toPrune.isReady());
         prunedModifications.setTotalMessagesSent(toPrune.getTotalMessagesSent());
-        for(Modification mod: toPrune.getModifications()) {
-            if(canForwardModificationToNewLeader(mod)) {
+        for (Modification mod: toPrune.getModifications()) {
+            if (canForwardModificationToNewLeader(mod)) {
                 prunedModifications.addModification(mod);
             }
         }
index 02bd00b..6c013c1 100644 (file)
@@ -9,6 +9,7 @@
 package org.opendaylight.controller.cluster.datastore.entityownership;
 
 import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.entityTypeFromEntityPath;
+
 import com.google.common.base.Optional;
 import com.google.common.base.Strings;
 import com.romix.scala.collection.concurrent.TrieMap;
@@ -24,13 +25,13 @@ import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNod
 /**
  * EntityOwnershipStatistics is a utility class that keeps track of ownership statistics for the candidates and
  * caches it for quick count queries.
- * <p>
+ * <p/>
  * While the entity ownership model does maintain the information about which entity is owned by which candidate
  * finding out how many entities of a given type are owned by a given candidate is not an efficient query.
  */
 class EntityOwnershipStatistics extends AbstractEntityOwnerChangeListener {
 
-    private TrieMap<String, TrieMap<String, Long>> statistics = new TrieMap<>();
+    private final TrieMap<String, TrieMap<String, Long>> statistics = new TrieMap<>();
 
     EntityOwnershipStatistics(){
     }
@@ -42,14 +43,14 @@ class EntityOwnershipStatistics extends AbstractEntityOwnerChangeListener {
             LeafNode<?> ownerLeaf = (LeafNode<?>) changeRoot.getDataAfter().get();
             String entityType = entityTypeFromEntityPath(change.getRootPath());
             String newOwner = extractOwner(ownerLeaf);
-            if(!Strings.isNullOrEmpty(newOwner)) {
+            if (!Strings.isNullOrEmpty(newOwner)) {
                 updateStatistics(entityType, newOwner, 1);
             }
 
             Optional<NormalizedNode<?, ?>> dataBefore = changeRoot.getDataBefore();
             if (dataBefore.isPresent()) {
                 String origOwner = extractOwner((LeafNode<?>) changeRoot.getDataBefore().get());
-                if(!Strings.isNullOrEmpty(origOwner)) {
+                if (!Strings.isNullOrEmpty(origOwner)) {
                     updateStatistics(entityType, origOwner, -1);
                 }
             }
@@ -64,26 +65,26 @@ class EntityOwnershipStatistics extends AbstractEntityOwnerChangeListener {
         return snapshot;
     }
 
-    Map<String, Long> byEntityType(String entityType){
-        if(statistics.get(entityType) != null) {
+    Map<String, Long> byEntityType(String entityType) {
+        if (statistics.get(entityType) != null) {
             return statistics.get(entityType).readOnlySnapshot();
         }
         return new HashMap<>();
     }
 
-    private void updateStatistics(String entityType, String candidateName, long count){
-        Map<String, Long> m = statistics.get(entityType);
-        if(m == null){
-            m = new TrieMap<>();
-            m.put(candidateName, count);
-            statistics.put(entityType, m);
+    private void updateStatistics(String entityType, String candidateName, long count) {
+        Map<String, Long> map = statistics.get(entityType);
+        if (map == null) {
+            map = new TrieMap<>();
+            map.put(candidateName, count);
+            statistics.put(entityType, map);
         } else {
-            Long candidateOwnedEntities = m.get(candidateName);
-            if(candidateOwnedEntities == null){
-                m.put(candidateName, count);
+            Long candidateOwnedEntities = map.get(candidateName);
+            if (candidateOwnedEntities == null) {
+                map.put(candidateName, count);
             } else {
-                m.put(candidateName, candidateOwnedEntities + count);
+                map.put(candidateName, candidateOwnedEntities + count);
             }
         }
     }
-}
\ No newline at end of file
+}
index 8a96a76..64a333f 100644 (file)
@@ -22,7 +22,8 @@ public class CandidateRemoved {
     private final String removedCandidate;
     private final Collection<String> remainingCandidates;
 
-    public CandidateRemoved(YangInstanceIdentifier entityPath, String removedCandidate, Collection<String> remainingCandidates) {
+    public CandidateRemoved(YangInstanceIdentifier entityPath, String removedCandidate,
+            Collection<String> remainingCandidates) {
         this.entityPath = entityPath;
         this.removedCandidate = removedCandidate;
         this.remainingCandidates = remainingCandidates;
index 4ecae72..17f80cd 100644 (file)
@@ -11,7 +11,7 @@ import java.io.Serializable;
 import org.opendaylight.controller.cluster.access.concepts.MemberName;
 
 /**
- * Message sent by an EntityOwnershipShard to its leader on startup to remove all its candidates.                                                                               .
+ * Message sent by an EntityOwnershipShard to its leader on startup to remove all its candidates.
  *
  * @author Thomas Pantelis
  */
index 250abf6..8cd4f78 100644 (file)
@@ -14,7 +14,7 @@ import org.opendaylight.controller.cluster.datastore.entityownership.selectionst
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 
 /**
- * Message sent when a new owner needs to be selected
+ * Message sent when a new owner needs to be selected.
  */
 public class SelectOwner {
     private final YangInstanceIdentifier entityPath;
@@ -44,10 +44,7 @@ public class SelectOwner {
 
     @Override
     public String toString() {
-        return "SelectOwner{" +
-                "entityPath=" + entityPath +
-                ", allCandidates=" + allCandidates +
-                ", ownerSelectionStrategy=" + ownerSelectionStrategy +
-                '}';
+        return "SelectOwner [entityPath=" + entityPath + ", allCandidates=" + allCandidates
+                + ", ownerSelectionStrategy=" + ownerSelectionStrategy + "]";
     }
 }
index 7cbc075..38899ec 100644 (file)
@@ -13,10 +13,11 @@ import javax.annotation.Nullable;
 
 /**
  * An EntityOwnerSelectionStrategy is to be used by the EntityOwnershipShard to select a new owner from a collection
- * of candidates
+ * of candidates.
  */
 public interface EntityOwnerSelectionStrategy {
     /**
+     * Returns the time in millis owner selection should be delayed.
      *
      * @return the time in millis owner selection should be delayed
      */
@@ -24,6 +25,8 @@ public interface EntityOwnerSelectionStrategy {
 
 
     /**
+     * Selects a new owner from the list of viable candidates.
+     *
      * @param currentOwner the current owner of the entity if any, null otherwise
      * @param viableCandidates the available candidates from which to choose the new owner
      * @return the new owner
index 5a785fc..1999296 100644 (file)
@@ -30,14 +30,14 @@ public final class EntityOwnerSelectionStrategyConfig {
         return entityTypeToStrategyInfo.get(entityType) != null;
     }
 
-    public EntityOwnerSelectionStrategy createStrategy(String entityType, Map<String, Long> initialStatistics){
+    public EntityOwnerSelectionStrategy createStrategy(String entityType, Map<String, Long> initialStatistics) {
         final EntityOwnerSelectionStrategy strategy;
         final EntityOwnerSelectionStrategy existingStrategy = entityTypeToOwnerSelectionStrategy.get(entityType);
-        if(existingStrategy != null){
+        if (existingStrategy != null) {
             strategy = existingStrategy;
         } else {
             EntityOwnerSelectionStrategyConfig.StrategyInfo strategyInfo = entityTypeToStrategyInfo.get(entityType);
-            if(strategyInfo == null){
+            if (strategyInfo == null) {
                 strategy = FirstCandidateSelectionStrategy.INSTANCE;
             } else {
                 strategy = strategyInfo.createStrategy(initialStatistics);
@@ -48,14 +48,13 @@ public final class EntityOwnerSelectionStrategyConfig {
     }
 
     /**
-     * @deprecated FIXME: THIS IS CONFIGURATION FOR A CUSTOM-LOADED CLASS CONSTRUCTOR
-     *
      * This class should not exist. It contains a single long, which is passed to the constructor (via reflection).
      * We are getting that information from a BundleContext. We are running in OSGi environment, hence this class
      * needs to be deployed in its own bundle, with its own configuration.
-     *
      * If this is used internally, it needs to be relocated into a separate package along with the implementation
      * using it.
+     *
+     * @deprecated FIXME: THIS IS CONFIGURATION FOR A CUSTOM-LOADED CLASS CONSTRUCTOR
      */
     @Deprecated
     public void clearStrategies() {
@@ -71,10 +70,12 @@ public final class EntityOwnerSelectionStrategyConfig {
             this.delay = delay;
         }
 
-        public EntityOwnerSelectionStrategy createStrategy(Map<String, Long> initialStatistics){
+        public EntityOwnerSelectionStrategy createStrategy(Map<String, Long> initialStatistics) {
             try {
-                return strategyClass.getDeclaredConstructor(long.class, Map.class).newInstance(delay, initialStatistics);
-            } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+                return strategyClass.getDeclaredConstructor(long.class, Map.class)
+                        .newInstance(delay, initialStatistics);
+            } catch (InstantiationException | IllegalAccessException | InvocationTargetException
+                    | NoSuchMethodException e) {
                 LOG.warn("could not create custom strategy", e);
             }
             return FirstCandidateSelectionStrategy.INSTANCE;
@@ -88,16 +89,17 @@ public final class EntityOwnerSelectionStrategyConfig {
     public static class Builder {
         private final EntityOwnerSelectionStrategyConfig config;
 
-        private Builder(final EntityOwnerSelectionStrategyConfig config){
+        private Builder(final EntityOwnerSelectionStrategyConfig config) {
             this.config = config;
         }
 
-        public Builder addStrategy(final String entityType, final Class<? extends EntityOwnerSelectionStrategy> strategy, final long delay){
+        public Builder addStrategy(final String entityType,
+                final Class<? extends EntityOwnerSelectionStrategy> strategy, final long delay) {
             config.entityTypeToStrategyInfo.put(entityType, new StrategyInfo(strategy, delay));
             return this;
         }
 
-        public EntityOwnerSelectionStrategyConfig build(){
+        public EntityOwnerSelectionStrategyConfig build() {
             return this.config;
         }
     }
index bc39460..29ace24 100644 (file)
@@ -21,6 +21,8 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
+ * Reads the entity owner selection strategy config.
+ *
  * @deprecated FIXME: Service injection class. This class needs to be eliminated in favor of proper service injection,
  *             which can be any of OSGi (which this class uses internally), java.util.ServiceLoader, or config
  *             subsystem.
@@ -36,6 +38,7 @@ public final class EntityOwnerSelectionStrategyConfigReader {
         // Hidden on purpose
     }
 
+    @SuppressWarnings("checkstyle:IllegalCatch")
     public static EntityOwnerSelectionStrategyConfig loadStrategyWithConfig(final BundleContext bundleContext) {
         final EntityOwnerSelectionStrategyConfig.Builder builder = EntityOwnerSelectionStrategyConfig.newBuilder();
 
@@ -74,7 +77,8 @@ public final class EntityOwnerSelectionStrategyConfigReader {
         return builder.build();
     }
 
-    private static EntityOwnerSelectionStrategyConfig parseConfiguration(final Builder builder, final Configuration config) {
+    private static EntityOwnerSelectionStrategyConfig parseConfiguration(final Builder builder,
+            final Configuration config) {
         // Historic note: java.util.Dictionary since introduction of java.util.Map in Java 1.2
         final Dictionary<String, Object> properties = config.getProperties();
         if (properties == null) {
@@ -121,7 +125,7 @@ public final class EntityOwnerSelectionStrategyConfigReader {
             throws ClassNotFoundException {
         final Class<?> clazz;
         try {
-           clazz = EntityOwnerSelectionStrategyConfigReader.class.getClassLoader().loadClass(strategyClassAndDelay);
+            clazz = EntityOwnerSelectionStrategyConfigReader.class.getClassLoader().loadClass(strategyClassAndDelay);
         } catch (ClassNotFoundException e) {
             throw new IllegalArgumentException("Failed to load strategy " + strategyClassAndDelay);
         }
index 1fe0296..c4c93b7 100644 (file)
@@ -14,11 +14,12 @@ import java.util.Collections;
 import java.util.Map;
 
 /**
- * The FirstCandidateSelectionStrategy always selects the first viable candidate from the list of candidates
+ * The FirstCandidateSelectionStrategy always selects the first viable candidate from the list of candidates.
  */
 public class FirstCandidateSelectionStrategy extends AbstractEntityOwnerSelectionStrategy {
 
-    public static final FirstCandidateSelectionStrategy INSTANCE = new FirstCandidateSelectionStrategy(0L, Collections.emptyMap());
+    public static final FirstCandidateSelectionStrategy INSTANCE =
+            new FirstCandidateSelectionStrategy(0L, Collections.emptyMap());
 
     public FirstCandidateSelectionStrategy(long selectionDelayInMillis, Map<String, Long> initialStatistics) {
         super(selectionDelayInMillis, initialStatistics);
index ee01d95..9db7b0b 100644 (file)
@@ -15,17 +15,13 @@ import com.google.common.base.Strings;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * The LeastLoadedCandidateSelectionStrategy assigns ownership for an entity to the candidate which owns the least
  * number of entities.
  */
 public class LeastLoadedCandidateSelectionStrategy extends AbstractEntityOwnerSelectionStrategy {
-    private static final Logger LOG = LoggerFactory.getLogger(LeastLoadedCandidateSelectionStrategy.class);
-
-    private Map<String, Long> localStatistics = new HashMap<>();
+    private final Map<String, Long> localStatistics = new HashMap<>();
 
     protected LeastLoadedCandidateSelectionStrategy(long selectionDelayInMillis, Map<String, Long> initialStatistics) {
         super(selectionDelayInMillis, initialStatistics);
@@ -39,20 +35,20 @@ public class LeastLoadedCandidateSelectionStrategy extends AbstractEntityOwnerSe
         String leastLoadedCandidate = null;
         long leastLoadedCount = Long.MAX_VALUE;
 
-        if(!Strings.isNullOrEmpty(currentOwner)){
+        if (!Strings.isNullOrEmpty(currentOwner)) {
             long localVal = MoreObjects.firstNonNull(localStatistics.get(currentOwner), 0L);
             localStatistics.put(currentOwner, localVal - 1);
         }
 
-        for(String candidateName : viableCandidates){
+        for (String candidateName : viableCandidates) {
             long val = MoreObjects.firstNonNull(localStatistics.get(candidateName), 0L);
-            if(val < leastLoadedCount){
+            if (val < leastLoadedCount) {
                 leastLoadedCount = val;
                 leastLoadedCandidate = candidateName;
             }
         }
 
-        if(leastLoadedCandidate == null){
+        if (leastLoadedCandidate == null) {
             leastLoadedCandidate = viableCandidates.iterator().next();
         }
 
@@ -61,7 +57,7 @@ public class LeastLoadedCandidateSelectionStrategy extends AbstractEntityOwnerSe
     }
 
     @VisibleForTesting
-    Map<String, Long> getLocalStatistics(){
+    Map<String, Long> getLocalStatistics() {
         return localStatistics;
     }
 }