import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public void testProperties() throws IOException, UserException {
    final Settings.Builder builder = Settings.builder().put("cluster.name", randomAsciiOfLength(16));
    if (randomBoolean()) {
        builder.put("node.name", randomAsciiOfLength(16));
    }
    final Settings settings = builder.build();
    setupLogging("minimal", settings);

    assertNotNull(System.getProperty("es.logs.base_path"));

    assertThat(System.getProperty("es.logs.cluster_name"), equalTo(ClusterName.CLUSTER_NAME_SETTING.get(settings).value()));
    if (Node.NODE_NAME_SETTING.exists(settings)) {
        assertThat(System.getProperty("es.logs.node_name"), equalTo(Node.NODE_NAME_SETTING.get(settings)));
    } else {
        assertNull(System.getProperty("es.logs.node_name"));
    }
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public NodesFailureDetectionService(Settings settings, ThreadPool threadPool, TransportService transportService, ClusterName clusterName, ClusterService clusterService, 
        RoutingService routingService, JoinClusterAction joinClusterAction, ClusterStateOpLog clusterStateOpLog) {
    super(settings);
    this.pingInterval = settings.getAsTime(SETTING_PING_INTERVAL, timeValueSeconds(1));
    this.pingTimeout = settings.getAsTime(SETTING_PING_TIMEOUT, timeValueSeconds(5));
    this.pingRetryCount = settings.getAsInt(SETTING_PING_RETRIES, 3);
    this.threadPool = threadPool;
    this.transportService = transportService;
    this.clusterName = clusterName;
    this.clusterService = clusterService;
    this.routingService = routingService;
    this.joinClusterAction = joinClusterAction;
    this.clusterStateOpLog = clusterStateOpLog;
    this.localNode = clusterService.localNode();
    logger.debug("[node  ] uses ping_interval [{}], ping_timeout [{}], ping_retries [{}]", pingInterval, pingTimeout, pingRetryCount);
    transportService.registerRequestHandler(PING_ACTION_NAME, PingRequest.class, ThreadPool.Names.SAME, new PingRequestHandler());
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public FaultDetection(Settings settings, ThreadPool threadPool, TransportService transportService, ClusterName clusterName) {
    super(settings);
    this.threadPool = threadPool;
    this.transportService = transportService;
    this.clusterName = clusterName;

    this.connectOnNetworkDisconnect = settings.getAsBoolean(SETTING_CONNECT_ON_NETWORK_DISCONNECT, false);
    this.pingInterval = settings.getAsTime(SETTING_PING_INTERVAL, timeValueSeconds(1));
    this.pingRetryTimeout = settings.getAsTime(SETTING_PING_TIMEOUT, timeValueSeconds(30));
    this.pingRetryCount = settings.getAsInt(SETTING_PING_RETRIES, 3);
    this.registerConnectionListener = settings.getAsBoolean(SETTING_REGISTER_CONNECTION_LISTENER, true);

    this.connectionListener = new FDConnectionListener();
    if (registerConnectionListener) {
        transportService.addConnectionListener(connectionListener);
    }
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public PublishClusterStateAction(
        Settings settings,
        TransportService transportService,
        NamedWriteableRegistry namedWriteableRegistry,
        Supplier<ClusterState> clusterStateSupplier,
        NewPendingClusterStateListener listener,
        DiscoverySettings discoverySettings,
        ClusterName clusterName) {
    super(settings);
    this.transportService = transportService;
    this.namedWriteableRegistry = namedWriteableRegistry;
    this.clusterStateSupplier = clusterStateSupplier;
    this.newPendingClusterStatelistener = listener;
    this.discoverySettings = discoverySettings;
    this.clusterName = clusterName;
    this.pendingStatesQueue = new PendingClusterStatesQueue(logger, settings.getAsInt(SETTINGS_MAX_PENDING_CLUSTER_STATES, 25));
    transportService.registerRequestHandler(SEND_ACTION_NAME, BytesTransportRequest::new, ThreadPool.Names.SAME, false, false,
        new SendClusterStateRequestHandler());
    transportService.registerRequestHandler(COMMIT_ACTION_NAME, CommitClusterStateRequest::new, ThreadPool.Names.SAME, false, false,
        new CommitClusterStateRequestHandler());
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
private ClusterState createInitialClusterState() {
    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(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 = strategy.reroute(clusterState, "reroute", false).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.ClusterName; //导入依赖的package包/类
/**
 * Build the service.
 *
 * @param clusterSettings if non null the the {@linkplain TransportService} will register with the {@link ClusterSettings} for settings
 *        updates for {@link #TRACE_LOG_EXCLUDE_SETTING} and {@link #TRACE_LOG_INCLUDE_SETTING}.
 */
public TransportService(Settings settings, Transport transport, ThreadPool threadPool, TransportInterceptor transportInterceptor,
                        Function<BoundTransportAddress, DiscoveryNode> localNodeFactory, @Nullable ClusterSettings clusterSettings) {
    super(settings);
    this.transport = transport;
    this.threadPool = threadPool;
    this.localNodeFactory = localNodeFactory;
    this.clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings);
    setTracerLogInclude(TRACE_LOG_INCLUDE_SETTING.get(settings));
    setTracerLogExclude(TRACE_LOG_EXCLUDE_SETTING.get(settings));
    tracerLog = Loggers.getLogger(logger, ".tracer");
    adapter = createAdapter();
    taskManager = createTaskManager();
    this.interceptor = transportInterceptor;
    this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
    if (clusterSettings != null) {
        clusterSettings.addSettingsUpdateConsumer(TRACE_LOG_INCLUDE_SETTING, this::setTracerLogInclude);
        clusterSettings.addSettingsUpdateConsumer(TRACE_LOG_EXCLUDE_SETTING, this::setTracerLogExclude);
    }
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
private List<ClusterState> simulateIndexCreationStates(final String indexName, final boolean withPrimaryAllocationFailures) {
    final int numberOfShards = randomIntBetween(1, 5);
    final int numberOfReplicas = randomIntBetween(1, numberOfShards);
    // initial index creation and new routing table info
    final IndexMetaData indexMetaData = IndexMetaData.builder(indexName)
                                                     .settings(settings(Version.CURRENT)
                                                                   .put(IndexMetaData.SETTING_INDEX_UUID, UUIDs.randomBase64UUID()))
                                                     .numberOfShards(numberOfShards)
                                                     .numberOfReplicas(numberOfReplicas)
                                                     .build();
    final MetaData metaData = MetaData.builder().put(indexMetaData, true).build();
    final RoutingTable routingTable = RoutingTable.builder().addAsNew(indexMetaData).build();

    ClusterState clusterState = ClusterState.builder(new ClusterName("test_cluster"))
                                            .metaData(metaData)
                                            .routingTable(routingTable)
                                            .build();
    return generateClusterStates(clusterState, indexName, numberOfReplicas, withPrimaryAllocationFailures);
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public void testConvertWildcardsTests() {
    MetaData.Builder mdBuilder = MetaData.builder()
            .put(indexBuilder("testXXX").putAlias(AliasMetaData.builder("alias1")).putAlias(AliasMetaData.builder("alias2")))
            .put(indexBuilder("testXYY").putAlias(AliasMetaData.builder("alias2")))
            .put(indexBuilder("testYYY").putAlias(AliasMetaData.builder("alias3")))
            .put(indexBuilder("kuku"));
    ClusterState state = ClusterState.builder(new ClusterName("_name")).metaData(mdBuilder).build();
    IndexNameExpressionResolver.WildcardExpressionResolver resolver = new IndexNameExpressionResolver.WildcardExpressionResolver();

    IndexNameExpressionResolver.Context context = new IndexNameExpressionResolver.Context(state, IndicesOptions.lenientExpandOpen());
    assertThat(newHashSet(resolver.resolve(context, Arrays.asList("testYY*", "alias*"))), equalTo(newHashSet("testXXX", "testXYY", "testYYY")));
    assertThat(newHashSet(resolver.resolve(context, Arrays.asList("-kuku"))), equalTo(newHashSet("-kuku")));
    assertThat(newHashSet(resolver.resolve(context, Arrays.asList("+test*", "-testYYY"))), equalTo(newHashSet("testXXX", "testXYY")));
    assertThat(newHashSet(resolver.resolve(context, Arrays.asList("+testX*", "+testYYY"))), equalTo(newHashSet("testXXX", "testXYY", "testYYY")));
    assertThat(newHashSet(resolver.resolve(context, Arrays.asList("+testYYY", "+testX*"))), equalTo(newHashSet("testXXX", "testXYY", "testYYY")));
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public ClusterService(Settings settings,
                      ClusterSettings clusterSettings, ThreadPool threadPool, Supplier<DiscoveryNode> localNodeSupplier) {
    super(settings);
    this.localNodeSupplier = localNodeSupplier;
    this.operationRouting = new OperationRouting(settings, clusterSettings);
    this.threadPool = threadPool;
    this.clusterSettings = clusterSettings;
    this.clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings);
    // will be replaced on doStart.
    this.state = new AtomicReference<>(ClusterState.builder(clusterName).build());

    this.clusterSettings.addSettingsUpdateConsumer(CLUSTER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING,
            this::setSlowTaskLoggingThreshold);

    this.slowTaskLoggingThreshold = CLUSTER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(settings);

    localNodeMasterListeners = new LocalNodeMasterListeners(threadPool);

    initialBlocks = ClusterBlocks.builder();
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
@Inject
public DLDiscovery(Settings settings, ClusterName clusterName, ThreadPool threadPool,
        TransportService transportService, final ClusterService clusterService, 
        DiscoverySettings discoverySettings, Environment nodeEnvironment) {
    super(settings);
    this.clusterService = clusterService;
    this.clusterName = clusterName;
    this.discoverySettings = discoverySettings;
    this.threadPool = threadPool;
    this.nodeEnvironment = nodeEnvironment;
    this.transportService = transportService;
    this.clusterStateOpLog = null;
    this.publishClusterStateVersionAction = null;
    this.joinClusterAction = null;
    this.nodesFailureDetectionService = null;
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public void testNumberOfDelayedUnassigned() throws Exception {
    MockAllocationService allocation = createAllocationService(Settings.EMPTY, new DelayedShardsMockGatewayAllocator());
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder("test1").settings(settings(Version.CURRENT)).numberOfShards(1).numberOfReplicas(1))
            .put(IndexMetaData.builder("test2").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("test1")).addAsNew(metaData.index("test2")).build()).build();
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2"))).build();
    clusterState = allocation.reroute(clusterState, "reroute");
    assertThat(UnassignedInfo.getNumberOfDelayedUnassigned(clusterState), equalTo(0));
    // 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();
    // make sure both replicas are marked as delayed (i.e. not reallocated)
    clusterState = allocation.deassociateDeadNodes(clusterState, true, "reroute");
    assertThat(clusterState.toString(), UnassignedInfo.getNumberOfDelayedUnassigned(clusterState), equalTo(2));
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
List<ClusterState> randomStates(int count, String... masters) {
    ArrayList<ClusterState> states = new ArrayList<>(count);
    ClusterState[] lastClusterStatePerMaster = new ClusterState[masters.length];
    for (; count > 0; count--) {
        int masterIndex = randomInt(masters.length - 1);
        ClusterState state = lastClusterStatePerMaster[masterIndex];
        if (state == null) {
            state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).nodes(DiscoveryNodes.builder()
                            .add(new DiscoveryNode(masters[masterIndex], buildNewFakeTransportAddress(),
                                    emptyMap(), emptySet(),Version.CURRENT)).masterNodeId(masters[masterIndex]).build()
            ).build();
        } else {
            state = ClusterState.builder(state).incrementVersion().build();
        }
        states.add(state);
        lastClusterStatePerMaster[masterIndex] = state;
    }
    return states;
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public void testFilterNonMasterPingResponse() {
    ArrayList<ZenPing.PingResponse> responses = new ArrayList<>();
    ArrayList<DiscoveryNode> masterNodes = new ArrayList<>();
    ArrayList<DiscoveryNode> allNodes = new ArrayList<>();
    for (int i = randomIntBetween(10, 20); i >= 0; i--) {
        Set<Role> roles = new HashSet<>(randomSubsetOf(Arrays.asList(Role.values())));
        DiscoveryNode node = new DiscoveryNode("node_" + i, "id_" + i, buildNewFakeTransportAddress(), Collections.emptyMap(),
                roles, Version.CURRENT);
        responses.add(new ZenPing.PingResponse(node, randomBoolean() ? null : node, new ClusterName("test"), randomLong()));
        allNodes.add(node);
        if (node.isMasterNode()) {
            masterNodes.add(node);
        }
    }

    boolean ignore = randomBoolean();
    List<ZenPing.PingResponse> filtered = ZenDiscovery.filterPingResponses(responses, ignore, logger);
    final List<DiscoveryNode> filteredNodes = filtered.stream().map(ZenPing.PingResponse::node).collect(Collectors.toList());
    if (ignore) {
        assertThat(filteredNodes, equalTo(masterNodes));
    } else {
        assertThat(filteredNodes, equalTo(allNodes));
    }
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public void testRemovingNonExistentNodes() throws Exception {
    final ZenDiscovery.NodeRemovalClusterStateTaskExecutor executor =
            new ZenDiscovery.NodeRemovalClusterStateTaskExecutor(null, null, null, logger);
    final DiscoveryNodes.Builder builder = DiscoveryNodes.builder();
    final int nodes = randomIntBetween(2, 16);
    for (int i = 0; i < nodes; i++) {
        builder.add(node(i));
    }
    final ClusterState clusterState = ClusterState.builder(new ClusterName("test")).nodes(builder).build();

    final DiscoveryNodes.Builder removeBuilder = DiscoveryNodes.builder();
    for (int i = nodes; i < nodes + randomIntBetween(1, 16); i++) {
        removeBuilder.add(node(i));
    }
    final List<ZenDiscovery.NodeRemovalClusterStateTaskExecutor.Task> tasks =
            StreamSupport
                    .stream(removeBuilder.build().spliterator(), false)
                    .map(node -> new ZenDiscovery.NodeRemovalClusterStateTaskExecutor.Task(node, randomBoolean() ? "left" : "failed"))
                    .collect(Collectors.toList());

    final ClusterStateTaskExecutor.ClusterTasksResult<ZenDiscovery.NodeRemovalClusterStateTaskExecutor.Task> result
            = executor.execute(clusterState, tasks);
    assertThat(result.resultingState, equalTo(clusterState));
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    super.setUp();
    allocationService = createAllocationService(Settings.builder()
        .put("cluster.routing.allocation.node_concurrent_recoveries", 8)
        .put(ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE_SETTING.getKey(), "always")
        .build());
    numberOfReplicas = randomIntBetween(2, 16);
    metaData = MetaData.builder()
        .put(IndexMetaData.builder(INDEX).settings(settings(Version.CURRENT))
            .numberOfShards(1).numberOfReplicas(numberOfReplicas).primaryTerm(0, randomIntBetween(2, 10)))
        .build();
    routingTable = RoutingTable.builder()
        .addAsNew(metaData.index(INDEX))
        .build();
    clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).metaData(metaData).routingTable(routingTable).build();
    executor = new ShardStateAction.ShardFailedClusterStateTaskExecutor(allocationService, null, logger);
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public void testDeleteWithExistingUnmatchedPipelines() {
    HashMap<String, PipelineConfiguration> pipelines = new HashMap<>();
    BytesArray definition = new BytesArray(
        "{\"processors\": [{\"set\" : {\"field\": \"_field\", \"value\": \"_value\"}}]}"
    );
    pipelines.put("p1", new PipelineConfiguration("p1", definition, XContentType.JSON));
    IngestMetadata ingestMetadata = new IngestMetadata(pipelines);
    ClusterState clusterState = ClusterState.builder(new ClusterName("_name")).build();
    ClusterState previousClusterState = clusterState;
    clusterState = ClusterState.builder(clusterState).metaData(MetaData.builder()
        .putCustom(IngestMetadata.TYPE, ingestMetadata)).build();
    store.innerUpdatePipelines(previousClusterState, clusterState);
    assertThat(store.get("p1"), notNullValue());

    DeletePipelineRequest deleteRequest = new DeletePipelineRequest("z*");
    try {
        store.innerDelete(deleteRequest, clusterState);
        fail("exception expected");
    } catch (ResourceNotFoundException e) {
        assertThat(e.getMessage(), equalTo("pipeline [z*] is missing"));
    }
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public void testMainResponseXContent() throws IOException {
    String clusterUUID = randomAsciiOfLengthBetween(10, 20);
    final MainResponse mainResponse = new MainResponse("node1", Version.CURRENT, new ClusterName("cluster1"), clusterUUID,
            Build.CURRENT, false);
    final String expected = "{" +
            "\"name\":\"node1\"," +
            "\"cluster_name\":\"cluster1\"," +
            "\"cluster_uuid\":\"" + clusterUUID + "\"," +
            "\"version\":{" +
            "\"number\":\"" + Version.CURRENT.toString() + "\"," +
            "\"build_hash\":\"" + Build.CURRENT.shortHash() + "\"," +
            "\"build_date\":\"" + Build.CURRENT.date() + "\"," +
            "\"build_snapshot\":" + Build.CURRENT.isSnapshot() +
            ",\"lucene_version\":\"" + Version.CURRENT.luceneVersion.toString() +
            "\"}," +
            "\"tagline\":\"You Know, for Search\"}";

    XContentBuilder builder = XContentFactory.jsonBuilder();
    mainResponse.toXContent(builder, ToXContent.EMPTY_PARAMS);
    String xContent = builder.string();

    assertEquals(expected, xContent);
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
private Settings.Builder createTribeSettings(Predicate<InternalTestCluster> filter) {
    assertNotNull(filter);

    final Settings.Builder settings = Settings.builder();
    settings.put(Node.NODE_NAME_SETTING.getKey(), TRIBE_NODE);
    settings.put(Node.NODE_DATA_SETTING.getKey(), false);
    settings.put(Node.NODE_MASTER_SETTING.getKey(), true);
    settings.put(NetworkModule.HTTP_ENABLED.getKey(), false);
    settings.put(NetworkModule.TRANSPORT_TYPE_SETTING.getKey(), MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME);

    doWithAllClusters(filter, c -> {
        String tribeSetting = "tribe." + c.getClusterName() + ".";
        settings.put(tribeSetting + ClusterName.CLUSTER_NAME_SETTING.getKey(), c.getClusterName());
        settings.put(tribeSetting + DiscoverySettings.INITIAL_STATE_TIMEOUT_SETTING.getKey(), "100ms");
        settings.put(tribeSetting + NetworkModule.TRANSPORT_TYPE_SETTING.getKey(), MockTcpTransportPlugin.MOCK_TCP_TRANSPORT_NAME);
    });

    return settings;
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的package包/类
public void testDefaultMaxConcurrentSearches() {
    int numDataNodes = randomIntBetween(1, 10);
    DiscoveryNodes.Builder builder = DiscoveryNodes.builder();
    for (int i = 0; i < numDataNodes; i++) {
        builder.add(new DiscoveryNode("_id" + i, buildNewFakeTransportAddress(), Collections.emptyMap(),
                Collections.singleton(DiscoveryNode.Role.DATA), Version.CURRENT));
    }
    builder.add(new DiscoveryNode("master", buildNewFakeTransportAddress(), Collections.emptyMap(),
            Collections.singleton(DiscoveryNode.Role.MASTER), Version.CURRENT));
    builder.add(new DiscoveryNode("ingest", buildNewFakeTransportAddress(), Collections.emptyMap(),
            Collections.singleton(DiscoveryNode.Role.INGEST), Version.CURRENT));

    ClusterState state = ClusterState.builder(new ClusterName("_name")).nodes(builder).build();
    int result = TransportMultiSearchAction.defaultMaxConcurrentSearches(10, state);
    assertThat(result, equalTo(10 * numDataNodes));

    state = ClusterState.builder(new ClusterName("_name")).build();
    result = TransportMultiSearchAction.defaultMaxConcurrentSearches(10, state);
    assertThat(result, equalTo(1));
}
 

import org.elasticsearch.cluster.ClusterName; //导入依赖的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()));
}