check connection

sdk/clientcore/http-netty4/src/main/java/io/clientcore/http/netty4/NettyHttpClientBuilder.java

@@ -14,7 +14,6 @@
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.EventLoopGroup;
-import io.netty.channel.WriteBufferWaterMark;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.channel.socket.nio.NioSocketChannel;
@@ -397,8 +396,6 @@ public HttpClient build() {
         // Disable auto-read as we want to control when and how data is read from the channel.
         bootstrap.option(ChannelOption.AUTO_READ, false);
         bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
-        bootstrap.option(ChannelOption.WRITE_BUFFER_WATER_MARK,
-            new WriteBufferWaterMark(8 * 1024 * 1024, 16 * 1024 * 1024));
 
         Configuration buildConfiguration
             = (configuration == null) ? Configuration.getGlobalConfiguration() : configuration;

sdk/clientcore/http-netty4/src/main/java/io/clientcore/http/netty4/implementation/Netty4ConnectionPool.java

@@ -16,6 +16,12 @@
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.EventLoopGroup;
+import io.netty.handler.codec.http.DefaultFullHttpRequest;
+import io.netty.handler.codec.http.FullHttpRequest;
+import io.netty.handler.codec.http.HttpHeaderNames;
+import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpResponse;
+import io.netty.handler.codec.http.HttpVersion;
 import io.netty.handler.codec.http2.Http2GoAwayFrame;
 import io.netty.handler.proxy.HttpProxyHandler;
 import io.netty.handler.proxy.ProxyHandler;
@@ -24,6 +30,7 @@
 import io.netty.handler.ssl.SslContextBuilder;
 import io.netty.handler.ssl.SslHandler;
 import io.netty.util.AttributeKey;
+import io.netty.util.ReferenceCountUtil;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.Promise;
 
@@ -341,15 +348,70 @@ private PooledConnection pollIdleConnection() {
                     return null;
                 }
 
-                if (isHealthy(connection)) {
-                    connection.idleSince = null; // Mark as active
-                    return connection;
+                boolean isConnectionAlive = isConnectionAlive(connection.channel);
+                System.out.println("ISCONNECTIONALIVE: " + isConnectionAlive);
+                if (isConnectionAlive) {
+                    if (isHealthy(connection)) {
+                        connection.idleSince = null; // Mark as active
+                        return connection;
+                    }
                 }
 
                 connection.close(); // The close listener will handle decrementing the counter.
             }
         }
 
+        private boolean isConnectionAlive(Channel channel) {
+            PooledConnection pooledConnection = channel.attr(POOLED_CONNECTION_KEY).get();
+            if (pooledConnection == null) {
+                return false;
+            }
+
+            SocketAddress address = pooledConnection.key.getFinalDestination();
+            if (!(address instanceof InetSocketAddress)) {
+                return false;
+            }
+
+            String host = ((InetSocketAddress) address).getHostString();
+            int port = ((InetSocketAddress) address).getPort();
+            String hostHeader = host + ":" + port;
+
+            try {
+                Promise<Boolean> validationPromise = channel.eventLoop().newPromise();
+
+                ChannelHandler validationHandler = new ChannelInboundHandlerAdapter() {
+                    @Override
+                    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+                        if (msg instanceof io.netty.handler.codec.http.HttpResponse) {
+                            validationPromise.trySuccess(true);
+                            io.netty.util.ReferenceCountUtil.release(msg);
+                            ctx.pipeline().remove(this);
+                        } else {
+                            super.channelRead(ctx, msg);
+                        }
+                    }
+
+                    @Override
+                    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+                        validationPromise.trySuccess(false);
+                        ctx.pipeline().remove(this);
+                    }
+                };
+
+                channel.pipeline().addLast("validationHandler", validationHandler);
+
+                FullHttpRequest pingRequest = new DefaultFullHttpRequest(
+                    HttpVersion.HTTP_1_1, HttpMethod.OPTIONS, "*");
+                pingRequest.headers().set(HttpHeaderNames.HOST, hostHeader);
+
+                channel.writeAndFlush(pingRequest);
+
+                return validationPromise.get(2, TimeUnit.SECONDS);
+            } catch (Exception e) {
+                return false;
+            }
+        }
+
         /**
          * Queues a new promise for a connection.
          * This is called when the pool is at max capacity.

sdk/core/azure-core/src/test/java/com/azure/core/validation/http/HttpClientTestsServer.java

@@ -82,8 +82,12 @@ public static LocalTestServer getHttpClientTestsServer() {
             boolean head = "HEAD".equalsIgnoreCase(req.getMethod());
             boolean delete = "DELETE".equalsIgnoreCase(req.getMethod());
             boolean patch = "PATCH".equalsIgnoreCase(req.getMethod());
+            boolean options = "OPTIONS".equalsIgnoreCase(req.getMethod());
 
-            if (get && path.startsWith("/bytes")) {
+            if (options && "*".equals(path)) {
+                resp.setStatus(200);
+                resp.flushBuffer();
+            } else if (get && path.startsWith("/bytes")) {
                 // Stub that will return a response with a body containing the passed number of bytes.
                 sendBytesResponse(path, resp);
             } else if (get && path.startsWith("/status")) {