SOLR-16505: Switch UpdateShardHandler.getRecoveryOnlyHttpClient to Jetty HTTP2

solr/CHANGES.txt

@@ -146,6 +146,8 @@ Other Changes
 * SOLR-17066: GenericSolrRequest now has a `setRequiresCollection` setter that allows it to specify whether
   it should make use of the client-level default collection/core. (Jason Gerlowski)
 
+* SOLR-17190: Replace org.apache.solr.util.LongSet with hppc LongHashSet (Michael Gibney)
+
 * SOLR-16505: Switch internal replica recovery commands to Jetty HTTP2 (Sanjay Dutt, David Smiley)
 
 ==================  9.5.0 ==================

solr/core/src/java/org/apache/solr/cloud/RecoveryStrategy.java

@@ -176,8 +176,6 @@ public final void setRecoveringAfterStartup(boolean recoveringAfterStartup) {
   }
 
   private Http2SolrClient.Builder recoverySolrClientBuilder(String baseUrl, String leaderCoreName) {
-    // workaround for SOLR-13605: get the configured timeouts & set them directly
-    // (even though getRecoveryOnlyHttpClient() already has them set)
     final UpdateShardHandlerConfig cfg = cc.getConfig().getUpdateShardHandlerConfig();
     return new Http2SolrClient.Builder(baseUrl)
         .withDefaultCollection(leaderCoreName)
@@ -188,9 +186,7 @@ private Http2SolrClient.Builder recoverySolrClientBuilder(String baseUrl, String
   @Override
   public final void close() {
     close = true;
-    if (prevSendPreRecoveryHttpUriRequest != null) {
-      prevSendPreRecoveryHttpUriRequest.cancel(true);
-    }
+    cancelPrepRecoveryCmd();
     log.warn("Stopping recovery for core=[{}] coreNodeName=[{}]", coreName, coreZkNodeName);
   }
 
@@ -631,7 +627,7 @@ public final void doSyncOrReplicateRecovery(SolrCore core) throws Exception {
                 .getCollection(cloudDesc.getCollectionName())
                 .getSlice(cloudDesc.getShardId());
 
-        Optional.ofNullable(prevSendPreRecoveryHttpUriRequest).ifPresent(req -> req.cancel(true));
+        cancelPrepRecoveryCmd();
 
         if (isClosed()) {
           log.info("RecoveryStrategy has been closed");
@@ -918,4 +914,8 @@ private final void sendPrepRecoveryCmd(String leaderBaseUrl, String leaderCoreNa
       prevSendPreRecoveryHttpUriRequest.run();
     }
   }
+
+  private void cancelPrepRecoveryCmd() {
+    Optional.ofNullable(prevSendPreRecoveryHttpUriRequest).ifPresent(req -> req.cancel(true));
+  }
 }

solr/core/src/java/org/apache/solr/handler/IndexFetcher.java

@@ -84,7 +84,6 @@
 import java.util.zip.Adler32;
 import java.util.zip.Checksum;
 import java.util.zip.InflaterInputStream;
-import org.apache.http.client.HttpClient;
 import org.apache.lucene.codecs.CodecUtil;
 import org.apache.lucene.index.IndexCommit;
 import org.apache.lucene.index.IndexWriter;
@@ -97,9 +96,9 @@
 import org.apache.lucene.store.IndexOutput;
 import org.apache.solr.client.solrj.SolrClient;
 import org.apache.solr.client.solrj.SolrServerException;
+import org.apache.solr.client.solrj.impl.Http2SolrClient;
 import org.apache.solr.client.solrj.impl.HttpClientUtil;
-import org.apache.solr.client.solrj.impl.HttpSolrClient;
-import org.apache.solr.client.solrj.impl.HttpSolrClient.Builder;
+import org.apache.solr.client.solrj.impl.InputStreamResponseParser;
 import org.apache.solr.client.solrj.request.QueryRequest;
 import org.apache.solr.cloud.CloudDescriptor;
 import org.apache.solr.cloud.ZkController;
@@ -133,7 +132,7 @@
 import org.apache.solr.util.RTimer;
 import org.apache.solr.util.RefCounted;
 import org.apache.solr.util.TestInjection;
-import org.apache.solr.util.stats.InstrumentedHttpRequestExecutor;
+import org.apache.solr.util.stats.InstrumentedHttpListenerFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -186,7 +185,7 @@ public class IndexFetcher {
 
   boolean fetchFromLeader = false;
 
-  private final HttpClient myHttpClient;
+  private final SolrClient solrClient;
 
   private Integer connTimeout;
 
@@ -261,22 +260,23 @@ public String getMessage() {
     }
   }
 
-  private static HttpClient createHttpClient(
-      SolrCore core,
-      String httpBasicAuthUser,
-      String httpBasicAuthPassword,
-      boolean useCompression) {
+  private Http2SolrClient createHttpClient(
+      SolrCore core, String httpBasicAuthUser, String httpBasicAuthPassword, String leaderBaseUrl) {
     final ModifiableSolrParams httpClientParams = new ModifiableSolrParams();
     httpClientParams.set(HttpClientUtil.PROP_BASIC_AUTH_USER, httpBasicAuthUser);
     httpClientParams.set(HttpClientUtil.PROP_BASIC_AUTH_PASS, httpBasicAuthPassword);
-    httpClientParams.set(HttpClientUtil.PROP_ALLOW_COMPRESSION, useCompression);
     // no metrics, just tracing
-    InstrumentedHttpRequestExecutor executor = new InstrumentedHttpRequestExecutor(null);
-    return HttpClientUtil.createClient(
-        httpClientParams,
-        core.getCoreContainer().getUpdateShardHandler().getRecoveryOnlyConnectionManager(),
-        true,
-        executor);
+    InstrumentedHttpListenerFactory httpListenerFactory = new InstrumentedHttpListenerFactory(null);
+    Http2SolrClient httpClient =
+        new Http2SolrClient.Builder(leaderBaseUrl)
+            .withHttpClient(
+                core.getCoreContainer().getUpdateShardHandler().getRecoveryOnlyHttpClient())
+            .withBasicAuthCredentials(httpBasicAuthUser, httpBasicAuthPassword)
+            .withIdleTimeout(soTimeout, TimeUnit.MILLISECONDS)
+            .withConnectionTimeout(connTimeout, TimeUnit.MILLISECONDS)
+            .build();
+    httpClient.addListenerFactory(httpListenerFactory);
+    return httpClient;
   }
 
   public IndexFetcher(
@@ -318,12 +318,10 @@ public IndexFetcher(
     if (soTimeout == -1) {
       soTimeout = getParameter(initArgs, HttpClientUtil.PROP_SO_TIMEOUT, 120000, null);
     }
-
     String httpBasicAuthUser = (String) initArgs.get(HttpClientUtil.PROP_BASIC_AUTH_USER);
     String httpBasicAuthPassword = (String) initArgs.get(HttpClientUtil.PROP_BASIC_AUTH_PASS);
-    myHttpClient =
-        createHttpClient(
-            solrCore, httpBasicAuthUser, httpBasicAuthPassword, useExternalCompression);
+    solrClient =
+        createHttpClient(solrCore, httpBasicAuthUser, httpBasicAuthPassword, leaderBaseUrl);
   }
 
   private void setLeaderCoreUrl(String leaderCoreUrl) {
@@ -380,16 +378,11 @@ public NamedList<Object> getLatestVersion() throws IOException {
     params.set(CommonParams.WT, JAVABIN);
     params.set(CommonParams.QT, ReplicationHandler.PATH);
     QueryRequest req = new QueryRequest(params);
-
+    req.setBasePath(leaderBaseUrl);
+    if (useExternalCompression) req.addHeader("Accept-Encoding", "gzip, deflate");
     // TODO modify to use shardhandler
-    try (SolrClient client =
-        new Builder(leaderBaseUrl)
-            .withHttpClient(myHttpClient)
-            .withConnectionTimeout(connTimeout, TimeUnit.MILLISECONDS)
-            .withSocketTimeout(soTimeout, TimeUnit.MILLISECONDS)
-            .build()) {
-
-      return client.request(req, leaderCoreName);
+    try {
+      return solrClient.request(req, leaderCoreName);
     } catch (SolrServerException e) {
       throw new SolrException(ErrorCode.SERVER_ERROR, e.getMessage(), e);
     }
@@ -407,15 +400,11 @@ private void fetchFileList(long gen) throws IOException {
     params.set(CommonParams.WT, JAVABIN);
     params.set(CommonParams.QT, ReplicationHandler.PATH);
     QueryRequest req = new QueryRequest(params);
-
+    req.setBasePath(leaderBaseUrl);
+    if (useExternalCompression) req.addHeader("Accept-Encoding", "gzip, deflate");
     // TODO modify to use shardhandler
-    try (SolrClient client =
-        new HttpSolrClient.Builder(leaderBaseUrl)
-            .withHttpClient(myHttpClient)
-            .withConnectionTimeout(connTimeout, TimeUnit.MILLISECONDS)
-            .withSocketTimeout(soTimeout, TimeUnit.MILLISECONDS)
-            .build()) {
-      NamedList<?> response = client.request(req, leaderCoreName);
+    try {
+      NamedList<?> response = solrClient.request(req, leaderCoreName);
 
       List<Map<String, Object>> files = (List<Map<String, Object>>) response.get(CMD_GET_FILE_LIST);
       if (files != null) filesToDownload = Collections.synchronizedList(files);
@@ -1990,17 +1979,13 @@ private FastInputStream getStream() throws IOException {
 
       NamedList<?> response;
       InputStream is = null;
-
       // TODO use shardhandler
-      try (SolrClient client =
-          new Builder(leaderBaseUrl)
-              .withHttpClient(myHttpClient)
-              .withResponseParser(null)
-              .withConnectionTimeout(connTimeout, TimeUnit.MILLISECONDS)
-              .withSocketTimeout(soTimeout, TimeUnit.MILLISECONDS)
-              .build()) {
+      try {
         QueryRequest req = new QueryRequest(params);
-        response = client.request(req, leaderCoreName);
+        req.setResponseParser(new InputStreamResponseParser(FILE_STREAM));
+        req.setBasePath(leaderBaseUrl);
+        if (useExternalCompression) req.addHeader("Accept-Encoding", "gzip, deflate");
+        response = solrClient.request(req, leaderCoreName);
         is = (InputStream) response.get("stream");
         if (useInternalCompression) {
           is = new InflaterInputStream(is);
@@ -2124,21 +2109,16 @@ NamedList<Object> getDetails() throws IOException, SolrServerException {
     params.set("follower", false);
     params.set(CommonParams.QT, ReplicationHandler.PATH);
 
+    QueryRequest request = new QueryRequest(params);
+    request.setBasePath(leaderBaseUrl);
+    if (useExternalCompression) request.addHeader("Accept-Encoding", "gzip, deflate");
     // TODO use shardhandler
-    try (SolrClient client =
-        new HttpSolrClient.Builder(leaderBaseUrl)
-            .withHttpClient(myHttpClient)
-            .withConnectionTimeout(connTimeout, TimeUnit.MILLISECONDS)
-            .withSocketTimeout(soTimeout, TimeUnit.MILLISECONDS)
-            .build()) {
-      QueryRequest request = new QueryRequest(params);
-      return client.request(request, leaderCoreName);
-    }
+    return solrClient.request(request, leaderCoreName);
   }
 
   public void destroy() {
     abortFetch();
-    HttpClientUtil.close(myHttpClient);
+    IOUtils.closeQuietly(solrClient);
   }
 
   String getLeaderCoreUrl() {

solr/core/src/java/org/apache/solr/update/UpdateShardHandler.java

@@ -79,8 +79,6 @@ public class UpdateShardHandler implements SolrInfoBean {
 
   private final CloseableHttpClient defaultClient;
 
-  private final InstrumentedPoolingHttpClientConnectionManager recoveryOnlyConnectionManager;
-
   private final InstrumentedPoolingHttpClientConnectionManager defaultConnectionManager;
 
   private final InstrumentedHttpRequestExecutor httpRequestExecutor;
@@ -93,16 +91,11 @@ public class UpdateShardHandler implements SolrInfoBean {
   private int connectionTimeout = HttpClientUtil.DEFAULT_CONNECT_TIMEOUT;
 
   public UpdateShardHandler(UpdateShardHandlerConfig cfg) {
-    recoveryOnlyConnectionManager =
-        new InstrumentedPoolingHttpClientConnectionManager(
-            HttpClientUtil.getSocketFactoryRegistryProvider().getSocketFactoryRegistry());
     defaultConnectionManager =
         new InstrumentedPoolingHttpClientConnectionManager(
             HttpClientUtil.getSocketFactoryRegistryProvider().getSocketFactoryRegistry());
     ModifiableSolrParams clientParams = new ModifiableSolrParams();
     if (cfg != null) {
-      recoveryOnlyConnectionManager.setMaxTotal(cfg.getMaxUpdateConnections());
-      recoveryOnlyConnectionManager.setDefaultMaxPerRoute(cfg.getMaxUpdateConnectionsPerHost());
       defaultConnectionManager.setMaxTotal(cfg.getMaxUpdateConnections());
       defaultConnectionManager.setDefaultMaxPerRoute(cfg.getMaxUpdateConnectionsPerHost());
       clientParams.set(HttpClientUtil.PROP_SO_TIMEOUT, cfg.getDistributedSocketTimeout());
@@ -271,10 +264,6 @@ public PoolingHttpClientConnectionManager getDefaultConnectionManager() {
     return defaultConnectionManager;
   }
 
-  public PoolingHttpClientConnectionManager getRecoveryOnlyConnectionManager() {
-    return recoveryOnlyConnectionManager;
-  }
-
   /**
    * @return executor for recovery operations
    */
@@ -300,7 +289,6 @@ public void close() {
       IOUtils.closeQuietly(recoveryOnlyClient);
       HttpClientUtil.close(defaultClient);
       defaultConnectionManager.close();
-      recoveryOnlyConnectionManager.close();
     }
   }
 
@@ -316,5 +304,6 @@ public int getConnectionTimeout() {
 
   public void setSecurityBuilder(HttpClientBuilderPlugin builder) {
     builder.setup(updateOnlyClient);
+    builder.setup(recoveryOnlyClient);
   }
 }

solr/solrj/src/java/org/apache/solr/client/solrj/impl/Http2SolrClient.java

@@ -203,6 +203,9 @@ protected Http2SolrClient(String serverBaseUrl, Builder builder) {
     } else {
       this.urlParamNames = Set.of();
     }
+    if (builder.listenerFactory != null) {
+      this.listenerFactory.addAll(builder.listenerFactory);
+    }
     assert ObjectReleaseTracker.track(this);
   }
 
@@ -1081,6 +1084,8 @@ public static class Builder {
     private boolean proxyIsSecure;
     private Long keyStoreReloadIntervalSecs;
 
+    private List<HttpListenerFactory> listenerFactory;
+
     public Builder() {}
 
     /**
@@ -1175,7 +1180,6 @@ private static CookieStore getDefaultCookieStore() {
      */
     public Builder withHttpClient(Http2SolrClient http2SolrClient) {
       this.httpClient = http2SolrClient.httpClient;
-
       if (this.basicAuthAuthorizationStr == null) {
         this.basicAuthAuthorizationStr = http2SolrClient.basicAuthAuthorizationStr;
       }
@@ -1197,6 +1201,9 @@ public Builder withHttpClient(Http2SolrClient http2SolrClient) {
       if (this.urlParamNames == null) {
         this.urlParamNames = http2SolrClient.urlParamNames;
       }
+      if (this.listenerFactory == null) {
+        this.listenerFactory = http2SolrClient.listenerFactory;
+      }
       return this;
     }