feat: support long link

Author: wardseptember

trpc-proto/trpc-proto-http/src/main/java/com/tencent/trpc/proto/http/client/Http2ConsumerInvoker.java

@@ -137,7 +137,11 @@ private Response handleResponse(Request request, SimpleHttpResponse simpleHttpRe
      */
     private SimpleHttpResponse execute(Request request, int requestTimeout,
             SimpleHttpRequest simpleHttpRequest) throws Exception {
-        CloseableHttpAsyncClient httpAsyncClient = ((Http2cRpcClient) client).getHttpAsyncClient();
+        Http2cRpcClient http2cRpcClient = (Http2cRpcClient) client;
+        // Refresh idle counter so the cluster manager's reconnect-check timer keeps treating
+        // this client as healthy while it's actively serving requests.
+        http2cRpcClient.markUsed();
+        CloseableHttpAsyncClient httpAsyncClient = http2cRpcClient.getHttpAsyncClient();
         Future<SimpleHttpResponse> httpResponseFuture = httpAsyncClient.execute(simpleHttpRequest,
                 new FutureCallback<SimpleHttpResponse>() {
                     @Override

trpc-proto/trpc-proto-http/src/main/java/com/tencent/trpc/proto/http/client/Http2cRpcClient.java

@@ -19,6 +19,7 @@
 import com.tencent.trpc.core.rpc.AbstractRpcClient;
 import com.tencent.trpc.core.rpc.ConsumerInvoker;
 import java.io.IOException;
+import java.util.concurrent.TimeUnit;
 import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
 import org.apache.hc.client5.http.impl.async.HttpAsyncClients;
 
@@ -29,10 +30,23 @@ public class Http2cRpcClient extends AbstractRpcClient {
 
     private static final Logger logger = LoggerFactory.getLogger(HttpRpcClient.class);
 
+    /**
+     * If this client has not been used by any RPC for longer than this window, the periodic
+     * scanner in {@code RpcClusterClientManager} will treat it as unavailable and eventually
+     * close & evict it. The window is intentionally large so that any actively-used client is
+     * never affected. See {@link HttpRpcClient} for the same mechanism on the HTTP/1.1 path.
+     */
+    private static final long IDLE_UNAVAILABLE_THRESHOLD_NANOS = TimeUnit.MINUTES.toNanos(10);
+
     /**
      * Asynchronous HTTP client
      */
     protected CloseableHttpAsyncClient httpAsyncClient;
+    /**
+     * Timestamp (System.nanoTime()) of the most recent RPC sent through this client. Updated by
+     * {@link Http2ConsumerInvoker} on each request.
+     */
+    private volatile long lastUsedNanos = System.nanoTime();
 
     public Http2cRpcClient(ProtocolConfig config) {
         setConfig(config);
@@ -74,6 +88,27 @@ public <T> ConsumerInvoker<T> createInvoker(ConsumerConfig<T> consumerConfig) {
         return new Http2ConsumerInvoker<>(this, consumerConfig, protocolConfig);
     }
 
+    /**
+     * Record that this client just served (or is about to serve) an RPC. Called by
+     * {@link Http2ConsumerInvoker} on every request.
+     */
+    public void markUsed() {
+        lastUsedNanos = System.nanoTime();
+    }
+
+    /**
+     * Reports the client as unavailable if it has been idle longer than
+     * {@link #IDLE_UNAVAILABLE_THRESHOLD_NANOS}. This lets the cluster manager's periodic
+     * reconnect-check timer eventually evict orphaned clients (e.g. after backend IP rotation).
+     */
+    @Override
+    public boolean isAvailable() {
+        if (!super.isAvailable()) {
+            return false;
+        }
+        return (System.nanoTime() - lastUsedNanos) <= IDLE_UNAVAILABLE_THRESHOLD_NANOS;
+    }
+
     public CloseableHttpAsyncClient getHttpAsyncClient() {
         return httpAsyncClient;
     }

trpc-proto/trpc-proto-http/src/main/java/com/tencent/trpc/proto/http/client/HttpConsumerInvoker.java

@@ -63,7 +63,11 @@ public HttpConsumerInvoker(HttpRpcClient client, ConsumerConfig<T> config,
     public Response send(Request request) throws Exception {
         HttpPost httpPost = buildRequest(request);
 
-        CloseableHttpClient httpClient = ((HttpRpcClient) client).getHttpClient();
+        HttpRpcClient httpRpcClient = (HttpRpcClient) client;
+        // Refresh idle counter so the cluster manager's reconnect-check timer keeps treating
+        // this client as healthy while it's actively serving requests.
+        httpRpcClient.markUsed();
+        CloseableHttpClient httpClient = httpRpcClient.getHttpClient();
 
         try (CloseableHttpResponse httpResponse = httpClient.execute(httpPost)) {
             return handleResponse(request, httpResponse);

trpc-proto/trpc-proto-http/src/main/java/com/tencent/trpc/proto/http/client/HttpRpcClient.java

@@ -18,18 +18,54 @@
 import com.tencent.trpc.core.rpc.AbstractRpcClient;
 import com.tencent.trpc.core.rpc.ConsumerInvoker;
 import java.io.IOException;
+import java.util.concurrent.TimeUnit;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
 import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
 
 /**
  * HTTP protocol client.
+ * <p>Long-connection mode: connections are pooled by Apache {@link PoolingHttpClientConnectionManager}
+ * and reused across requests via HTTP/1.1 keep-alive. Two safeguards are enabled by default to
+ * keep the pool healthy in long-running processes:
+ * <ul>
+ *     <li>{@code validateAfterInactivity}: re-check a connection's liveness before reuse if it
+ *         has been idle for a short period (avoids the classic "stale connection / NoHttpResponseException"
+ *         when the server has half-closed an idle keep-alive connection);</li>
+ *     <li>{@code evictIdleConnections}: a small background thread evicts connections that have
+ *         been idle longer than the configured limit, freeing OS file descriptors.</li>
+ * </ul>
  */
 public class HttpRpcClient extends AbstractRpcClient {
 
     private static final Logger logger = LoggerFactory.getLogger(HttpRpcClient.class);
 
+    /**
+     * Validate a pooled connection before reuse if it has been idle for at least this many
+     * milliseconds. Cheap heuristic that catches most server-side half-closed keep-alive sockets.
+     */
+    private static final int VALIDATE_AFTER_INACTIVITY_MS = 2000;
+    /**
+     * Evict pooled connections that have been idle for longer than this duration.
+     */
+    private static final long EVICT_IDLE_CONNECTIONS_SECONDS = 60L;
+    /**
+     * If this client has not been used by any RPC for longer than this window, the periodic
+     * scanner in {@code RpcClusterClientManager} will treat it as unavailable. After
+     * a few consecutive unavailable observations the client gets closed and evicted from the
+     * cluster cache, which is how we reclaim {@link HttpRpcClient} instances orphaned by backend
+     * IP rotation (e.g. K8s pod IP drift). The window is intentionally large so that any
+     * actively-used client is never affected.
+     */
+    private static final long IDLE_UNAVAILABLE_THRESHOLD_NANOS =
+            java.util.concurrent.TimeUnit.MINUTES.toNanos(10);
+
     private CloseableHttpClient httpClient;
+    /**
+     * Timestamp (System.nanoTime()) of the most recent RPC sent through this client. Updated by
+     * {@link HttpConsumerInvoker} on each send.
+     */
+    private volatile long lastUsedNanos = System.nanoTime();
 
     public HttpRpcClient(ProtocolConfig config) {
         setConfig(config);
@@ -44,7 +80,16 @@ protected void doOpen() {
         // If there is only one route, the maximum number of connections for a single route is the same
         // as the maximum number of connections for the entire connection pool.
         cm.setDefaultMaxPerRoute(maxConns);
-        httpClient = HttpClients.custom().setConnectionManager(cm).build();
+        // Re-validate idle pooled connections before reuse so we do not send a request through a
+        // socket the server has already half-closed.
+        cm.setValidateAfterInactivity(VALIDATE_AFTER_INACTIVITY_MS);
+        httpClient = HttpClients.custom()
+                .setConnectionManager(cm)
+                // Background eviction of stale & long-idle connections; keeps the pool tidy in
+                // long-running processes without affecting hot connections.
+                .evictExpiredConnections()
+                .evictIdleConnections(EVICT_IDLE_CONNECTIONS_SECONDS, TimeUnit.SECONDS)
+                .build();
     }
 
     @Override
@@ -64,6 +109,28 @@ public <T> ConsumerInvoker<T> createInvoker(ConsumerConfig<T> consumerConfig) {
         return new HttpConsumerInvoker<>(this, consumerConfig, protocolConfig);
     }
 
+    /**
+     * Record that this client just served (or is about to serve) an RPC. Called by
+     * {@link HttpConsumerInvoker} on every request.
+     */
+    public void markUsed() {
+        lastUsedNanos = System.nanoTime();
+    }
+
+    /**
+     * Reports the client as unavailable if it has been idle longer than
+     * {@link #IDLE_UNAVAILABLE_THRESHOLD_NANOS}. This lets the cluster manager's periodic
+     * reconnect-check timer eventually evict orphaned clients (e.g. after backend IP rotation)
+     * even though Apache HttpClient itself has no notion of "remote permanently gone".
+     */
+    @Override
+    public boolean isAvailable() {
+        if (!super.isAvailable()) {
+            return false;
+        }
+        return (System.nanoTime() - lastUsedNanos) <= IDLE_UNAVAILABLE_THRESHOLD_NANOS;
+    }
+
     public CloseableHttpClient getHttpClient() {
         return httpClient;
     }