@Test
  public void testClusterStateSerialization() throws Exception {
    MetaData metaData =
        MetaData.builder()
            .put(IndexMetaData.builder("test").numberOfShards(10).numberOfReplicas(1))
            .build();

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

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

    ClusterState clusterState =
        ClusterState.builder().nodes(nodes).metaData(metaData).routingTable(routingTable).build();

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

    ClusterState serializedClusterState =
        ClusterState.Builder.fromBytes(
            ClusterState.Builder.toBytes(clusterState), newNode("node1"));

    assertThat(
        serializedClusterState.routingTable().prettyPrint(),
        equalTo(clusterState.routingTable().prettyPrint()));
  }
  private ClusterState addNode(ClusterState clusterState, AllocationService strategy) {
    logger.info(
        "now, start 1 more node, check that rebalancing will happen because we set it to always");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(
                DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node" + numberOfNodes)))
            .build();

    RoutingTable routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    RoutingNodes routingNodes = clusterState.getRoutingNodes();

    // move initializing to started

    RoutingTable prev = routingTable;
    while (true) {
      routingTable =
          strategy
              .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
              .routingTable();
      clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
      routingNodes = clusterState.getRoutingNodes();
      if (routingTable == prev) break;
      prev = routingTable;
    }

    return clusterState;
  }
  @Test
  public void testRoutingTableSerialization() throws Exception {
    MetaData metaData =
        MetaData.builder()
            .put(IndexMetaData.builder("test").numberOfShards(10).numberOfReplicas(1))
            .build();

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

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

    ClusterState clusterState =
        ClusterState.builder().nodes(nodes).metaData(metaData).routingTable(routingTable).build();

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

    BytesStreamOutput outStream = new BytesStreamOutput();
    RoutingTable.Builder.writeTo(source, outStream);
    BytesStreamInput inStream = new BytesStreamInput(outStream.bytes().toBytes(), false);
    RoutingTable target = RoutingTable.Builder.readFrom(inStream);

    assertThat(target.prettyPrint(), equalTo(source.prettyPrint()));
  }
  @Test
  public void testSingleIndexShardFailed() {
    AllocationService strategy =
        createAllocationService(
            settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build());

    logger.info("Building initial routing table");

    MetaData metaData =
        MetaData.builder()
            .put(IndexMetaData.builder("test").numberOfShards(1).numberOfReplicas(0))
            .build();

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

    ClusterState clusterState =
        ClusterState.builder().metaData(metaData).routingTable(routingTable).build();

    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(UNASSIGNED));
    assertThat(routingTable.index("test").shard(0).shards().get(0).currentNodeId(), nullValue());

    logger.info("Adding one node and rerouting");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder().put(newNode("node1")))
            .build();
    RoutingTable prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().get(0).unassigned(), equalTo(false));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(INITIALIZING));
    assertThat(
        routingTable.index("test").shard(0).shards().get(0).currentNodeId(), equalTo("node1"));

    logger.info("Marking the shard as failed");
    RoutingNodes routingNodes = clusterState.routingNodes();
    prevRoutingTable = routingTable;
    routingTable =
        strategy
            .applyFailedShard(
                clusterState, routingNodes.node("node1").shardsWithState(INITIALIZING).get(0))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(UNASSIGNED));
    assertThat(routingTable.index("test").shard(0).shards().get(0).currentNodeId(), nullValue());
  }
  public static void main(String[] args) {
    final int numberOfRuns = 1;
    final int numIndices = 5 * 365; // five years
    final int numShards = 6;
    final int numReplicas = 2;
    final int numberOfNodes = 30;
    final int numberOfTags = 2;
    AllocationService strategy =
        ElasticsearchAllocationTestCase.createAllocationService(
            ImmutableSettings.EMPTY, new Random(1));

    MetaData.Builder mb = MetaData.builder();
    for (int i = 1; i <= numIndices; i++) {
      mb.put(
          IndexMetaData.builder("test_" + i)
              .numberOfShards(numShards)
              .numberOfReplicas(numReplicas));
    }
    MetaData metaData = mb.build();
    RoutingTable.Builder rb = RoutingTable.builder();
    for (int i = 1; i <= numIndices; i++) {
      rb.addAsNew(metaData.index("test_" + i));
    }
    RoutingTable routingTable = rb.build();
    DiscoveryNodes.Builder nb = DiscoveryNodes.builder();
    for (int i = 1; i <= numberOfNodes; i++) {
      nb.put(newNode("node" + i, ImmutableMap.of("tag", "tag_" + (i % numberOfTags))));
    }
    ClusterState initialClusterState =
        ClusterState.builder().metaData(metaData).routingTable(routingTable).nodes(nb).build();

    long start = System.currentTimeMillis();
    for (int i = 0; i < numberOfRuns; i++) {
      logger.info("[{}] starting... ", i);
      long runStart = System.currentTimeMillis();
      ClusterState clusterState = initialClusterState;
      while (clusterState.readOnlyRoutingNodes().hasUnassignedShards()) {
        logger.info(
            "[{}] remaining unassigned {}",
            i,
            clusterState.readOnlyRoutingNodes().unassigned().size());
        RoutingAllocation.Result result =
            strategy.applyStartedShards(
                clusterState, clusterState.readOnlyRoutingNodes().shardsWithState(INITIALIZING));
        clusterState = ClusterState.builder(clusterState).routingResult(result).build();
        result = strategy.reroute(clusterState);
        clusterState = ClusterState.builder(clusterState).routingResult(result).build();
      }
      logger.info(
          "[{}] took {}", i, TimeValue.timeValueMillis(System.currentTimeMillis() - runStart));
    }
    long took = System.currentTimeMillis() - start;
    logger.info(
        "total took {}, AVG {}",
        TimeValue.timeValueMillis(took),
        TimeValue.timeValueMillis(took / numberOfRuns));
  }
Ejemplo n.º 6
0
  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;
  }
  private ClusterState removeNodes(ClusterState clusterState, AllocationService strategy) {
    logger.info("Removing half the nodes (" + (numberOfNodes + 1) / 2 + ")");
    DiscoveryNodes.Builder nodes = DiscoveryNodes.builder(clusterState.nodes());

    for (int i = (numberOfNodes + 1) / 2; i <= numberOfNodes; i++) {
      nodes.remove("node" + i);
    }

    clusterState = ClusterState.builder(clusterState).nodes(nodes.build()).build();
    RoutingNodes routingNodes = clusterState.getRoutingNodes();

    logger.info("start all the primary shards, replicas will start initializing");
    RoutingTable routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    routingNodes = clusterState.getRoutingNodes();

    logger.info("start the replica shards");
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    routingNodes = clusterState.getRoutingNodes();

    logger.info("rebalancing");
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    routingNodes = clusterState.getRoutingNodes();

    logger.info("complete rebalancing");
    RoutingTable prev = routingTable;
    while (true) {
      routingTable =
          strategy
              .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
              .routingTable();
      clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
      routingNodes = clusterState.getRoutingNodes();
      if (routingTable == prev) break;
      prev = routingTable;
    }

    return clusterState;
  }
  @Test
  public void simpleFlagTests() {
    AllocationService allocation =
        new AllocationService(
            settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build());

    logger.info("creating an index with 1 shard, no replica");
    MetaData metaData =
        newMetaDataBuilder()
            .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0))
            .build();
    RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).build();
    ClusterState clusterState =
        newClusterStateBuilder().metaData(metaData).routingTable(routingTable).build();
    assertThat(
        clusterState.routingTable().index("test").shard(0).primaryAllocatedPostApi(),
        equalTo(false));

    logger.info("adding two nodes and performing rerouting");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(newNodesBuilder().put(newNode("node1")).put(newNode("node2")))
            .build();
    RoutingAllocation.Result rerouteResult = allocation.reroute(clusterState);
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(
        clusterState.routingTable().index("test").shard(0).primaryAllocatedPostApi(),
        equalTo(false));

    logger.info("start primary shard");
    rerouteResult =
        allocation.applyStartedShards(
            clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(
        clusterState.routingTable().index("test").shard(0).primaryAllocatedPostApi(),
        equalTo(true));
  }
  @Test
  public void sameHost() {
    AllocationService strategy =
        new AllocationService(
            settingsBuilder().put(SameShardAllocationDecider.SAME_HOST_SETTING, true).build());

    MetaData metaData =
        newMetaDataBuilder()
            .put(newIndexMetaDataBuilder("test").numberOfShards(2).numberOfReplicas(1))
            .build();

    RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).build();
    ClusterState clusterState =
        newClusterStateBuilder().metaData(metaData).routingTable(routingTable).build();

    logger.info("--> adding two nodes with the same host");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(
                newNodesBuilder()
                    .put(newNode("node1", new InetSocketTransportAddress("test1", 80)))
                    .put(newNode("node2", new InetSocketTransportAddress("test1", 80))))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(
        clusterState.readOnlyRoutingNodes().numberOfShardsOfType(ShardRoutingState.INITIALIZING),
        equalTo(2));

    logger.info(
        "--> start all primary shards, no replica will be started since its on the same host");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.readOnlyRoutingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(
        clusterState.readOnlyRoutingNodes().numberOfShardsOfType(ShardRoutingState.STARTED),
        equalTo(2));
    assertThat(
        clusterState.readOnlyRoutingNodes().numberOfShardsOfType(ShardRoutingState.INITIALIZING),
        equalTo(0));

    logger.info("--> add another node, with a different host, replicas will be allocating");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(
                newNodesBuilder()
                    .putAll(clusterState.nodes())
                    .put(newNode("node3", new InetSocketTransportAddress("test2", 80))))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(
        clusterState.readOnlyRoutingNodes().numberOfShardsOfType(ShardRoutingState.STARTED),
        equalTo(2));
    assertThat(
        clusterState.readOnlyRoutingNodes().numberOfShardsOfType(ShardRoutingState.INITIALIZING),
        equalTo(2));
    for (MutableShardRouting shardRouting :
        clusterState.readOnlyRoutingNodes().shardsWithState(INITIALIZING)) {
      assertThat(shardRouting.currentNodeId(), equalTo("node3"));
    }
  }
Ejemplo n.º 10
0
  public void testSimple() {
    AllocationService strategy =
        createAllocationService(
            Settings.builder()
                .put(
                    ClusterRebalanceAllocationDecider
                        .CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE_SETTING.getKey(),
                    ClusterRebalanceAllocationDecider.ClusterRebalanceType.ALWAYS.toString())
                .build());

    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();

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

    ClusterState clusterState =
        ClusterState.builder(org.elasticsearch.cluster.ClusterName.DEFAULT)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();

    logger.info("start two nodes");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder().put(newNode("node1")).put(newNode("node2")))
            .build();
    routingTable = strategy.reroute(clusterState, "reroute").routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    for (int i = 0; i < routingTable.index("test1").shards().size(); i++) {
      assertThat(routingTable.index("test1").shard(i).shards().size(), equalTo(2));
      assertThat(
          routingTable.index("test1").shard(i).primaryShard().state(), equalTo(INITIALIZING));
      assertThat(
          routingTable.index("test1").shard(i).replicaShards().get(0).state(), equalTo(UNASSIGNED));
    }

    for (int i = 0; i < routingTable.index("test2").shards().size(); i++) {
      assertThat(routingTable.index("test2").shard(i).shards().size(), equalTo(2));
      assertThat(
          routingTable.index("test2").shard(i).primaryShard().state(), equalTo(INITIALIZING));
      assertThat(
          routingTable.index("test2").shard(i).replicaShards().get(0).state(), equalTo(UNASSIGNED));
    }

    logger.info("start all the primary shards for test1, replicas will start initializing");
    RoutingNodes routingNodes = clusterState.getRoutingNodes();
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState("test1", INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    routingNodes = clusterState.getRoutingNodes();

    for (int i = 0; i < routingTable.index("test1").shards().size(); i++) {
      assertThat(routingTable.index("test1").shard(i).shards().size(), equalTo(2));
      assertThat(routingTable.index("test1").shard(i).primaryShard().state(), equalTo(STARTED));
      assertThat(
          routingTable.index("test1").shard(i).replicaShards().get(0).state(),
          equalTo(INITIALIZING));
    }

    for (int i = 0; i < routingTable.index("test2").shards().size(); i++) {
      assertThat(routingTable.index("test2").shard(i).shards().size(), equalTo(2));
      assertThat(
          routingTable.index("test2").shard(i).primaryShard().state(), equalTo(INITIALIZING));
      assertThat(
          routingTable.index("test2").shard(i).replicaShards().get(0).state(), equalTo(UNASSIGNED));
    }
  }
  /**
   * Tests that higher prioritized primaries and replicas are allocated first even on the balanced
   * shard allocator See https://github.com/elastic/elasticsearch/issues/13249 for details
   */
  public void testPrioritizedIndicesAllocatedFirst() {
    AllocationService allocation =
        createAllocationService(
            Settings.builder()
                .put(
                    ThrottlingAllocationDecider
                        .CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_RECOVERIES_SETTING.getKey(),
                    1)
                .put(
                    ThrottlingAllocationDecider
                        .CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_OUTGOING_RECOVERIES_SETTING
                        .getKey(),
                    10)
                .put(
                    ThrottlingAllocationDecider
                        .CLUSTER_ROUTING_ALLOCATION_NODE_INITIAL_PRIMARIES_RECOVERIES_SETTING
                        .getKey(),
                    1)
                .put(
                    ThrottlingAllocationDecider
                        .CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_INCOMING_RECOVERIES_SETTING
                        .getKey(),
                    1)
                .build());
    final String highPriorityName;
    final String lowPriorityName;
    final int priorityFirst;
    final int prioritySecond;
    if (randomBoolean()) {
      highPriorityName = "first";
      lowPriorityName = "second";
      prioritySecond = 1;
      priorityFirst = 100;
    } else {
      lowPriorityName = "first";
      highPriorityName = "second";
      prioritySecond = 100;
      priorityFirst = 1;
    }
    MetaData metaData =
        MetaData.builder()
            .put(
                IndexMetaData.builder("first")
                    .settings(
                        settings(Version.CURRENT)
                            .put(IndexMetaData.SETTING_PRIORITY, priorityFirst))
                    .numberOfShards(2)
                    .numberOfReplicas(1))
            .put(
                IndexMetaData.builder("second")
                    .settings(
                        settings(Version.CURRENT)
                            .put(IndexMetaData.SETTING_PRIORITY, prioritySecond))
                    .numberOfShards(2)
                    .numberOfReplicas(1))
            .build();
    RoutingTable routingTable =
        RoutingTable.builder()
            .addAsNew(metaData.index("first"))
            .addAsNew(metaData.index("second"))
            .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().put(newNode("node1")).put(newNode("node2")))
            .build();
    RoutingAllocation.Result rerouteResult = allocation.reroute(clusterState, "reroute");
    clusterState =
        ClusterState.builder(clusterState).routingTable(rerouteResult.routingTable()).build();

    routingTable = allocation.reroute(clusterState, "reroute").routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    assertEquals(2, clusterState.getRoutingNodes().shardsWithState(INITIALIZING).size());
    assertEquals(
        highPriorityName,
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).get(0).getIndexName());
    assertEquals(
        highPriorityName,
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).get(1).getIndexName());

    routingTable =
        allocation
            .applyStartedShards(
                clusterState, clusterState.getRoutingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    assertEquals(2, clusterState.getRoutingNodes().shardsWithState(INITIALIZING).size());
    assertEquals(
        lowPriorityName,
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).get(0).getIndexName());
    assertEquals(
        lowPriorityName,
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).get(1).getIndexName());

    routingTable =
        allocation
            .applyStartedShards(
                clusterState, clusterState.getRoutingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    assertEquals(
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).toString(),
        2,
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).size());
    assertEquals(
        highPriorityName,
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).get(0).getIndexName());
    assertEquals(
        highPriorityName,
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).get(1).getIndexName());

    routingTable =
        allocation
            .applyStartedShards(
                clusterState, clusterState.getRoutingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    assertEquals(2, clusterState.getRoutingNodes().shardsWithState(INITIALIZING).size());
    assertEquals(
        lowPriorityName,
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).get(0).getIndexName());
    assertEquals(
        lowPriorityName,
        clusterState.getRoutingNodes().shardsWithState(INITIALIZING).get(1).getIndexName());
  }
  @Test
  public void testPrimaryRecoveryThrottling() {
    AllocationService strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.node_concurrent_recoveries", 3)
                .put("cluster.routing.allocation.node_initial_primaries_recoveries", 3)
                .build());

    logger.info("Building initial routing table");

    MetaData metaData =
        newMetaDataBuilder()
            .put(newIndexMetaDataBuilder("test").numberOfShards(10).numberOfReplicas(1))
            .build();

    RoutingTable routingTable =
        routingTable()
            .add(indexRoutingTable("test").initializeEmpty(metaData.index("test")))
            .build();

    ClusterState clusterState =
        newClusterStateBuilder().metaData(metaData).routingTable(routingTable).build();

    logger.info("start one node, do reroute, only 3 should initialize");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(newNodesBuilder().put(RoutingAllocationTests.newNode("node1")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(routingTable.shardsWithState(STARTED).size(), equalTo(0));
    assertThat(routingTable.shardsWithState(INITIALIZING).size(), equalTo(3));
    assertThat(routingTable.shardsWithState(UNASSIGNED).size(), equalTo(17));

    logger.info("start initializing, another 3 should initialize");
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingTable.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(routingTable.shardsWithState(STARTED).size(), equalTo(3));
    assertThat(routingTable.shardsWithState(INITIALIZING).size(), equalTo(3));
    assertThat(routingTable.shardsWithState(UNASSIGNED).size(), equalTo(14));

    logger.info("start initializing, another 3 should initialize");
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingTable.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(routingTable.shardsWithState(STARTED).size(), equalTo(6));
    assertThat(routingTable.shardsWithState(INITIALIZING).size(), equalTo(3));
    assertThat(routingTable.shardsWithState(UNASSIGNED).size(), equalTo(11));

    logger.info("start initializing, another 1 should initialize");
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingTable.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(routingTable.shardsWithState(STARTED).size(), equalTo(9));
    assertThat(routingTable.shardsWithState(INITIALIZING).size(), equalTo(1));
    assertThat(routingTable.shardsWithState(UNASSIGNED).size(), equalTo(10));

    logger.info("start initializing, all primaries should be started");
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingTable.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(routingTable.shardsWithState(STARTED).size(), equalTo(10));
    assertThat(routingTable.shardsWithState(INITIALIZING).size(), equalTo(0));
    assertThat(routingTable.shardsWithState(UNASSIGNED).size(), equalTo(10));
  }
  @Test
  public void indexLevelShardsLimitRemain() {
    AllocationService strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put("cluster.routing.allocation.node_initial_primaries_recoveries", 10)
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .put("cluster.routing.allocation.balance.index", 0.0f)
                .put("cluster.routing.allocation.balance.replica", 1.0f)
                .put("cluster.routing.allocation.balance.primary", 0.0f)
                .build());

    logger.info("Building initial routing table");

    MetaData metaData =
        newMetaDataBuilder()
            .put(
                newIndexMetaDataBuilder("test")
                    .settings(
                        ImmutableSettings.settingsBuilder()
                            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 5)
                            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0)))
            .build();

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

    ClusterState clusterState =
        newClusterStateBuilder().metaData(metaData).routingTable(routingTable).build();
    logger.info("Adding one node and reroute");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(newNodesBuilder().put(newNode("node1")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    logger.info("Start the primary shards");
    RoutingNodes routingNodes = clusterState.routingNodes();
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(clusterState.readOnlyRoutingNodes().numberOfShardsOfType(STARTED), equalTo(5));

    logger.info("add another index with 5 shards");
    metaData =
        newMetaDataBuilder()
            .metaData(metaData)
            .put(
                newIndexMetaDataBuilder("test1")
                    .settings(
                        ImmutableSettings.settingsBuilder()
                            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 5)
                            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0)))
            .build();
    routingTable =
        routingTable().routingTable(routingTable).addAsNew(metaData.index("test1")).build();

    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();

    logger.info("Add another one node and reroute");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(newNodesBuilder().putAll(clusterState.nodes()).put(newNode("node2")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    routingNodes = clusterState.routingNodes();
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(clusterState.readOnlyRoutingNodes().numberOfShardsOfType(STARTED), equalTo(10));

    for (MutableShardRouting shardRouting : clusterState.readOnlyRoutingNodes().node("node1")) {
      assertThat(shardRouting.index(), equalTo("test"));
    }
    for (MutableShardRouting shardRouting : clusterState.readOnlyRoutingNodes().node("node2")) {
      assertThat(shardRouting.index(), equalTo("test1"));
    }

    logger.info(
        "update "
            + ShardsLimitAllocationDecider.INDEX_TOTAL_SHARDS_PER_NODE
            + " for test, see that things move");
    metaData =
        newMetaDataBuilder()
            .metaData(metaData)
            .put(
                newIndexMetaDataBuilder("test")
                    .settings(
                        ImmutableSettings.settingsBuilder()
                            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 5)
                            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0)
                            .put(ShardsLimitAllocationDecider.INDEX_TOTAL_SHARDS_PER_NODE, 3)))
            .build();

    clusterState = newClusterStateBuilder().state(clusterState).metaData(metaData).build();

    logger.info("reroute after setting");
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(
        clusterState.readOnlyRoutingNodes().node("node1").numberOfShardsWithState(STARTED),
        equalTo(3));
    assertThat(
        clusterState.readOnlyRoutingNodes().node("node1").numberOfShardsWithState(RELOCATING),
        equalTo(2));
    assertThat(
        clusterState.readOnlyRoutingNodes().node("node2").numberOfShardsWithState(RELOCATING),
        equalTo(2));
    assertThat(
        clusterState.readOnlyRoutingNodes().node("node2").numberOfShardsWithState(STARTED),
        equalTo(3));
    // the first move will destroy the balance and the balancer will move 2 shards from node2 to
    // node one right after
    // moving the nodes to node2 since we consider INITIALIZING nodes during rebalance
    routingNodes = clusterState.routingNodes();
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
    // now we are done compared to EvenShardCountAllocator since the Balancer is not soely based on
    // the average
    assertThat(
        clusterState.readOnlyRoutingNodes().node("node1").numberOfShardsWithState(STARTED),
        equalTo(5));
    assertThat(
        clusterState.readOnlyRoutingNodes().node("node2").numberOfShardsWithState(STARTED),
        equalTo(5));
  }
  public void testBalanceAllNodesStartedAddIndex() {
    AllocationService strategy =
        createAllocationService(
            Settings.builder()
                .put("cluster.routing.allocation.node_concurrent_recoveries", 10)
                .put("cluster.routing.allocation.node_initial_primaries_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider
                        .CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE_SETTING.getKey(),
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build());

    logger.info("Building initial routing table");

    MetaData metaData =
        MetaData.builder()
            .put(
                IndexMetaData.builder("test")
                    .settings(settings(Version.CURRENT))
                    .numberOfShards(3)
                    .numberOfReplicas(1))
            .build();

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

    ClusterState clusterState =
        ClusterState.builder(
                org.elasticsearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(
                    Settings.EMPTY))
            .metaData(metaData)
            .routingTable(initialRoutingTable)
            .build();

    assertThat(clusterState.routingTable().index("test").shards().size(), equalTo(3));
    for (int i = 0; i < clusterState.routingTable().index("test").shards().size(); i++) {
      assertThat(clusterState.routingTable().index("test").shard(i).size(), equalTo(2));
      assertThat(clusterState.routingTable().index("test").shard(i).shards().size(), equalTo(2));
      assertThat(
          clusterState.routingTable().index("test").shard(i).shards().get(0).state(),
          equalTo(UNASSIGNED));
      assertThat(
          clusterState.routingTable().index("test").shard(i).shards().get(1).state(),
          equalTo(UNASSIGNED));
      assertThat(
          clusterState.routingTable().index("test").shard(i).shards().get(0).currentNodeId(),
          nullValue());
      assertThat(
          clusterState.routingTable().index("test").shard(i).shards().get(1).currentNodeId(),
          nullValue());
    }

    logger.info("Adding three node and performing rerouting");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(
                DiscoveryNodes.builder()
                    .add(newNode("node1"))
                    .add(newNode("node2"))
                    .add(newNode("node3")))
            .build();

    ClusterState newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, not(equalTo(clusterState)));
    clusterState = newState;
    assertThat(clusterState.routingTable().index("test").shards().size(), equalTo(3));
    for (int i = 0; i < clusterState.routingTable().index("test").shards().size(); i++) {
      assertThat(clusterState.routingTable().index("test").shard(i).size(), equalTo(2));
      assertThat(clusterState.routingTable().index("test").shard(i).shards().size(), equalTo(2));
      assertThat(
          clusterState.routingTable().index("test").shard(i).primaryShard().state(),
          equalTo(INITIALIZING));
      assertThat(
          clusterState.routingTable().index("test").shard(i).replicaShards().size(), equalTo(1));
      assertThat(
          clusterState.routingTable().index("test").shard(i).replicaShards().get(0).state(),
          equalTo(UNASSIGNED));
      assertThat(
          clusterState.routingTable().index("test").shard(i).replicaShards().get(0).currentNodeId(),
          nullValue());
    }

    logger.info("Another round of rebalancing");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()))
            .build();
    newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, equalTo(clusterState));

    RoutingNodes routingNodes = clusterState.getRoutingNodes();
    newState =
        strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));
    assertThat(newState, not(equalTo(clusterState)));
    clusterState = newState;
    assertThat(clusterState.routingTable().index("test").shards().size(), equalTo(3));
    for (int i = 0; i < clusterState.routingTable().index("test").shards().size(); i++) {
      assertThat(clusterState.routingTable().index("test").shard(i).size(), equalTo(2));
      assertThat(clusterState.routingTable().index("test").shard(i).shards().size(), equalTo(2));
      assertThat(
          clusterState.routingTable().index("test").shard(i).primaryShard().state(),
          equalTo(STARTED));
      assertThat(
          clusterState.routingTable().index("test").shard(i).replicaShards().size(), equalTo(1));
      // backup shards are initializing as well, we make sure that they
      // recover from primary *started* shards in the
      // IndicesClusterStateService
      assertThat(
          clusterState.routingTable().index("test").shard(i).replicaShards().get(0).state(),
          equalTo(INITIALIZING));
    }

    logger.info("Reroute, nothing should change");
    newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, equalTo(clusterState));

    logger.info("Start the more shards");
    routingNodes = clusterState.getRoutingNodes();
    newState =
        strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));
    assertThat(newState, not(equalTo(clusterState)));
    clusterState = newState;
    routingNodes = clusterState.getRoutingNodes();
    assertThat(clusterState.routingTable().index("test").shards().size(), equalTo(3));
    for (int i = 0; i < clusterState.routingTable().index("test").shards().size(); i++) {
      assertThat(clusterState.routingTable().index("test").shard(i).size(), equalTo(2));
      assertThat(clusterState.routingTable().index("test").shard(i).shards().size(), equalTo(2));
      assertThat(
          clusterState.routingTable().index("test").shard(i).primaryShard().state(),
          equalTo(STARTED));
      assertThat(
          clusterState.routingTable().index("test").shard(i).replicaShards().size(), equalTo(1));
    }
    assertThat(routingNodes.node("node1").numberOfShardsWithState(STARTED), equalTo(2));
    assertThat(routingNodes.node("node2").numberOfShardsWithState(STARTED), equalTo(2));
    assertThat(routingNodes.node("node3").numberOfShardsWithState(STARTED), equalTo(2));

    assertThat(routingNodes.node("node1").shardsWithState("test", STARTED).size(), equalTo(2));
    assertThat(routingNodes.node("node2").shardsWithState("test", STARTED).size(), equalTo(2));
    assertThat(routingNodes.node("node3").shardsWithState("test", STARTED).size(), equalTo(2));

    logger.info("Add new index 3 shards 1 replica");

    MetaData updatedMetaData =
        MetaData.builder(clusterState.metaData())
            .put(
                IndexMetaData.builder("test1")
                    .settings(
                        settings(Version.CURRENT)
                            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 3)
                            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1)))
            .build();
    RoutingTable updatedRoutingTable =
        RoutingTable.builder(clusterState.routingTable())
            .addAsNew(updatedMetaData.index("test1"))
            .build();
    clusterState =
        ClusterState.builder(clusterState)
            .metaData(updatedMetaData)
            .routingTable(updatedRoutingTable)
            .build();

    assertThat(clusterState.routingTable().index("test1").shards().size(), equalTo(3));

    newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, not(equalTo(clusterState)));
    clusterState = newState;
    assertThat(clusterState.routingTable().index("test1").shards().size(), equalTo(3));
    for (int i = 0; i < clusterState.routingTable().index("test1").shards().size(); i++) {
      assertThat(clusterState.routingTable().index("test1").shard(i).size(), equalTo(2));
      assertThat(clusterState.routingTable().index("test1").shard(i).shards().size(), equalTo(2));
      assertThat(
          clusterState.routingTable().index("test1").shard(i).primaryShard().state(),
          equalTo(INITIALIZING));
      assertThat(
          clusterState.routingTable().index("test1").shard(i).replicaShards().size(), equalTo(1));
      assertThat(
          clusterState.routingTable().index("test1").shard(i).replicaShards().get(0).state(),
          equalTo(UNASSIGNED));
      assertThat(
          clusterState
              .routingTable()
              .index("test1")
              .shard(i)
              .replicaShards()
              .get(0)
              .currentNodeId(),
          nullValue());
    }

    logger.info("Another round of rebalancing");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()))
            .build();
    newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, equalTo(clusterState));

    routingNodes = clusterState.getRoutingNodes();
    newState =
        strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));
    assertThat(newState, not(equalTo(clusterState)));
    clusterState = newState;
    assertThat(clusterState.routingTable().index("test1").shards().size(), equalTo(3));
    for (int i = 0; i < clusterState.routingTable().index("test1").shards().size(); i++) {
      assertThat(clusterState.routingTable().index("test1").shard(i).size(), equalTo(2));
      assertThat(clusterState.routingTable().index("test1").shard(i).shards().size(), equalTo(2));
      assertThat(
          clusterState.routingTable().index("test1").shard(i).primaryShard().state(),
          equalTo(STARTED));
      assertThat(
          clusterState.routingTable().index("test1").shard(i).replicaShards().size(), equalTo(1));
      // backup shards are initializing as well, we make sure that they
      // recover from primary *started* shards in the
      // IndicesClusterStateService
      assertThat(
          clusterState.routingTable().index("test1").shard(i).replicaShards().get(0).state(),
          equalTo(INITIALIZING));
    }

    logger.info("Reroute, nothing should change");
    newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, equalTo(clusterState));

    logger.info("Start the more shards");
    routingNodes = clusterState.getRoutingNodes();
    newState =
        strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));
    assertThat(newState, not(equalTo(clusterState)));
    clusterState = newState;
    routingNodes = clusterState.getRoutingNodes();
    assertThat(clusterState.routingTable().index("test1").shards().size(), equalTo(3));
    for (int i = 0; i < clusterState.routingTable().index("test1").shards().size(); i++) {
      assertThat(clusterState.routingTable().index("test1").shard(i).size(), equalTo(2));
      assertThat(clusterState.routingTable().index("test1").shard(i).shards().size(), equalTo(2));
      assertThat(
          clusterState.routingTable().index("test1").shard(i).primaryShard().state(),
          equalTo(STARTED));
      assertThat(
          clusterState.routingTable().index("test1").shard(i).replicaShards().size(), equalTo(1));
    }
    assertThat(routingNodes.node("node1").numberOfShardsWithState(STARTED), equalTo(4));
    assertThat(routingNodes.node("node2").numberOfShardsWithState(STARTED), equalTo(4));
    assertThat(routingNodes.node("node3").numberOfShardsWithState(STARTED), equalTo(4));

    assertThat(routingNodes.node("node1").shardsWithState("test1", STARTED).size(), equalTo(2));
    assertThat(routingNodes.node("node2").shardsWithState("test1", STARTED).size(), equalTo(2));
    assertThat(routingNodes.node("node3").shardsWithState("test1", STARTED).size(), equalTo(2));
  }
  @Test
  @TestLogging("cluster.routing.allocation.decider:TRACE")
  public void diskThresholdWithAbsoluteSizesTest() {
    Settings diskSettings =
        settingsBuilder()
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK, "30b")
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK, "9b")
            .build();

    Map<String, DiskUsage> usages = new HashMap<>();
    usages.put("node1", new DiskUsage("node1", 100, 10)); // 90% used
    usages.put("node2", new DiskUsage("node2", 100, 10)); // 90% used
    usages.put("node3", new DiskUsage("node3", 100, 60)); // 40% used
    usages.put("node4", new DiskUsage("node4", 100, 80)); // 20% used
    usages.put("node5", new DiskUsage("node5", 100, 85)); // 15% used

    Map<String, Long> shardSizes = new HashMap<>();
    shardSizes.put("[test][0][p]", 10L); // 10 bytes
    shardSizes.put("[test][0][r]", 10L);
    final ClusterInfo clusterInfo =
        new ClusterInfo(ImmutableMap.copyOf(usages), ImmutableMap.copyOf(shardSizes));

    AllocationDeciders deciders =
        new AllocationDeciders(
            ImmutableSettings.EMPTY,
            new HashSet<>(
                Arrays.asList(
                    new SameShardAllocationDecider(ImmutableSettings.EMPTY),
                    new DiskThresholdDecider(diskSettings))));

    ClusterInfoService cis =
        new ClusterInfoService() {
          @Override
          public ClusterInfo getClusterInfo() {
            logger.info("--> calling fake getClusterInfo");
            return clusterInfo;
          }
        };

    AllocationService strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    MetaData metaData =
        MetaData.builder()
            .put(IndexMetaData.builder("test").numberOfShards(1).numberOfReplicas(2))
            .build();

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

    ClusterState clusterState =
        ClusterState.builder(org.elasticsearch.cluster.ClusterName.DEFAULT)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();

    logger.info("--> adding node1 and node2 node");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder().put(newNode("node1")).put(newNode("node2")))
            .build();

    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logShardStates(clusterState);

    // Primary should initialize, even though both nodes are over the limit initialize
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(1));

    String nodeWithPrimary, nodeWithoutPrimary;
    if (clusterState.getRoutingNodes().node("node1").size() == 1) {
      nodeWithPrimary = "node1";
      nodeWithoutPrimary = "node2";
    } else {
      nodeWithPrimary = "node2";
      nodeWithoutPrimary = "node1";
    }
    logger.info("--> nodeWithPrimary: {}", nodeWithPrimary);
    logger.info("--> nodeWithoutPrimary: {}", nodeWithoutPrimary);

    // Make node without the primary now habitable to replicas
    usages.put(nodeWithoutPrimary, new DiskUsage(nodeWithoutPrimary, 100, 35)); // 65% used
    final ClusterInfo clusterInfo2 =
        new ClusterInfo(ImmutableMap.copyOf(usages), ImmutableMap.copyOf(shardSizes));
    cis =
        new ClusterInfoService() {
          @Override
          public ClusterInfo getClusterInfo() {
            logger.info("--> calling fake getClusterInfo");
            return clusterInfo2;
          }
        };
    strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logShardStates(clusterState);

    // Now the replica should be able to initialize
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(2));

    logger.info("--> start the shards (primaries)");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Assert that we're able to start the primary and replica, since they were both initializing
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(2));
    // Assert that node1 got a single shard (the primary), even though its disk usage is too high
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(1));
    // Assert that node2 got a single shard (a replica)
    assertThat(clusterState.getRoutingNodes().node("node2").size(), equalTo(1));

    // Assert that one replica is still unassigned
    // assertThat(clusterState.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED).size(),
    // equalTo(1));

    logger.info("--> adding node3");

    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node3")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Assert that the replica is initialized now that node3 is available with enough space
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(2));
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size(),
        equalTo(1));

    logger.info("--> start the shards (replicas)");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Assert that all replicas could be started
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(3));
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node2").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));

    logger.info("--> changing decider settings");

    // Set the low threshold to 60 instead of 70
    // Set the high threshold to 70 instead of 80
    // node2 now should not have new shards allocated to it, but shards can remain
    diskSettings =
        settingsBuilder()
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK, "40b")
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK, "30b")
            .build();

    deciders =
        new AllocationDeciders(
            ImmutableSettings.EMPTY,
            new HashSet<>(
                Arrays.asList(
                    new SameShardAllocationDecider(ImmutableSettings.EMPTY),
                    new DiskThresholdDecider(diskSettings))));

    strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logShardStates(clusterState);

    // Shards remain started
    assertThat(clusterState.routingNodes().shardsWithState(STARTED).size(), equalTo(3));
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node2").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));

    logger.info("--> changing settings again");

    // Set the low threshold to 50 instead of 60
    // Set the high threshold to 60 instead of 70
    // node2 now should not have new shards allocated to it, and shards cannot remain
    diskSettings =
        settingsBuilder()
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK, "50b")
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK, "40b")
            .build();

    deciders =
        new AllocationDeciders(
            ImmutableSettings.EMPTY,
            new HashSet<>(
                Arrays.asList(
                    new SameShardAllocationDecider(ImmutableSettings.EMPTY),
                    new DiskThresholdDecider(diskSettings))));

    strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Shards remain started
    assertThat(clusterState.routingNodes().shardsWithState(STARTED).size(), equalTo(3));
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(1));
    // Shard hasn't been moved off of node2 yet because there's nowhere for it to go
    assertThat(clusterState.getRoutingNodes().node("node2").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));

    logger.info("--> adding node4");

    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node4")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Shards remain started
    assertThat(clusterState.routingNodes().shardsWithState(STARTED).size(), equalTo(2));
    // One shard is relocating off of node1
    assertThat(clusterState.routingNodes().shardsWithState(RELOCATING).size(), equalTo(1));
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(1));

    logger.info("--> apply INITIALIZING shards");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // primary shard already has been relocated away
    assertThat(clusterState.getRoutingNodes().node(nodeWithPrimary).size(), equalTo(0));
    // node with increased space still has its shard
    assertThat(clusterState.getRoutingNodes().node(nodeWithoutPrimary).size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node4").size(), equalTo(1));

    logger.info("--> adding node5");

    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node5")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Shards remain started on node3 and node4
    assertThat(clusterState.routingNodes().shardsWithState(STARTED).size(), equalTo(2));
    // One shard is relocating off of node2 now
    assertThat(clusterState.routingNodes().shardsWithState(RELOCATING).size(), equalTo(1));
    // Initializing on node5
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(1));

    logger.info("--> apply INITIALIZING shards");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logger.info("--> final cluster state:");
    logShardStates(clusterState);
    // Node1 still has no shards because it has no space for them
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(0));
    // Node5 is available now, so the shard is moved off of node2
    assertThat(clusterState.getRoutingNodes().node("node2").size(), equalTo(0));
    assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node4").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node5").size(), equalTo(1));
  }
  @Test
  public void tesStartedShardsMatching() {
    AllocationService allocation = createAllocationService();

    logger.info("--> building initial cluster state");
    final IndexMetaData indexMetaData =
        IndexMetaData.builder("test").numberOfShards(3).numberOfReplicas(0).build();
    ClusterState.Builder stateBuilder =
        ClusterState.builder(ClusterName.DEFAULT)
            .nodes(DiscoveryNodes.builder().put(newNode("node1")).put(newNode("node2")))
            .metaData(MetaData.builder().put(indexMetaData, false));

    final ImmutableShardRouting initShard =
        new ImmutableShardRouting(
            "test", 0, "node1", randomBoolean(), ShardRoutingState.INITIALIZING, 1);
    final ImmutableShardRouting startedShard =
        new ImmutableShardRouting(
            "test", 1, "node2", randomBoolean(), ShardRoutingState.STARTED, 1);
    final ImmutableShardRouting relocatingShard =
        new ImmutableShardRouting(
            "test", 2, "node1", "node2", randomBoolean(), ShardRoutingState.RELOCATING, 1);
    stateBuilder.routingTable(
        RoutingTable.builder()
            .add(
                IndexRoutingTable.builder("test")
                    .addIndexShard(
                        new IndexShardRoutingTable.Builder(initShard.shardId(), true)
                            .addShard(initShard)
                            .build())
                    .addIndexShard(
                        new IndexShardRoutingTable.Builder(startedShard.shardId(), true)
                            .addShard(startedShard)
                            .build())
                    .addIndexShard(
                        new IndexShardRoutingTable.Builder(relocatingShard.shardId(), true)
                            .addShard(relocatingShard)
                            .build())));

    ClusterState state = stateBuilder.build();

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

    RoutingAllocation.Result result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    initShard.index(),
                    initShard.id(),
                    initShard.currentNodeId(),
                    initShard.relocatingNodeId(),
                    initShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    randomInt())),
            false);
    assertTrue(
        "failed to start "
            + initShard
            + "\ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());
    assertTrue(
        initShard + "isn't started \ncurrent routing table:" + result.routingTable().prettyPrint(),
        result
                .routingTable()
                .index("test")
                .shard(initShard.id())
                .countWithState(ShardRoutingState.STARTED)
            == 1);

    logger.info("--> testing shard variants that shouldn't match the started shard");

    result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    initShard.index(),
                    initShard.id(),
                    initShard.currentNodeId(),
                    initShard.relocatingNodeId(),
                    !initShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    1)),
            false);
    assertFalse(
        "wrong primary flag shouldn't start shard "
            + initShard
            + "\ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());

    result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    initShard.index(),
                    initShard.id(),
                    "some_node",
                    initShard.currentNodeId(),
                    initShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    1)),
            false);
    assertFalse(
        "relocating shard from node shouldn't start shard "
            + initShard
            + "\ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());

    result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    initShard.index(),
                    initShard.id(),
                    initShard.currentNodeId(),
                    "some_node",
                    initShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    1)),
            false);
    assertFalse(
        "relocating shard to node shouldn't start shard "
            + initShard
            + "\ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());

    logger.info("--> testing double starting");

    result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    startedShard.index(),
                    startedShard.id(),
                    startedShard.currentNodeId(),
                    startedShard.relocatingNodeId(),
                    startedShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    1)),
            false);
    assertFalse(
        "duplicate starting of the same shard should be ignored \ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());

    logger.info("--> testing starting of relocating shards");
    result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    relocatingShard.index(),
                    relocatingShard.id(),
                    relocatingShard.relocatingNodeId(),
                    relocatingShard.currentNodeId(),
                    relocatingShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    randomInt())),
            false);
    assertTrue(
        "failed to start "
            + relocatingShard
            + "\ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());
    ShardRouting shardRouting =
        result.routingTable().index("test").shard(relocatingShard.id()).getShards().get(0);
    assertThat(shardRouting.state(), equalTo(ShardRoutingState.STARTED));
    assertThat(shardRouting.currentNodeId(), equalTo("node2"));
    assertThat(shardRouting.relocatingNodeId(), nullValue());

    logger.info("--> testing shard variants that shouldn't match the relocating shard");

    result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    relocatingShard.index(),
                    relocatingShard.id(),
                    relocatingShard.relocatingNodeId(),
                    relocatingShard.currentNodeId(),
                    !relocatingShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    1)),
            false);
    assertFalse(
        "wrong primary flag shouldn't start shard "
            + relocatingShard
            + "\ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());

    result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    relocatingShard.index(),
                    relocatingShard.id(),
                    "some_node",
                    relocatingShard.currentNodeId(),
                    relocatingShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    1)),
            false);
    assertFalse(
        "relocating shard to a different node shouldn't start shard "
            + relocatingShard
            + "\ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());

    result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    relocatingShard.index(),
                    relocatingShard.id(),
                    relocatingShard.relocatingNodeId(),
                    "some_node",
                    relocatingShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    1)),
            false);
    assertFalse(
        "relocating shard from a different node shouldn't start shard "
            + relocatingShard
            + "\ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());

    result =
        allocation.applyStartedShards(
            state,
            Arrays.asList(
                new ImmutableShardRouting(
                    relocatingShard.index(),
                    relocatingShard.id(),
                    relocatingShard.relocatingNodeId(),
                    relocatingShard.primary(),
                    ShardRoutingState.INITIALIZING,
                    1)),
            false);
    assertFalse(
        "non-relocating shard shouldn't start shard"
            + relocatingShard
            + "\ncurrent routing table:"
            + result.routingTable().prettyPrint(),
        result.changed());
  }
  @Test
  public void moveShardCommand() {
    AllocationService allocation =
        new AllocationService(
            settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build());

    logger.info("creating an index with 1 shard, no replica");
    MetaData metaData =
        newMetaDataBuilder()
            .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(0))
            .build();
    RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).build();
    ClusterState clusterState =
        newClusterStateBuilder().metaData(metaData).routingTable(routingTable).build();

    logger.info("adding two nodes and performing rerouting");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(newNodesBuilder().put(newNode("node1")).put(newNode("node2")))
            .build();
    RoutingAllocationResult rerouteResult = allocation.reroute(clusterState);
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();

    logger.info("start primary shard");
    rerouteResult =
        allocation.applyStartedShards(
            clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();

    logger.info("move the shard");
    String existingNodeId =
        clusterState.routingTable().index("test").shard(0).primaryShard().currentNodeId();
    String toNodeId;
    if ("node1".equals(existingNodeId)) {
      toNodeId = "node2";
    } else {
      toNodeId = "node1";
    }
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new MoveAllocationCommand(new ShardId("test", 0), existingNodeId, toNodeId)));
    assertThat(rerouteResult.changed(), equalTo(true));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(
        clusterState.routingNodes().node(existingNodeId).shards().get(0).state(),
        equalTo(ShardRoutingState.RELOCATING));
    assertThat(
        clusterState.routingNodes().node(toNodeId).shards().get(0).state(),
        equalTo(ShardRoutingState.INITIALIZING));

    logger.info("finish moving the shard");
    rerouteResult =
        allocation.applyStartedShards(
            clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();

    assertThat(clusterState.routingNodes().node(existingNodeId).shards().isEmpty(), equalTo(true));
    assertThat(
        clusterState.routingNodes().node(toNodeId).shards().get(0).state(),
        equalTo(ShardRoutingState.STARTED));
  }
  @Test
  public void cancelCommand() {
    AllocationService allocation =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.disable_new_allocation", true)
                .put("cluster.routing.allocation.disable_allocation", true)
                .build());

    logger.info("--> building initial routing table");
    MetaData metaData =
        newMetaDataBuilder()
            .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
            .build();
    RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).build();
    ClusterState clusterState =
        newClusterStateBuilder().metaData(metaData).routingTable(routingTable).build();

    logger.info("--> adding 3 nodes");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(
                newNodesBuilder().put(newNode("node1")).put(newNode("node2")).put(newNode("node3")))
            .build();
    RoutingAllocationResult rerouteResult = allocation.reroute(clusterState);
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(0));

    logger.info("--> allocating with primary flag set to true");
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new AllocateAllocationCommand(new ShardId("test", 0), "node1", true)));
    assertThat(rerouteResult.changed(), equalTo(true));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(0));

    logger.info("--> cancel primary allocation, make sure it fails...");
    try {
      allocation.reroute(
          clusterState,
          new AllocationCommands(
              new CancelAllocationCommand(new ShardId("test", 0), "node1", false)));
      assert false;
    } catch (ElasticSearchIllegalArgumentException e) {
    }

    logger.info("--> start the primary shard");
    rerouteResult =
        allocation.applyStartedShards(
            clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(0));

    logger.info("--> cancel primary allocation, make sure it fails...");
    try {
      allocation.reroute(
          clusterState,
          new AllocationCommands(
              new CancelAllocationCommand(new ShardId("test", 0), "node1", false)));
      assert false;
    } catch (ElasticSearchIllegalArgumentException e) {
    }

    logger.info("--> allocate the replica shard on on the second node");
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new AllocateAllocationCommand(new ShardId("test", 0), "node2", false)));
    assertThat(rerouteResult.changed(), equalTo(true));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node2").shardsWithState(INITIALIZING).size(), equalTo(1));

    logger.info("--> cancel the relocation allocation");
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new CancelAllocationCommand(new ShardId("test", 0), "node2", false)));
    assertThat(rerouteResult.changed(), equalTo(true));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(0));
    assertThat(clusterState.routingNodes().node("node3").shards().size(), equalTo(0));

    logger.info("--> allocate the replica shard on on the second node");
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new AllocateAllocationCommand(new ShardId("test", 0), "node2", false)));
    assertThat(rerouteResult.changed(), equalTo(true));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node2").shardsWithState(INITIALIZING).size(), equalTo(1));

    logger.info("--> cancel the primary being replicated, make sure it fails");
    try {
      allocation.reroute(
          clusterState,
          new AllocationCommands(
              new CancelAllocationCommand(new ShardId("test", 0), "node1", false)));
      assert false;
    } catch (ElasticSearchIllegalArgumentException e) {
    }

    logger.info("--> start the replica shard");
    rerouteResult =
        allocation.applyStartedShards(
            clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node2").shardsWithState(STARTED).size(), equalTo(1));

    logger.info("--> cancel allocation of the replica shard");
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new CancelAllocationCommand(new ShardId("test", 0), "node2", false)));
    assertThat(rerouteResult.changed(), equalTo(true));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(0));
    assertThat(clusterState.routingNodes().node("node3").shards().size(), equalTo(0));

    logger.info("--> allocate the replica shard on on the second node");
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new AllocateAllocationCommand(new ShardId("test", 0), "node2", false)));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(rerouteResult.changed(), equalTo(true));
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node2").shardsWithState(INITIALIZING).size(), equalTo(1));
    logger.info("--> start the replica shard");
    rerouteResult =
        allocation.applyStartedShards(
            clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node2").shardsWithState(STARTED).size(), equalTo(1));

    logger.info("--> cancel the primary allocation (with allow_primary set to true)");
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new CancelAllocationCommand(new ShardId("test", 0), "node1", true)));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(rerouteResult.changed(), equalTo(true));
    assertThat(
        clusterState.routingNodes().node("node2").shardsWithState(STARTED).get(0).primary(),
        equalTo(true));
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(0));
    assertThat(clusterState.routingNodes().node("node3").shards().size(), equalTo(0));
  }
  @Test
  public void allocateCommand() {
    AllocationService allocation =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.disable_new_allocation", true)
                .put("cluster.routing.allocation.disable_allocation", true)
                .build());

    logger.info("--> building initial routing table");
    MetaData metaData =
        newMetaDataBuilder()
            .put(newIndexMetaDataBuilder("test").numberOfShards(1).numberOfReplicas(1))
            .build();
    RoutingTable routingTable = routingTable().addAsNew(metaData.index("test")).build();
    ClusterState clusterState =
        newClusterStateBuilder().metaData(metaData).routingTable(routingTable).build();

    logger.info("--> adding 3 nodes on same rack and do rerouting");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(
                newNodesBuilder().put(newNode("node1")).put(newNode("node2")).put(newNode("node3")))
            .build();
    RoutingAllocationResult rerouteResult = allocation.reroute(clusterState);
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(0));

    logger.info("--> allocating with primary flag set to false, should fail");
    try {
      allocation.reroute(
          clusterState,
          new AllocationCommands(
              new AllocateAllocationCommand(new ShardId("test", 0), "node1", false)));
      assert false;
    } catch (ElasticSearchIllegalArgumentException e) {
    }

    logger.info("--> allocating with primary flag set to true");
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new AllocateAllocationCommand(new ShardId("test", 0), "node1", true)));
    assertThat(rerouteResult.changed(), equalTo(true));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(INITIALIZING).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(0));

    logger.info("--> start the primary shard");
    rerouteResult =
        allocation.applyStartedShards(
            clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(0));

    logger.info("--> allocate the replica shard on the primary shard node, should fail");
    try {
      allocation.reroute(
          clusterState,
          new AllocationCommands(
              new AllocateAllocationCommand(new ShardId("test", 0), "node1", false)));
      assert false;
    } catch (ElasticSearchIllegalArgumentException e) {
    }

    logger.info("--> allocate the replica shard on on the second node");
    rerouteResult =
        allocation.reroute(
            clusterState,
            new AllocationCommands(
                new AllocateAllocationCommand(new ShardId("test", 0), "node2", false)));
    assertThat(rerouteResult.changed(), equalTo(true));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node2").shardsWithState(INITIALIZING).size(), equalTo(1));

    logger.info("--> start the replica shard");
    rerouteResult =
        allocation.applyStartedShards(
            clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING));
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .routingTable(rerouteResult.routingTable())
            .build();
    assertThat(clusterState.routingNodes().node("node1").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node1").shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().node("node2").shards().size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().node("node2").shardsWithState(STARTED).size(), equalTo(1));

    logger.info("--> verify that we fail when there are no unassigned shards");
    try {
      allocation.reroute(
          clusterState,
          new AllocationCommands(
              new AllocateAllocationCommand(new ShardId("test", 0), "node3", false)));
      assert false;
    } catch (ElasticSearchIllegalArgumentException e) {
    }
  }
  public void testSingleRetryOnIgnore() {
    ClusterState clusterState = createInitialClusterState();
    RoutingTable routingTable = clusterState.routingTable();
    final int retries = MaxRetryAllocationDecider.SETTING_ALLOCATION_MAX_RETRY.get(Settings.EMPTY);
    // now fail it N-1 times
    for (int i = 0; i < retries - 1; i++) {
      List<FailedRerouteAllocation.FailedShard> failedShards =
          Collections.singletonList(
              new FailedRerouteAllocation.FailedShard(
                  routingTable.index("idx").shard(0).shards().get(0),
                  "boom" + i,
                  new UnsupportedOperationException()));
      RoutingAllocation.Result result = strategy.applyFailedShards(clusterState, failedShards);
      assertTrue(result.changed());
      routingTable = result.routingTable();
      clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
      assertEquals(routingTable.index("idx").shards().size(), 1);
      assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), INITIALIZING);
      assertEquals(
          routingTable
              .index("idx")
              .shard(0)
              .shards()
              .get(0)
              .unassignedInfo()
              .getNumFailedAllocations(),
          i + 1);
      assertEquals(
          routingTable.index("idx").shard(0).shards().get(0).unassignedInfo().getMessage(),
          "boom" + i);
    }
    // now we go and check that we are actually stick to unassigned on the next failure
    List<FailedRerouteAllocation.FailedShard> failedShards =
        Collections.singletonList(
            new FailedRerouteAllocation.FailedShard(
                routingTable.index("idx").shard(0).shards().get(0),
                "boom",
                new UnsupportedOperationException()));
    RoutingAllocation.Result result = strategy.applyFailedShards(clusterState, failedShards);
    assertTrue(result.changed());
    routingTable = result.routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    assertEquals(routingTable.index("idx").shards().size(), 1);
    assertEquals(
        routingTable
            .index("idx")
            .shard(0)
            .shards()
            .get(0)
            .unassignedInfo()
            .getNumFailedAllocations(),
        retries);
    assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), UNASSIGNED);
    assertEquals(
        routingTable.index("idx").shard(0).shards().get(0).unassignedInfo().getMessage(), "boom");

    result =
        strategy.reroute(
            clusterState,
            new AllocationCommands(),
            false,
            true); // manual reroute should retry once
    assertTrue(result.changed());
    routingTable = result.routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    assertEquals(routingTable.index("idx").shards().size(), 1);
    assertEquals(
        routingTable
            .index("idx")
            .shard(0)
            .shards()
            .get(0)
            .unassignedInfo()
            .getNumFailedAllocations(),
        retries);
    assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), INITIALIZING);
    assertEquals(
        routingTable.index("idx").shard(0).shards().get(0).unassignedInfo().getMessage(), "boom");

    // now we go and check that we are actually stick to unassigned on the next failure ie. no retry
    failedShards =
        Collections.singletonList(
            new FailedRerouteAllocation.FailedShard(
                routingTable.index("idx").shard(0).shards().get(0),
                "boom",
                new UnsupportedOperationException()));
    result = strategy.applyFailedShards(clusterState, failedShards);
    assertTrue(result.changed());
    routingTable = result.routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    assertEquals(routingTable.index("idx").shards().size(), 1);
    assertEquals(
        routingTable
            .index("idx")
            .shard(0)
            .shards()
            .get(0)
            .unassignedInfo()
            .getNumFailedAllocations(),
        retries + 1);
    assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), UNASSIGNED);
    assertEquals(
        routingTable.index("idx").shard(0).shards().get(0).unassignedInfo().getMessage(), "boom");
  }
Ejemplo n.º 21
0
  public void testClusterStateUpdateTask() {
    AllocationService allocationService =
        new AllocationService(
            Settings.builder().build(),
            new AllocationDeciders(
                Settings.EMPTY,
                Collections.singleton(new MaxRetryAllocationDecider(Settings.EMPTY))),
            NoopGatewayAllocator.INSTANCE,
            new BalancedShardsAllocator(Settings.EMPTY),
            EmptyClusterInfoService.INSTANCE);
    ClusterState clusterState = createInitialClusterState(allocationService);
    ClusterRerouteRequest req = new ClusterRerouteRequest();
    req.dryRun(true);
    AtomicReference<ClusterRerouteResponse> responseRef = new AtomicReference<>();
    ActionListener<ClusterRerouteResponse> responseActionListener =
        new ActionListener<ClusterRerouteResponse>() {
          @Override
          public void onResponse(ClusterRerouteResponse clusterRerouteResponse) {
            responseRef.set(clusterRerouteResponse);
          }

          @Override
          public void onFailure(Exception e) {}
        };
    TransportClusterRerouteAction.ClusterRerouteResponseAckedClusterStateUpdateTask task =
        new TransportClusterRerouteAction.ClusterRerouteResponseAckedClusterStateUpdateTask(
            logger, allocationService, req, responseActionListener);
    ClusterState execute = task.execute(clusterState);
    assertSame(execute, clusterState); // dry-run
    task.onAllNodesAcked(null);
    assertNotSame(responseRef.get().getState(), execute);

    req.dryRun(false); // now we allocate

    final int retries = MaxRetryAllocationDecider.SETTING_ALLOCATION_MAX_RETRY.get(Settings.EMPTY);
    // now fail it N-1 times
    for (int i = 0; i < retries; i++) {
      ClusterState newState = task.execute(clusterState);
      assertNotSame(newState, clusterState); // dry-run=false
      clusterState = newState;
      RoutingTable routingTable = clusterState.routingTable();
      assertEquals(routingTable.index("idx").shards().size(), 1);
      assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), INITIALIZING);
      assertEquals(
          routingTable
              .index("idx")
              .shard(0)
              .shards()
              .get(0)
              .unassignedInfo()
              .getNumFailedAllocations(),
          i);
      List<FailedRerouteAllocation.FailedShard> failedShards =
          Collections.singletonList(
              new FailedRerouteAllocation.FailedShard(
                  routingTable.index("idx").shard(0).shards().get(0),
                  "boom" + i,
                  new UnsupportedOperationException()));
      RoutingAllocation.Result result =
          allocationService.applyFailedShards(clusterState, failedShards);
      assertTrue(result.changed());
      clusterState = ClusterState.builder(clusterState).routingTable(result.routingTable()).build();
      routingTable = clusterState.routingTable();
      assertEquals(routingTable.index("idx").shards().size(), 1);
      if (i == retries - 1) {
        assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), UNASSIGNED);
      } else {
        assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), INITIALIZING);
      }
      assertEquals(
          routingTable
              .index("idx")
              .shard(0)
              .shards()
              .get(0)
              .unassignedInfo()
              .getNumFailedAllocations(),
          i + 1);
    }

    // without retry_failed we won't allocate that shard
    ClusterState newState = task.execute(clusterState);
    assertNotSame(newState, clusterState); // dry-run=false
    task.onAllNodesAcked(null);
    assertSame(responseRef.get().getState(), newState);
    RoutingTable routingTable = clusterState.routingTable();
    assertEquals(routingTable.index("idx").shards().size(), 1);
    assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), UNASSIGNED);
    assertEquals(
        routingTable
            .index("idx")
            .shard(0)
            .shards()
            .get(0)
            .unassignedInfo()
            .getNumFailedAllocations(),
        retries);

    req.setRetryFailed(true); // now we manually retry and get the shard back into initializing
    newState = task.execute(clusterState);
    assertNotSame(newState, clusterState); // dry-run=false
    clusterState = newState;
    routingTable = clusterState.routingTable();
    assertEquals(routingTable.index("idx").shards().size(), 1);
    assertEquals(routingTable.index("idx").shard(0).shards().get(0).state(), INITIALIZING);
    assertEquals(
        routingTable
            .index("idx")
            .shard(0)
            .shards()
            .get(0)
            .unassignedInfo()
            .getNumFailedAllocations(),
        retries);
  }
  @Test
  public void testUpdateNumberOfReplicas() {
    AllocationService strategy =
        createAllocationService(
            settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build());

    logger.info("Building initial routing table");

    MetaData metaData =
        MetaData.builder()
            .put(IndexMetaData.builder("test").numberOfShards(1).numberOfReplicas(1))
            .build();

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

    ClusterState clusterState =
        ClusterState.builder().metaData(metaData).routingTable(routingTable).build();

    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(2));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(2));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(UNASSIGNED));
    assertThat(routingTable.index("test").shard(0).shards().get(1).state(), equalTo(UNASSIGNED));
    assertThat(routingTable.index("test").shard(0).shards().get(0).currentNodeId(), nullValue());
    assertThat(routingTable.index("test").shard(0).shards().get(1).currentNodeId(), nullValue());

    logger.info("Adding two nodes and performing rerouting");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder().put(newNode("node1")).put(newNode("node2")))
            .build();

    RoutingTable prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logger.info("Start all the primary shards");
    RoutingNodes routingNodes = clusterState.routingNodes();
    prevRoutingTable = routingTable;
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logger.info("Start all the replica shards");
    routingNodes = clusterState.routingNodes();
    prevRoutingTable = routingTable;
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    final String nodeHoldingPrimary =
        routingTable.index("test").shard(0).primaryShard().currentNodeId();
    final String nodeHoldingReplica =
        routingTable.index("test").shard(0).replicaShards().get(0).currentNodeId();
    assertThat(nodeHoldingPrimary, not(equalTo(nodeHoldingReplica)));
    assertThat(prevRoutingTable != routingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(2));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(2));
    assertThat(routingTable.index("test").shard(0).primaryShard().state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).primaryShard().currentNodeId(),
        equalTo(nodeHoldingPrimary));
    assertThat(routingTable.index("test").shard(0).replicaShards().size(), equalTo(1));
    assertThat(
        routingTable.index("test").shard(0).replicaShards().get(0).state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).replicaShards().get(0).currentNodeId(),
        equalTo(nodeHoldingReplica));

    logger.info("add another replica");
    routingNodes = clusterState.routingNodes();
    prevRoutingTable = routingTable;
    routingTable = RoutingTable.builder(routingTable).updateNumberOfReplicas(2).build();
    metaData = MetaData.builder(clusterState.metaData()).updateNumberOfReplicas(2).build();
    clusterState =
        ClusterState.builder(clusterState).routingTable(routingTable).metaData(metaData).build();

    assertThat(clusterState.metaData().index("test").numberOfReplicas(), equalTo(2));

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(3));
    assertThat(routingTable.index("test").shard(0).primaryShard().state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).primaryShard().currentNodeId(),
        equalTo(nodeHoldingPrimary));
    assertThat(routingTable.index("test").shard(0).replicaShards().size(), equalTo(2));
    assertThat(
        routingTable.index("test").shard(0).replicaShards().get(0).state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).replicaShards().get(0).currentNodeId(),
        equalTo(nodeHoldingReplica));
    assertThat(
        routingTable.index("test").shard(0).replicaShards().get(1).state(), equalTo(UNASSIGNED));

    logger.info("Add another node and start the added replica");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node3")))
            .build();
    prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(3));
    assertThat(routingTable.index("test").shard(0).primaryShard().state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).primaryShard().currentNodeId(),
        equalTo(nodeHoldingPrimary));
    assertThat(routingTable.index("test").shard(0).replicaShards().size(), equalTo(2));
    assertThat(
        routingTable.index("test").shard(0).replicaShardsWithState(STARTED).size(), equalTo(1));
    assertThat(
        routingTable.index("test").shard(0).replicaShardsWithState(STARTED).get(0).currentNodeId(),
        equalTo(nodeHoldingReplica));
    assertThat(
        routingTable.index("test").shard(0).replicaShardsWithState(INITIALIZING).size(),
        equalTo(1));
    assertThat(
        routingTable
            .index("test")
            .shard(0)
            .replicaShardsWithState(INITIALIZING)
            .get(0)
            .currentNodeId(),
        equalTo("node3"));

    routingNodes = clusterState.routingNodes();
    prevRoutingTable = routingTable;
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(3));
    assertThat(routingTable.index("test").shard(0).primaryShard().state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).primaryShard().currentNodeId(),
        equalTo(nodeHoldingPrimary));
    assertThat(routingTable.index("test").shard(0).replicaShards().size(), equalTo(2));
    assertThat(
        routingTable.index("test").shard(0).replicaShardsWithState(STARTED).size(), equalTo(2));
    assertThat(
        routingTable.index("test").shard(0).replicaShardsWithState(STARTED).get(0).currentNodeId(),
        anyOf(equalTo(nodeHoldingReplica), equalTo("node3")));
    assertThat(
        routingTable.index("test").shard(0).replicaShardsWithState(STARTED).get(1).currentNodeId(),
        anyOf(equalTo(nodeHoldingReplica), equalTo("node3")));

    logger.info("now remove a replica");
    routingNodes = clusterState.routingNodes();
    prevRoutingTable = routingTable;
    routingTable = RoutingTable.builder(routingTable).updateNumberOfReplicas(1).build();
    metaData = MetaData.builder(clusterState.metaData()).updateNumberOfReplicas(1).build();
    clusterState =
        ClusterState.builder(clusterState).routingTable(routingTable).metaData(metaData).build();

    assertThat(clusterState.metaData().index("test").numberOfReplicas(), equalTo(1));

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(2));
    assertThat(routingTable.index("test").shard(0).primaryShard().state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).primaryShard().currentNodeId(),
        equalTo(nodeHoldingPrimary));
    assertThat(routingTable.index("test").shard(0).replicaShards().size(), equalTo(1));
    assertThat(
        routingTable.index("test").shard(0).replicaShards().get(0).state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).replicaShards().get(0).currentNodeId(),
        anyOf(equalTo(nodeHoldingReplica), equalTo("node3")));

    logger.info("do a reroute, should remain the same");
    prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(false));
  }
  @Test
  public void diskThresholdTest() {
    Settings diskSettings =
        settingsBuilder()
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK, 0.7)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK, 0.8)
            .build();

    Map<String, DiskUsage> usages = new HashMap<>();
    usages.put("node1", new DiskUsage("node1", 100, 10)); // 90% used
    usages.put("node2", new DiskUsage("node2", 100, 35)); // 65% used
    usages.put("node3", new DiskUsage("node3", 100, 60)); // 40% used
    usages.put("node4", new DiskUsage("node4", 100, 80)); // 20% used

    Map<String, Long> shardSizes = new HashMap<>();
    shardSizes.put("[test][0][p]", 10L); // 10 bytes
    shardSizes.put("[test][0][r]", 10L);
    final ClusterInfo clusterInfo =
        new ClusterInfo(ImmutableMap.copyOf(usages), ImmutableMap.copyOf(shardSizes));

    AllocationDeciders deciders =
        new AllocationDeciders(
            ImmutableSettings.EMPTY,
            new HashSet<>(
                Arrays.asList(
                    new SameShardAllocationDecider(ImmutableSettings.EMPTY),
                    new DiskThresholdDecider(diskSettings))));

    ClusterInfoService cis =
        new ClusterInfoService() {
          @Override
          public ClusterInfo getClusterInfo() {
            logger.info("--> calling fake getClusterInfo");
            return clusterInfo;
          }
        };

    AllocationService strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    MetaData metaData =
        MetaData.builder()
            .put(IndexMetaData.builder("test").numberOfShards(1).numberOfReplicas(1))
            .build();

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

    ClusterState clusterState =
        ClusterState.builder(org.elasticsearch.cluster.ClusterName.DEFAULT)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();

    logger.info("--> adding two nodes");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder().put(newNode("node1")).put(newNode("node2")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logShardStates(clusterState);

    // Primary shard should be initializing, replica should not
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(1));

    logger.info("--> start the shards (primaries)");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Assert that we're able to start the primary
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(1));
    // Assert that node1 didn't get any shards because its disk usage is too high
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(0));

    logger.info("--> start the shards (replicas)");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Assert that the replica couldn't be started since node1 doesn't have enough space
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(1));

    logger.info("--> adding node3");

    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node3")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Assert that the replica is initialized now that node3 is available with enough space
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(1));
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size(),
        equalTo(1));

    logger.info("--> start the shards (replicas)");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Assert that the replica couldn't be started since node1 doesn't have enough space
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(2));
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(0));
    assertThat(clusterState.getRoutingNodes().node("node2").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));

    logger.info("--> changing decider settings");

    // Set the low threshold to 60 instead of 70
    // Set the high threshold to 70 instead of 80
    // node2 now should not have new shards allocated to it, but shards can remain
    diskSettings =
        settingsBuilder()
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK, "60%")
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK, 0.7)
            .build();

    deciders =
        new AllocationDeciders(
            ImmutableSettings.EMPTY,
            new HashSet<>(
                Arrays.asList(
                    new SameShardAllocationDecider(ImmutableSettings.EMPTY),
                    new DiskThresholdDecider(diskSettings))));

    strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logShardStates(clusterState);

    // Shards remain started
    assertThat(clusterState.routingNodes().shardsWithState(STARTED).size(), equalTo(2));
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(0));
    assertThat(clusterState.getRoutingNodes().node("node2").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));

    logger.info("--> changing settings again");

    // Set the low threshold to 50 instead of 60
    // Set the high threshold to 60 instead of 70
    // node2 now should not have new shards allocated to it, and shards cannot remain
    diskSettings =
        settingsBuilder()
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK, 0.5)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK, 0.6)
            .build();

    deciders =
        new AllocationDeciders(
            ImmutableSettings.EMPTY,
            new HashSet<>(
                Arrays.asList(
                    new SameShardAllocationDecider(ImmutableSettings.EMPTY),
                    new DiskThresholdDecider(diskSettings))));

    strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Shards remain started
    assertThat(clusterState.routingNodes().shardsWithState(STARTED).size(), equalTo(2));
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(0));
    // Shard hasn't been moved off of node2 yet because there's nowhere for it to go
    assertThat(clusterState.getRoutingNodes().node("node2").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));

    logger.info("--> adding node4");

    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node4")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Shards remain started
    assertThat(clusterState.routingNodes().shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(1));

    logger.info("--> apply INITIALIZING shards");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(0));
    // Node4 is available now, so the shard is moved off of node2
    assertThat(clusterState.getRoutingNodes().node("node2").size(), equalTo(0));
    assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node4").size(), equalTo(1));
  }
  @Test
  public void testMultiIndexUnevenNodes() {
    AllocationService strategy =
        createAllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build());

    final int numberOfIndices = 10;
    logger.info("Building initial routing table with " + numberOfIndices + " indices");

    MetaData.Builder metaDataBuilder = MetaData.builder();
    for (int i = 0; i < numberOfIndices; i++) {
      metaDataBuilder.put(
          IndexMetaData.builder("test" + i)
              .settings(settings(Version.CURRENT))
              .numberOfShards(1)
              .numberOfReplicas(0));
    }
    MetaData metaData = metaDataBuilder.build();

    RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
    for (int i = 0; i < numberOfIndices; i++) {
      routingTableBuilder.addAsNew(metaData.index("test" + i));
    }
    RoutingTable routingTable = routingTableBuilder.build();

    ClusterState clusterState =
        ClusterState.builder(org.elasticsearch.cluster.ClusterName.DEFAULT)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();

    assertThat(routingTable.indicesRouting().size(), equalTo(numberOfIndices));

    logger.info("Starting 3 nodes and rerouting");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(
                DiscoveryNodes.builder()
                    .put(newNode("node1"))
                    .put(newNode("node2"))
                    .put(newNode("node3")))
            .build();
    RoutingTable prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    for (int i = 0; i < numberOfIndices; i++) {
      assertThat(routingTable.index("test" + i).shards().size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).shards().size(), equalTo(1));
      assertThat(
          routingTable.index("test" + i).shard(0).shards().get(0).state(), equalTo(INITIALIZING));
    }
    RoutingNodes routingNodes = clusterState.routingNodes();
    assertThat(numberOfShardsOfType(routingNodes, INITIALIZING), equalTo(numberOfIndices));
    assertThat(
        routingNodes.node("node1").numberOfShardsWithState(INITIALIZING),
        anyOf(equalTo(3), equalTo(4)));
    assertThat(
        routingNodes.node("node2").numberOfShardsWithState(INITIALIZING),
        anyOf(equalTo(3), equalTo(4)));
    assertThat(
        routingNodes.node("node2").numberOfShardsWithState(INITIALIZING),
        anyOf(equalTo(3), equalTo(4)));

    logger.info("Start two more nodes, things should remain the same");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(
                DiscoveryNodes.builder(clusterState.nodes())
                    .put(newNode("node4"))
                    .put(newNode("node5")))
            .build();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();

    assertThat(prevRoutingTable == routingTable, equalTo(true));

    routingNodes = clusterState.routingNodes();
    prevRoutingTable = routingTable;
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    for (int i = 0; i < numberOfIndices; i++) {
      assertThat(routingTable.index("test" + i).shards().size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).shards().size(), equalTo(1));
      assertThat(
          routingTable.index("test" + i).shard(0).shards().get(0).state(),
          anyOf(equalTo(RELOCATING), equalTo(STARTED)));
    }
    routingNodes = clusterState.routingNodes();
    assertThat(
        "4 source shard routing are relocating",
        numberOfShardsOfType(routingNodes, RELOCATING),
        equalTo(4));
    assertThat(
        "4 target shard routing are initializing",
        numberOfShardsOfType(routingNodes, INITIALIZING),
        equalTo(4));

    logger.info("Now, mark the relocated as started");
    prevRoutingTable = routingTable;
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    //        routingTable = strategy.reroute(new RoutingStrategyInfo(metaData, routingTable),
    // nodes);

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    for (int i = 0; i < numberOfIndices; i++) {
      assertThat(routingTable.index("test" + i).shards().size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).shards().size(), equalTo(1));
      assertThat(
          routingTable.index("test" + i).shard(0).shards().get(0).state(),
          anyOf(equalTo(RELOCATING), equalTo(STARTED)));
    }
    routingNodes = clusterState.routingNodes();
    assertThat(numberOfShardsOfType(routingNodes, STARTED), equalTo(numberOfIndices));
    for (RoutingNode routingNode : routingNodes) {
      assertThat(routingNode.numberOfShardsWithState(STARTED), equalTo(2));
    }
  }
  @Test
  public void testMultiIndexEvenDistribution() {
    AllocationService strategy =
        createAllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build());

    final int numberOfIndices = 50;
    logger.info("Building initial routing table with " + numberOfIndices + " indices");

    MetaData.Builder metaDataBuilder = MetaData.builder();
    for (int i = 0; i < numberOfIndices; i++) {
      metaDataBuilder.put(
          IndexMetaData.builder("test" + i)
              .settings(settings(Version.CURRENT))
              .numberOfShards(1)
              .numberOfReplicas(0));
    }
    MetaData metaData = metaDataBuilder.build();

    RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
    for (int i = 0; i < numberOfIndices; i++) {
      routingTableBuilder.addAsNew(metaData.index("test" + i));
    }
    RoutingTable routingTable = routingTableBuilder.build();
    ClusterState clusterState =
        ClusterState.builder(org.elasticsearch.cluster.ClusterName.DEFAULT)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();

    assertThat(routingTable.indicesRouting().size(), equalTo(numberOfIndices));
    for (int i = 0; i < numberOfIndices; i++) {
      assertThat(routingTable.index("test" + i).shards().size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).shards().size(), equalTo(1));
      assertThat(
          routingTable.index("test" + i).shard(0).shards().get(0).state(), equalTo(UNASSIGNED));
      assertThat(
          routingTable.index("test" + i).shard(0).shards().get(0).currentNodeId(), nullValue());
    }

    logger.info("Adding " + (numberOfIndices / 2) + " nodes");
    DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder();
    List<DiscoveryNode> nodes = newArrayList();
    for (int i = 0; i < (numberOfIndices / 2); i++) {
      nodesBuilder.put(newNode("node" + i));
    }
    RoutingTable prevRoutingTable = routingTable;
    clusterState = ClusterState.builder(clusterState).nodes(nodesBuilder).build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    for (int i = 0; i < numberOfIndices; i++) {
      assertThat(routingTable.index("test" + i).shards().size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).shards().size(), equalTo(1));
      assertThat(
          routingTable.index("test" + i).shard(0).shards().get(0).unassigned(), equalTo(false));
      assertThat(
          routingTable.index("test" + i).shard(0).shards().get(0).state(), equalTo(INITIALIZING));
      assertThat(routingTable.index("test" + i).shard(0).shards().get(0).primary(), equalTo(true));
      // make sure we still have 2 shards initializing per node on the first 25 nodes
      String nodeId = routingTable.index("test" + i).shard(0).shards().get(0).currentNodeId();
      int nodeIndex = Integer.parseInt(nodeId.substring("node".length()));
      assertThat(nodeIndex, lessThan(25));
    }
    RoutingNodes routingNodes = clusterState.routingNodes();
    Set<String> encounteredIndices = newHashSet();
    for (RoutingNode routingNode : routingNodes) {
      assertThat(routingNode.numberOfShardsWithState(STARTED), equalTo(0));
      assertThat(routingNode.size(), equalTo(2));
      // make sure we still have 2 shards initializing per node on the only 25 nodes
      int nodeIndex = Integer.parseInt(routingNode.nodeId().substring("node".length()));
      assertThat(nodeIndex, lessThan(25));
      // check that we don't have a shard associated with a node with the same index name (we have a
      // single shard)
      for (ShardRouting shardRoutingEntry : routingNode) {
        assertThat(encounteredIndices, not(hasItem(shardRoutingEntry.index())));
        encounteredIndices.add(shardRoutingEntry.index());
      }
    }

    logger.info("Adding additional " + (numberOfIndices / 2) + " nodes, nothing should change");
    nodesBuilder = DiscoveryNodes.builder(clusterState.nodes());
    for (int i = (numberOfIndices / 2); i < numberOfIndices; i++) {
      nodesBuilder.put(newNode("node" + i));
    }
    prevRoutingTable = routingTable;
    clusterState = ClusterState.builder(clusterState).nodes(nodesBuilder).build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(false));

    logger.info("Marking the shard as started");
    prevRoutingTable = routingTable;
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(prevRoutingTable != routingTable, equalTo(true));
    int numberOfRelocatingShards = 0;
    int numberOfStartedShards = 0;
    for (int i = 0; i < numberOfIndices; i++) {
      assertThat(routingTable.index("test" + i).shards().size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).size(), equalTo(1));
      assertThat(routingTable.index("test" + i).shard(0).shards().size(), equalTo(1));
      assertThat(
          routingTable.index("test" + i).shard(0).shards().get(0).unassigned(), equalTo(false));
      assertThat(
          routingTable.index("test" + i).shard(0).shards().get(0).state(),
          anyOf(equalTo(STARTED), equalTo(RELOCATING)));
      if (routingTable.index("test" + i).shard(0).shards().get(0).state() == STARTED) {
        numberOfStartedShards++;
      } else if (routingTable.index("test" + i).shard(0).shards().get(0).state() == RELOCATING) {
        numberOfRelocatingShards++;
      }
      assertThat(routingTable.index("test" + i).shard(0).shards().get(0).primary(), equalTo(true));
      // make sure we still have 2 shards either relocating or started on the first 25 nodes (still)
      String nodeId = routingTable.index("test" + i).shard(0).shards().get(0).currentNodeId();
      int nodeIndex = Integer.parseInt(nodeId.substring("node".length()));
      assertThat(nodeIndex, lessThan(25));
    }
    assertThat(numberOfRelocatingShards, equalTo(25));
    assertThat(numberOfStartedShards, equalTo(25));
  }
  @Test
  public void diskThresholdWithShardSizes() {
    Settings diskSettings =
        settingsBuilder()
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK, 0.7)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK, "71%")
            .build();

    Map<String, DiskUsage> usages = new HashMap<>();
    usages.put("node1", new DiskUsage("node1", 100, 31)); // 69% used
    usages.put("node2", new DiskUsage("node2", 100, 1)); // 99% used

    Map<String, Long> shardSizes = new HashMap<>();
    shardSizes.put("[test][0][p]", 10L); // 10 bytes
    final ClusterInfo clusterInfo =
        new ClusterInfo(ImmutableMap.copyOf(usages), ImmutableMap.copyOf(shardSizes));

    AllocationDeciders deciders =
        new AllocationDeciders(
            ImmutableSettings.EMPTY,
            new HashSet<>(
                Arrays.asList(
                    new SameShardAllocationDecider(ImmutableSettings.EMPTY),
                    new DiskThresholdDecider(diskSettings))));

    ClusterInfoService cis =
        new ClusterInfoService() {
          @Override
          public ClusterInfo getClusterInfo() {
            logger.info("--> calling fake getClusterInfo");
            return clusterInfo;
          }
        };

    AllocationService strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    MetaData metaData =
        MetaData.builder()
            .put(IndexMetaData.builder("test").numberOfShards(1).numberOfReplicas(0))
            .build();

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

    ClusterState clusterState =
        ClusterState.builder(org.elasticsearch.cluster.ClusterName.DEFAULT)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();
    logger.info("--> adding node1");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(
                DiscoveryNodes.builder()
                    .put(newNode("node1"))
                    .put(
                        newNode(
                            "node2")) // node2 is added because DiskThresholdDecider automatically
                                      // ignore single-node clusters
                )
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logger.info("--> start the shards (primaries)");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logShardStates(clusterState);

    // Shard can't be allocated to node1 (or node2) because it would cause too much usage
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(0));
    // No shards are started, no nodes have enough disk for allocation
    assertThat(clusterState.routingNodes().shardsWithState(STARTED).size(), equalTo(0));
  }
  @Test
  public void testSingleIndexStartedShard() {
    AllocationService strategy =
        createAllocationService(
            settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build());

    logger.info("Building initial routing table");

    MetaData metaData =
        MetaData.builder()
            .put(
                IndexMetaData.builder("test")
                    .settings(settings(Version.CURRENT))
                    .numberOfShards(1)
                    .numberOfReplicas(0))
            .build();

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

    ClusterState clusterState =
        ClusterState.builder(org.elasticsearch.cluster.ClusterName.DEFAULT)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();

    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(UNASSIGNED));
    assertThat(routingTable.index("test").shard(0).shards().get(0).currentNodeId(), nullValue());

    logger.info("Adding one node and performing rerouting");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder().put(newNode("node1")))
            .build();
    RoutingTable prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(INITIALIZING));
    assertThat(
        routingTable.index("test").shard(0).shards().get(0).currentNodeId(), equalTo("node1"));

    logger.info("Rerouting again, nothing should change");
    prevRoutingTable = routingTable;
    clusterState = ClusterState.builder(clusterState).build();
    routingTable = strategy.reroute(clusterState).routingTable();
    assertThat(routingTable == prevRoutingTable, equalTo(true));
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logger.info("Marking the shard as started");
    RoutingNodes routingNodes = clusterState.routingNodes();
    prevRoutingTable = routingTable;
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, routingNodes.node("node1").shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(routingTable != prevRoutingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).shards().get(0).currentNodeId(), equalTo("node1"));

    logger.info("Starting another node and making sure nothing changed");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node2")))
            .build();
    prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(routingTable == prevRoutingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).shards().get(0).currentNodeId(), equalTo("node1"));

    logger.info("Killing node1 where the shard is, checking the shard is relocated");

    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).remove("node1"))
            .build();
    prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(routingTable != prevRoutingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(INITIALIZING));
    assertThat(
        routingTable.index("test").shard(0).shards().get(0).currentNodeId(), equalTo("node2"));

    logger.info(
        "Start another node, make sure that things remain the same (shard is in node2 and initializing)");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node3")))
            .build();
    prevRoutingTable = routingTable;
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    assertThat(routingTable == prevRoutingTable, equalTo(true));

    logger.info("Start the shard on node 2");
    routingNodes = clusterState.routingNodes();
    prevRoutingTable = routingTable;
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, routingNodes.node("node2").shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    assertThat(routingTable != prevRoutingTable, equalTo(true));
    assertThat(routingTable.index("test").shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().size(), equalTo(1));
    assertThat(routingTable.index("test").shard(0).shards().get(0).state(), equalTo(STARTED));
    assertThat(
        routingTable.index("test").shard(0).shards().get(0).currentNodeId(), equalTo("node2"));
  }
  @Test
  public void unknownDiskUsageTest() {
    Settings diskSettings =
        settingsBuilder()
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK, 0.7)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK, 0.85)
            .build();

    Map<String, DiskUsage> usages = new HashMap<>();
    usages.put("node2", new DiskUsage("node2", 100, 50)); // 50% used
    usages.put("node3", new DiskUsage("node3", 100, 0)); // 100% used

    Map<String, Long> shardSizes = new HashMap<>();
    shardSizes.put("[test][0][p]", 10L); // 10 bytes
    shardSizes.put("[test][0][r]", 10L); // 10 bytes
    final ClusterInfo clusterInfo =
        new ClusterInfo(ImmutableMap.copyOf(usages), ImmutableMap.copyOf(shardSizes));

    AllocationDeciders deciders =
        new AllocationDeciders(
            ImmutableSettings.EMPTY,
            new HashSet<>(
                Arrays.asList(
                    new SameShardAllocationDecider(ImmutableSettings.EMPTY),
                    new DiskThresholdDecider(diskSettings))));

    ClusterInfoService cis =
        new ClusterInfoService() {
          @Override
          public ClusterInfo getClusterInfo() {
            logger.info("--> calling fake getClusterInfo");
            return clusterInfo;
          }
        };

    AllocationService strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    MetaData metaData =
        MetaData.builder()
            .put(IndexMetaData.builder("test").numberOfShards(1).numberOfReplicas(0))
            .build();

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

    ClusterState clusterState =
        ClusterState.builder(org.elasticsearch.cluster.ClusterName.DEFAULT)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();
    logger.info("--> adding node1");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(
                DiscoveryNodes.builder()
                    .put(newNode("node1"))
                    .put(
                        newNode(
                            "node3")) // node3 is added because DiskThresholdDecider automatically
                                      // ignore single-node clusters
                )
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    // Shard can be allocated to node1, even though it only has 25% free,
    // because it's a primary that's never been allocated before
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(1));

    logger.info("--> start the shards (primaries)");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logShardStates(clusterState);

    // A single shard is started on node1, even though it normally would not
    // be allowed, because it's a primary that hasn't been allocated, and node1
    // is still below the high watermark (unlike node3)
    assertThat(clusterState.routingNodes().shardsWithState(STARTED).size(), equalTo(1));
    assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(1));
  }
  @Test
  public void indexLevelShardsLimitAllocate() {
    AllocationService strategy =
        new AllocationService(
            settingsBuilder().put("cluster.routing.allocation.concurrent_recoveries", 10).build());

    logger.info("Building initial routing table");

    MetaData metaData =
        newMetaDataBuilder()
            .put(
                newIndexMetaDataBuilder("test")
                    .settings(
                        ImmutableSettings.settingsBuilder()
                            .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 4)
                            .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 1)
                            .put(ShardsLimitAllocationDecider.INDEX_TOTAL_SHARDS_PER_NODE, 2)))
            .build();

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

    ClusterState clusterState =
        newClusterStateBuilder().metaData(metaData).routingTable(routingTable).build();
    logger.info("Adding two nodes and performing rerouting");
    clusterState =
        newClusterStateBuilder()
            .state(clusterState)
            .nodes(newNodesBuilder().put(newNode("node1")).put(newNode("node2")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(
        clusterState
            .readOnlyRoutingNodes()
            .node("node1")
            .numberOfShardsWithState(ShardRoutingState.INITIALIZING),
        equalTo(2));
    assertThat(
        clusterState
            .readOnlyRoutingNodes()
            .node("node2")
            .numberOfShardsWithState(ShardRoutingState.INITIALIZING),
        equalTo(2));

    logger.info("Start the primary shards");
    RoutingNodes routingNodes = clusterState.routingNodes();
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();

    assertThat(
        clusterState
            .readOnlyRoutingNodes()
            .node("node1")
            .numberOfShardsWithState(ShardRoutingState.STARTED),
        equalTo(2));
    assertThat(
        clusterState
            .readOnlyRoutingNodes()
            .node("node1")
            .numberOfShardsWithState(ShardRoutingState.INITIALIZING),
        equalTo(0));
    assertThat(
        clusterState
            .readOnlyRoutingNodes()
            .node("node2")
            .numberOfShardsWithState(ShardRoutingState.STARTED),
        equalTo(2));
    assertThat(
        clusterState
            .readOnlyRoutingNodes()
            .node("node2")
            .numberOfShardsWithState(ShardRoutingState.INITIALIZING),
        equalTo(0));
    assertThat(clusterState.readOnlyRoutingNodes().unassigned().size(), equalTo(4));

    logger.info("Do another reroute, make sure its still not allocated");
    routingNodes = clusterState.routingNodes();
    routingTable =
        strategy
            .applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = newClusterStateBuilder().state(clusterState).routingTable(routingTable).build();
  }
  @Test
  public void testShardRelocationsTakenIntoAccount() {
    Settings diskSettings =
        settingsBuilder()
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_INCLUDE_RELOCATIONS, true)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK, 0.7)
            .put(DiskThresholdDecider.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK, 0.8)
            .build();

    Map<String, DiskUsage> usages = new HashMap<>();
    usages.put("node1", new DiskUsage("node1", 100, 40)); // 60% used
    usages.put("node2", new DiskUsage("node2", 100, 40)); // 60% used
    usages.put("node2", new DiskUsage("node3", 100, 40)); // 60% used

    Map<String, Long> shardSizes = new HashMap<>();
    shardSizes.put("[test][0][p]", 14L); // 14 bytes
    shardSizes.put("[test][0][r]", 14L);
    shardSizes.put("[test2][0][p]", 1L); // 1 bytes
    shardSizes.put("[test2][0][r]", 1L);
    final ClusterInfo clusterInfo =
        new ClusterInfo(ImmutableMap.copyOf(usages), ImmutableMap.copyOf(shardSizes));

    AllocationDeciders deciders =
        new AllocationDeciders(
            ImmutableSettings.EMPTY,
            new HashSet<>(
                Arrays.asList(
                    new SameShardAllocationDecider(ImmutableSettings.EMPTY),
                    new DiskThresholdDecider(diskSettings))));

    ClusterInfoService cis =
        new ClusterInfoService() {
          @Override
          public ClusterInfo getClusterInfo() {
            logger.info("--> calling fake getClusterInfo");
            return clusterInfo;
          }
        };

    AllocationService strategy =
        new AllocationService(
            settingsBuilder()
                .put("cluster.routing.allocation.concurrent_recoveries", 10)
                .put(
                    ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE,
                    "always")
                .put("cluster.routing.allocation.cluster_concurrent_rebalance", -1)
                .build(),
            deciders,
            new ShardsAllocators(),
            cis);

    MetaData metaData =
        MetaData.builder()
            .put(IndexMetaData.builder("test").numberOfShards(1).numberOfReplicas(1))
            .put(IndexMetaData.builder("test2").numberOfShards(1).numberOfReplicas(1))
            .build();

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

    ClusterState clusterState =
        ClusterState.builder(org.elasticsearch.cluster.ClusterName.DEFAULT)
            .metaData(metaData)
            .routingTable(routingTable)
            .build();

    logger.info("--> adding two nodes");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder().put(newNode("node1")).put(newNode("node2")))
            .build();
    routingTable = strategy.reroute(clusterState).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logShardStates(clusterState);

    // shards should be initializing
    assertThat(clusterState.routingNodes().shardsWithState(INITIALIZING).size(), equalTo(4));

    logger.info("--> start the shards");
    routingTable =
        strategy
            .applyStartedShards(
                clusterState, clusterState.routingNodes().shardsWithState(INITIALIZING))
            .routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();

    logShardStates(clusterState);
    // Assert that we're able to start the primary and replicas
    assertThat(
        clusterState.routingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo(4));

    logger.info("--> adding node3");
    clusterState =
        ClusterState.builder(clusterState)
            .nodes(DiscoveryNodes.builder(clusterState.nodes()).put(newNode("node3")))
            .build();

    AllocationCommand relocate1 =
        new MoveAllocationCommand(new ShardId("test", 0), "node2", "node3");
    AllocationCommands cmds = new AllocationCommands(relocate1);

    routingTable = strategy.reroute(clusterState, cmds).routingTable();
    clusterState = ClusterState.builder(clusterState).routingTable(routingTable).build();
    logShardStates(clusterState);

    AllocationCommand relocate2 =
        new MoveAllocationCommand(new ShardId("test2", 0), "node2", "node3");
    cmds = new AllocationCommands(relocate2);

    try {
      // The shard for the "test" index is already being relocated to
      // node3, which will put it over the low watermark when it
      // completes, with shard relocations taken into account this should
      // throw an exception about not being able to complete
      strategy.reroute(clusterState, cmds).routingTable();
      fail("should not have been able to reroute the shard");
    } catch (ElasticsearchIllegalArgumentException e) {
      assertThat(
          "can't allocated because there isn't enough room: " + e.getMessage(),
          e.getMessage().contains("less than required [30.0%] free disk on node, free: [26.0%]"),
          equalTo(true));
    }
  }