SOLR-18382: remove DocCollection.getReplicas(), migrate 60 call sites

changelog/unreleased/SOLR-18382-remove-doccollection-getreplicas.yml

@@ -0,0 +1,8 @@
+# See https://github.com/apache/solr/blob/main/dev-docs/changelog.adoc
+title: Remove the deprecated DocCollection.getReplicas() method, which allocated a new list on every call. DocCollection is Iterable<Slice>, so iterate its slices and call Slice.getReplicas(), or use getSlices().stream().flatMap(slice -> slice.getReplicas().stream()).
+type: removed
+authors:
+  - name: Serhiy Bzhezytskyy
+links:
+  - name: SOLR-18382
+    url: https://issues.apache.org/jira/browse/SOLR-18382

solr/core/src/java/org/apache/solr/cloud/api/collections/ReindexCollectionCmd.java

@@ -672,7 +672,7 @@ private boolean maybeAbort(String collection) throws Exception {
   }
 
   // XXX see #waitForDaemon() for why we need this
-  private Replica getReplicaForDaemon(SolrResponse rsp, DocCollection coll) {
+  private Replica getReplicaForDaemon(SolrResponse rsp, DocCollection collectionState) {
     @SuppressWarnings({"unchecked"})
     Map<String, Object> rs = (Map<String, Object>) rsp.getResponse().get("result-set");
     if (rs == null || rs.isEmpty()) {
@@ -713,13 +713,13 @@ private Replica getReplicaForDaemon(SolrResponse rsp, DocCollection coll) {
     if (replicaName == null) {
       return null;
     }
+    final String finalReplicaName = replicaName;
     // build a baseUrl of the replica
-    for (Replica r : coll.getReplicas()) {
-      if (replicaName.equals(r.getCoreName())) {
-        return r;
-      }
-    }
-    return null;
+    return collectionState
+        .replicaStream()
+        .filter(r -> finalReplicaName.equals(r.getCoreName()))
+        .findFirst()
+        .orElse(null);
   }
 
   // XXX currently this is complicated to due a bug in the way the daemon 'list'

solr/core/src/java/org/apache/solr/handler/designer/SchemaDesignerConfigSetHelper.java

@@ -542,7 +542,7 @@ private String getBaseUrl(final String collection) {
       DocCollection docColl = zkStateReader().getCollection(collection);
       if (docColl != null && !liveNodes.isEmpty()) {
         Optional<Replica> maybeActive =
-            docColl.getReplicas().stream().filter(r -> r.isActive(liveNodes)).findAny();
+            docColl.replicaStream().filter(r -> r.isActive(liveNodes)).findAny();
         if (maybeActive.isPresent()) {
           baseUrl = maybeActive.get().getBaseUrl();
         }

solr/core/src/test/org/apache/solr/cloud/AddReplicaTest.java

@@ -73,15 +73,15 @@ public void testAddMultipleReplicas() throws Exception {
 
     DocCollection docCollection = cloudClient.getClusterState().getCollectionOrNull(collection);
     assertNotNull(docCollection);
-    assertEquals(4, docCollection.getReplicas().size());
+    assertEquals(4, docCollection.replicaStream().count());
     assertEquals(2, getReplicas(docCollection, EnumSet.of(Replica.Type.NRT)).size());
     assertEquals(1, getReplicas(docCollection, EnumSet.of(Replica.Type.TLOG)).size());
     assertEquals(1, getReplicas(docCollection, EnumSet.of(Replica.Type.PULL)).size());
 
     docCollection = cloudClient.getClusterState().getCollectionOrNull(collection);
     assertNotNull(docCollection);
     // sanity check that everything is as before
-    assertEquals(4, docCollection.getReplicas().size());
+    assertEquals(4, docCollection.replicaStream().count());
     assertEquals(2, getReplicas(docCollection, EnumSet.of(Replica.Type.NRT)).size());
     assertEquals(1, getReplicas(docCollection, EnumSet.of(Replica.Type.TLOG)).size());
     assertEquals(1, getReplicas(docCollection, EnumSet.of(Replica.Type.PULL)).size());
@@ -106,7 +106,7 @@ public void testAddMultipleReplicas() throws Exception {
     docCollection = cloudClient.getClusterState().getCollectionOrNull(collection);
     assertNotNull(docCollection);
     // sanity check that everything is as before
-    assertEquals(9, docCollection.getReplicas().size());
+    assertEquals(9, docCollection.replicaStream().count());
     assertEquals(5, getReplicas(docCollection, EnumSet.of(Replica.Type.NRT)).size());
     assertEquals(2, getReplicas(docCollection, EnumSet.of(Replica.Type.TLOG)).size());
     assertEquals(2, getReplicas(docCollection, EnumSet.of(Replica.Type.PULL)).size());
@@ -211,7 +211,13 @@ public void testAddReplicaWithUserDefinedProperties() throws Exception {
     // Verify that the new core was created with user-defined properties coming from the request
     // and inherited from the collection (the former taking precedence over the latter).
     Replica replica =
-        cloudClient.getClusterState().getCollection(collectionName).getReplicas().get(1);
+        cloudClient
+            .getClusterState()
+            .getCollection(collectionName)
+            .replicaStream()
+            .skip(1)
+            .findFirst()
+            .orElseThrow();
     CoreDescriptor coreDescriptor =
         cluster
             .getReplicaJetty(replica)

solr/core/src/test/org/apache/solr/cloud/BalanceReplicasTest.java

@@ -97,7 +97,7 @@ public void testAllNodes() throws Exception {
     collection = cloudClient.getClusterState().getCollectionOrNull(coll, false);
     log.debug("### After balancing: {}", collection);
     Set<String> replicaNodes =
-        collection.getReplicas().stream().map(Replica::getNodeName).collect(Collectors.toSet());
+        collection.replicaStream().map(Replica::getNodeName).collect(Collectors.toSet());
     assertEquals("Incorrect nodes for replicas after balancing", liveNodes, replicaNodes);
   }
 
@@ -145,7 +145,7 @@ public void testSomeNodes() throws Exception {
     collection = cloudClient.getClusterState().getCollectionOrNull(coll, false);
     log.debug("### After balancing: {}", collection);
     Set<String> replicaNodes =
-        collection.getReplicas().stream().map(Replica::getNodeName).collect(Collectors.toSet());
+        collection.replicaStream().map(Replica::getNodeName).collect(Collectors.toSet());
     assertEquals("Incorrect nodes for replicas after balancing", 4, replicaNodes.size());
     assertTrue(
         "A non-balanced node lost replicas during balancing", replicaNodes.contains(l.get(0)));

solr/core/src/test/org/apache/solr/cloud/CollectionsAPISolrJTest.java

@@ -409,13 +409,9 @@ public void testSplitShard() throws Exception {
     waitForState(
         "Expected all shards to be active and parent shard to be removed",
         collectionName,
-        (n, c) -> {
-          if (c.getSlice("shard1").getState() == Slice.State.ACTIVE) return false;
-          for (Replica r : c.getReplicas()) {
-            if (r.isActive(n) == false) return false;
-          }
-          return true;
-        });
+        (n, collectionState) ->
+            collectionState.getSlice("shard1").getState() != Slice.State.ACTIVE
+                && collectionState.replicaStream().allMatch(r -> r.isActive(n)));
 
     // Test splitting using split.key
     response =
@@ -455,7 +451,7 @@ public void testCreateCollectionWithPropertyParam() throws Exception {
 
     DocCollection testCollection = getCollectionState(collectionName);
 
-    Replica replica1 = testCollection.getReplicas().iterator().next();
+    Replica replica1 = testCollection.replicaStream().findFirst().orElseThrow();
     final var coreStatus = getCoreStatus(replica1);
 
     assertEquals(Path.of(coreStatus.dataDir).toString(), dataDir.toString());
@@ -501,7 +497,8 @@ public void testAddAndDeleteReplica() throws Exception {
   private Replica grabNewReplica(CollectionAdminResponse response, DocCollection docCollection) {
     String replicaName = response.getCollectionCoresStatus().keySet().iterator().next();
     Optional<Replica> optional =
-        docCollection.getReplicas().stream()
+        docCollection
+            .replicaStream()
             .filter(replica -> replicaName.equals(replica.getCoreName()))
             .findAny();
     if (optional.isPresent()) {
@@ -1334,8 +1331,8 @@ public void testBalanceShardUnique() throws IOException, SolrServerException {
     waitForState(
         "Expecting 'preferredleader' property to be balanced across all shards",
         collection,
-        c -> {
-          for (Slice slice : c) {
+        collectionState -> {
+          for (Slice slice : collectionState) {
             int count = 0;
             for (Replica replica : slice) {
               if ("true".equals(replica.getProperty("preferredleader"))) count += 1;

solr/core/src/test/org/apache/solr/cloud/CreateCollectionWithPropertiesTest.java

@@ -57,7 +57,12 @@ public void testCreateCollectionWithUserDefinedProperties() throws Exception {
 
     // Verify that the core was created with user-defined properties
     Replica replica =
-        cloudClient.getClusterState().getCollection(collectionName).getReplicas().get(0);
+        cloudClient
+            .getClusterState()
+            .getCollection(collectionName)
+            .replicaStream()
+            .findFirst()
+            .orElseThrow();
     CoreDescriptor coreDescriptor =
         cluster
             .getReplicaJetty(replica)

solr/core/src/test/org/apache/solr/cloud/DeleteCoreRemnantsOnCreateTest.java

@@ -211,7 +211,7 @@ public void testCreateCollectionWithRemnantsWithSetting() throws Exception {
     // Verify collection was created successfully
     DocCollection collection = getCollectionState(collectionName);
     assertNotNull("Collection should exist", collection);
-    assertEquals("Should have 1 replica", 1, collection.getReplicas().size());
+    assertEquals("Should have 1 replica", 1, collection.replicaStream().count());
 
     // Verify replica on the node where we had the remnant is active
     Replica recreatedReplica =
@@ -271,7 +271,7 @@ public void testAddReplicaWithRemnantWithSetting() throws Exception {
     // Verify collection now has 2 replicas
     DocCollection collection = getCollectionState(collectionName);
     assertNotNull("Collection should exist", collection);
-    assertEquals("Should have 2 replicas after adding", 2, collection.getReplicas().size());
+    assertEquals("Should have 2 replicas after adding", 2, collection.replicaStream().count());
 
     // Verify the replica was added on the single node and is active
     Replica addedReplica = getReplicaOnNode(collectionName, "shard1", primaryNode);

solr/core/src/test/org/apache/solr/cloud/DeleteReplicaTest.java

@@ -538,7 +538,7 @@ public void deleteReplicaOnIndexing() throws Exception {
     waitForState(
         "Waiting for single replica in state",
         collectionName,
-        collectionState -> collectionState.getReplicas().size() == 1);
+        collectionState -> collectionState.replicaStream().count() == 1);
   }
 
   /**

solr/core/src/test/org/apache/solr/cloud/DistribDocExpirationUpdateProcessorTest.java

@@ -285,39 +285,41 @@ private Map<String, ReplicaData> getTestDataForAllReplicas()
     DocCollection collectionState =
         cluster.getSolrClient().getClusterState().getCollection(COLLECTION);
 
-    for (Replica replica : collectionState.getReplicas()) {
-
-      String coreName = replica.getCoreName();
-      try (SolrClient client = getHttpSolrClient(replica)) {
-
-        ModifiableSolrParams params = new ModifiableSolrParams();
-        params.set("command", "indexversion");
-        params.set("_trace", "getIndexVersion");
-        QueryRequest req = setAuthIfNeeded(new QueryRequest(ReplicationHandler.PATH, params));
-
-        NamedList<Object> res = client.request(req);
-        assertNotNull("null response from server: " + coreName, res);
-
-        Object version = res.get("indexversion");
-        assertNotNull("null version from server: " + coreName, version);
-        assertTrue("version isn't a long: " + coreName, version instanceof Long);
-
-        long numDocs =
-            setAuthIfNeeded(
-                    new QueryRequest(
-                        params(
-                            "q", "*:*",
-                            "distrib", "false",
-                            "rows", "0",
-                            "_trace", "counting_docs")))
-                .process(client)
-                .getResults()
-                .getNumFound();
-
-        final ReplicaData data =
-            new ReplicaData(replica.getShard(), coreName, (Long) version, numDocs);
-        log.info("{}", data);
-        results.put(coreName, data);
+    for (Slice slice : collectionState) {
+      for (Replica replica : slice.getReplicas()) {
+
+        String coreName = replica.getCoreName();
+        try (SolrClient client = getHttpSolrClient(replica)) {
+
+          ModifiableSolrParams params = new ModifiableSolrParams();
+          params.set("command", "indexversion");
+          params.set("_trace", "getIndexVersion");
+          QueryRequest req = setAuthIfNeeded(new QueryRequest(ReplicationHandler.PATH, params));
+
+          NamedList<Object> res = client.request(req);
+          assertNotNull("null response from server: " + coreName, res);
+
+          Object version = res.get("indexversion");
+          assertNotNull("null version from server: " + coreName, version);
+          assertTrue("version isn't a long: " + coreName, version instanceof Long);
+
+          long numDocs =
+              setAuthIfNeeded(
+                      new QueryRequest(
+                          params(
+                              "q", "*:*",
+                              "distrib", "false",
+                              "rows", "0",
+                              "_trace", "counting_docs")))
+                  .process(client)
+                  .getResults()
+                  .getNumFound();
+
+          final ReplicaData data =
+              new ReplicaData(replica.getShard(), coreName, (Long) version, numDocs);
+          log.info("{}", data);
+          results.put(coreName, data);
+        }
       }
     }
 

solr/core/src/test/org/apache/solr/cloud/DistributedVersionInfoTest.java

@@ -92,7 +92,10 @@ public void testReplicaVersionHandling() throws Exception {
 
     // verify doc is on the leader and replica
     final List<Replica> notLeaders =
-        stateReader.getClusterState().getCollection(COLLECTION).getReplicas().stream()
+        stateReader
+            .getClusterState()
+            .getCollection(COLLECTION)
+            .replicaStream()
             .filter(r -> r.getCoreName().equals(leader.getCoreName()) == false)
             .collect(Collectors.toList());
     assertDocsExistInAllReplicas(leader, notLeaders, COLLECTION, 1, 1, null);

solr/core/src/test/org/apache/solr/cloud/MigrateRouteKeyTest.java

@@ -133,7 +133,7 @@ public void multipleShardMigrateTest() throws Exception {
     indexer.start();
 
     DocCollection state = getCollectionState(targetCollection);
-    Replica replica = state.getReplicas().get(0);
+    Replica replica = state.replicaStream().findFirst().orElseThrow();
     try (SolrClient collectionClient = getHttpSolrClient(replica)) {
 
       SolrQuery solrQuery = new SolrQuery("*:*");

solr/core/src/test/org/apache/solr/cloud/MoveReplicaTest.java

@@ -342,9 +342,9 @@ private CollectionAdminRequest.MoveReplica createMoveReplicaRequest(
   }
 
   private Replica getRandomReplica(String coll, CloudSolrClient cloudClient) throws IOException {
-    List<Replica> replicas = cloudClient.getClusterState().getCollection(coll).getReplicas();
-    Collections.shuffle(replicas, random());
-    return replicas.get(0);
+    List<Replica> replicas =
+        cloudClient.getClusterState().getCollection(coll).replicaStream().toList();
+    return replicas.get(random().nextInt(replicas.size()));
   }
 
   private void checkNumOfCores(

solr/core/src/test/org/apache/solr/cloud/NestedShardedAtomicUpdateTest.java

@@ -33,7 +33,6 @@
 import org.apache.solr.common.SolrDocument;
 import org.apache.solr.common.SolrInputDocument;
 import org.apache.solr.common.cloud.ClusterState;
-import org.apache.solr.common.cloud.Replica;
 import org.apache.solr.common.params.ModifiableSolrParams;
 import org.apache.solr.common.params.SolrParams;
 import org.apache.solr.util.RandomNoReverseMergePolicyFactory;
@@ -71,9 +70,10 @@ public static void beforeClass() throws Exception {
 
     clients = new ArrayList<>();
     ClusterState clusterState = cloudClient.getClusterState();
-    for (Replica replica : clusterState.getCollection(DEFAULT_COLLECTION).getReplicas()) {
-      clients.add(getHttpSolrClient(replica));
-    }
+    clusterState
+        .getCollection(DEFAULT_COLLECTION)
+        .replicaStream()
+        .forEach(replica -> clients.add(getHttpSolrClient(replica)));
   }
 
   @AfterClass

solr/core/src/test/org/apache/solr/cloud/TestCloudConsistency.java

@@ -133,7 +133,7 @@ public void testOutOfSyncReplicasCannotBecomeLeader(boolean onRestart) throws Ex
     }
 
     assertDocsExistInAllReplicas(
-        getCollectionState(collectionName).getReplicas(), collectionName, 1, 4);
+        getCollectionState(collectionName).replicaStream().toList(), collectionName, 1, 4);
 
     CollectionAdminRequest.deleteCollection(collectionName).process(cluster.getSolrClient());
   }

solr/core/src/test/org/apache/solr/cloud/TestCloudSearcherWarming.java

@@ -213,14 +213,13 @@ public void testPeersyncFailureReplicationSuccess() throws Exception {
     // the above call is not enough because we want to assert that the downed replica is not active
     // but clusterShape will also return true if replica is not live -- which we don't want
     Predicate<DocCollection> collectionStatePredicate =
-        collectionState -> {
-          for (Replica r : collectionState.getReplicas()) {
-            if (r.getNodeName().equals(oldNodeName.get())) {
-              return r.getState() == Replica.State.DOWN;
-            }
-          }
-          return false;
-        };
+        collectionState ->
+            collectionState
+                .replicaStream()
+                .filter(r -> r.getNodeName().equals(oldNodeName.get()))
+                .findFirst()
+                .map(r -> r.getState() == Replica.State.DOWN)
+                .orElse(false);
     waitForState("", collectionName, collectionStatePredicate);
     assertNotNull(ZkStateReader.from(solrClient).getLeaderRetry(collectionName, "shard1"));
 

solr/core/src/test/org/apache/solr/cloud/TestOnReconnectListenerSupport.java

@@ -47,7 +47,8 @@ public void test() throws Exception {
         .process(cluster.getSolrClient());
     cluster.waitForActiveCollection(testCollectionName, 1, 1);
 
-    Replica leader = getCollectionState(testCollectionName).getReplicas().get(0);
+    Replica leader =
+        getCollectionState(testCollectionName).replicaStream().findFirst().orElseThrow();
     CoreContainer cores = cluster.getJettySolrRunner(0).getCoreContainer();
     ZkController zkController = cores.getZkController();
     assertNotNull("ZkController is null", zkController);