import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
private boolean waitingShardsStartedOrUnassigned(ClusterChangedEvent event) {
    SnapshotsInProgress curr = event.state().custom(SnapshotsInProgress.TYPE);
    if (curr != null) {
        for (SnapshotsInProgress.Entry entry : curr.entries()) {
            if (entry.state() == State.STARTED && !entry.waitingIndices().isEmpty()) {
                for (ObjectCursor<String> index : entry.waitingIndices().keys()) {
                    if (event.indexRoutingTableChanged(index.value)) {
                        IndexRoutingTable indexShardRoutingTable = event.state().getRoutingTable().index(index.value);
                        for (ShardId shardId : entry.waitingIndices().get(index.value)) {
                            ShardRouting shardRouting = indexShardRoutingTable.shard(shardId.id()).primaryShard();
                            if (shardRouting != null && (shardRouting.started() || shardRouting.unassigned())) {
                                return true;
                            }
                        }
                    }
                }
            }
        }
    }
    return false;
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
private RoutingAllocation onePrimaryOnNode1And1ReplicaRecovering(AllocationDeciders deciders) {
    ShardRouting primaryShard = TestShardRouting.newShardRouting(shardId, node1.getId(), true, ShardRoutingState.STARTED);
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder(shardId.getIndexName()).settings(settings(Version.CURRENT))
                .numberOfShards(1).numberOfReplicas(1)
                .putInSyncAllocationIds(0, Sets.newHashSet(primaryShard.allocationId().getId())))
            .build();
    RoutingTable routingTable = RoutingTable.builder()
            .add(IndexRoutingTable.builder(shardId.getIndex())
                            .addIndexShard(new IndexShardRoutingTable.Builder(shardId)
                                    .addShard(primaryShard)
                                    .addShard(TestShardRouting.newShardRouting(shardId, node2.getId(), null, false, ShardRoutingState.INITIALIZING, new UnassignedInfo(UnassignedInfo.Reason.CLUSTER_RECOVERED, null)))
                                    .build())
            )
            .build();
    ClusterState state = ClusterState.builder(org.elasticsearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
            .metaData(metaData)
            .routingTable(routingTable)
            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3)).build();
    return new RoutingAllocation(deciders, new RoutingNodes(state, false), state, ClusterInfo.EMPTY, System.nanoTime(), false);
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
private ClusterState startPrimaries(final ClusterState clusterState, final String indexName) {
    RoutingTable routingTable = clusterState.routingTable();
    IndexRoutingTable indexRoutingTable = routingTable.index(indexName);
    IndexRoutingTable.Builder newIndexRoutingTable = IndexRoutingTable.builder(indexRoutingTable.getIndex());
    for (final ObjectCursor<IndexShardRoutingTable> shardEntry : indexRoutingTable.getShards().values()) {
        final IndexShardRoutingTable shardRoutingTable = shardEntry.value;
        for (ShardRouting shardRouting : shardRoutingTable.getShards()) {
            if (shardRouting.primary()) {
                shardRouting = shardRouting.initialize(randomAsciiOfLength(8), null, shardRouting.getExpectedShardSize())
                                   .moveToStarted();
            }
            newIndexRoutingTable.addShard(shardRouting);
        }
    }
    routingTable = RoutingTable.builder(routingTable).add(newIndexRoutingTable).build();
    return ClusterState.builder(clusterState).routingTable(routingTable).build();
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
private ClusterState startAllShards(final ClusterState clusterState, final String indexName) {
    RoutingTable routingTable = clusterState.routingTable();
    IndexRoutingTable indexRoutingTable = routingTable.index(indexName);
    IndexRoutingTable.Builder newIndexRoutingTable = IndexRoutingTable.builder(indexRoutingTable.getIndex());
    for (final ObjectCursor<IndexShardRoutingTable> shardEntry : indexRoutingTable.getShards().values()) {
        final IndexShardRoutingTable shardRoutingTable = shardEntry.value;
        for (ShardRouting shardRouting : shardRoutingTable.getShards()) {
            if (shardRouting.primary()) {
                assertTrue(shardRouting.active());
            } else {
                if (shardRouting.active() == false) {
                    shardRouting = shardRouting.initialize(randomAsciiOfLength(8), null, shardRouting.getExpectedShardSize())
                                       .moveToStarted();
                }
            }
            newIndexRoutingTable.addShard(shardRouting);
        }
    }
    routingTable = RoutingTable.builder(routingTable).add(newIndexRoutingTable).build();
    return ClusterState.builder(clusterState).routingTable(routingTable).build();
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
@Override
public void clusterChanged(ClusterChangedEvent event) {
    if (!event.routingTableChanged()) {
        return;
    }

    if (event.state().blocks().disableStatePersistence()) {
        return;
    }

    for (IndexRoutingTable indexRoutingTable : event.state().routingTable()) {
        // Note, closed indices will not have any routing information, so won't be deleted
        for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
            if (shardCanBeDeleted(event.state(), indexShardRoutingTable)) {
                ShardId shardId = indexShardRoutingTable.shardId();
                if (indicesService.canDeleteShardContent(shardId, event.state().getMetaData().index(shardId.getIndex()))) {
                    deleteShardIfExistElseWhere(event.state(), indexShardRoutingTable);
                }
            }
        }
    }
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
private boolean waitingShardsStartedOrUnassigned(ClusterChangedEvent event) {
    SnapshotsInProgress curr = event.state().custom(SnapshotsInProgress.TYPE);
    if (curr != null) {
        for (SnapshotsInProgress.Entry entry : curr.entries()) {
            if (entry.state() == State.STARTED && !entry.waitingIndices().isEmpty()) {
                for (String index : entry.waitingIndices().keySet()) {
                    if (event.indexRoutingTableChanged(index)) {
                        IndexRoutingTable indexShardRoutingTable = event.state().getRoutingTable().index(index);
                        for (ShardId shardId : entry.waitingIndices().get(index)) {
                            ShardRouting shardRouting = indexShardRoutingTable.shard(shardId.id()).primaryShard();
                            if (shardRouting != null && (shardRouting.started() || shardRouting.unassigned())) {
                                return true;
                            }
                        }
                    }
                }
            }
        }
    }
    return false;
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
/**
 * Asserts that all shards are allocated on nodes matching the given node pattern.
 */
public Set<String> assertAllShardsOnNodes(final String index, final String... pattern) {
    final Set<String> nodes = new HashSet<>();
    final ClusterState clusterState = client().admin().cluster().prepareState().execute().actionGet().getState();
    for (final IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
        for (final IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
            for (final ShardRouting shardRouting : indexShardRoutingTable) {
                if (shardRouting.currentNodeId() != null && index.equals(shardRouting.getIndex())) {
                    final String name = clusterState.nodes().get(shardRouting.currentNodeId()).name();
                    nodes.add(name);
                    assertThat("Allocated on new node: " + name, Regex.simpleMatch(pattern, name), is(true));
                }
            }
        }
    }
    return nodes;
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
/**
 * Asserts that all shards are allocated on nodes matching the given node pattern.
 */
public Set<String> assertAllShardsOnNodes(String index, String... pattern) {
    Set<String> nodes = new HashSet<>();
    ClusterState clusterState = client().admin().cluster().prepareState().execute().actionGet().getState();
    for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
        for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
            for (ShardRouting shardRouting : indexShardRoutingTable) {
                if (shardRouting.currentNodeId() != null && index.equals(shardRouting.getIndexName())) {
                    String name = clusterState.nodes().get(shardRouting.currentNodeId()).getName();
                    nodes.add(name);
                    assertThat("Allocated on new node: " + name, Regex.simpleMatch(pattern, name), is(true));
                }
            }
        }
    }
    return nodes;
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
private ImmutableOpenMap<ShardId, ShardSnapshotStatus> processWaitingShards(
        ImmutableOpenMap<ShardId, ShardSnapshotStatus> snapshotShards, RoutingTable routingTable) {
    boolean snapshotChanged = false;
    ImmutableOpenMap.Builder<ShardId, ShardSnapshotStatus> shards = ImmutableOpenMap.builder();
    for (ObjectObjectCursor<ShardId, ShardSnapshotStatus> shardEntry : snapshotShards) {
        ShardSnapshotStatus shardStatus = shardEntry.value;
        ShardId shardId = shardEntry.key;
        if (shardStatus.state() == State.WAITING) {
            IndexRoutingTable indexShardRoutingTable = routingTable.index(shardId.getIndex());
            if (indexShardRoutingTable != null) {
                IndexShardRoutingTable shardRouting = indexShardRoutingTable.shard(shardId.id());
                if (shardRouting != null && shardRouting.primaryShard() != null) {
                    if (shardRouting.primaryShard().started()) {
                        // Shard that we were waiting for has started on a node, let's process it
                        snapshotChanged = true;
                        logger.trace("starting shard that we were waiting for [{}] on node [{}]", shardId, shardStatus.nodeId());
                        shards.put(shardId, new ShardSnapshotStatus(shardRouting.primaryShard().currentNodeId()));
                        continue;
                    } else if (shardRouting.primaryShard().initializing() || shardRouting.primaryShard().relocating()) {
                        // Shard that we were waiting for hasn't started yet or still relocating - will continue to wait
                        shards.put(shardId, shardStatus);
                        continue;
                    }
                }
            }
            // Shard that we were waiting for went into unassigned state or disappeared - giving up
            snapshotChanged = true;
            logger.warn("failing snapshot of shard [{}] on unassigned shard [{}]", shardId, shardStatus.nodeId());
            shards.put(shardId, new ShardSnapshotStatus(shardStatus.nodeId(), State.FAILED, "shard is unassigned"));
        } else {
            shards.put(shardId, shardStatus);
        }
    }
    if (snapshotChanged) {
        return shards.build();
    } else {
        return null;
    }
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
/**
 * Finds all indices that have not all primaries available
 */
private Set<String> indicesWithMissingPrimaries(ClusterState clusterState, String[] concreteIndices) {
    Set<String> indices = new HashSet<>();
    RoutingTable routingTable = clusterState.routingTable();
    for (String index : concreteIndices) {
        IndexRoutingTable indexRoutingTable = routingTable.index(index);
        if (indexRoutingTable.allPrimaryShardsActive() == false) {
            indices.add(index);
        }
    }
    return indices;
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
@Override
protected void masterOperation(IndicesShardStoresRequest request, ClusterState state, ActionListener<IndicesShardStoresResponse> listener) {
    final RoutingTable routingTables = state.routingTable();
    final RoutingNodes routingNodes = state.getRoutingNodes();
    final String[] concreteIndices = indexNameExpressionResolver.concreteIndexNames(state, request);
    final Set<ShardId> shardIdsToFetch = new HashSet<>();

    logger.trace("using cluster state version [{}] to determine shards", state.version());
    // collect relevant shard ids of the requested indices for fetching store infos
    for (String index : concreteIndices) {
        IndexRoutingTable indexShardRoutingTables = routingTables.index(index);
        if (indexShardRoutingTables == null) {
            continue;
        }
        for (IndexShardRoutingTable routing : indexShardRoutingTables) {
            final int shardId = routing.shardId().id();
            ClusterShardHealth shardHealth = new ClusterShardHealth(shardId, routing);
            if (request.shardStatuses().contains(shardHealth.getStatus())) {
                shardIdsToFetch.add(routing.shardId());
            }
        }
    }

    // async fetch store infos from all the nodes
    // NOTE: instead of fetching shard store info one by one from every node (nShards * nNodes requests)
    // we could fetch all shard store info from every node once (nNodes requests)
    // we have to implement a TransportNodesAction instead of using TransportNodesListGatewayStartedShards
    // for fetching shard stores info, that operates on a list of shards instead of a single shard
    new AsyncShardStoresInfoFetches(state.nodes(), routingNodes, shardIdsToFetch, listener).start();
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
private RoutingAllocation onePrimaryOnNode1And1Replica(AllocationDeciders deciders, Settings settings, UnassignedInfo.Reason reason) {
    ShardRouting primaryShard = TestShardRouting.newShardRouting(shardId, node1.getId(), true, ShardRoutingState.STARTED);
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder(shardId.getIndexName()).settings(settings(Version.CURRENT).put(settings))
                .numberOfShards(1).numberOfReplicas(1)
                .putInSyncAllocationIds(0, Sets.newHashSet(primaryShard.allocationId().getId())))
        .build();
    // mark shard as delayed if reason is NODE_LEFT
    boolean delayed = reason == UnassignedInfo.Reason.NODE_LEFT &&
        UnassignedInfo.INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.get(settings).nanos() > 0;
    int failedAllocations = reason == UnassignedInfo.Reason.ALLOCATION_FAILED ? 1 : 0;
    RoutingTable routingTable = RoutingTable.builder()
            .add(IndexRoutingTable.builder(shardId.getIndex())
                            .addIndexShard(new IndexShardRoutingTable.Builder(shardId)
                                    .addShard(primaryShard)
                                    .addShard(ShardRouting.newUnassigned(shardId, false,
                                        RecoverySource.PeerRecoverySource.INSTANCE,
                                        new UnassignedInfo(reason, null, null, failedAllocations, System.nanoTime(),
                                            System.currentTimeMillis(), delayed, UnassignedInfo.AllocationStatus.NO_ATTEMPT)
                                        ))
                                    .build())
            )
            .build();
    ClusterState state = ClusterState.builder(org.elasticsearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
            .metaData(metaData)
            .routingTable(routingTable)
            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3)).build();
    return new RoutingAllocation(deciders, new RoutingNodes(state, false), state, ClusterInfo.EMPTY, System.nanoTime(), false);
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
public void testStartedShardsMatching() {
    AllocationService allocation = createAllocationService();

    logger.info("--> building initial cluster state");
    AllocationId allocationId = AllocationId.newRelocation(AllocationId.newInitializing());
    final IndexMetaData indexMetaData = IndexMetaData.builder("test")
            .settings(settings(Version.CURRENT))
            .numberOfShards(2).numberOfReplicas(0)
            .putInSyncAllocationIds(1, Collections.singleton(allocationId.getId()))
            .build();
    final Index index = indexMetaData.getIndex();
    ClusterState.Builder stateBuilder = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
            .nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")))
            .metaData(MetaData.builder().put(indexMetaData, false));

    final ShardRouting initShard = TestShardRouting.newShardRouting(new ShardId(index, 0), "node1", true, ShardRoutingState.INITIALIZING);
    final ShardRouting relocatingShard = TestShardRouting.newShardRouting(new ShardId(index, 1), "node1", "node2", true, ShardRoutingState.RELOCATING, allocationId);
    stateBuilder.routingTable(RoutingTable.builder().add(IndexRoutingTable.builder(index)
            .addIndexShard(new IndexShardRoutingTable.Builder(initShard.shardId()).addShard(initShard).build())
            .addIndexShard(new IndexShardRoutingTable.Builder(relocatingShard.shardId()).addShard(relocatingShard).build())).build());

    ClusterState state = stateBuilder.build();

    logger.info("--> test starting of shard");

    ClusterState newState = allocation.applyStartedShards(state, Arrays.asList(initShard));
    assertThat("failed to start " + initShard + "\ncurrent routing table:" + newState.routingTable(), newState, not(equalTo(state)));
    assertTrue(initShard + "isn't started \ncurrent routing table:" + newState.routingTable(),
            newState.routingTable().index("test").shard(initShard.id()).allShardsStarted());
    state = newState;

    logger.info("--> testing starting of relocating shards");
    newState = allocation.applyStartedShards(state, Arrays.asList(relocatingShard.getTargetRelocatingShard()));
    assertThat("failed to start " + relocatingShard + "\ncurrent routing table:" + newState.routingTable(),
        newState, not(equalTo(state)));
    ShardRouting shardRouting = newState.routingTable().index("test").shard(relocatingShard.id()).getShards().get(0);
    assertThat(shardRouting.state(), equalTo(ShardRoutingState.STARTED));
    assertThat(shardRouting.currentNodeId(), equalTo("node2"));
    assertThat(shardRouting.relocatingNodeId(), nullValue());
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
public void testClusterHealth() throws IOException {
    RoutingTableGenerator routingTableGenerator = new RoutingTableGenerator();
    RoutingTableGenerator.ShardCounter counter = new RoutingTableGenerator.ShardCounter();
    RoutingTable.Builder routingTable = RoutingTable.builder();
    MetaData.Builder metaData = MetaData.builder();
    for (int i = randomInt(4); i >= 0; i--) {
        int numberOfShards = randomInt(3) + 1;
        int numberOfReplicas = randomInt(4);
        IndexMetaData indexMetaData = IndexMetaData
                .builder("test_" + Integer.toString(i))
                .settings(settings(Version.CURRENT))
                .numberOfShards(numberOfShards)
                .numberOfReplicas(numberOfReplicas)
                .build();
        IndexRoutingTable indexRoutingTable = routingTableGenerator.genIndexRoutingTable(indexMetaData, counter);
        metaData.put(indexMetaData, true);
        routingTable.add(indexRoutingTable);
    }
    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
                                            .metaData(metaData)
                                            .routingTable(routingTable.build())
                                            .build();
    String[] concreteIndices = indexNameExpressionResolver.concreteIndexNames(
        clusterState, IndicesOptions.strictExpand(), (String[]) null
    );
    ClusterStateHealth clusterStateHealth = new ClusterStateHealth(clusterState, concreteIndices);
    logger.info("cluster status: {}, expected {}", clusterStateHealth.getStatus(), counter.status());
    clusterStateHealth = maybeSerialize(clusterStateHealth);
    assertClusterHealth(clusterStateHealth, counter);
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
public void testClusterIndexHealth() {
    RoutingTableGenerator routingTableGenerator = new RoutingTableGenerator();
    int numberOfShards = randomInt(3) + 1;
    int numberOfReplicas = randomInt(4);
    IndexMetaData indexMetaData = IndexMetaData.builder("test1").settings(settings(Version.CURRENT)).numberOfShards(numberOfShards).numberOfReplicas(numberOfReplicas).build();
    RoutingTableGenerator.ShardCounter counter = new RoutingTableGenerator.ShardCounter();
    IndexRoutingTable indexRoutingTable = routingTableGenerator.genIndexRoutingTable(indexMetaData, counter);

    ClusterIndexHealth indexHealth = new ClusterIndexHealth(indexMetaData, indexRoutingTable);
    logger.info("index status: {}, expected {}", indexHealth.getStatus(), counter.status());
    assertIndexHealth(indexHealth, counter, indexMetaData);
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
public void testDecommissionNodeNoReplicas() throws Exception {
    logger.info("--> starting 2 nodes");
    List<String> nodesIds = internalCluster().startNodes(2);
    final String node_0 = nodesIds.get(0);
    final String node_1 = nodesIds.get(1);
    assertThat(cluster().size(), equalTo(2));

    logger.info("--> creating an index with no replicas");
    client().admin().indices().prepareCreate("test")
            .setSettings(Settings.builder().put("index.number_of_replicas", 0))
            .execute().actionGet();
    ensureGreen();
    logger.info("--> index some data");
    for (int i = 0; i < 100; i++) {
        client().prepareIndex("test", "type", Integer.toString(i)).setSource("field", "value" + i).execute().actionGet();
    }
    client().admin().indices().prepareRefresh().execute().actionGet();
    assertThat(client().prepareSearch().setSize(0).setQuery(QueryBuilders.matchAllQuery()).execute().actionGet().getHits().getTotalHits(), equalTo(100L));

    logger.info("--> decommission the second node");
    client().admin().cluster().prepareUpdateSettings()
            .setTransientSettings(Settings.builder().put("cluster.routing.allocation.exclude._name", node_1))
            .execute().actionGet();
    waitForRelocation();

    logger.info("--> verify all are allocated on node1 now");
    ClusterState clusterState = client().admin().cluster().prepareState().execute().actionGet().getState();
    for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
        for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
            for (ShardRouting shardRouting : indexShardRoutingTable) {
                assertThat(clusterState.nodes().get(shardRouting.currentNodeId()).getName(), equalTo(node_0));
            }
        }
    }

    client().admin().indices().prepareRefresh().execute().actionGet();
    assertThat(client().prepareSearch().setSize(0).setQuery(QueryBuilders.matchAllQuery()).execute().actionGet().getHits().getTotalHits(), equalTo(100L));
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
private Set<String> findNodesWithShard(String index) {
    ClusterState state = client().admin().cluster().prepareState().get().getState();
    IndexRoutingTable indexRoutingTable = state.routingTable().index(index);
    List<ShardRouting> startedShards = indexRoutingTable.shardsWithState(ShardRoutingState.STARTED);
    Set<String> nodesWithShard = new HashSet<>();
    for (ShardRouting startedShard : startedShards) {
        nodesWithShard.add(state.nodes().get(startedShard.currentNodeId()).getName());
    }
    return nodesWithShard;
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
void setClusterState(ClusterService clusterService, String index) {
    int numberOfNodes = randomIntBetween(3, 5);
    DiscoveryNodes.Builder discoBuilder = DiscoveryNodes.builder();
    IndexRoutingTable.Builder indexRoutingTable = IndexRoutingTable.builder(new Index(index, "_na_"));

    int shardIndex = -1;
    int totalIndexShards = 0;
    for (int i = 0; i < numberOfNodes; i++) {
        final DiscoveryNode node = newNode(i);
        discoBuilder = discoBuilder.add(node);
        int numberOfShards = randomIntBetween(1, 10);
        totalIndexShards += numberOfShards;
        for (int j = 0; j < numberOfShards; j++) {
            final ShardId shardId = new ShardId(index, "_na_", ++shardIndex);
            ShardRouting shard = TestShardRouting.newShardRouting(index, shardId.getId(), node.getId(), true, ShardRoutingState.STARTED);
            IndexShardRoutingTable.Builder indexShard = new IndexShardRoutingTable.Builder(shardId);
            indexShard.addShard(shard);
            indexRoutingTable.addIndexShard(indexShard.build());
        }
    }
    discoBuilder.localNodeId(newNode(0).getId());
    discoBuilder.masterNodeId(newNode(numberOfNodes - 1).getId());
    ClusterState.Builder stateBuilder = ClusterState.builder(new ClusterName(TEST_CLUSTER));
    stateBuilder.nodes(discoBuilder);
    final IndexMetaData.Builder indexMetaData = IndexMetaData.builder(index)
            .settings(Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT))
            .numberOfReplicas(0)
            .numberOfShards(totalIndexShards);

    stateBuilder.metaData(MetaData.builder().put(indexMetaData));
    stateBuilder.routingTable(RoutingTable.builder().add(indexRoutingTable.build()).build());
    ClusterState clusterState = stateBuilder.build();
    setState(clusterService, clusterState);
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
/**
 * Creates cluster state with several shards and one replica and all shards STARTED.
 */
public static ClusterState stateWithAssignedPrimariesAndOneReplica(String index, int numberOfShards) {

    int numberOfNodes = 2; // we need a non-local master to test shard failures
    DiscoveryNodes.Builder discoBuilder = DiscoveryNodes.builder();
    for (int i = 0; i < numberOfNodes + 1; i++) {
        final DiscoveryNode node = newNode(i);
        discoBuilder = discoBuilder.add(node);
    }
    discoBuilder.localNodeId(newNode(0).getId());
    discoBuilder.masterNodeId(newNode(1).getId()); // we need a non-local master to test shard failures
    IndexMetaData indexMetaData = IndexMetaData.builder(index).settings(Settings.builder()
            .put(SETTING_VERSION_CREATED, Version.CURRENT)
            .put(SETTING_NUMBER_OF_SHARDS, numberOfShards).put(SETTING_NUMBER_OF_REPLICAS, 1)
            .put(SETTING_CREATION_DATE, System.currentTimeMillis())).build();
    ClusterState.Builder state = ClusterState.builder(new ClusterName("test"));
    state.nodes(discoBuilder);
    state.metaData(MetaData.builder().put(indexMetaData, false).generateClusterUuidIfNeeded());
    IndexRoutingTable.Builder indexRoutingTableBuilder = IndexRoutingTable.builder(indexMetaData.getIndex());
    for (int i = 0; i < numberOfShards; i++) {
        RoutingTable.Builder routing = new RoutingTable.Builder();
        routing.addAsNew(indexMetaData);
        final ShardId shardId = new ShardId(index, "_na_", i);
        IndexShardRoutingTable.Builder indexShardRoutingBuilder = new IndexShardRoutingTable.Builder(shardId);
        indexShardRoutingBuilder.addShard(TestShardRouting.newShardRouting(index, i, newNode(0).getId(), null, true,
                ShardRoutingState.STARTED));
        indexShardRoutingBuilder.addShard(TestShardRouting.newShardRouting(index, i, newNode(1).getId(), null, false,
                ShardRoutingState.STARTED));
        indexRoutingTableBuilder.addIndexShard(indexShardRoutingBuilder.build());
    }
    state.routingTable(RoutingTable.builder().add(indexRoutingTableBuilder.build()).build());
    return state.build();
}
 

import org.elasticsearch.cluster.routing.IndexRoutingTable; //导入依赖的package包/类
public ClusterIndexHealth(IndexMetaData indexMetaData, IndexRoutingTable indexRoutingTable) {
    this.index = indexMetaData.getIndex();
    this.numberOfShards = indexMetaData.getNumberOfShards();
    this.numberOfReplicas = indexMetaData.getNumberOfReplicas();
    this.validationFailures = indexRoutingTable.validate(indexMetaData);

    for (IndexShardRoutingTable shardRoutingTable : indexRoutingTable) {
        int shardId = shardRoutingTable.shardId().id();
        shards.put(shardId, new ClusterShardHealth(shardId, shardRoutingTable));
    }

    // update the index status
    status = ClusterHealthStatus.GREEN;

    for (ClusterShardHealth shardHealth : shards.values()) {
        if (shardHealth.isPrimaryActive()) {
            activePrimaryShards++;
        }
        activeShards += shardHealth.getActiveShards();
        relocatingShards += shardHealth.getRelocatingShards();
        initializingShards += shardHealth.getInitializingShards();
        unassignedShards += shardHealth.getUnassignedShards();

        if (shardHealth.getStatus() == ClusterHealthStatus.RED) {
            status = ClusterHealthStatus.RED;
        } else if (shardHealth.getStatus() == ClusterHealthStatus.YELLOW && status != ClusterHealthStatus.RED) {
            // do not override an existing red
            status = ClusterHealthStatus.YELLOW;
        }
    }
    if (!validationFailures.isEmpty()) {
        status = ClusterHealthStatus.RED;
    } else if (shards.isEmpty()) { // might be since none has been created yet (two phase index creation)
        status = ClusterHealthStatus.RED;
    }
}