github-advanced-security[bot] commented on code in PR #19094:
URL: https://github.com/apache/druid/pull/19094#discussion_r2891595932
##########
server/src/test/java/org/apache/druid/client/selector/TierSelectorStrategyTest.java:
##########
@@ -568,4 +586,366 @@
preferredTierHighPriority, preferredTierLowPriority,
nonPreferredTierHighestPriority
);
}
+
+ @Test
+ public void testStrictTierSelectorStrategyAllConfigured()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer pNeg1 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, -1),
+ client
+ );
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ testTierSelectorStrategy(
+ new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of(2, 0, -1)),
+ serviceEmitter
+ ),
+ p2, p0, pNeg1
+ );
+ }
+
+ @Test
+ public void testStrictTierSelectorStrategyNoMatchingPriorities()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p1 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 1),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ final ServerSelector serverSelector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
Review Comment:
## Deprecated method or constructor invocation
Invoking [DataSegment.DataSegment](1) should be avoided because it has been
deprecated.
[Show more
details](https://github.com/apache/druid/security/code-scanning/10856)
##########
server/src/test/java/org/apache/druid/client/selector/TierSelectorStrategyTest.java:
##########
@@ -568,4 +586,366 @@
preferredTierHighPriority, preferredTierLowPriority,
nonPreferredTierHighestPriority
);
}
+
+ @Test
+ public void testStrictTierSelectorStrategyAllConfigured()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer pNeg1 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, -1),
+ client
+ );
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ testTierSelectorStrategy(
+ new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of(2, 0, -1)),
+ serviceEmitter
+ ),
+ p2, p0, pNeg1
+ );
+ }
+
+ @Test
+ public void testStrictTierSelectorStrategyNoMatchingPriorities()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p1 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 1),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ final ServerSelector serverSelector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
+ new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of(5, 6)),
+ serviceEmitter
+ ),
+ HistoricalFilter.IDENTITY_FILTER
+ );
+
+ List<QueryableDruidServer> servers = List.of(p0, p1, p2);
+ for (QueryableDruidServer server : servers) {
+ serverSelector.addServerAndUpdateSegment(server,
serverSelector.getSegment());
+ }
+
+ // Should return null when no matching priorities
+ Assert.assertNull(serverSelector.pick(null, CloneQueryMode.EXCLUDECLONES));
+ Assert.assertNull(serverSelector.pick(GroupByQuery.builder()
+ .setDataSource("foo3")
+ .setInterval(new
MultipleIntervalSegmentSpec(ImmutableList.of(Intervals.of("2000/3000"))))
+
.setGranularity(Granularities.ALL)
+ .setDimensions(new
DefaultDimensionSpec("dim2", "d0"))
+ .build(),
CloneQueryMode.EXCLUDECLONES));
+
+ serviceEmitter.verifyEmitted("tierSelector/noServer", 1);
+
+ // Should return empty list for getCandidates
+ Assert.assertEquals(Collections.emptyList(),
serverSelector.getCandidates(2, CloneQueryMode.EXCLUDECLONES));
+ }
+
+ @Test
+ public void testEmptyStrictTierPrioritiesThrowsException()
+ {
+ DruidException ex = Assert.assertThrows(
+ DruidException.class,
+ () -> new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of()),
+ serviceEmitter
+ )
+ );
+ Assert.assertEquals(
+ "priorities must be non-empty when using strict tier selector on the
Broker. Found priorities[[]].",
+ ex.getMessage()
+ );
+ }
+
+ @Test
+ public void testPooledTierSelectorWithRandomServerStrategy()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer pNeg1 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, -1),
+ client
+ );
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ TierSelectorStrategy strategy = new PooledTierSelectorStrategy(
+ new RandomServerSelectorStrategy(),
+ new PooledTierSelectorStrategyConfig(Set.of(2, 0, -1))
+ );
+
+ final ServerSelector serverSelector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
Review Comment:
## Deprecated method or constructor invocation
Invoking [DataSegment.DataSegment](1) should be avoided because it has been
deprecated.
[Show more
details](https://github.com/apache/druid/security/code-scanning/10857)
##########
server/src/test/java/org/apache/druid/client/selector/TierSelectorStrategyTest.java:
##########
@@ -568,4 +586,366 @@
preferredTierHighPriority, preferredTierLowPriority,
nonPreferredTierHighestPriority
);
}
+
+ @Test
+ public void testStrictTierSelectorStrategyAllConfigured()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer pNeg1 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, -1),
+ client
+ );
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ testTierSelectorStrategy(
+ new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of(2, 0, -1)),
+ serviceEmitter
+ ),
+ p2, p0, pNeg1
+ );
+ }
+
+ @Test
+ public void testStrictTierSelectorStrategyNoMatchingPriorities()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p1 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 1),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ final ServerSelector serverSelector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
+ new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of(5, 6)),
+ serviceEmitter
+ ),
+ HistoricalFilter.IDENTITY_FILTER
+ );
+
+ List<QueryableDruidServer> servers = List.of(p0, p1, p2);
+ for (QueryableDruidServer server : servers) {
+ serverSelector.addServerAndUpdateSegment(server,
serverSelector.getSegment());
+ }
+
+ // Should return null when no matching priorities
+ Assert.assertNull(serverSelector.pick(null, CloneQueryMode.EXCLUDECLONES));
+ Assert.assertNull(serverSelector.pick(GroupByQuery.builder()
+ .setDataSource("foo3")
+ .setInterval(new
MultipleIntervalSegmentSpec(ImmutableList.of(Intervals.of("2000/3000"))))
+
.setGranularity(Granularities.ALL)
+ .setDimensions(new
DefaultDimensionSpec("dim2", "d0"))
+ .build(),
CloneQueryMode.EXCLUDECLONES));
+
+ serviceEmitter.verifyEmitted("tierSelector/noServer", 1);
+
+ // Should return empty list for getCandidates
+ Assert.assertEquals(Collections.emptyList(),
serverSelector.getCandidates(2, CloneQueryMode.EXCLUDECLONES));
+ }
+
+ @Test
+ public void testEmptyStrictTierPrioritiesThrowsException()
+ {
+ DruidException ex = Assert.assertThrows(
+ DruidException.class,
+ () -> new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of()),
+ serviceEmitter
+ )
+ );
+ Assert.assertEquals(
+ "priorities must be non-empty when using strict tier selector on the
Broker. Found priorities[[]].",
+ ex.getMessage()
+ );
+ }
+
+ @Test
+ public void testPooledTierSelectorWithRandomServerStrategy()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer pNeg1 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, -1),
+ client
+ );
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ TierSelectorStrategy strategy = new PooledTierSelectorStrategy(
+ new RandomServerSelectorStrategy(),
+ new PooledTierSelectorStrategyConfig(Set.of(2, 0, -1))
+ );
+
+ final ServerSelector serverSelector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
+ strategy,
+ HistoricalFilter.IDENTITY_FILTER
+ );
+
+ List<QueryableDruidServer> servers = List.of(pNeg1, p0, p2);
+ for (QueryableDruidServer server : servers) {
+ serverSelector.addServerAndUpdateSegment(server,
serverSelector.getSegment());
+ }
+
+ // All 3 servers should be configured
+ List<DruidServerMetadata> allServers =
serverSelector.getAllServers(CloneQueryMode.EXCLUDECLONES);
+ Assert.assertEquals(3, allServers.size());
+ Set<Integer> priorities = allServers.stream()
+ .map(DruidServerMetadata::getPriority)
+ .collect(Collectors.toSet());
+ Assert.assertEquals(Set.of(-1, 0, 2), priorities);
+
+ // Test getCandidates with different sizes - verify correct count
+ List<DruidServerMetadata> candidates1 = serverSelector.getCandidates(1,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertEquals(1, candidates1.size());
+ Assert.assertTrue(Set.of(-1, 0,
2).contains(candidates1.get(0).getPriority()));
+
+ List<DruidServerMetadata> candidates2 = serverSelector.getCandidates(2,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertEquals(2, candidates2.size());
+
+ List<DruidServerMetadata> candidates3 = serverSelector.getCandidates(3,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertEquals(3, candidates3.size());
+ Set<Integer> candidates3Priorities = candidates3.stream()
+
.map(DruidServerMetadata::getPriority)
+
.collect(Collectors.toSet());
+ Assert.assertEquals(Set.of(-1, 0, 2), candidates3Priorities);
+
+ // Pick should return one of the three servers (any priority -
demonstrates flattening)
+ QueryableDruidServer picked = serverSelector.pick(null,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertNotNull(picked);
+ Assert.assertTrue(
+ "Picked server should have one of the configured priorities",
+ picked.getServer().getPriority() == -1 ||
+ picked.getServer().getPriority() == 0 ||
+ picked.getServer().getPriority() == 2
+ );
+
+ // Pick multiple times to verify servers from flattened pool are accessible
+ Set<Integer> pickedPriorities = new HashSet<>();
+ for (int i = 0; i < 20; i++) {
+ QueryableDruidServer server = serverSelector.pick(null,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertNotNull(server);
+ pickedPriorities.add(server.getServer().getPriority());
+ }
+ // With RandomServerSelectorStrategy and 20 picks from 3 servers, we
should see multiple priorities
+ Assert.assertTrue(
+ "Expected to see servers from multiple priorities, but only saw: " +
pickedPriorities,
+ pickedPriorities.size() >= 2
+ );
+ }
+
+ @Test
+ public void testPooledTierSelectorWithConnectionCountServerStrategy()
+ {
+ AtomicInteger c0 = new AtomicInteger(20);
+ AtomicInteger c1 = new AtomicInteger(25);
+ AtomicInteger c2a = new AtomicInteger(1);
+ AtomicInteger c2b = new AtomicInteger(2);
+
+ DirectDruidClient client0 = EasyMock.createMock(DirectDruidClient.class);
+
EasyMock.expect(client0.getNumOpenConnections()).andAnswer(c0::get).anyTimes();
+
+ DirectDruidClient client1 = EasyMock.createMock(DirectDruidClient.class);
+
EasyMock.expect(client1.getNumOpenConnections()).andAnswer(c1::get).anyTimes();
+
+ DirectDruidClient client2a = EasyMock.createMock(DirectDruidClient.class);
+
EasyMock.expect(client2a.getNumOpenConnections()).andAnswer(c2a::get).anyTimes();
+
+ DirectDruidClient client2b = EasyMock.createMock(DirectDruidClient.class);
+
EasyMock.expect(client2b.getNumOpenConnections()).andAnswer(c2b::get).anyTimes();
+
+ EasyMock.replay(client0, client1, client2a, client2b);
+
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("p0", "localhost:8001", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 0),
+ client0
+ );
+ QueryableDruidServer p1 = new QueryableDruidServer(
+ new DruidServer("p1", "localhost:8002", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 1),
+ client1
+ );
+ QueryableDruidServer p2a = new QueryableDruidServer(
+ new DruidServer("p2a", "localhost:8003", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 2),
+ client2a
+ );
+ QueryableDruidServer p2b = new QueryableDruidServer(
+ new DruidServer("p2b", "localhost:8004", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 2),
+ client2b
+ );
+
+ TierSelectorStrategy strategy = new PooledTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new PooledTierSelectorStrategyConfig(Set.of(0, 1, 2))
+ );
+
+ ServerSelector selector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
Review Comment:
## Deprecated method or constructor invocation
Invoking [DataSegment.DataSegment](1) should be avoided because it has been
deprecated.
[Show more
details](https://github.com/apache/druid/security/code-scanning/10858)
##########
server/src/test/java/org/apache/druid/client/selector/TierSelectorStrategyTest.java:
##########
@@ -568,4 +586,366 @@
preferredTierHighPriority, preferredTierLowPriority,
nonPreferredTierHighestPriority
);
}
+
+ @Test
+ public void testStrictTierSelectorStrategyAllConfigured()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer pNeg1 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, -1),
+ client
+ );
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ testTierSelectorStrategy(
+ new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of(2, 0, -1)),
+ serviceEmitter
+ ),
+ p2, p0, pNeg1
+ );
+ }
+
+ @Test
+ public void testStrictTierSelectorStrategyNoMatchingPriorities()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p1 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 1),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ final ServerSelector serverSelector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
+ new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of(5, 6)),
+ serviceEmitter
+ ),
+ HistoricalFilter.IDENTITY_FILTER
+ );
+
+ List<QueryableDruidServer> servers = List.of(p0, p1, p2);
+ for (QueryableDruidServer server : servers) {
+ serverSelector.addServerAndUpdateSegment(server,
serverSelector.getSegment());
+ }
+
+ // Should return null when no matching priorities
+ Assert.assertNull(serverSelector.pick(null, CloneQueryMode.EXCLUDECLONES));
+ Assert.assertNull(serverSelector.pick(GroupByQuery.builder()
+ .setDataSource("foo3")
+ .setInterval(new
MultipleIntervalSegmentSpec(ImmutableList.of(Intervals.of("2000/3000"))))
+
.setGranularity(Granularities.ALL)
+ .setDimensions(new
DefaultDimensionSpec("dim2", "d0"))
+ .build(),
CloneQueryMode.EXCLUDECLONES));
+
+ serviceEmitter.verifyEmitted("tierSelector/noServer", 1);
+
+ // Should return empty list for getCandidates
+ Assert.assertEquals(Collections.emptyList(),
serverSelector.getCandidates(2, CloneQueryMode.EXCLUDECLONES));
+ }
+
+ @Test
+ public void testEmptyStrictTierPrioritiesThrowsException()
+ {
+ DruidException ex = Assert.assertThrows(
+ DruidException.class,
+ () -> new StrictTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new StrictTierSelectorStrategyConfig(List.of()),
+ serviceEmitter
+ )
+ );
+ Assert.assertEquals(
+ "priorities must be non-empty when using strict tier selector on the
Broker. Found priorities[[]].",
+ ex.getMessage()
+ );
+ }
+
+ @Test
+ public void testPooledTierSelectorWithRandomServerStrategy()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer pNeg1 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, -1),
+ client
+ );
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ TierSelectorStrategy strategy = new PooledTierSelectorStrategy(
+ new RandomServerSelectorStrategy(),
+ new PooledTierSelectorStrategyConfig(Set.of(2, 0, -1))
+ );
+
+ final ServerSelector serverSelector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
+ strategy,
+ HistoricalFilter.IDENTITY_FILTER
+ );
+
+ List<QueryableDruidServer> servers = List.of(pNeg1, p0, p2);
+ for (QueryableDruidServer server : servers) {
+ serverSelector.addServerAndUpdateSegment(server,
serverSelector.getSegment());
+ }
+
+ // All 3 servers should be configured
+ List<DruidServerMetadata> allServers =
serverSelector.getAllServers(CloneQueryMode.EXCLUDECLONES);
+ Assert.assertEquals(3, allServers.size());
+ Set<Integer> priorities = allServers.stream()
+ .map(DruidServerMetadata::getPriority)
+ .collect(Collectors.toSet());
+ Assert.assertEquals(Set.of(-1, 0, 2), priorities);
+
+ // Test getCandidates with different sizes - verify correct count
+ List<DruidServerMetadata> candidates1 = serverSelector.getCandidates(1,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertEquals(1, candidates1.size());
+ Assert.assertTrue(Set.of(-1, 0,
2).contains(candidates1.get(0).getPriority()));
+
+ List<DruidServerMetadata> candidates2 = serverSelector.getCandidates(2,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertEquals(2, candidates2.size());
+
+ List<DruidServerMetadata> candidates3 = serverSelector.getCandidates(3,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertEquals(3, candidates3.size());
+ Set<Integer> candidates3Priorities = candidates3.stream()
+
.map(DruidServerMetadata::getPriority)
+
.collect(Collectors.toSet());
+ Assert.assertEquals(Set.of(-1, 0, 2), candidates3Priorities);
+
+ // Pick should return one of the three servers (any priority -
demonstrates flattening)
+ QueryableDruidServer picked = serverSelector.pick(null,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertNotNull(picked);
+ Assert.assertTrue(
+ "Picked server should have one of the configured priorities",
+ picked.getServer().getPriority() == -1 ||
+ picked.getServer().getPriority() == 0 ||
+ picked.getServer().getPriority() == 2
+ );
+
+ // Pick multiple times to verify servers from flattened pool are accessible
+ Set<Integer> pickedPriorities = new HashSet<>();
+ for (int i = 0; i < 20; i++) {
+ QueryableDruidServer server = serverSelector.pick(null,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertNotNull(server);
+ pickedPriorities.add(server.getServer().getPriority());
+ }
+ // With RandomServerSelectorStrategy and 20 picks from 3 servers, we
should see multiple priorities
+ Assert.assertTrue(
+ "Expected to see servers from multiple priorities, but only saw: " +
pickedPriorities,
+ pickedPriorities.size() >= 2
+ );
+ }
+
+ @Test
+ public void testPooledTierSelectorWithConnectionCountServerStrategy()
+ {
+ AtomicInteger c0 = new AtomicInteger(20);
+ AtomicInteger c1 = new AtomicInteger(25);
+ AtomicInteger c2a = new AtomicInteger(1);
+ AtomicInteger c2b = new AtomicInteger(2);
+
+ DirectDruidClient client0 = EasyMock.createMock(DirectDruidClient.class);
+
EasyMock.expect(client0.getNumOpenConnections()).andAnswer(c0::get).anyTimes();
+
+ DirectDruidClient client1 = EasyMock.createMock(DirectDruidClient.class);
+
EasyMock.expect(client1.getNumOpenConnections()).andAnswer(c1::get).anyTimes();
+
+ DirectDruidClient client2a = EasyMock.createMock(DirectDruidClient.class);
+
EasyMock.expect(client2a.getNumOpenConnections()).andAnswer(c2a::get).anyTimes();
+
+ DirectDruidClient client2b = EasyMock.createMock(DirectDruidClient.class);
+
EasyMock.expect(client2b.getNumOpenConnections()).andAnswer(c2b::get).anyTimes();
+
+ EasyMock.replay(client0, client1, client2a, client2b);
+
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("p0", "localhost:8001", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 0),
+ client0
+ );
+ QueryableDruidServer p1 = new QueryableDruidServer(
+ new DruidServer("p1", "localhost:8002", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 1),
+ client1
+ );
+ QueryableDruidServer p2a = new QueryableDruidServer(
+ new DruidServer("p2a", "localhost:8003", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 2),
+ client2a
+ );
+ QueryableDruidServer p2b = new QueryableDruidServer(
+ new DruidServer("p2b", "localhost:8004", null, 0, null,
ServerType.INDEXER_EXECUTOR, DruidServer.DEFAULT_TIER, 2),
+ client2b
+ );
+
+ TierSelectorStrategy strategy = new PooledTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new PooledTierSelectorStrategyConfig(Set.of(0, 1, 2))
+ );
+
+ ServerSelector selector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
+ strategy,
+ HistoricalFilter.IDENTITY_FILTER
+ );
+
+ for (QueryableDruidServer s : List.of(p0, p1, p2a, p2b)) {
+ selector.addServerAndUpdateSegment(s, selector.getSegment());
+ }
+
+ for (int i = 0; i < 20; i++) {
+ QueryableDruidServer picked = selector.pick(null,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertNotNull(picked);
+
+ // Should always be one of the priority-2 replicas
+ Assert.assertEquals(2, picked.getServer().getPriority());
+
+ if (picked.getServer().equals(p2a.getServer())) {
+ c2a.incrementAndGet();
+ } else if (picked.getServer().equals(p2b.getServer())) {
+ c2b.incrementAndGet();
+ } else {
+ Assert.fail("Expected pick to be either p2a or p2b but got: " +
picked);
+ }
+ }
+
+ // Now we just verify that all the servers are picked at least once
+ final Set<DruidServer> pickedServers = new HashSet<>();
+ for (int i = 0; i < 50; i++) {
+ QueryableDruidServer picked = selector.pick(null,
CloneQueryMode.EXCLUDECLONES);
+ Assert.assertNotNull(picked);
+
+ DruidServer pickedServer = picked.getServer();
+ pickedServers.add(pickedServer);
+
+ if (pickedServer.equals(p0.getServer())) {
+ c0.incrementAndGet();
+ } else if (pickedServer.equals(p1.getServer())) {
+ c1.incrementAndGet();
+ } else if (pickedServer.equals(p2a.getServer())) {
+ c2a.incrementAndGet();
+ } else {
+ c2b.incrementAndGet();
+ }
+ }
+
+ Assert.assertEquals(4, pickedServers.size());
+
+ EasyMock.verify(client0, client1, client2a, client2b);
+ }
+
+ @Test
+ public void testPooledTierSelectorStrategyWithNoServerCandidatesInPool()
+ {
+ DirectDruidClient client = EasyMock.createMock(DirectDruidClient.class);
+ QueryableDruidServer p0 = new QueryableDruidServer(
+ new DruidServer("test1", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 0),
+ client
+ );
+ QueryableDruidServer p1 = new QueryableDruidServer(
+ new DruidServer("test2", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 1),
+ client
+ );
+ QueryableDruidServer p2 = new QueryableDruidServer(
+ new DruidServer("test3", "localhost", null, 0, null,
ServerType.HISTORICAL, DruidServer.DEFAULT_TIER, 2),
+ client
+ );
+
+ TierSelectorStrategy strategy = new PooledTierSelectorStrategy(
+ new ConnectionCountServerSelectorStrategy(),
+ new PooledTierSelectorStrategyConfig(Set.of(5, 6))
+ );
+
+ final ServerSelector serverSelector = new ServerSelector(
+ new DataSegment(
+ "test",
+ Intervals.of("2013-01-01/2013-01-02"),
+ DateTimes.of("2013-01-01").toString(),
+ new HashMap<>(),
+ new ArrayList<>(),
+ new ArrayList<>(),
+ NoneShardSpec.instance(),
+ 0,
+ 0L
+ ),
Review Comment:
## Deprecated method or constructor invocation
Invoking [DataSegment.DataSegment](1) should be avoided because it has been
deprecated.
[Show more
details](https://github.com/apache/druid/security/code-scanning/10859)
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
