move all allocations to be Decision base

kimchy · kimchy · commit 2c7850584d09 · 2012-10-16T10:10:06.000-04:00
this again will allow to provide better output as to why a specific decision has been made (like a shard needing to move from a node)
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/AllocationService.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/AllocationService.java
@@ -28,6 +28,7 @@
 import org.elasticsearch.cluster.routing.allocation.allocator.ShardsAllocators;
 import org.elasticsearch.cluster.routing.allocation.command.AllocationCommands;
 import org.elasticsearch.cluster.routing.allocation.decider.AllocationDeciders;
+import org.elasticsearch.cluster.routing.allocation.decider.Decision;
 import org.elasticsearch.common.component.AbstractComponent;
 import org.elasticsearch.common.inject.Inject;
 import org.elasticsearch.common.settings.ImmutableSettings;
@@ -223,7 +224,8 @@ private boolean moveShards(RoutingAllocation allocation) {
                 continue;
             }
             RoutingNode routingNode = allocation.routingNodes().node(shardRouting.currentNodeId());
-            if (!allocation.deciders().canRemain(shardRouting, routingNode, allocation)) {
+            Decision decision = allocation.deciders().canRemain(shardRouting, routingNode, allocation);
+            if (decision.type() == Decision.Type.NO) {
                 logger.debug("[{}][{}] allocated on [{}], but can no longer be allocated on it, moving...", shardRouting.index(), shardRouting.id(), routingNode.node());
                 boolean moved = shardsAllocators.move(shardRouting, routingNode, allocation);
                 if (!moved) {
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/allocator/EvenShardsCountAllocator.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/allocator/EvenShardsCountAllocator.java
@@ -141,12 +141,13 @@ public boolean rebalance(RoutingAllocation allocation) {
                 boolean relocated = false;
                 List<MutableShardRouting> startedShards = highRoutingNode.shardsWithState(STARTED);
                 for (MutableShardRouting startedShard : startedShards) {
-                    if (!allocation.deciders().canRebalance(startedShard, allocation)) {
+                    Decision rebalanceDecision = allocation.deciders().canRebalance(startedShard, allocation);
+                    if (rebalanceDecision.type() == Decision.Type.NO) {
                         continue;
                     }
 
-                    Decision decision = allocation.deciders().canAllocate(startedShard, lowRoutingNode, allocation);
-                    if (decision.type() == Decision.Type.YES) {
+                    Decision allocateDecision = allocation.deciders().canAllocate(startedShard, lowRoutingNode, allocation);
+                    if (allocateDecision.type() == Decision.Type.YES) {
                         changed = true;
                         lowRoutingNode.add(new MutableShardRouting(startedShard.index(), startedShard.id(),
                                 lowRoutingNode.nodeId(), startedShard.currentNodeId(),
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/AllocationDecider.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/AllocationDecider.java
@@ -34,18 +34,24 @@ protected AllocationDecider(Settings settings) {
         super(settings);
     }
 
-    public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
-        return true;
+    /**
+     * Are we allowed to rebalance this shard?
+     */
+    public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
+        return Decision.ALWAYS;
     }
 
+    /**
+     * Can the provided shard routing be allocated on the node.
+     */
     public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
         return Decision.ALWAYS;
     }
 
     /**
      * Can the provided shard routing remain on the node?
      */
-    public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
-        return true;
+    public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+        return Decision.ALWAYS;
     }
 }
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/AllocationDeciders.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/AllocationDeciders.java
@@ -59,13 +59,15 @@ public AllocationDeciders(Settings settings, Set<AllocationDecider> allocations)
     }
 
     @Override
-    public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
-        for (AllocationDecider allocation1 : allocations) {
-            if (!allocation1.canRebalance(shardRouting, allocation)) {
-                return false;
+    public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
+        Decision.Multi ret = new Decision.Multi();
+        for (AllocationDecider allocationDecider : allocations) {
+            Decision decision = allocationDecider.canRebalance(shardRouting, allocation);
+            if (decision != Decision.ALWAYS) {
+                ret.add(decision);
             }
         }
-        return true;
+        return ret;
     }
 
     @Override
@@ -86,15 +88,17 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
     }
 
     @Override
-    public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+    public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
         if (allocation.shouldIgnoreShardForNode(shardRouting.shardId(), node.nodeId())) {
-            return false;
+            return Decision.NO;
         }
-        for (AllocationDecider allocation1 : allocations) {
-            if (!allocation1.canRemain(shardRouting, node, allocation)) {
-                return false;
+        Decision.Multi ret = new Decision.Multi();
+        for (AllocationDecider allocationDecider : allocations) {
+            Decision decision = allocationDecider.canRemain(shardRouting, node, allocation);
+            if (decision != Decision.ALWAYS) {
+                ret.add(decision);
             }
         }
-        return true;
+        return ret;
     }
 }
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java
@@ -107,8 +107,8 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
     }
 
     @Override
-    public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
-        return underCapacity(shardRouting, node, allocation, false);
+    public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+        return underCapacity(shardRouting, node, allocation, false) ? Decision.YES : Decision.NO;
     }
 
     private boolean underCapacity(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation, boolean moveToNode) {
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/ClusterRebalanceAllocationDecider.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/ClusterRebalanceAllocationDecider.java
@@ -56,39 +56,39 @@ public ClusterRebalanceAllocationDecider(Settings settings) {
     }
 
     @Override
-    public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
+    public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
         if (type == ClusterRebalanceType.INDICES_PRIMARIES_ACTIVE) {
             for (MutableShardRouting shard : allocation.routingNodes().unassigned()) {
                 if (shard.primary()) {
-                    return false;
+                    return Decision.NO;
                 }
             }
             for (RoutingNode node : allocation.routingNodes()) {
                 List<MutableShardRouting> shards = node.shards();
                 for (int i = 0; i < shards.size(); i++) {
                     MutableShardRouting shard = shards.get(i);
                     if (shard.primary() && !shard.active() && shard.relocatingNodeId() == null) {
-                        return false;
+                        return Decision.NO;
                     }
                 }
             }
-            return true;
+            return Decision.YES;
         }
         if (type == ClusterRebalanceType.INDICES_ALL_ACTIVE) {
             if (!allocation.routingNodes().unassigned().isEmpty()) {
-                return false;
+                return Decision.NO;
             }
             for (RoutingNode node : allocation.routingNodes()) {
                 List<MutableShardRouting> shards = node.shards();
                 for (int i = 0; i < shards.size(); i++) {
                     MutableShardRouting shard = shards.get(i);
                     if (!shard.active() && shard.relocatingNodeId() == null) {
-                        return false;
+                        return Decision.NO;
                     }
                 }
             }
         }
         // type == Type.ALWAYS
-        return true;
+        return Decision.YES;
     }
 }
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/ConcurrentRebalanceAllocationDecider.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/ConcurrentRebalanceAllocationDecider.java
@@ -61,9 +61,9 @@ public ConcurrentRebalanceAllocationDecider(Settings settings, NodeSettingsServi
     }
 
     @Override
-    public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
+    public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
         if (clusterConcurrentRebalance == -1) {
-            return true;
+            return Decision.YES;
         }
         int rebalance = 0;
         for (RoutingNode node : allocation.routingNodes()) {
@@ -75,8 +75,8 @@ public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocat
             }
         }
         if (rebalance >= clusterConcurrentRebalance) {
-            return false;
+            return Decision.NO;
         }
-        return true;
+        return Decision.YES;
     }
 }
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/FilterAllocationDecider.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/FilterAllocationDecider.java
@@ -72,8 +72,8 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
     }
 
     @Override
-    public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
-        return !shouldFilter(shardRouting, node, allocation);
+    public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+        return shouldFilter(shardRouting, node, allocation) ? Decision.NO : Decision.YES;
     }
 
     private boolean shouldFilter(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/RebalanceOnlyWhenActiveAllocationDecider.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/RebalanceOnlyWhenActiveAllocationDecider.java
@@ -38,15 +38,15 @@ public RebalanceOnlyWhenActiveAllocationDecider(Settings settings) {
     }
 
     @Override
-    public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
+    public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
         List<MutableShardRouting> shards = allocation.routingNodes().shardsRoutingFor(shardRouting);
         // its ok to check for active here, since in relocation, a shard is split into two in routing
         // nodes, once relocating, and one initializing
         for (int i = 0; i < shards.size(); i++) {
             if (!shards.get(i).active()) {
-                return false;
+                return Decision.NO;
             }
         }
-        return true;
+        return Decision.YES;
     }
 }
diff --git a/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/ShardsLimitAllocationDecider.java b/src/main/java/org/elasticsearch/cluster/routing/allocation/decider/ShardsLimitAllocationDecider.java
@@ -75,11 +75,11 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
     }
 
     @Override
-    public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+    public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
         IndexMetaData indexMd = allocation.routingNodes().metaData().index(shardRouting.index());
         int totalShardsPerNode = indexMd.settings().getAsInt(INDEX_TOTAL_SHARDS_PER_NODE, -1);
         if (totalShardsPerNode <= 0) {
-            return true;
+            return Decision.YES;
         }
 
         int nodeCount = 0;
@@ -96,8 +96,8 @@ public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAll
             nodeCount++;
         }
         if (nodeCount > totalShardsPerNode) {
-            return false;
+            return Decision.NO;
         }
-        return true;
+        return Decision.YES;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -34,18 +34,24 @@ protected AllocationDecider(Settings settings) {`
`34`	`34`	`super(settings);`
`35`	`35`	`}`
`36`	`36`
`37`		`- public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
`38`		`- return true;`
	`37`	`+ /**`
	`38`	`+ * Are we allowed to rebalance this shard?`
	`39`	`+ */`
	`40`	`+ public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
	`41`	`+ return Decision.ALWAYS;`
`39`	`42`	`}`
`40`	`43`
	`44`	`+ /**`
	`45`	`+ * Can the provided shard routing be allocated on the node.`
	`46`	`+ */`
`41`	`47`	`public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
`42`	`48`	`return Decision.ALWAYS;`
`43`	`49`	`}`
`44`	`50`
`45`	`51`	`/**`
`46`	`52`	`* Can the provided shard routing remain on the node?`
`47`	`53`	`*/`
`48`		`- public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
`49`		`- return true;`
	`54`	`+ public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
	`55`	`+ return Decision.ALWAYS;`
`50`	`56`	`}`
`51`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,13 +59,15 @@ public AllocationDeciders(Settings settings, Set<AllocationDecider> allocations)`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`@Override`
`62`		`- public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
`63`		`- for (AllocationDecider allocation1 : allocations) {`
`64`		`- if (!allocation1.canRebalance(shardRouting, allocation)) {`
`65`		`- return false;`
	`62`	`+ public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
	`63`	`+ Decision.Multi ret = new Decision.Multi();`
	`64`	`+ for (AllocationDecider allocationDecider : allocations) {`
	`65`	`+ Decision decision = allocationDecider.canRebalance(shardRouting, allocation);`
	`66`	`+ if (decision != Decision.ALWAYS) {`
	`67`	`+ ret.add(decision);`
`66`	`68`	`}`
`67`	`69`	`}`
`68`		`- return true;`
	`70`	`+ return ret;`
`69`	`71`	`}`
`70`	`72`
`71`	`73`	`@Override`
`@@ -86,15 +88,17 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing`
`86`	`88`	`}`
`87`	`89`
`88`	`90`	`@Override`
`89`		`- public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
	`91`	`+ public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
`90`	`92`	`if (allocation.shouldIgnoreShardForNode(shardRouting.shardId(), node.nodeId())) {`
`91`		`- return false;`
	`93`	`+ return Decision.NO;`
`92`	`94`	`}`
`93`		`- for (AllocationDecider allocation1 : allocations) {`
`94`		`- if (!allocation1.canRemain(shardRouting, node, allocation)) {`
`95`		`- return false;`
	`95`	`+ Decision.Multi ret = new Decision.Multi();`
	`96`	`+ for (AllocationDecider allocationDecider : allocations) {`
	`97`	`+ Decision decision = allocationDecider.canRemain(shardRouting, node, allocation);`
	`98`	`+ if (decision != Decision.ALWAYS) {`
	`99`	`+ ret.add(decision);`
`96`	`100`	`}`
`97`	`101`	`}`
`98`		`- return true;`
	`102`	`+ return ret;`
`99`	`103`	`}`
`100`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -107,8 +107,8 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`@Override`
`110`		`- public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
`111`		`- return underCapacity(shardRouting, node, allocation, false);`
	`110`	`+ public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
	`111`	`+ return underCapacity(shardRouting, node, allocation, false) ? Decision.YES : Decision.NO;`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`private boolean underCapacity(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation, boolean moveToNode) {`
Original file line number	Diff line number	Diff line change
`@@ -56,39 +56,39 @@ public ClusterRebalanceAllocationDecider(Settings settings) {`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`@Override`
`59`		`- public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
	`59`	`+ public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
`60`	`60`	`if (type == ClusterRebalanceType.INDICES_PRIMARIES_ACTIVE) {`
`61`	`61`	`for (MutableShardRouting shard : allocation.routingNodes().unassigned()) {`
`62`	`62`	`if (shard.primary()) {`
`63`		`- return false;`
	`63`	`+ return Decision.NO;`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`	`for (RoutingNode node : allocation.routingNodes()) {`
`67`	`67`	`List<MutableShardRouting> shards = node.shards();`
`68`	`68`	`for (int i = 0; i < shards.size(); i++) {`
`69`	`69`	`MutableShardRouting shard = shards.get(i);`
`70`	`70`	`if (shard.primary() && !shard.active() && shard.relocatingNodeId() == null) {`
`71`		`- return false;`
	`71`	`+ return Decision.NO;`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`	`}`
`75`		`- return true;`
	`75`	`+ return Decision.YES;`
`76`	`76`	`}`
`77`	`77`	`if (type == ClusterRebalanceType.INDICES_ALL_ACTIVE) {`
`78`	`78`	`if (!allocation.routingNodes().unassigned().isEmpty()) {`
`79`		`- return false;`
	`79`	`+ return Decision.NO;`
`80`	`80`	`}`
`81`	`81`	`for (RoutingNode node : allocation.routingNodes()) {`
`82`	`82`	`List<MutableShardRouting> shards = node.shards();`
`83`	`83`	`for (int i = 0; i < shards.size(); i++) {`
`84`	`84`	`MutableShardRouting shard = shards.get(i);`
`85`	`85`	`if (!shard.active() && shard.relocatingNodeId() == null) {`
`86`		`- return false;`
	`86`	`+ return Decision.NO;`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`// type == Type.ALWAYS`
`92`		`- return true;`
	`92`	`+ return Decision.YES;`
`93`	`93`	`}`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,9 +61,9 @@ public ConcurrentRebalanceAllocationDecider(Settings settings, NodeSettingsServi`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`@Override`
`64`		`- public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
	`64`	`+ public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
`65`	`65`	`if (clusterConcurrentRebalance == -1) {`
`66`		`- return true;`
	`66`	`+ return Decision.YES;`
`67`	`67`	`}`
`68`	`68`	`int rebalance = 0;`
`69`	`69`	`for (RoutingNode node : allocation.routingNodes()) {`
`@@ -75,8 +75,8 @@ public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocat`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`if (rebalance >= clusterConcurrentRebalance) {`
`78`		`- return false;`
	`78`	`+ return Decision.NO;`
`79`	`79`	`}`
`80`		`- return true;`
	`80`	`+ return Decision.YES;`
`81`	`81`	`}`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,8 +72,8 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`@Override`
`75`		`- public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
`76`		`- return !shouldFilter(shardRouting, node, allocation);`
	`75`	`+ public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
	`76`	`+ return shouldFilter(shardRouting, node, allocation) ? Decision.NO : Decision.YES;`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`private boolean shouldFilter(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
Original file line number	Diff line number	Diff line change
`@@ -38,15 +38,15 @@ public RebalanceOnlyWhenActiveAllocationDecider(Settings settings) {`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`@Override`
`41`		`- public boolean canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
	`41`	`+ public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {`
`42`	`42`	`List<MutableShardRouting> shards = allocation.routingNodes().shardsRoutingFor(shardRouting);`
`43`	`43`	`// its ok to check for active here, since in relocation, a shard is split into two in routing`
`44`	`44`	`// nodes, once relocating, and one initializing`
`45`	`45`	`for (int i = 0; i < shards.size(); i++) {`
`46`	`46`	`if (!shards.get(i).active()) {`
`47`		`- return false;`
	`47`	`+ return Decision.NO;`
`48`	`48`	`}`
`49`	`49`	`}`
`50`		`- return true;`
	`50`	`+ return Decision.YES;`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,11 +75,11 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`@Override`
`78`		`- public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
	`78`	`+ public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {`
`79`	`79`	`IndexMetaData indexMd = allocation.routingNodes().metaData().index(shardRouting.index());`
`80`	`80`	`int totalShardsPerNode = indexMd.settings().getAsInt(INDEX_TOTAL_SHARDS_PER_NODE, -1);`
`81`	`81`	`if (totalShardsPerNode <= 0) {`
`82`		`- return true;`
	`82`	`+ return Decision.YES;`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`int nodeCount = 0;`
`@@ -96,8 +96,8 @@ public boolean canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAll`
`96`	`96`	`nodeCount++;`
`97`	`97`	`}`
`98`	`98`	`if (nodeCount > totalShardsPerNode) {`
`99`		`- return false;`
	`99`	`+ return Decision.NO;`
`100`	`100`	`}`
`101`		`- return true;`
	`101`	`+ return Decision.YES;`
`102`	`102`	`}`
`103`	`103`	`}`