Examples with RoutingNode org.elasticsearch.cluster.routing.RoutingNode used on opensource projects

Example 46 with RoutingNode

use of org.elasticsearch.cluster.routing.RoutingNode in project elasticsearch by elastic.

the class DiskThresholdDeciderTests method testAverageUsage.

public void testAverageUsage() {
    RoutingNode rn = new RoutingNode("node1", newNode("node1"));
    DiskThresholdDecider decider = makeDecider(Settings.EMPTY);
    ImmutableOpenMap.Builder<String, DiskUsage> usages = ImmutableOpenMap.builder();
    // 50% used
    usages.put("node2", new DiskUsage("node2", "n2", "/dev/null", 100, 50));
    // 100% used
    usages.put("node3", new DiskUsage("node3", "n3", "/dev/null", 100, 0));
    DiskUsage node1Usage = decider.averageUsage(rn, usages.build());
    assertThat(node1Usage.getTotalBytes(), equalTo(100L));
    assertThat(node1Usage.getFreeBytes(), equalTo(25L));
}

Example 47 with RoutingNode

use of org.elasticsearch.cluster.routing.RoutingNode in project elasticsearch by elastic.

the class SameShardRoutingTests method testForceAllocatePrimaryOnSameNodeNotAllowed.

public void testForceAllocatePrimaryOnSameNodeNotAllowed() {
    SameShardAllocationDecider decider = new SameShardAllocationDecider(Settings.EMPTY, new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS));
    ClusterState clusterState = ClusterStateCreationUtils.state("idx", randomIntBetween(2, 4), 1);
    Index index = clusterState.getMetaData().index("idx").getIndex();
    ShardRouting primaryShard = clusterState.routingTable().index(index).shard(0).primaryShard();
    RoutingNode routingNode = clusterState.getRoutingNodes().node(primaryShard.currentNodeId());
    RoutingAllocation routingAllocation = new RoutingAllocation(new AllocationDeciders(Settings.EMPTY, Collections.emptyList()), new RoutingNodes(clusterState, false), clusterState, ClusterInfo.EMPTY, System.nanoTime(), false);
    // can't force allocate same shard copy to the same node
    ShardRouting newPrimary = TestShardRouting.newShardRouting(primaryShard.shardId(), null, true, ShardRoutingState.UNASSIGNED);
    Decision decision = decider.canForceAllocatePrimary(newPrimary, routingNode, routingAllocation);
    assertEquals(Decision.Type.NO, decision.type());
    // can force allocate to a different node
    RoutingNode unassignedNode = null;
    for (RoutingNode node : clusterState.getRoutingNodes()) {
        if (node.isEmpty()) {
            unassignedNode = node;
            break;
        }
    }
    decision = decider.canForceAllocatePrimary(newPrimary, unassignedNode, routingAllocation);
    assertEquals(Decision.Type.YES, decision.type());
}

Example 48 with RoutingNode

use of org.elasticsearch.cluster.routing.RoutingNode in project elasticsearch by elastic.

the class SingleShardNoReplicasRoutingTests method testMultiIndexUnevenNodes.

public void testMultiIndexUnevenNodes() {
    AllocationService strategy = createAllocationService(Settings.builder().put("cluster.routing.allocation.node_concurrent_recoveries", 10).put(ClusterRebalanceAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ALLOW_REBALANCE_SETTING.getKey(), "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));
    }
    ClusterState clusterState = ClusterState.builder(org.elasticsearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).metaData(metaData).routingTable(routingTableBuilder.build()).build();
    assertThat(clusterState.routingTable().indicesRouting().size(), equalTo(numberOfIndices));
    logger.info("Starting 3 nodes and 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;
    for (int i = 0; i < numberOfIndices; i++) {
        assertThat(clusterState.routingTable().index("test" + i).shards().size(), equalTo(1));
        assertThat(clusterState.routingTable().index("test" + i).shard(0).size(), equalTo(1));
        assertThat(clusterState.routingTable().index("test" + i).shard(0).shards().size(), equalTo(1));
        assertThat(clusterState.routingTable().index("test" + i).shard(0).shards().get(0).state(), equalTo(INITIALIZING));
    }
    RoutingNodes routingNodes = clusterState.getRoutingNodes();
    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()).add(newNode("node4")).add(newNode("node5"))).build();
    newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, equalTo(clusterState));
    clusterState = newState;
    routingNodes = clusterState.getRoutingNodes();
    newState = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));
    assertThat(newState, not(equalTo(clusterState)));
    clusterState = newState;
    for (int i = 0; i < numberOfIndices; i++) {
        assertThat(clusterState.routingTable().index("test" + i).shards().size(), equalTo(1));
        assertThat(clusterState.routingTable().index("test" + i).shard(0).size(), equalTo(1));
        assertThat(clusterState.routingTable().index("test" + i).shard(0).shards().size(), equalTo(1));
        assertThat(clusterState.routingTable().index("test" + i).shard(0).shards().get(0).state(), anyOf(equalTo(RELOCATING), equalTo(STARTED)));
    }
    routingNodes = clusterState.getRoutingNodes();
    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");
    newState = strategy.applyStartedShards(clusterState, routingNodes.shardsWithState(INITIALIZING));
    //        routingTable = strategy.reroute(new RoutingStrategyInfo(metaData, routingTable), nodes);
    assertThat(newState, not(equalTo(clusterState)));
    clusterState = newState;
    for (int i = 0; i < numberOfIndices; i++) {
        assertThat(clusterState.routingTable().index("test" + i).shards().size(), equalTo(1));
        assertThat(clusterState.routingTable().index("test" + i).shard(0).size(), equalTo(1));
        assertThat(clusterState.routingTable().index("test" + i).shard(0).shards().size(), equalTo(1));
        assertThat(clusterState.routingTable().index("test" + i).shard(0).shards().get(0).state(), anyOf(equalTo(RELOCATING), equalTo(STARTED)));
    }
    routingNodes = clusterState.getRoutingNodes();
    assertThat(numberOfShardsOfType(routingNodes, STARTED), equalTo(numberOfIndices));
    for (RoutingNode routingNode : routingNodes) {
        assertThat(routingNode.numberOfShardsWithState(STARTED), equalTo(2));
    }
}

Example 49 with RoutingNode

use of org.elasticsearch.cluster.routing.RoutingNode in project elasticsearch by elastic.

the class IndexLifecycleActionIT method testIndexLifecycleActionsWith11Shards1Backup.

public void testIndexLifecycleActionsWith11Shards1Backup() throws Exception {
    Settings settings = Settings.builder().put(indexSettings()).put(SETTING_NUMBER_OF_SHARDS, 11).put(SETTING_NUMBER_OF_REPLICAS, 1).build();
    // start one server
    logger.info("Starting sever1");
    final String server_1 = internalCluster().startNode();
    final String node1 = getLocalNodeId(server_1);
    logger.info("Creating index [test]");
    CreateIndexResponse createIndexResponse = client().admin().indices().create(createIndexRequest("test").settings(settings)).actionGet();
    assertAcked(createIndexResponse);
    ClusterState clusterState = client().admin().cluster().prepareState().get().getState();
    RoutingNode routingNodeEntry1 = clusterState.getRoutingNodes().node(node1);
    assertThat(routingNodeEntry1.numberOfShardsWithState(STARTED), equalTo(11));
    logger.info("Starting server2");
    // start another server
    String server_2 = internalCluster().startNode();
    // first wait for 2 nodes in the cluster
    logger.info("Waiting for replicas to be assigned");
    ClusterHealthResponse clusterHealth = client().admin().cluster().health(clusterHealthRequest().waitForGreenStatus().waitForNodes("2")).actionGet();
    logger.info("Done Cluster Health, status {}", clusterHealth.getStatus());
    assertThat(clusterHealth.isTimedOut(), equalTo(false));
    assertThat(clusterHealth.getStatus(), equalTo(ClusterHealthStatus.GREEN));
    final String node2 = getLocalNodeId(server_2);
    // explicitly call reroute, so shards will get relocated to the new node (we delay it in ES in case other nodes join)
    client().admin().cluster().prepareReroute().execute().actionGet();
    clusterHealth = client().admin().cluster().health(clusterHealthRequest().waitForGreenStatus().waitForNodes("2").waitForNoRelocatingShards(true)).actionGet();
    assertThat(clusterHealth.isTimedOut(), equalTo(false));
    assertThat(clusterHealth.getStatus(), equalTo(ClusterHealthStatus.GREEN));
    assertThat(clusterHealth.getNumberOfDataNodes(), equalTo(2));
    assertThat(clusterHealth.getInitializingShards(), equalTo(0));
    assertThat(clusterHealth.getUnassignedShards(), equalTo(0));
    assertThat(clusterHealth.getRelocatingShards(), equalTo(0));
    assertThat(clusterHealth.getActiveShards(), equalTo(22));
    assertThat(clusterHealth.getActivePrimaryShards(), equalTo(11));
    clusterState = client().admin().cluster().prepareState().get().getState();
    assertNodesPresent(clusterState.getRoutingNodes(), node1, node2);
    routingNodeEntry1 = clusterState.getRoutingNodes().node(node1);
    assertThat(routingNodeEntry1.numberOfShardsWithState(RELOCATING), equalTo(0));
    assertThat(routingNodeEntry1.numberOfShardsWithState(STARTED), equalTo(11));
    RoutingNode routingNodeEntry2 = clusterState.getRoutingNodes().node(node2);
    assertThat(routingNodeEntry2.numberOfShardsWithState(INITIALIZING), equalTo(0));
    assertThat(routingNodeEntry2.numberOfShardsWithState(STARTED), equalTo(11));
    logger.info("Starting server3");
    // start another server
    String server_3 = internalCluster().startNode();
    // first wait for 3 nodes in the cluster
    logger.info("Waiting for replicas to be assigned");
    clusterHealth = client().admin().cluster().health(clusterHealthRequest().waitForGreenStatus().waitForNodes("3")).actionGet();
    assertThat(clusterHealth.isTimedOut(), equalTo(false));
    assertThat(clusterHealth.getStatus(), equalTo(ClusterHealthStatus.GREEN));
    final String node3 = getLocalNodeId(server_3);
    // explicitly call reroute, so shards will get relocated to the new node (we delay it in ES in case other nodes join)
    client().admin().cluster().prepareReroute().execute().actionGet();
    clusterHealth = client().admin().cluster().health(clusterHealthRequest().waitForGreenStatus().waitForNodes("3").waitForNoRelocatingShards(true)).actionGet();
    assertThat(clusterHealth.isTimedOut(), equalTo(false));
    assertThat(clusterHealth.getStatus(), equalTo(ClusterHealthStatus.GREEN));
    assertThat(clusterHealth.getNumberOfDataNodes(), equalTo(3));
    assertThat(clusterHealth.getInitializingShards(), equalTo(0));
    assertThat(clusterHealth.getUnassignedShards(), equalTo(0));
    assertThat(clusterHealth.getRelocatingShards(), equalTo(0));
    assertThat(clusterHealth.getActiveShards(), equalTo(22));
    assertThat(clusterHealth.getActivePrimaryShards(), equalTo(11));
    clusterState = client().admin().cluster().prepareState().get().getState();
    assertNodesPresent(clusterState.getRoutingNodes(), node1, node2, node3);
    routingNodeEntry1 = clusterState.getRoutingNodes().node(node1);
    routingNodeEntry2 = clusterState.getRoutingNodes().node(node2);
    RoutingNode routingNodeEntry3 = clusterState.getRoutingNodes().node(node3);
    assertThat(routingNodeEntry1.numberOfShardsWithState(STARTED) + routingNodeEntry2.numberOfShardsWithState(STARTED) + routingNodeEntry3.numberOfShardsWithState(STARTED), equalTo(22));
    assertThat(routingNodeEntry1.numberOfShardsWithState(RELOCATING), equalTo(0));
    assertThat(routingNodeEntry1.numberOfShardsWithState(STARTED), anyOf(equalTo(7), equalTo(8)));
    assertThat(routingNodeEntry2.numberOfShardsWithState(RELOCATING), equalTo(0));
    assertThat(routingNodeEntry2.numberOfShardsWithState(STARTED), anyOf(equalTo(7), equalTo(8)));
    assertThat(routingNodeEntry3.numberOfShardsWithState(INITIALIZING), equalTo(0));
    assertThat(routingNodeEntry3.numberOfShardsWithState(STARTED), equalTo(7));
    logger.info("Closing server1");
    // kill the first server
    internalCluster().stopRandomNode(InternalTestCluster.nameFilter(server_1));
    // verify health
    logger.info("Running Cluster Health");
    clusterHealth = client().admin().cluster().health(clusterHealthRequest().waitForGreenStatus().waitForNodes("2")).actionGet();
    logger.info("Done Cluster Health, status {}", clusterHealth.getStatus());
    assertThat(clusterHealth.isTimedOut(), equalTo(false));
    assertThat(clusterHealth.getStatus(), equalTo(ClusterHealthStatus.GREEN));
    client().admin().cluster().prepareReroute().get();
    clusterHealth = client().admin().cluster().health(clusterHealthRequest().waitForGreenStatus().waitForNoRelocatingShards(true).waitForNodes("2")).actionGet();
    assertThat(clusterHealth.isTimedOut(), equalTo(false));
    assertThat(clusterHealth.getStatus(), equalTo(ClusterHealthStatus.GREEN));
    assertThat(clusterHealth.getRelocatingShards(), equalTo(0));
    assertThat(clusterHealth.getActiveShards(), equalTo(22));
    assertThat(clusterHealth.getActivePrimaryShards(), equalTo(11));
    clusterState = client().admin().cluster().prepareState().get().getState();
    assertNodesPresent(clusterState.getRoutingNodes(), node3, node2);
    routingNodeEntry2 = clusterState.getRoutingNodes().node(node2);
    routingNodeEntry3 = clusterState.getRoutingNodes().node(node3);
    assertThat(routingNodeEntry2.numberOfShardsWithState(STARTED) + routingNodeEntry3.numberOfShardsWithState(STARTED), equalTo(22));
    assertThat(routingNodeEntry2.numberOfShardsWithState(RELOCATING), equalTo(0));
    assertThat(routingNodeEntry2.numberOfShardsWithState(STARTED), equalTo(11));
    assertThat(routingNodeEntry3.numberOfShardsWithState(RELOCATING), equalTo(0));
    assertThat(routingNodeEntry3.numberOfShardsWithState(STARTED), equalTo(11));
    logger.info("Deleting index [test]");
    // last, lets delete the index
    DeleteIndexResponse deleteIndexResponse = client().admin().indices().prepareDelete("test").execute().actionGet();
    assertThat(deleteIndexResponse.isAcknowledged(), equalTo(true));
    clusterState = client().admin().cluster().prepareState().get().getState();
    assertNodesPresent(clusterState.getRoutingNodes(), node3, node2);
    routingNodeEntry2 = clusterState.getRoutingNodes().node(node2);
    assertThat(routingNodeEntry2.isEmpty(), equalTo(true));
    routingNodeEntry3 = clusterState.getRoutingNodes().node(node3);
    assertThat(routingNodeEntry3.isEmpty(), equalTo(true));
}

Example 50 with RoutingNode

use of org.elasticsearch.cluster.routing.RoutingNode in project elasticsearch by elastic.

the class AckIT method getAllocationCommand.

private MoveAllocationCommand getAllocationCommand() {
    String fromNodeId = null;
    String toNodeId = null;
    ShardRouting shardToBeMoved = null;
    ClusterStateResponse clusterStateResponse = client().admin().cluster().prepareState().get();
    for (RoutingNode routingNode : clusterStateResponse.getState().getRoutingNodes()) {
        if (routingNode.node().isDataNode()) {
            if (fromNodeId == null && routingNode.numberOfOwningShards() > 0) {
                fromNodeId = routingNode.nodeId();
                shardToBeMoved = routingNode.copyShards().get(randomInt(routingNode.size() - 1));
            } else {
                toNodeId = routingNode.nodeId();
            }
            if (toNodeId != null && fromNodeId != null) {
                break;
            }
        }
    }
    assertNotNull(fromNodeId);
    assertNotNull(toNodeId);
    assertNotNull(shardToBeMoved);
    logger.info("==> going to move shard [{}] from [{}] to [{}]", shardToBeMoved, fromNodeId, toNodeId);
    return new MoveAllocationCommand(shardToBeMoved.getIndexName(), shardToBeMoved.id(), fromNodeId, toNodeId);
}