Examples with EmptyClusterInfoService org.opensearch.cluster.EmptyClusterInfoService used on opensource projects

Example 1 with EmptyClusterInfoService

use of org.opensearch.cluster.EmptyClusterInfoService in project OpenSearch by opensearch-project.

the class AllocationServiceTests method testAssignsPrimariesInPriorityOrderThenReplicas.

public void testAssignsPrimariesInPriorityOrderThenReplicas() {
    // throttle (incoming) recoveries in order to observe the order of operations, but do not throttle outgoing recoveries since
    // the effects of that depend on the earlier (random) allocations
    final Settings settings = Settings.builder().put(CLUSTER_ROUTING_ALLOCATION_NODE_INITIAL_PRIMARIES_RECOVERIES_SETTING.getKey(), 1).put(CLUSTER_ROUTING_ALLOCATION_NODE_INITIAL_REPLICAS_RECOVERIES_SETTING.getKey(), 1).put(CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_INCOMING_RECOVERIES_SETTING.getKey(), 1).put(CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_OUTGOING_RECOVERIES_SETTING.getKey(), Integer.MAX_VALUE).build();
    final ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
    final AllocationService allocationService = new AllocationService(new AllocationDeciders(Arrays.asList(new SameShardAllocationDecider(settings, clusterSettings), new ThrottlingAllocationDecider(settings, clusterSettings))), new ShardsAllocator() {

        @Override
        public void allocate(RoutingAllocation allocation) {
            // all primaries are handled by existing shards allocators in these tests; even the invalid allocator prevents shards
            // from falling through to here
            assertThat(allocation.routingNodes().unassigned().getNumPrimaries(), equalTo(0));
        }

        @Override
        public ShardAllocationDecision decideShardAllocation(ShardRouting shard, RoutingAllocation allocation) {
            return ShardAllocationDecision.NOT_TAKEN;
        }
    }, new EmptyClusterInfoService(), EmptySnapshotsInfoService.INSTANCE);
    final String unrealisticAllocatorName = "unrealistic";
    final Map<String, ExistingShardsAllocator> allocatorMap = new HashMap<>();
    final TestGatewayAllocator testGatewayAllocator = new TestGatewayAllocator();
    allocatorMap.put(GatewayAllocator.ALLOCATOR_NAME, testGatewayAllocator);
    allocatorMap.put(unrealisticAllocatorName, new UnrealisticAllocator());
    allocationService.setExistingShardsAllocators(allocatorMap);
    final DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder();
    nodesBuilder.add(new DiscoveryNode("node1", buildNewFakeTransportAddress(), Version.CURRENT));
    nodesBuilder.add(new DiscoveryNode("node2", buildNewFakeTransportAddress(), Version.CURRENT));
    nodesBuilder.add(new DiscoveryNode("node3", buildNewFakeTransportAddress(), Version.CURRENT));
    final Metadata.Builder metadata = Metadata.builder().put(indexMetadata("highPriority", Settings.builder().put(IndexMetadata.SETTING_PRIORITY, 10))).put(indexMetadata("mediumPriority", Settings.builder().put(IndexMetadata.SETTING_PRIORITY, 5).put(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_SETTING.getKey(), unrealisticAllocatorName))).put(indexMetadata("lowPriority", Settings.builder().put(IndexMetadata.SETTING_PRIORITY, 3))).put(indexMetadata("invalid", Settings.builder().put(IndexMetadata.SETTING_PRIORITY, between(0, 15)).put(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_SETTING.getKey(), "unknown")));
    final RoutingTable.Builder routingTableBuilder = RoutingTable.builder().addAsRecovery(metadata.get("highPriority")).addAsRecovery(metadata.get("mediumPriority")).addAsRecovery(metadata.get("lowPriority")).addAsRecovery(metadata.get("invalid"));
    final ClusterState clusterState = ClusterState.builder(ClusterName.DEFAULT).nodes(nodesBuilder).metadata(metadata).routingTable(routingTableBuilder.build()).build();
    // permit the testGatewayAllocator to allocate primaries to every node
    for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
        for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
            final ShardRouting primaryShard = indexShardRoutingTable.primaryShard();
            for (DiscoveryNode node : clusterState.nodes()) {
                testGatewayAllocator.addKnownAllocation(primaryShard.initialize(node.getId(), FAKE_IN_SYNC_ALLOCATION_ID, 0L));
            }
        }
    }
    final ClusterState reroutedState1 = rerouteAndStartShards(allocationService, clusterState);
    final RoutingTable routingTable1 = reroutedState1.routingTable();
    // the test harness only permits one recovery per node, so we must have allocated all the high-priority primaries and one of the
    // medium-priority ones
    assertThat(routingTable1.shardsWithState(ShardRoutingState.INITIALIZING), empty());
    assertThat(routingTable1.shardsWithState(ShardRoutingState.RELOCATING), empty());
    assertTrue(routingTable1.shardsWithState(ShardRoutingState.STARTED).stream().allMatch(ShardRouting::primary));
    assertThat(routingTable1.index("highPriority").primaryShardsActive(), equalTo(2));
    assertThat(routingTable1.index("mediumPriority").primaryShardsActive(), equalTo(1));
    assertThat(routingTable1.index("lowPriority").shardsWithState(ShardRoutingState.STARTED), empty());
    assertThat(routingTable1.index("invalid").shardsWithState(ShardRoutingState.STARTED), empty());
    final ClusterState reroutedState2 = rerouteAndStartShards(allocationService, reroutedState1);
    final RoutingTable routingTable2 = reroutedState2.routingTable();
    // this reroute starts the one remaining medium-priority primary and both of the low-priority ones,
    // and also 1 medium priority replica
    assertThat(routingTable2.shardsWithState(ShardRoutingState.INITIALIZING), empty());
    assertThat(routingTable2.shardsWithState(ShardRoutingState.RELOCATING), empty());
    assertTrue(routingTable2.index("highPriority").allPrimaryShardsActive());
    assertTrue(routingTable2.index("mediumPriority").allPrimaryShardsActive());
    assertThat(routingTable2.index("mediumPriority").shardsWithState(ShardRoutingState.STARTED).size(), equalTo(3));
    assertThat(routingTable2.index("mediumPriority").shardsWithState(ShardRoutingState.UNASSIGNED).size(), equalTo(1));
    assertTrue(routingTable2.index("lowPriority").allPrimaryShardsActive());
    assertThat(routingTable2.index("invalid").shardsWithState(ShardRoutingState.STARTED), empty());
    final ClusterState reroutedState3 = rerouteAndStartShards(allocationService, reroutedState2);
    final RoutingTable routingTable3 = reroutedState3.routingTable();
    // this reroute starts the one remaining medium-priority replica
    assertThat(routingTable3.shardsWithState(ShardRoutingState.INITIALIZING), empty());
    assertThat(routingTable3.shardsWithState(ShardRoutingState.RELOCATING), empty());
    assertTrue(routingTable3.index("highPriority").allPrimaryShardsActive());
    assertTrue(routingTable3.index("mediumPriority").allPrimaryShardsActive());
    assertThat(routingTable3.index("mediumPriority").shardsWithState(ShardRoutingState.UNASSIGNED), empty());
    assertThat(routingTable3.index("mediumPriority").shardsWithState(ShardRoutingState.STARTED).size(), equalTo(4));
    assertTrue(routingTable3.index("lowPriority").allPrimaryShardsActive());
    assertThat(routingTable3.index("invalid").shardsWithState(ShardRoutingState.STARTED), empty());
}