Examples with RoutingTable org.opensearch.cluster.routing.RoutingTable used on opensource projects

Example 81 with RoutingTable

use of org.opensearch.cluster.routing.RoutingTable in project OpenSearch by opensearch-project.

the class ClusterSerializationTests method testRoutingTableSerialization.

public void testRoutingTableSerialization() throws Exception {
    Metadata metadata = Metadata.builder().put(IndexMetadata.builder("test").settings(settings(Version.CURRENT)).numberOfShards(10).numberOfReplicas(1)).build();
    RoutingTable routingTable = RoutingTable.builder().addAsNew(metadata.index("test")).build();
    DiscoveryNodes nodes = DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")).add(newNode("node3")).build();
    ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).nodes(nodes).metadata(metadata).routingTable(routingTable).build();
    AllocationService strategy = createAllocationService();
    RoutingTable source = strategy.reroute(clusterState, "reroute").routingTable();
    BytesStreamOutput outStream = new BytesStreamOutput();
    source.writeTo(outStream);
    StreamInput inStream = outStream.bytes().streamInput();
    RoutingTable target = RoutingTable.readFrom(inStream);
    assertThat(target.toString(), equalTo(source.toString()));
}

Example 82 with RoutingTable

use of org.opensearch.cluster.routing.RoutingTable in project OpenSearch by opensearch-project.

the class ThrottlingAllocationTests method increaseReplicaCountAndTriggerReroute.

private ClusterState increaseReplicaCountAndTriggerReroute(AllocationService strategy, ClusterState clusterState, String[] indices, int replicaCount) {
    Metadata metaData;
    logger.info("increasing the number of replicas to 1, and perform a reroute (to get the replicas allocation going)");
    RoutingTable updatedRoutingTable = RoutingTable.builder(clusterState.routingTable()).updateNumberOfReplicas(replicaCount, indices).build();
    metaData = Metadata.builder(clusterState.metadata()).updateNumberOfReplicas(replicaCount, indices).build();
    clusterState = ClusterState.builder(clusterState).routingTable(updatedRoutingTable).metadata(metaData).build();
    clusterState = strategy.reroute(clusterState, "reroute");
    return clusterState;
}

Example 83 with RoutingTable

use of org.opensearch.cluster.routing.RoutingTable in project OpenSearch by opensearch-project.

the class ThrottlingAllocationTests method createNewIndexAndStartAllPrimaries.

private ClusterState createNewIndexAndStartAllPrimaries(int newIndexPrimaries, int newIndexReplicas, AllocationService strategy, ClusterState clusterState) {
    Metadata metadata = Metadata.builder(clusterState.metadata()).put(IndexMetadata.builder("new_index").settings(settings(Version.CURRENT)).numberOfShards(newIndexPrimaries).numberOfReplicas(newIndexReplicas)).build();
    RoutingTable updatedRoutingTable = RoutingTable.builder(clusterState.routingTable()).addAsNew(metadata.index("new_index")).build();
    clusterState = ClusterState.builder(clusterState).metadata(metadata).routingTable(updatedRoutingTable).build();
    logger.info("reroute, verify that primaries for the new index primary shards are allocated");
    clusterState = strategy.reroute(clusterState, "reroute");
    logger.info("Apply started shards for new index");
    clusterState = strategy.applyStartedShards(clusterState, clusterState.routingTable().index("new_index").shardsWithState(INITIALIZING));
    return clusterState;
}

Example 84 with RoutingTable

use of org.opensearch.cluster.routing.RoutingTable in project OpenSearch by opensearch-project.

the class ConcurrentRecoveriesAllocationDeciderTests method testClusterConcurrentRecoveries.

public void testClusterConcurrentRecoveries() {
    int primaryShards = 5, replicaShards = 1, numberIndices = 12;
    int clusterConcurrentRecoveries = -1;
    int nodeConcurrentRecoveries = 4;
    AllocationService initialStrategy = createAllocationService(Settings.builder().put("cluster.routing.allocation.awareness.attributes", "zone").put("cluster.routing.allocation.node_initial_primaries_recoveries", "8").put("cluster.routing.allocation.node_concurrent_recoveries", String.valueOf(nodeConcurrentRecoveries)).put("cluster.routing.allocation.exclude.tag", "tag_0").build());
    AllocationService excludeStrategy = null;
    logger.info("Building initial routing table");
    Metadata.Builder metadataBuilder = Metadata.builder();
    for (int i = 0; i < numberIndices; i++) {
        metadataBuilder.put(IndexMetadata.builder("test_" + i).settings(settings(Version.CURRENT)).numberOfShards(primaryShards).numberOfReplicas(replicaShards));
    }
    RoutingTable.Builder initialRoutingTableBuilder = RoutingTable.builder();
    Metadata metadata = metadataBuilder.build();
    for (int i = 0; i < numberIndices; i++) {
        initialRoutingTableBuilder.addAsNew(metadata.index("test_" + i));
    }
    RoutingTable routingTable = initialRoutingTableBuilder.build();
    logger.info("--> adding nodes and starting shards");
    List<Tuple<Integer, Integer>> srcTargetNodes = Collections.unmodifiableList(Arrays.<Tuple<Integer, Integer>>asList(new Tuple(10, 4), new Tuple(4, 10), new Tuple(10, 10)));
    for (Tuple<Integer, Integer> srcTargetNode : srcTargetNodes) {
        int srcNodes = srcTargetNode.v1();
        int targetNodes = srcTargetNode.v2();
        logger.info("Setting up tests for src node {} and target node {}", srcNodes, targetNodes);
        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).metadata(metadata).routingTable(routingTable).nodes(setUpClusterNodes(srcNodes, targetNodes)).build();
        clusterState = initialStrategy.reroute(clusterState, "reroute");
        // Initialize shards
        logger.info("--> Starting primary shards");
        while (clusterState.getRoutingNodes().hasUnassignedShards()) {
            clusterState = startInitializingShardsAndReroute(initialStrategy, clusterState);
        }
        logger.info("--> Starting replica shards");
        while (clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size() > 0) {
            clusterState = startInitializingShardsAndReroute(initialStrategy, clusterState);
        }
        assertThat(clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.STARTED).size(), equalTo((replicaShards + 1) * primaryShards * numberIndices));
        assertThat(clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size(), equalTo(0));
        assertThat(clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.RELOCATING).size(), equalTo(0));
        clusterConcurrentRecoveries = Math.min(srcNodes, targetNodes) * nodeConcurrentRecoveries;
        excludeStrategy = createAllocationService(Settings.builder().put("cluster.routing.allocation.awareness.attributes", "zone").put("cluster.routing.allocation.node_concurrent_recoveries", String.valueOf(nodeConcurrentRecoveries)).put("cluster.routing.allocation.cluster_concurrent_recoveries", String.valueOf(clusterConcurrentRecoveries)).put("cluster.routing.allocation.exclude.tag", "tag_1").build());
        for (int counter = 0; counter < 3; counter++) {
            logger.info("--> Performing a reroute ");
            clusterState = excludeStrategy.reroute(clusterState, "reroute");
            assertThat(clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.RELOCATING).size(), equalTo(clusterConcurrentRecoveries));
            for (ShardRouting startedShard : clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.STARTED)) {
                assertThat(clusterState.getRoutingNodes().node(startedShard.currentNodeId()).node().getAttributes().get("tag"), equalTo("tag_1"));
            }
        }
        // Ensure all shards are started
        while (clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size() > 0) {
            clusterState = startInitializingShardsAndReroute(initialStrategy, clusterState);
        }
        clusterConcurrentRecoveries = clusterConcurrentRecoveries - randomInt(5);
        excludeStrategy = createAllocationService(Settings.builder().put("cluster.routing.allocation.awareness.attributes", "zone").put("cluster.routing.allocation.node_concurrent_recoveries", String.valueOf(nodeConcurrentRecoveries)).put("cluster.routing.allocation.cluster_concurrent_recoveries", String.valueOf(clusterConcurrentRecoveries)).put("cluster.routing.allocation.exclude.tag", "tag_1").build());
        for (int counter = 0; counter < 3; counter++) {
            logger.info("--> Performing a reroute ");
            clusterState = excludeStrategy.reroute(clusterState, "reroute");
            assertThat(clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.RELOCATING).size(), equalTo(clusterConcurrentRecoveries));
            for (ShardRouting startedShard : clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.STARTED)) {
                assertThat(clusterState.getRoutingNodes().node(startedShard.currentNodeId()).node().getAttributes().get("tag"), equalTo("tag_1"));
            }
        }
        // Ensure all shards are started
        while (clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size() > 0) {
            clusterState = startInitializingShardsAndReroute(initialStrategy, clusterState);
        }
        logger.info("--> Disabling cluster_concurrent_recoveries and re-routing ");
        clusterConcurrentRecoveries = Math.min(srcNodes, targetNodes) * nodeConcurrentRecoveries;
        for (int counter = 0; counter < 3; counter++) {
            logger.info("--> Performing a reroute ");
            excludeStrategy = createAllocationService(Settings.builder().put("cluster.routing.allocation.awareness.attributes", "zone").put("cluster.routing.allocation.node_concurrent_recoveries", String.valueOf(nodeConcurrentRecoveries)).put("cluster.routing.allocation.exclude.tag", "tag_1").build());
            clusterState = excludeStrategy.reroute(clusterState, "reroute");
            // outgoing recoveries happens target nodes which anyways doesn't get throttled on incoming recoveries
            if (srcNodes >= targetNodes) {
                assertThat(clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.RELOCATING).size(), equalTo(clusterConcurrentRecoveries));
            } else {
                assertThat(clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.RELOCATING).size(), greaterThanOrEqualTo(clusterConcurrentRecoveries));
            }
        }
        // Ensure all shards are started
        while (clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size() > 0) {
            clusterState = startInitializingShardsAndReroute(initialStrategy, clusterState);
        }
        logger.info("--> Bumping cluster_concurrent_recoveries up and re-routing ");
        clusterConcurrentRecoveries = clusterConcurrentRecoveries + randomInt(5);
        int expectedClusterConcurrentRecoveries = Math.min(srcNodes, targetNodes) * nodeConcurrentRecoveries;
        for (int counter = 0; counter < 3; counter++) {
            logger.info("--> Performing a reroute ");
            excludeStrategy = createAllocationService(Settings.builder().put("cluster.routing.allocation.awareness.attributes", "zone").put("cluster.routing.allocation.node_concurrent_recoveries", String.valueOf(nodeConcurrentRecoveries)).put("cluster.routing.allocation.exclude.tag", "tag_1").build());
            clusterState = excludeStrategy.reroute(clusterState, "reroute");
            assertThat(clusterState.getRoutingNodes().shardsWithState(ShardRoutingState.RELOCATING).size(), equalTo(expectedClusterConcurrentRecoveries));
        }
    }
}

Example 85 with RoutingTable

use of org.opensearch.cluster.routing.RoutingTable in project OpenSearch by opensearch-project.

the class RoutingNodesIntegrityTests method testBalanceAllNodesStartedAddIndex.

public void testBalanceAllNodesStartedAddIndex() {
    AllocationService strategy = createAllocationService(Settings.builder().put("cluster.routing.allocation.node_concurrent_recoveries", 1).put(CLUSTER_ROUTING_ALLOCATION_NODE_INITIAL_REPLICAS_RECOVERIES_SETTING.getKey(), 1).put("cluster.routing.allocation.node_initial_primaries_recoveries", 3).put(ThrottlingAllocationDecider.CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_OUTGOING_RECOVERIES_SETTING.getKey(), 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.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).metadata(metadata).routingTable(initialRoutingTable).build();
    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();
    RoutingNodes routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(false));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(false));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(true));
    clusterState = strategy.reroute(clusterState, "reroute");
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(true));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(true));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(false));
    logger.info("Another round of rebalancing");
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder(clusterState.nodes())).build();
    ClusterState newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, equalTo(clusterState));
    routingNodes = clusterState.getRoutingNodes();
    assertThat(routingNodes.node("node1").numberOfShardsWithState(INITIALIZING), equalTo(1));
    assertThat(routingNodes.node("node2").numberOfShardsWithState(INITIALIZING), equalTo(1));
    assertThat(routingNodes.node("node3").numberOfShardsWithState(INITIALIZING), equalTo(1));
    clusterState = startInitializingShardsAndReroute(strategy, clusterState);
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(true));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(false));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(false));
    assertThat(routingNodes.node("node1").numberOfShardsWithState(STARTED), equalTo(1));
    assertThat(routingNodes.node("node2").numberOfShardsWithState(STARTED), equalTo(1));
    assertThat(routingNodes.node("node3").numberOfShardsWithState(STARTED), equalTo(1));
    logger.info("Reroute, nothing should change");
    newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, equalTo(clusterState));
    logger.info("Start the more shards");
    clusterState = startInitializingShardsAndReroute(strategy, clusterState);
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(false));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(false));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(false));
    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 = 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(metadata.index("test1")).build();
    clusterState = ClusterState.builder(clusterState).metadata(metadata).routingTable(updatedRoutingTable).build();
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(false));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(false));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(true));
    assertThat(clusterState.routingTable().index("test1").shards().size(), equalTo(3));
    clusterState = strategy.reroute(clusterState, "reroute");
    logger.info("Reroute, assign");
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder(clusterState.nodes())).build();
    newState = strategy.reroute(clusterState, "reroute");
    assertThat(newState, equalTo(clusterState));
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(true));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(true));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(false));
    logger.info("Reroute, start the primaries");
    clusterState = startInitializingShardsAndReroute(strategy, clusterState);
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(true));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(false));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(false));
    logger.info("Reroute, start the replicas");
    clusterState = startInitializingShardsAndReroute(strategy, clusterState);
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(false));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(false));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(false));
    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));
    logger.info("kill one node");
    IndexShardRoutingTable indexShardRoutingTable = clusterState.routingTable().index("test").shard(0);
    clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder(clusterState.nodes()).remove(indexShardRoutingTable.primaryShard().currentNodeId())).build();
    clusterState = strategy.disassociateDeadNodes(clusterState, true, "reroute");
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(true));
    // replica got promoted to primary
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(false));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(false));
    logger.info("Start Recovering shards round 1");
    clusterState = startInitializingShardsAndReroute(strategy, clusterState);
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(true));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(false));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(false));
    logger.info("Start Recovering shards round 2");
    clusterState = startInitializingShardsAndReroute(strategy, clusterState);
    routingNodes = clusterState.getRoutingNodes();
    assertThat(assertShardStats(routingNodes), equalTo(true));
    assertThat(routingNodes.hasInactiveShards(), equalTo(false));
    assertThat(routingNodes.hasInactivePrimaries(), equalTo(false));
    assertThat(routingNodes.hasUnassignedPrimaries(), equalTo(false));
}