This is an automated email from the ASF dual-hosted git repository.

Jackie-Jiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/pinot.git


The following commit(s) were added to refs/heads/master by this push:
     new 72bc378edc5 Use compact bounded port ranges for parallel tests (#20199)
72bc378edc5 is described below

commit 72bc378edc5bf109a6a2c852a86efbd95137278d
Author: Xiaotian (Jackie) Jiang <[email protected]>
AuthorDate: Tue Nov 10 11:00:33 2026 -0800

    Use compact bounded port ranges for parallel tests (#20199)
---
 .../ControllerStarterDynamicEnvTest.java           |   5 +-
 .../controller/ControllerStarterStatelessTest.java |   7 +-
 .../pinot/controller/helix/ControllerTest.java     |  42 +++++--
 .../pinot/controller/helix/TestPortRange.java      |  57 +++++++++
 .../pinot/controller/helix/TestPortRangeTest.java  | 136 +++++++++++++++++++++
 .../PinotTaskManagerDistributedLockingTest.java    |   8 --
 .../pinot/integration/tests/ClusterTest.java       |  19 ++-
 .../tests/ServerStarterIntegrationTest.java        |   4 +-
 .../integration/tests/TlsIntegrationTest.java      |  11 +-
 .../BaseMultiClusterIntegrationTest.java           |  17 ++-
 10 files changed, 251 insertions(+), 55 deletions(-)

diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerStarterDynamicEnvTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerStarterDynamicEnvTest.java
index 7c876623485..49815efe239 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerStarterDynamicEnvTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerStarterDynamicEnvTest.java
@@ -30,7 +30,6 @@ import org.apache.pinot.common.utils.helix.HelixHelper;
 import org.apache.pinot.controller.helix.ControllerTest;
 import org.apache.pinot.spi.env.PinotConfiguration;
 import org.apache.pinot.spi.utils.CommonConstants;
-import org.apache.pinot.spi.utils.NetUtils;
 import org.testng.annotations.Test;
 
 import static org.apache.pinot.controller.ControllerConf.CONTROLLER_HOST;
@@ -134,7 +133,7 @@ public class ControllerStarterDynamicEnvTest extends 
ControllerTest {
     properties.put(CONTROLLER_HOST, "HOST");
     properties.put(CONTROLLER_PORT, "PORT");
 
-    int controllerPort = NetUtils.findOpenPort(_nextControllerPort);
+    int controllerPort = 
_controllerPortRange.findOpenPort(_nextControllerPort);
     properties.put(ControllerConf.CONTROLLER_PORT, controllerPort);
     if (_controllerPort == 0) {
       _controllerPort = controllerPort;
@@ -190,7 +189,7 @@ public class ControllerStarterDynamicEnvTest extends 
ControllerTest {
   }
 
   private int findControllerPortInForkRange() {
-    _controllerPortOverride = NetUtils.findOpenPort(_nextControllerPort);
+    _controllerPortOverride = 
_controllerPortRange.findOpenPort(_nextControllerPort);
     return _controllerPortOverride;
   }
 }
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerStarterStatelessTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerStarterStatelessTest.java
index 9b5c837aa74..5c904449085 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerStarterStatelessTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerStarterStatelessTest.java
@@ -24,7 +24,6 @@ import java.util.Set;
 import org.apache.helix.model.InstanceConfig;
 import org.apache.pinot.common.utils.helix.HelixHelper;
 import org.apache.pinot.controller.helix.ControllerTest;
-import org.apache.pinot.spi.utils.NetUtils;
 import org.testng.annotations.Test;
 
 import static org.apache.pinot.controller.ControllerConf.CONTROLLER_HOST;
@@ -47,7 +46,7 @@ public class ControllerStarterStatelessTest extends 
ControllerTest {
   @Test
   public void testHostnamePortOverride()
       throws Exception {
-    int controllerPort = NetUtils.findOpenPort(_nextControllerPort);
+    int controllerPort = 
_controllerPortRange.findOpenPort(_nextControllerPort);
     _configOverride.clear();
     _configOverride.put(CONFIG_OF_INSTANCE_ID, "Controller_myInstance");
     _configOverride.put(CONTROLLER_HOST, "myHost");
@@ -71,7 +70,7 @@ public class ControllerStarterStatelessTest extends 
ControllerTest {
   @Test
   public void testInvalidInstanceId()
       throws Exception {
-    int controllerPort = NetUtils.findOpenPort(_nextControllerPort);
+    int controllerPort = 
_controllerPortRange.findOpenPort(_nextControllerPort);
     _configOverride.clear();
     _configOverride.put(CONFIG_OF_INSTANCE_ID, "myInstance");
     _configOverride.put(CONTROLLER_HOST, "myHost");
@@ -91,7 +90,7 @@ public class ControllerStarterStatelessTest extends 
ControllerTest {
   @Test
   public void testDefaultInstanceId()
       throws Exception {
-    int controllerPort = NetUtils.findOpenPort(_nextControllerPort);
+    int controllerPort = 
_controllerPortRange.findOpenPort(_nextControllerPort);
     _configOverride.clear();
     _configOverride.put(CONTROLLER_HOST, "myHost");
     _configOverride.put(CONTROLLER_PORT, controllerPort);
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/ControllerTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/ControllerTest.java
index a11a2f0b13f..906b7034b0a 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/ControllerTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/ControllerTest.java
@@ -138,10 +138,11 @@ public class ControllerTest {
   /// Per-fork port offset so that concurrent surefire forks (forkCount > 1, 
reuseForks=false)
   /// allocate disjoint port ranges. surefire injects a 1-based 
`surefire.forkNumber` into each
   /// fork (so it is 1 even at forkCount=1, 1..N under parallel forks); it is 
0 only outside a
-  /// surefire fork. The stride (5000) comfortably exceeds the ~3000-port span 
one ControllerTest
-  /// instance uses. Ports are still probed with findOpenPort, so the offset 
only separates the
-  /// per-fork starting points; no test depends on a literal base port.
-  private static final int FORK_PORT_OFFSET = forkNumber() * 5000;
+  /// surefire fork. Each fork has a 1000-port block with bounded component 
ranges below. With
+  /// the default base of 20000, the three CI forks use 21000-23999, below 
Linux's default
+  /// ephemeral range (32768-60999). Custom bases or additional forks must 
also avoid that range.
+  /// Probing a port does not reserve it until the listener binds.
+  private static final int FORK_PORT_OFFSET = forkNumber() * 1000;
 
   private static int forkNumber() {
     try {
@@ -173,12 +174,27 @@ public class ControllerTest {
   protected final String _clusterName = getClass().getSimpleName();
   protected final List<HelixManager> _fakeInstanceHelixManagers = new 
ArrayList<>();
 
-  protected int _nextControllerPort = 
Integer.getInteger(TEST_PORT_BASE_PROPERTY, 20000) + FORK_PORT_OFFSET;
-  protected int _nextBrokerPort = _nextControllerPort + 1000;
-  protected int _nextBrokerGrpcPort = _nextBrokerPort + 500;
-  protected int _nextBrokerQueryRunnerPort = _nextBrokerGrpcPort + 250;
-  protected int _nextServerPort = _nextBrokerPort + 1000;
-  protected int _nextMinionPort = _nextServerPort + 1000;
+  private final int _testPortBase = 
Integer.getInteger(TEST_PORT_BASE_PROPERTY, 20000) + FORK_PORT_OFFSET;
+  protected final TestPortRange _controllerPortRange =
+      new TestPortRange("controller", _testPortBase, _testPortBase + 100);
+  protected final TestPortRange _brokerPortRange =
+      new TestPortRange("broker HTTP", _testPortBase + 100, _testPortBase + 
200);
+  protected final TestPortRange _brokerGrpcPortRange =
+      new TestPortRange("broker gRPC", _testPortBase + 200, _testPortBase + 
300);
+  protected final TestPortRange _brokerQueryRunnerPortRange =
+      new TestPortRange("broker query runner", _testPortBase + 300, 
_testPortBase + 400);
+  // Servers allocate five ports per configuration, with additional ports in 
TLS tests.
+  protected final TestPortRange _serverPortRange =
+      new TestPortRange("server", _testPortBase + 400, _testPortBase + 800);
+  protected final TestPortRange _minionPortRange =
+      new TestPortRange("minion", _testPortBase + 800, _testPortBase + 900);
+  // Offsets 900-999 are spare. Keep cursors separate so subclasses can reuse 
existing configurations on restart.
+  protected int _nextControllerPort = _controllerPortRange.getStart();
+  protected int _nextBrokerPort = _brokerPortRange.getStart();
+  protected int _nextBrokerGrpcPort = _brokerGrpcPortRange.getStart();
+  protected int _nextBrokerQueryRunnerPort = 
_brokerQueryRunnerPortRange.getStart();
+  protected int _nextServerPort = _serverPortRange.getStart();
+  protected int _nextMinionPort = _minionPortRange.getStart();
 
   private ZkStarter.ZookeeperInstance _zookeeperInstance;
 
@@ -298,7 +314,7 @@ public class ControllerTest {
     properties.put(ControllerConf.ZK_STR, getZkUrl());
     properties.put(ControllerConf.HELIX_CLUSTER_NAME, getHelixClusterName());
     properties.put(ControllerConf.CONTROLLER_HOST, LOCAL_HOST);
-    int controllerPort = NetUtils.findOpenPort(_nextControllerPort);
+    int controllerPort = 
_controllerPortRange.findOpenPort(_nextControllerPort);
     properties.put(ControllerConf.CONTROLLER_PORT, controllerPort);
     if (_controllerPort == 0) {
       _controllerPort = controllerPort;
@@ -555,7 +571,7 @@ public class ControllerTest {
     }
     HelixConfigScope configScope = new 
HelixConfigScopeBuilder(HelixConfigScope.ConfigScopeProperty.PARTICIPANT,
         getHelixClusterName()).forParticipant(instanceId).build();
-    int adminPort = NetUtils.findOpenPort(_nextServerPort);
+    int adminPort = _serverPortRange.findOpenPort(_nextServerPort);
     helixAdmin.setConfig(configScope, Map.of(Helix.Instance.ADMIN_PORT_KEY, 
Integer.toString(adminPort)));
     _nextServerPort = adminPort + 1;
     _fakeInstanceHelixManagers.add(helixManager);
@@ -576,7 +592,7 @@ public class ControllerTest {
     }
     HelixConfigScope configScope = new 
HelixConfigScopeBuilder(HelixConfigScope.ConfigScopeProperty.PARTICIPANT,
         getHelixClusterName()).forParticipant(instanceId).build();
-    int adminPort = NetUtils.findOpenPort(_nextServerPort);
+    int adminPort = _serverPortRange.findOpenPort(_nextServerPort);
     helixAdmin.setConfig(configScope, Map.of(Helix.Instance.ADMIN_PORT_KEY, 
Integer.toString(adminPort)));
     _nextServerPort = adminPort + 1;
     _fakeInstanceHelixManagers.add(helixManager);
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/TestPortRange.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/TestPortRange.java
new file mode 100644
index 00000000000..0b7a05b5591
--- /dev/null
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/TestPortRange.java
@@ -0,0 +1,57 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.controller.helix;
+
+import com.google.common.base.Preconditions;
+import java.util.Objects;
+import org.apache.pinot.spi.utils.NetUtils;
+
+
+/// An immutable, thread-safe range of test listener ports with an inclusive 
start and exclusive end. Searches never
+/// cross the range boundary. Probing does not reserve a socket, so callers 
must coordinate their allocation cursors
+/// and the subsequent listener binds; concurrent callers can observe the same 
available port.
+public final class TestPortRange {
+  private final String _component;
+  private final int _start;
+  private final int _end;
+
+  public TestPortRange(String component, int start, int end) {
+    _component = Objects.requireNonNull(component);
+    Preconditions.checkArgument(start > 0 && start < end && end <= 65536,
+        "Invalid port range for %s: [%s, %s); expected 1 <= start < end <= 
65536", component, start, end);
+    _start = start;
+    _end = end;
+  }
+
+  public int getStart() {
+    return _start;
+  }
+
+  public int findOpenPort(int startPort) {
+    Preconditions.checkArgument(startPort >= _start,
+        "Starting port %s is below the %s port range [%s, %s)", startPort, 
_component, _start, _end);
+    for (int port = startPort; port < _end; port++) {
+      if (NetUtils.available(port)) {
+        return port;
+      }
+    }
+    throw new IllegalStateException("No available port for " + _component + " 
in range [" + _start + ", " + _end
+        + ") starting at " + startPort);
+  }
+}
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/TestPortRangeTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/TestPortRangeTest.java
new file mode 100644
index 00000000000..1664a5ce4bc
--- /dev/null
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/TestPortRangeTest.java
@@ -0,0 +1,136 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.controller.helix;
+
+import java.util.Map;
+import org.apache.pinot.controller.ControllerConf;
+import org.apache.pinot.spi.utils.NetUtils;
+import org.mockito.MockedStatic;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.mockStatic;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.expectThrows;
+
+
+/// Verifies bounded test-port searches without binding host ports. Tests have 
no shared mutable state; the static
+/// availability mocks are scoped to the executing thread.
+public class TestPortRangeTest {
+  @Test
+  public void testControllerConfigurationsExhaustOnlyControllerRange() {
+    ControllerTest fixture = new ControllerTest() {
+      @Override
+      public String getZkUrl() {
+        return "localhost:2181";
+      }
+    };
+    int controllerStart = fixture._controllerPortRange.getStart();
+    int brokerStart = fixture._brokerPortRange.getStart();
+    assertEquals(brokerStart - controllerStart, 100);
+
+    try (MockedStatic<NetUtils> netUtils = mockStatic(NetUtils.class)) {
+      netUtils.when(() -> NetUtils.available(anyInt())).thenReturn(true);
+      for (int i = 0; i < 100; i++) {
+        Map<String, Object> configuration = 
fixture.getDefaultControllerConfiguration();
+        assertEquals(configuration.get(ControllerConf.CONTROLLER_PORT), 
controllerStart + i);
+      }
+
+      netUtils.clearInvocations();
+      expectThrows(IllegalStateException.class, 
fixture::getDefaultControllerConfiguration);
+      netUtils.verifyNoInteractions();
+    }
+  }
+
+  @Test
+  public void testSkipsOccupiedPortsWithinRange() {
+    TestPortRange range = new TestPortRange("controller", 21000, 21100);
+    try (MockedStatic<NetUtils> netUtils = mockStatic(NetUtils.class)) {
+      netUtils.when(() -> NetUtils.available(21002)).thenReturn(true);
+
+      assertEquals(range.findOpenPort(range.getStart()), 21002);
+
+      netUtils.verify(() -> NetUtils.available(21000));
+      netUtils.verify(() -> NetUtils.available(21001));
+      netUtils.verify(() -> NetUtils.available(21002));
+      netUtils.verifyNoMoreInteractions();
+    }
+  }
+
+  @Test
+  public void testExhaustedRangeDoesNotProbeNextComponent() {
+    TestPortRange range = new TestPortRange("server", 21400, 21800);
+    try (MockedStatic<NetUtils> netUtils = mockStatic(NetUtils.class)) {
+      netUtils.when(() -> NetUtils.available(21800)).thenReturn(true);
+
+      IllegalStateException exception = 
expectThrows(IllegalStateException.class, () -> range.findOpenPort(21799));
+      assertEquals(exception.getMessage(), "No available port for server in 
range [21400, 21800) starting at 21799");
+
+      netUtils.verify(() -> NetUtils.available(21799));
+      netUtils.verifyNoMoreInteractions();
+    }
+  }
+
+  @Test
+  public void testExhaustedCursorDoesNotProbe() {
+    TestPortRange range = new TestPortRange("minion", 21800, 21900);
+    try (MockedStatic<NetUtils> netUtils = mockStatic(NetUtils.class)) {
+      for (int startPort : new int[]{21900, 21901, Integer.MAX_VALUE}) {
+        IllegalStateException exception =
+            expectThrows(IllegalStateException.class, () -> 
range.findOpenPort(startPort));
+        assertEquals(exception.getMessage(),
+            "No available port for minion in range [21800, 21900) starting at 
" + startPort);
+      }
+      netUtils.verifyNoInteractions();
+    }
+  }
+
+  @Test
+  public void testRejectsCursorBelowRange() {
+    TestPortRange range = new TestPortRange("broker", 21100, 21200);
+    try (MockedStatic<NetUtils> netUtils = mockStatic(NetUtils.class)) {
+      expectThrows(IllegalArgumentException.class, () -> 
range.findOpenPort(21099));
+      netUtils.verifyNoInteractions();
+    }
+  }
+
+  @Test
+  public void testHighestTcpPortIsIncluded() {
+    TestPortRange range = new TestPortRange("controller", 65535, 65536);
+    try (MockedStatic<NetUtils> netUtils = mockStatic(NetUtils.class)) {
+      netUtils.when(() -> NetUtils.available(65535)).thenReturn(true);
+
+      assertEquals(range.findOpenPort(range.getStart()), 65535);
+
+      netUtils.verify(() -> NetUtils.available(65535));
+      netUtils.verifyNoMoreInteractions();
+    }
+  }
+
+  @DataProvider
+  public Object[][] invalidRanges() {
+    return new Object[][]{{0, 100}, {-1, 100}, {100, 100}, {101, 100}, {65535, 
65537}, {65536, 65537}};
+  }
+
+  @Test(dataProvider = "invalidRanges")
+  public void testRejectsInvalidRange(int start, int end) {
+    expectThrows(IllegalArgumentException.class, () -> new 
TestPortRange("controller", start, end));
+  }
+}
diff --git 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/minion/PinotTaskManagerDistributedLockingTest.java
 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/minion/PinotTaskManagerDistributedLockingTest.java
index 997489e400c..d0c40c8ef2d 100644
--- 
a/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/minion/PinotTaskManagerDistributedLockingTest.java
+++ 
b/pinot-controller/src/test/java/org/apache/pinot/controller/helix/core/minion/PinotTaskManagerDistributedLockingTest.java
@@ -105,14 +105,12 @@ public class PinotTaskManagerDistributedLockingTest 
extends ControllerTest {
     Map<String, Object> properties1 = getDefaultControllerConfiguration();
     
properties1.put(ControllerConf.ControllerPeriodicTasksConf.PINOT_TASK_MANAGER_SCHEDULER_ENABLED,
 true);
     
properties1.put(ControllerConf.ControllerPeriodicTasksConf.ENABLE_DISTRIBUTED_LOCKING,
 true);
-    properties1.put(ControllerConf.CONTROLLER_PORT, 21002);
 
     // Setup second controller with distributed locking enabled (different 
port)
     Map<String, Object> properties2 = getDefaultControllerConfiguration();
     // Disable scheduler to avoid Quartz conflicts
     
properties2.put(ControllerConf.ControllerPeriodicTasksConf.PINOT_TASK_MANAGER_SCHEDULER_ENABLED,
 false);
     
properties2.put(ControllerConf.ControllerPeriodicTasksConf.ENABLE_DISTRIBUTED_LOCKING,
 true);
-    properties2.put(ControllerConf.CONTROLLER_PORT, 21003);
 
     // Start both controllers
     startController(properties1);
@@ -260,13 +258,11 @@ public class PinotTaskManagerDistributedLockingTest 
extends ControllerTest {
     Map<String, Object> properties1 = getDefaultControllerConfiguration();
     
properties1.put(ControllerConf.ControllerPeriodicTasksConf.PINOT_TASK_MANAGER_SCHEDULER_ENABLED,
 true);
     
properties1.put(ControllerConf.ControllerPeriodicTasksConf.ENABLE_DISTRIBUTED_LOCKING,
 true);
-    properties1.put(ControllerConf.CONTROLLER_PORT, 21000);
 
     // Setup second controller with distributed locking enabled (different 
port)
     Map<String, Object> properties2 = getDefaultControllerConfiguration();
     
properties2.put(ControllerConf.ControllerPeriodicTasksConf.PINOT_TASK_MANAGER_SCHEDULER_ENABLED,
 true);
     
properties2.put(ControllerConf.ControllerPeriodicTasksConf.ENABLE_DISTRIBUTED_LOCKING,
 true);
-    properties2.put(ControllerConf.CONTROLLER_PORT, 21001);
 
     // Start both controllers
     startController(properties1);
@@ -396,14 +392,12 @@ public class PinotTaskManagerDistributedLockingTest 
extends ControllerTest {
     Map<String, Object> properties1 = getDefaultControllerConfiguration();
     
properties1.put(ControllerConf.ControllerPeriodicTasksConf.PINOT_TASK_MANAGER_SCHEDULER_ENABLED,
 true);
     
properties1.put(ControllerConf.ControllerPeriodicTasksConf.ENABLE_DISTRIBUTED_LOCKING,
 true);
-    properties1.put(ControllerConf.CONTROLLER_PORT, 21002);
 
     // Setup second controller with distributed locking enabled (different 
port)
     Map<String, Object> properties2 = getDefaultControllerConfiguration();
     // Disable scheduler to avoid Quartz conflicts
     
properties2.put(ControllerConf.ControllerPeriodicTasksConf.PINOT_TASK_MANAGER_SCHEDULER_ENABLED,
 false);
     
properties2.put(ControllerConf.ControllerPeriodicTasksConf.ENABLE_DISTRIBUTED_LOCKING,
 true);
-    properties2.put(ControllerConf.CONTROLLER_PORT, 21003);
 
     // Start both controllers
     startController(properties1);
@@ -572,14 +566,12 @@ public class PinotTaskManagerDistributedLockingTest 
extends ControllerTest {
     Map<String, Object> properties1 = getDefaultControllerConfiguration();
     
properties1.put(ControllerConf.ControllerPeriodicTasksConf.PINOT_TASK_MANAGER_SCHEDULER_ENABLED,
 true);
     
properties1.put(ControllerConf.ControllerPeriodicTasksConf.ENABLE_DISTRIBUTED_LOCKING,
 true);
-    properties1.put(ControllerConf.CONTROLLER_PORT, 21002);
 
     // Setup second controller with distributed locking enabled (different 
port)
     Map<String, Object> properties2 = getDefaultControllerConfiguration();
     // Disable scheduler to avoid Quartz conflicts
     
properties2.put(ControllerConf.ControllerPeriodicTasksConf.PINOT_TASK_MANAGER_SCHEDULER_ENABLED,
 false);
     
properties2.put(ControllerConf.ControllerPeriodicTasksConf.ENABLE_DISTRIBUTED_LOCKING,
 true);
-    properties2.put(ControllerConf.CONTROLLER_PORT, 21003);
 
     // Start both controllers
     startController(properties1);
diff --git 
a/pinot-integration-test-base/src/test/java/org/apache/pinot/integration/tests/ClusterTest.java
 
b/pinot-integration-test-base/src/test/java/org/apache/pinot/integration/tests/ClusterTest.java
index 4ce8b26ef99..163bd12616d 100644
--- 
a/pinot-integration-test-base/src/test/java/org/apache/pinot/integration/tests/ClusterTest.java
+++ 
b/pinot-integration-test-base/src/test/java/org/apache/pinot/integration/tests/ClusterTest.java
@@ -79,7 +79,6 @@ import org.apache.pinot.spi.utils.CommonConstants.Helix;
 import org.apache.pinot.spi.utils.CommonConstants.MultiStageQueryRunner;
 import org.apache.pinot.spi.utils.CommonConstants.Server;
 import org.apache.pinot.spi.utils.JsonUtils;
-import org.apache.pinot.spi.utils.NetUtils;
 import org.intellij.lang.annotations.Language;
 import org.testng.Assert;
 import org.testng.SkipException;
@@ -180,7 +179,7 @@ public abstract class ClusterTest extends ControllerTest {
     brokerConf.setProperty(Helix.CONFIG_OF_ZOOKEEPER_SERVER, getZkUrl());
     brokerConf.setProperty(Helix.CONFIG_OF_CLUSTER_NAME, 
getHelixClusterName());
     brokerConf.setProperty(Broker.CONFIG_OF_BROKER_HOSTNAME, LOCAL_HOST);
-    int brokerPort = NetUtils.findOpenPort(_nextBrokerPort);
+    int brokerPort = _brokerPortRange.findOpenPort(_nextBrokerPort);
     brokerConf.setProperty(Helix.KEY_OF_BROKER_QUERY_PORT, brokerPort);
     _brokerPorts.add(brokerPort);
     if (_brokerBaseApiUrl == null) {
@@ -191,13 +190,13 @@ public abstract class ClusterTest extends ControllerTest {
     brokerConf.setProperty(Broker.CONFIG_OF_DELAY_SHUTDOWN_TIME_MS, 0);
     brokerConf.setProperty(CommonConstants.CONFIG_OF_TIMEZONE, "UTC");
 
-    int brokerGrpcPort = NetUtils.findOpenPort(_nextBrokerGrpcPort);
+    int brokerGrpcPort = 
_brokerGrpcPortRange.findOpenPort(_nextBrokerGrpcPort);
     brokerConf.setProperty(Broker.Grpc.KEY_OF_GRPC_PORT, brokerGrpcPort);
     if (_brokerGrpcEndpoint == null) {
       _brokerGrpcEndpoint = "localhost:" + brokerGrpcPort;
     }
     _nextBrokerGrpcPort = brokerGrpcPort + 1;
-    int brokerQueryRunnerPort = 
NetUtils.findOpenPort(_nextBrokerQueryRunnerPort);
+    int brokerQueryRunnerPort = 
_brokerQueryRunnerPortRange.findOpenPort(_nextBrokerQueryRunnerPort);
     brokerConf.setProperty(MultiStageQueryRunner.KEY_OF_QUERY_RUNNER_PORT, 
brokerQueryRunnerPort);
     _nextBrokerQueryRunnerPort = brokerQueryRunnerPort + 1;
     overrideBrokerConf(brokerConf);
@@ -253,19 +252,19 @@ public abstract class ClusterTest extends ControllerTest {
     serverConf.setProperty(Server.CONFIG_OF_SEGMENT_FORMAT_VERSION, "v3");
     serverConf.setProperty(Server.CONFIG_OF_SHUTDOWN_ENABLE_QUERY_CHECK, 
false);
 
-    int serverAdminApiPort = NetUtils.findOpenPort(_nextServerPort);
+    int serverAdminApiPort = _serverPortRange.findOpenPort(_nextServerPort);
     serverConf.setProperty(Server.CONFIG_OF_ADMIN_API_PORT, 
serverAdminApiPort);
-    int serverNettyPort = NetUtils.findOpenPort(serverAdminApiPort + 1);
+    int serverNettyPort = _serverPortRange.findOpenPort(serverAdminApiPort + 
1);
     serverConf.setProperty(Helix.KEY_OF_SERVER_NETTY_PORT, serverNettyPort);
-    int serverGrpcPort = NetUtils.findOpenPort(serverNettyPort + 1);
+    int serverGrpcPort = _serverPortRange.findOpenPort(serverNettyPort + 1);
     serverConf.setProperty(Server.CONFIG_OF_GRPC_PORT, serverGrpcPort);
     // Assign the multi-stage query engine ports explicitly using the 
incremental findOpenPort pattern so that
     // rapid back-to-back server starts in the same JVM don't collide on 
OS-ephemeral ports. Otherwise
     // BaseServerStarter.init() falls back to NetUtils.findOpenPort() which 
probes and releases a ServerSocket(0)
     // before the gRPC server binds, opening a window where the same port can 
be handed to a later caller.
-    int queryServerPort = NetUtils.findOpenPort(serverGrpcPort + 1);
+    int queryServerPort = _serverPortRange.findOpenPort(serverGrpcPort + 1);
     serverConf.setProperty(MultiStageQueryRunner.KEY_OF_QUERY_SERVER_PORT, 
queryServerPort);
-    int queryRunnerPort = NetUtils.findOpenPort(queryServerPort + 1);
+    int queryRunnerPort = _serverPortRange.findOpenPort(queryServerPort + 1);
     serverConf.setProperty(MultiStageQueryRunner.KEY_OF_QUERY_RUNNER_PORT, 
queryRunnerPort);
     if (_serverAdminApiPort == 0) {
       _serverAdminApiPort = serverAdminApiPort;
@@ -333,7 +332,7 @@ public abstract class ClusterTest extends ControllerTest {
     minionConf.setProperty(Helix.CONFIG_OF_ZOOKEEPER_SERVER, getZkUrl());
     minionConf.setProperty(Helix.CONFIG_OF_CLUSTER_NAME, 
getHelixClusterName());
     minionConf.setProperty(Helix.KEY_OF_MINION_HOST, LOCAL_HOST);
-    int minionPort = NetUtils.findOpenPort(_nextMinionPort);
+    int minionPort = _minionPortRange.findOpenPort(_nextMinionPort);
     minionConf.setProperty(Helix.KEY_OF_MINION_PORT, minionPort);
     if (_minionBaseApiUrl == null) {
       _minionBaseApiUrl = "http://localhost:"; + minionPort;
diff --git 
a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/ServerStarterIntegrationTest.java
 
b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/ServerStarterIntegrationTest.java
index 9d833d4ca49..472a89b228a 100644
--- 
a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/ServerStarterIntegrationTest.java
+++ 
b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/ServerStarterIntegrationTest.java
@@ -59,8 +59,8 @@ public class ServerStarterIntegrationTest extends 
ControllerTest {
       throws Exception {
     serverConf.setProperty(CONFIG_OF_CLUSTER_NAME, getHelixClusterName());
     serverConf.setProperty(CONFIG_OF_ZOOKEEPER_SERVER, getZkUrl());
-    int queryServerPort = NetUtils.findOpenPort(_nextServerPort);
-    int queryRunnerPort = NetUtils.findOpenPort(queryServerPort + 1);
+    int queryServerPort = _serverPortRange.findOpenPort(_nextServerPort);
+    int queryRunnerPort = _serverPortRange.findOpenPort(queryServerPort + 1);
     serverConf.setProperty(KEY_OF_QUERY_SERVER_PORT, queryServerPort);
     serverConf.setProperty(KEY_OF_QUERY_RUNNER_PORT, queryRunnerPort);
     _nextServerPort = queryRunnerPort + 1;
diff --git 
a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/TlsIntegrationTest.java
 
b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/TlsIntegrationTest.java
index 9c8db73105e..97b8829e380 100644
--- 
a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/TlsIntegrationTest.java
+++ 
b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/TlsIntegrationTest.java
@@ -70,7 +70,6 @@ import org.apache.pinot.spi.data.Schema;
 import org.apache.pinot.spi.env.PinotConfiguration;
 import org.apache.pinot.spi.utils.CommonConstants;
 import org.apache.pinot.spi.utils.JsonUtils;
-import org.apache.pinot.spi.utils.NetUtils;
 import org.apache.pinot.spi.utils.builder.TableNameBuilder;
 import org.apache.pinot.tools.utils.PinotConfigUtils;
 import org.apache.pinot.util.TestUtils;
@@ -181,7 +180,7 @@ public class TlsIntegrationTest extends 
BaseClusterIntegrationTest {
     prop.put("controller.access.protocols.internal.port", 
_internalControllerPort);
     prop.put("controller.access.protocols.internal.tls.client.auth.enabled", 
"true");
     prop.put("controller.access.protocols.external.protocol", "https");
-    _externalControllerPort = NetUtils.findOpenPort(_internalControllerPort + 
1);
+    _externalControllerPort = 
_controllerPortRange.findOpenPort(_internalControllerPort + 1);
     prop.put("controller.access.protocols.external.port", 
_externalControllerPort);
     _nextControllerPort = _externalControllerPort + 1;
     prop.put("controller.access.protocols.external.tls.keystore.path", 
TLS_STORE_JKS);
@@ -211,12 +210,12 @@ public class TlsIntegrationTest extends 
BaseClusterIntegrationTest {
     // CAUTION: order matters. first listener becomes registered as internal 
address in zookeeper
     brokerConf.setProperty("pinot.broker.client.access.protocols", 
"internal,external");
     
brokerConf.setProperty("pinot.broker.client.access.protocols.internal.protocol",
 "https");
-    _internalBrokerPort = NetUtils.findOpenPort(_nextBrokerPort);
+    _internalBrokerPort = _brokerPortRange.findOpenPort(_nextBrokerPort);
     
brokerConf.setProperty("pinot.broker.client.access.protocols.internal.port", 
_internalBrokerPort);
     _brokerPorts.add(_internalBrokerPort);
     
brokerConf.setProperty("pinot.broker.client.access.protocols.internal.tls.client.auth.enabled",
 "true");
     
brokerConf.setProperty("pinot.broker.client.access.protocols.external.protocol",
 "https");
-    _externalBrokerPort = NetUtils.findOpenPort(_internalBrokerPort + 1);
+    _externalBrokerPort = _brokerPortRange.findOpenPort(_internalBrokerPort + 
1);
     
brokerConf.setProperty("pinot.broker.client.access.protocols.external.port", 
_externalBrokerPort);
     _brokerPorts.add(_externalBrokerPort);
     _brokerBaseApiUrl = "https://localhost:"; + _externalBrokerPort;
@@ -249,11 +248,11 @@ public class TlsIntegrationTest extends 
BaseClusterIntegrationTest {
         CertBasedTlsChannelAccessControlFactory.class.getName());
     serverConf.setProperty("pinot.server.adminapi.access.protocols", 
"internal");
     
serverConf.setProperty("pinot.server.adminapi.access.protocols.internal.protocol",
 "https");
-    int internalAdminPort = NetUtils.findOpenPort(_nextServerPort);
+    int internalAdminPort = _serverPortRange.findOpenPort(_nextServerPort);
     
serverConf.setProperty("pinot.server.adminapi.access.protocols.internal.port", 
internalAdminPort);
     serverConf.setProperty("pinot.server.netty.enabled", "false");
     serverConf.setProperty("pinot.server.nettytls.enabled", "true");
-    int nettyTlsPort = NetUtils.findOpenPort(internalAdminPort + 1);
+    int nettyTlsPort = _serverPortRange.findOpenPort(internalAdminPort + 1);
     serverConf.setProperty("pinot.server.nettytls.port", nettyTlsPort);
     _nextServerPort = nettyTlsPort + 1;
     serverConf.setProperty("pinot.server.segment.uploader.protocol", "https");
diff --git 
a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/multicluster/BaseMultiClusterIntegrationTest.java
 
b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/multicluster/BaseMultiClusterIntegrationTest.java
index 6537e80900a..e7cdcad9051 100644
--- 
a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/multicluster/BaseMultiClusterIntegrationTest.java
+++ 
b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/multicluster/BaseMultiClusterIntegrationTest.java
@@ -58,7 +58,6 @@ import org.apache.pinot.spi.utils.CommonConstants.Helix;
 import org.apache.pinot.spi.utils.CommonConstants.MultiStageQueryRunner;
 import org.apache.pinot.spi.utils.CommonConstants.Server;
 import org.apache.pinot.spi.utils.JsonUtils;
-import org.apache.pinot.spi.utils.NetUtils;
 import org.apache.pinot.spi.utils.builder.ControllerRequestURLBuilder;
 import org.apache.pinot.spi.utils.builder.LogicalTableConfigBuilder;
 import org.apache.pinot.spi.utils.builder.TableConfigBuilder;
@@ -184,7 +183,7 @@ public abstract class BaseMultiClusterIntegrationTest 
extends ClusterTest {
 
   protected void startController(ClusterComponents cluster)
       throws Exception {
-    int controllerPort = NetUtils.findOpenPort(_nextControllerPort);
+    int controllerPort = 
_controllerPortRange.findOpenPort(_nextControllerPort);
     _nextControllerPort = controllerPort + 1;
     Map<String, Object> controllerConfig = new HashMap<>();
     controllerConfig.put(ControllerConf.ZK_STR, cluster._zkUrl);
@@ -211,9 +210,9 @@ public abstract class BaseMultiClusterIntegrationTest 
extends ClusterTest {
   /// cluster is unreachable, and the OS can hand an ephemeral port to an 
outgoing connection in the meantime.
   private BaseBrokerStarter initBroker(ClusterComponents cluster, Map<String, 
String> remoteZkUrls)
       throws Exception {
-    int brokerPort = NetUtils.findOpenPort(_nextBrokerPort);
+    int brokerPort = _brokerPortRange.findOpenPort(_nextBrokerPort);
     _nextBrokerPort = brokerPort + 1;
-    int queryRunnerPort = NetUtils.findOpenPort(_nextBrokerQueryRunnerPort);
+    int queryRunnerPort = 
_brokerQueryRunnerPortRange.findOpenPort(_nextBrokerQueryRunnerPort);
     _nextBrokerQueryRunnerPort = queryRunnerPort + 1;
     PinotConfiguration brokerConfig = new PinotConfiguration();
     brokerConfig.setProperty(Helix.CONFIG_OF_ZOOKEEPER_SERVER, cluster._zkUrl);
@@ -243,11 +242,11 @@ public abstract class BaseMultiClusterIntegrationTest 
extends ClusterTest {
     serverConfig.setProperty(Server.CONFIG_OF_INSTANCE_SEGMENT_TAR_DIR, 
cluster._tempDir + "/segmentTar");
     serverConfig.setProperty(Server.CONFIG_OF_SEGMENT_FORMAT_VERSION, "v3");
     serverConfig.setProperty(Server.CONFIG_OF_SHUTDOWN_ENABLE_QUERY_CHECK, 
false);
-    int adminPort = NetUtils.findOpenPort(_nextServerPort);
-    int nettyPort = NetUtils.findOpenPort(adminPort + 1);
-    int grpcPort = NetUtils.findOpenPort(nettyPort + 1);
-    int queryServerPort = NetUtils.findOpenPort(grpcPort + 1);
-    int queryRunnerPort = NetUtils.findOpenPort(queryServerPort + 1);
+    int adminPort = _serverPortRange.findOpenPort(_nextServerPort);
+    int nettyPort = _serverPortRange.findOpenPort(adminPort + 1);
+    int grpcPort = _serverPortRange.findOpenPort(nettyPort + 1);
+    int queryServerPort = _serverPortRange.findOpenPort(grpcPort + 1);
+    int queryRunnerPort = _serverPortRange.findOpenPort(queryServerPort + 1);
     _nextServerPort = queryRunnerPort + 1;
     serverConfig.setProperty(Server.CONFIG_OF_ADMIN_API_PORT, adminPort);
     serverConfig.setProperty(Helix.KEY_OF_SERVER_NETTY_PORT, nettyPort);


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to