import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Override
protected void configure() {
    bind(GatewayAllocator.class).asEagerSingleton();
    bind(AllocationService.class).asEagerSingleton();
    bind(ClusterService.class).toInstance(clusterService);
    bind(NodeConnectionsService.class).asEagerSingleton();
    bind(MetaDataCreateIndexService.class).asEagerSingleton();
    bind(MetaDataDeleteIndexService.class).asEagerSingleton();
    bind(MetaDataIndexStateService.class).asEagerSingleton();
    bind(MetaDataMappingService.class).asEagerSingleton();
    bind(MetaDataIndexAliasesService.class).asEagerSingleton();
    bind(MetaDataUpdateSettingsService.class).asEagerSingleton();
    bind(MetaDataIndexTemplateService.class).asEagerSingleton();
    bind(IndexNameExpressionResolver.class).toInstance(indexNameExpressionResolver);
    bind(RoutingService.class).asEagerSingleton();
    bind(DelayedAllocationService.class).asEagerSingleton();
    bind(ShardStateAction.class).asEagerSingleton();
    bind(NodeMappingRefreshAction.class).asEagerSingleton();
    bind(MappingUpdatedAction.class).asEagerSingleton();
    bind(TaskResultsService.class).asEagerSingleton();
    bind(AllocationDeciders.class).toInstance(new AllocationDeciders(settings, allocationDeciders));
    bind(ShardsAllocator.class).toInstance(shardsAllocator);
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Inject
public MetaDataCreateIndexService(Settings settings, ClusterService clusterService,
                                  IndicesService indicesService, AllocationService allocationService,
                                  AliasValidator aliasValidator, Environment env,
                                  IndexScopedSettings indexScopedSettings, ThreadPool threadPool,
                                  NamedXContentRegistry xContentRegistry) {
    super(settings);
    this.clusterService = clusterService;
    this.indicesService = indicesService;
    this.allocationService = allocationService;
    this.aliasValidator = aliasValidator;
    this.env = env;
    this.indexScopedSettings = indexScopedSettings;
    this.activeShardsObserver = new ActiveShardsObserver(settings, clusterService, threadPool);
    this.threadPool = threadPool;
    this.xContentRegistry = xContentRegistry;
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
public void testClusterStateSerialization() throws Exception {
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder("test").settings(settings(Version.CURRENT)).numberOfShards(10).numberOfReplicas(1))
            .build();

    RoutingTable routingTable = RoutingTable.builder()
            .addAsNew(metaData.index("test"))
            .build();

    DiscoveryNodes nodes = DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")).add(newNode("node3")).localNodeId("node1").masterNodeId("node2").build();

    ClusterState clusterState = ClusterState.builder(new ClusterName("clusterName1")).nodes(nodes).metaData(metaData).routingTable(routingTable).build();

    AllocationService strategy = createAllocationService();
    clusterState = ClusterState.builder(clusterState).routingTable(strategy.reroute(clusterState, "reroute").routingTable()).build();

    ClusterState serializedClusterState = ClusterState.Builder.fromBytes(ClusterState.Builder.toBytes(clusterState), newNode("node1"),
        new NamedWriteableRegistry(ClusterModule.getNamedWriteables()));

    assertThat(serializedClusterState.getClusterName().value(), equalTo(clusterState.getClusterName().value()));

    assertThat(serializedClusterState.routingTable().toString(), equalTo(clusterState.routingTable().toString()));
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
public void testRoutingTableSerialization() throws Exception {
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder("test").settings(settings(Version.CURRENT)).numberOfShards(10).numberOfReplicas(1))
            .build();

    RoutingTable routingTable = RoutingTable.builder()
            .addAsNew(metaData.index("test"))
            .build();

    DiscoveryNodes nodes = DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")).add(newNode("node3")).build();

    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).nodes(nodes)
        .metaData(metaData).routingTable(routingTable).build();

    AllocationService strategy = createAllocationService();
    RoutingTable source = strategy.reroute(clusterState, "reroute").routingTable();

    BytesStreamOutput outStream = new BytesStreamOutput();
    source.writeTo(outStream);
    StreamInput inStream = outStream.bytes().streamInput();
    RoutingTable target = RoutingTable.readFrom(inStream);

    assertThat(target.toString(), equalTo(source.toString()));
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
public void testClusterStateSerialization() throws Exception {
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder("test_idx").settings(settings(Version.CURRENT)).numberOfShards(10).numberOfReplicas(1))
            .put(IndexTemplateMetaData.builder("test_template").build())
            .build();

    RoutingTable routingTable = RoutingTable.builder()
            .addAsNew(metaData.index("test_idx"))
            .build();

    DiscoveryNodes nodes = DiscoveryNodes.builder().add(new DiscoveryNode("node_foo", buildNewFakeTransportAddress(),
            emptyMap(), emptySet(), Version.CURRENT)).localNodeId("node_foo").masterNodeId("node_foo").build();

    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).nodes(nodes)
        .metaData(metaData).routingTable(routingTable).build();

    AllocationService strategy = createAllocationService();
    clusterState = ClusterState.builder(clusterState).routingTable(strategy.reroute(clusterState, "reroute").routingTable()).build();

    String clusterStateString = Strings.toString(clusterState);
    assertNotNull(clusterStateString);

    assertThat(clusterStateString, containsString("test_idx"));
    assertThat(clusterStateString, containsString("test_template"));
    assertThat(clusterStateString, containsString("node_foo"));
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
/**
 * Tests that during reroute when a node is detected as leaving the cluster, the right unassigned meta is set
 */
public void testNodeLeave() {
    AllocationService allocation = createAllocationService();
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder("test").settings(settings(Version.CURRENT)).numberOfShards(1).numberOfReplicas(1))
            .build();
    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
            .metaData(metaData)
            .routingTable(RoutingTable.builder().addAsNew(metaData.index("test")).build()).build();
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2"))).build();
    clusterState = allocation.reroute(clusterState, "reroute");
    // starting primaries
    clusterState = allocation.applyStartedShards(clusterState, clusterState.getRoutingNodes().shardsWithState(INITIALIZING));
    // starting replicas
    clusterState = allocation.applyStartedShards(clusterState, clusterState.getRoutingNodes().shardsWithState(INITIALIZING));
    assertThat(clusterState.getRoutingNodes().unassigned().size() > 0, equalTo(false));
    // remove node2 and reroute
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder(clusterState.nodes()).remove("node2")).build();
    clusterState = allocation.deassociateDeadNodes(clusterState, true, "reroute");
    // verify that NODE_LEAVE is the reason for meta
    assertThat(clusterState.getRoutingNodes().unassigned().size() > 0, equalTo(true));
    assertThat(clusterState.getRoutingNodes().shardsWithState(UNASSIGNED).size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().shardsWithState(UNASSIGNED).get(0).unassignedInfo(), notNullValue());
    assertThat(clusterState.getRoutingNodes().shardsWithState(UNASSIGNED).get(0).unassignedInfo().getReason(), equalTo(UnassignedInfo.Reason.NODE_LEFT));
    assertThat(clusterState.getRoutingNodes().shardsWithState(UNASSIGNED).get(0).unassignedInfo().getUnassignedTimeInMillis(), greaterThan(0L));
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
private ClusterState createInitialClusterState(AllocationService service) {
    MetaData.Builder metaBuilder = MetaData.builder();
    metaBuilder.put(IndexMetaData.builder("idx").settings(settings(Version.CURRENT)).numberOfShards(1).numberOfReplicas(0));
    MetaData metaData = metaBuilder.build();
    RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
    routingTableBuilder.addAsNew(metaData.index("idx"));

    RoutingTable routingTable = routingTableBuilder.build();
    ClusterState clusterState = ClusterState.builder(org.elasticsearch.cluster.ClusterName.CLUSTER_NAME_SETTING
        .getDefault(Settings.EMPTY))
        .metaData(metaData).routingTable(routingTable).build();
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")))
        .build();
    RoutingTable prevRoutingTable = routingTable;
    routingTable = service.reroute(clusterState, "reroute").routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertEquals(prevRoutingTable.index("idx").shards().size(), 1);
    assertEquals(prevRoutingTable.index("idx").shard(0).shards().get(0).state(), UNASSIGNED);

    assertEquals(routingTable.index("idx").shards().size(), 1);
    assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), INITIALIZING);
    return clusterState;
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
protected  static ClusterState startRandomInitializingShard(ClusterState clusterState, AllocationService strategy) {
    List<ShardRouting> initializingShards = clusterState.getRoutingNodes().shardsWithState(INITIALIZING);
    if (initializingShards.isEmpty()) {
        return clusterState;
    }
    return strategy.applyStartedShards(clusterState,
        arrayAsArrayList(initializingShards.get(randomInt(initializingShards.size() - 1))));
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
protected ClusterState applyStartedShardsUntilNoChange(ClusterState clusterState, AllocationService service) {
    ClusterState lastClusterState;
    do {
        lastClusterState = clusterState;
        logger.debug("ClusterState: {}", clusterState.getRoutingNodes());
        clusterState = service.applyStartedShards(clusterState, clusterState.getRoutingNodes().shardsWithState(INITIALIZING));
    } while (lastClusterState.equals(clusterState) == false);
    return clusterState;
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
public NodeJoinController(ClusterService clusterService, AllocationService allocationService, ElectMasterService electMaster,
                          Settings settings) {
    super(settings);
    this.clusterService = clusterService;
    this.allocationService = allocationService;
    this.electMaster = electMaster;
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
NodeRemovalClusterStateTaskExecutor(
        final AllocationService allocationService,
        final ElectMasterService electMasterService,
        final Consumer<String> rejoin,
        final Logger logger) {
    this.allocationService = allocationService;
    this.electMasterService = electMasterService;
    this.rejoin = rejoin;
    this.logger = logger;
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Inject
public GatewayService(Settings settings, AllocationService allocationService, ClusterService clusterService,
                      ThreadPool threadPool, GatewayMetaState metaState,
                      TransportNodesListGatewayMetaState listGatewayMetaState, Discovery discovery,
                      IndicesService indicesService) {
    super(settings);
    this.gateway = new Gateway(settings, clusterService, metaState, listGatewayMetaState, discovery,
        indicesService);
    this.allocationService = allocationService;
    this.clusterService = clusterService;
    this.threadPool = threadPool;
    // allow to control a delay of when indices will get created
    this.expectedNodes = EXPECTED_NODES_SETTING.get(this.settings);
    this.expectedDataNodes = EXPECTED_DATA_NODES_SETTING.get(this.settings);
    this.expectedMasterNodes = EXPECTED_MASTER_NODES_SETTING.get(this.settings);

    if (RECOVER_AFTER_TIME_SETTING.exists(this.settings)) {
        recoverAfterTime = RECOVER_AFTER_TIME_SETTING.get(this.settings);
    } else if (expectedNodes >= 0 || expectedDataNodes >= 0 || expectedMasterNodes >= 0) {
        recoverAfterTime = DEFAULT_RECOVER_AFTER_TIME_IF_EXPECTED_NODES_IS_SET;
    } else {
        recoverAfterTime = null;
    }
    this.recoverAfterNodes = RECOVER_AFTER_NODES_SETTING.get(this.settings);
    this.recoverAfterDataNodes = RECOVER_AFTER_DATA_NODES_SETTING.get(this.settings);
    // default the recover after master nodes to the minimum master nodes in the discovery
    if (RECOVER_AFTER_MASTER_NODES_SETTING.exists(this.settings)) {
        recoverAfterMasterNodes = RECOVER_AFTER_MASTER_NODES_SETTING.get(this.settings);
    } else {
        // TODO: change me once the minimum_master_nodes is changed too
        recoverAfterMasterNodes = settings.getAsInt("discovery.zen.minimum_master_nodes", -1);
    }

    // Add the not recovered as initial state block, we don't allow anything until
    this.clusterService.addInitialStateBlock(STATE_NOT_RECOVERED_BLOCK);
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Inject
public LocalAllocateDangledIndices(Settings settings, TransportService transportService, ClusterService clusterService,
                                   AllocationService allocationService, MetaDataIndexUpgradeService metaDataIndexUpgradeService) {
    super(settings);
    this.transportService = transportService;
    this.clusterService = clusterService;
    this.allocationService = allocationService;
    this.metaDataIndexUpgradeService = metaDataIndexUpgradeService;
    transportService.registerRequestHandler(ACTION_NAME, AllocateDangledRequest::new, ThreadPool.Names.SAME, new AllocateDangledRequestHandler());
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Inject
public DelayedAllocationService(Settings settings, ThreadPool threadPool, ClusterService clusterService,
                                AllocationService allocationService) {
    super(settings);
    this.threadPool = threadPool;
    this.clusterService = clusterService;
    this.allocationService = allocationService;
    clusterService.addListener(this);
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Inject
public MetaDataUpdateSettingsService(Settings settings, ClusterService clusterService, AllocationService allocationService,
                                     IndexScopedSettings indexScopedSettings, IndicesService indicesService, ThreadPool threadPool) {
    super(settings);
    this.clusterService = clusterService;
    this.threadPool = threadPool;
    this.clusterService.addListener(this);
    this.allocationService = allocationService;
    this.indexScopedSettings = indexScopedSettings;
    this.indicesService = indicesService;
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Inject
public MetaDataIndexStateService(Settings settings, ClusterService clusterService, AllocationService allocationService,
                                 MetaDataIndexUpgradeService metaDataIndexUpgradeService,
                                 IndicesService indicesService) {
    super(settings);
    this.indicesService = indicesService;
    this.clusterService = clusterService;
    this.allocationService = allocationService;
    this.metaDataIndexUpgradeService = metaDataIndexUpgradeService;
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Inject
public ShardStateAction(Settings settings, ClusterService clusterService, TransportService transportService,
                        AllocationService allocationService, RoutingService routingService, ThreadPool threadPool) {
    super(settings);
    this.transportService = transportService;
    this.clusterService = clusterService;
    this.threadPool = threadPool;

    transportService.registerRequestHandler(SHARD_STARTED_ACTION_NAME, ShardEntry::new, ThreadPool.Names.SAME, new ShardStartedTransportHandler(clusterService, new ShardStartedClusterStateTaskExecutor(allocationService, logger), logger));
    transportService.registerRequestHandler(SHARD_FAILED_ACTION_NAME, ShardEntry::new, ThreadPool.Names.SAME, new ShardFailedTransportHandler(clusterService, new ShardFailedClusterStateTaskExecutor(allocationService, routingService, logger), logger));
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Inject
public RestoreService(Settings settings, ClusterService clusterService, RepositoriesService repositoriesService,
                      AllocationService allocationService, MetaDataCreateIndexService createIndexService,
                      MetaDataIndexUpgradeService metaDataIndexUpgradeService, ClusterSettings clusterSettings) {
    super(settings);
    this.clusterService = clusterService;
    this.repositoriesService = repositoriesService;
    this.allocationService = allocationService;
    this.createIndexService = createIndexService;
    this.metaDataIndexUpgradeService = metaDataIndexUpgradeService;
    clusterService.addStateApplier(this);
    this.clusterSettings = clusterSettings;
    this.cleanRestoreStateTaskExecutor = new CleanRestoreStateTaskExecutor(logger);
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
ClusterRerouteResponseAckedClusterStateUpdateTask(Logger logger, AllocationService allocationService, ClusterRerouteRequest request,
                                                  ActionListener<ClusterRerouteResponse> listener) {
    super(Priority.IMMEDIATE, request, listener);
    this.request = request;
    this.listener = listener;
    this.logger = logger;
    this.allocationService = allocationService;
}
 

import org.elasticsearch.cluster.routing.allocation.AllocationService; //导入依赖的package包/类
@Override
public ClusterState execute(ClusterState currentState) {
    AllocationService.CommandsResult commandsResult =
        allocationService.reroute(currentState, request.getCommands(), request.explain(), request.isRetryFailed());
    clusterStateToSend = commandsResult.getClusterState();
    explanations = commandsResult.explanations();
    if (request.dryRun()) {
        return currentState;
    }
    return commandsResult.getClusterState();
}