Remove Dead Code + Duplication in o.e.c.routing (elastic#36678)

* Removed obviously unused fields+methods
* Inlined public methods that only had one caller
* Simplified `Optional` chain
* Simplified some obviously redundant conditions

Author: original-brownbear

server/src/main/java/org/elasticsearch/cluster/routing/OperationRouting.java

@@ -19,8 +19,6 @@
 
 package org.elasticsearch.cluster.routing;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.elasticsearch.Version;
 import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.metadata.IndexMetaData;
@@ -33,7 +31,6 @@
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.index.IndexNotFoundException;
 import org.elasticsearch.index.shard.ShardId;
-import org.elasticsearch.index.shard.ShardNotFoundException;
 import org.elasticsearch.node.ResponseCollectorService;
 
 import java.util.ArrayList;
@@ -47,8 +44,6 @@
 
 public class OperationRouting {
 
-    private static final Logger logger = LogManager.getLogger(OperationRouting.class);
-
     public static final Setting<Boolean> USE_ADAPTIVE_REPLICA_SELECTION_SETTING =
             Setting.boolSetting("cluster.routing.use_adaptive_replica_selection", true,
                     Setting.Property.Dynamic, Setting.Property.NodeScope);
@@ -129,7 +124,7 @@ private Set<IndexShardRoutingTable> computeTargetedShards(ClusterState clusterSt
                 for (String r : effectiveRouting) {
                     final int routingPartitionSize = indexMetaData.getRoutingPartitionSize();
                     for (int partitionOffset = 0; partitionOffset < routingPartitionSize; partitionOffset++) {
-                        set.add(shardRoutingTable(indexRouting, calculateScaledShardId(indexMetaData, r, partitionOffset)));
+                        set.add(RoutingTable.shardRoutingTable(indexRouting, calculateScaledShardId(indexMetaData, r, partitionOffset)));
                     }
                 }
             } else {
@@ -146,15 +141,7 @@ private ShardIterator preferenceActiveShardIterator(IndexShardRoutingTable index
                                                         @Nullable ResponseCollectorService collectorService,
                                                         @Nullable Map<String, Long> nodeCounts) {
         if (preference == null || preference.isEmpty()) {
-            if (awarenessAttributes.isEmpty()) {
-                if (useAdaptiveReplicaSelection) {
-                    return indexShard.activeInitializingShardsRankedIt(collectorService, nodeCounts);
-                } else {
-                    return indexShard.activeInitializingShardsRandomIt();
-                }
-            } else {
-                return indexShard.preferAttributesActiveInitializingShardsIt(awarenessAttributes, nodes);
-            }
+            return shardRoutings(indexShard, nodes, collectorService, nodeCounts);
         }
         if (preference.charAt(0) == '_') {
             Preference preferenceType = Preference.parse(preference);
@@ -181,15 +168,7 @@ private ShardIterator preferenceActiveShardIterator(IndexShardRoutingTable index
                 }
                 // no more preference
                 if (index == -1 || index == preference.length() - 1) {
-                    if (awarenessAttributes.isEmpty()) {
-                        if (useAdaptiveReplicaSelection) {
-                            return indexShard.activeInitializingShardsRankedIt(collectorService, nodeCounts);
-                        } else {
-                            return indexShard.activeInitializingShardsRandomIt();
-                        }
-                    } else {
-                        return indexShard.preferAttributesActiveInitializingShardsIt(awarenessAttributes, nodes);
-                    }
+                    return shardRoutings(indexShard, nodes, collectorService, nodeCounts);
                 } else {
                     // update the preference and continue
                     preference = preference.substring(index + 1);
@@ -232,12 +211,17 @@ private ShardIterator preferenceActiveShardIterator(IndexShardRoutingTable index
         }
     }
 
-    private IndexShardRoutingTable shardRoutingTable(IndexRoutingTable indexRouting, int shardId) {
-        IndexShardRoutingTable indexShard = indexRouting.shard(shardId);
-        if (indexShard == null) {
-            throw new ShardNotFoundException(new ShardId(indexRouting.getIndex(), shardId));
+    private ShardIterator shardRoutings(IndexShardRoutingTable indexShard, DiscoveryNodes nodes,
+            @Nullable ResponseCollectorService collectorService, @Nullable Map<String, Long> nodeCounts) {
+        if (awarenessAttributes.isEmpty()) {
+            if (useAdaptiveReplicaSelection) {
+                return indexShard.activeInitializingShardsRankedIt(collectorService, nodeCounts);
+            } else {
+                return indexShard.activeInitializingShardsRandomIt();
+            }
+        } else {
+            return indexShard.preferAttributesActiveInitializingShardsIt(awarenessAttributes, nodes);
         }
-        return indexShard;
     }
 
     protected IndexRoutingTable indexRoutingTable(ClusterState clusterState, String index) {

server/src/main/java/org/elasticsearch/cluster/routing/RoutingChangesObserver.java

@@ -59,11 +59,6 @@ public interface RoutingChangesObserver {
      */
     void relocationSourceRemoved(ShardRouting removedReplicaRelocationSource);
 
-    /**
-     * Called on started primary shard after it has been promoted from replica to primary and is reinitialized due to shadow replicas.
-     */
-    void startedPrimaryReinitialized(ShardRouting startedPrimaryShard, ShardRouting initializedShard);
-
     /**
      * Called when started replica is promoted to primary.
      */
@@ -117,11 +112,6 @@ public void relocationSourceRemoved(ShardRouting removedReplicaRelocationSource)
 
         }
 
-        @Override
-        public void startedPrimaryReinitialized(ShardRouting startedPrimaryShard, ShardRouting initializedShard) {
-
-        }
-
         @Override
         public void replicaPromoted(ShardRouting replicaShard) {
 
@@ -190,13 +180,6 @@ public void relocationSourceRemoved(ShardRouting removedReplicaRelocationSource)
             }
         }
 
-        @Override
-        public void startedPrimaryReinitialized(ShardRouting startedPrimaryShard, ShardRouting initializedShard) {
-            for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {
-                routingChangesObserver.startedPrimaryReinitialized(startedPrimaryShard, initializedShard);
-            }
-        }
-
         @Override
         public void replicaPromoted(ShardRouting replicaShard) {
             for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {

server/src/main/java/org/elasticsearch/cluster/routing/RoutingException.java

@@ -29,15 +29,11 @@
  */
 public class RoutingException extends ElasticsearchException {
 
-    public RoutingException(String message) {
-        super(message);
-    }
-
     public RoutingException(String message, Throwable cause) {
         super(message, cause);
     }
 
     public RoutingException(StreamInput in) throws IOException{
         super(in);
     }
-}
+}

server/src/main/java/org/elasticsearch/cluster/routing/RoutingNodes.java

@@ -577,13 +577,7 @@ assert getByAllocationId(failedShard.shardId(), failedShard.allocationId().getId
             if (failedShard.relocatingNodeId() == null) {
                 if (failedShard.primary()) {
                     // promote active replica to primary if active replica exists (only the case for shadow replicas)
-                    ShardRouting activeReplica = activeReplicaWithHighestVersion(failedShard.shardId());
-                    if (activeReplica == null) {
-                        moveToUnassigned(failedShard, unassignedInfo);
-                    } else {
-                        movePrimaryToUnassignedAndDemoteToReplica(failedShard, unassignedInfo);
-                        promoteReplicaToPrimary(activeReplica, routingChangesObserver);
-                    }
+                    unassignPrimaryAndPromoteActiveReplicaIfExists(failedShard, unassignedInfo, routingChangesObserver);
                 } else {
                     // initializing shard that is not relocation target, just move to unassigned
                     moveToUnassigned(failedShard, unassignedInfo);
@@ -601,32 +595,36 @@ assert getByAllocationId(failedShard.shardId(), failedShard.allocationId().getId
                 cancelRelocation(sourceShard);
                 remove(failedShard);
             }
-            routingChangesObserver.shardFailed(failedShard, unassignedInfo);
         } else {
             assert failedShard.active();
             if (failedShard.primary()) {
                 // promote active replica to primary if active replica exists
-                ShardRouting activeReplica = activeReplicaWithHighestVersion(failedShard.shardId());
-                if (activeReplica == null) {
-                    moveToUnassigned(failedShard, unassignedInfo);
-                } else {
-                    movePrimaryToUnassignedAndDemoteToReplica(failedShard, unassignedInfo);
-                    promoteReplicaToPrimary(activeReplica, routingChangesObserver);
-                }
+                unassignPrimaryAndPromoteActiveReplicaIfExists(failedShard, unassignedInfo, routingChangesObserver);
             } else {
-                assert failedShard.primary() == false;
                 if (failedShard.relocating()) {
                     remove(failedShard);
                 } else {
                     moveToUnassigned(failedShard, unassignedInfo);
                 }
             }
-            routingChangesObserver.shardFailed(failedShard, unassignedInfo);
         }
+        routingChangesObserver.shardFailed(failedShard, unassignedInfo);
         assert node(failedShard.currentNodeId()).getByShardId(failedShard.shardId()) == null : "failedShard " + failedShard +
             " was matched but wasn't removed";
     }
 
+    private void unassignPrimaryAndPromoteActiveReplicaIfExists(ShardRouting failedShard, UnassignedInfo unassignedInfo,
+                                                                RoutingChangesObserver routingChangesObserver) {
+        assert failedShard.primary();
+        ShardRouting activeReplica = activeReplicaWithHighestVersion(failedShard.shardId());
+        if (activeReplica == null) {
+            moveToUnassigned(failedShard, unassignedInfo);
+        } else {
+            movePrimaryToUnassignedAndDemoteToReplica(failedShard, unassignedInfo);
+            promoteReplicaToPrimary(activeReplica, routingChangesObserver);
+        }
+    }
+
     private void promoteReplicaToPrimary(ShardRouting activeReplica, RoutingChangesObserver routingChangesObserver) {
         // if the activeReplica was relocating before this call to failShard, its relocation was cancelled earlier when we
         // failed initializing replica shards (and moved replica relocation source back to started)
@@ -1168,10 +1166,6 @@ private static final class Recoveries {
         private int incoming = 0;
         private int outgoing = 0;
 
-        int getTotal() {
-            return incoming + outgoing;
-        }
-
         void addOutgoing(int howMany) {
             assert outgoing + howMany >= 0 : outgoing + howMany+ " must be >= 0";
             outgoing += howMany;