Package org.asynchttpclient.netty.channel

Class ChannelManager

  • public class ChannelManager
extends Object

    • Constructor Detail

      • ChannelManager

        public ChannelManager​(AsyncHttpClientConfig config,
                      io.netty.util.Timer nettyTimer)

    • Method Detail

      • isSslHandlerConfigured

        public static boolean isSslHandlerConfigured​(io.netty.channel.ChannelPipeline pipeline)

      • configureBootstraps

        public void configureBootstraps​(NettyRequestSender requestSender)

      • tryToOfferChannelToPool

        public void tryToOfferChannelToPool​(io.netty.channel.Channel channel,
                                    NettyResponseFuture<?> future,
                                    boolean keepAlive,
                                    Object partitionKey)

      • tryToOfferChannelToPool

        public final void tryToOfferChannelToPool​(io.netty.channel.Channel channel,
                                          AsyncHandler<?> asyncHandler,
                                          boolean keepAlive,
                                          Object partitionKey)

      • registerHttp2Connection

        public void registerHttp2Connection​(Object partitionKey,
                                    io.netty.channel.Channel channel)
        Registers an HTTP/2 connection in the registry for the given partition key. The connection stays in the registry (not the regular pool) to allow multiplexing — multiple requests can share the same connection concurrently.

      • addHttp2ConnectionWaiter

        public boolean addHttp2ConnectionWaiter​(Object partitionKey,
                                        Consumer<io.netty.channel.Channel> onConnection)
        Registers a one-shot waiter to be invoked when an HTTP/2 connection is registered for the same host (or with null on client close). See the http2ConnectionWaiters field and NettyRequestSender's HTTP/2 deferral. Waiters are grouped by the per-host base key (baseKeyOf(java.lang.Object)), NOT the full per-IP partition key: in round-robin mode a permit-starved request pinned to one IP must be woken by a connection that registers for ANY IP of the host so it can multiplex onto that sibling (issue #2214) — the per-IP registration key on its own would never wake it. The waiter must be idempotent — it may be invoked by a registration, by the client-close sweep, or removed and invoked by its own timeout concurrently.
        Returns:
        true if the waiter was registered; false if the client is already closing, in which case it is NOT registered and the caller must fail its request immediately rather than arm a timeout (no connection will register and the timer that would fire the deadline is being stopped). This closes the window where a request arms a waiter between the failHttp2ConnectionWaiters() sweep and nettyTimer.stop() and then hangs forever.

      • removeHttp2ConnectionWaiter

        public void removeHttp2ConnectionWaiter​(Object partitionKey,
                                        Consumer<io.netty.channel.Channel> onConnection)

      • removeHttp2Connection

        public void removeHttp2Connection​(Object partitionKey,
                                  io.netty.channel.Channel channel)
        Removes an HTTP/2 connection from the registry, but only if it's the currently registered connection for that partition key (avoids removing a replacement connection). The emptied per-host inner map is pruned atomically — computeIfPresent serializes with registerHttp2Connection's compute() on the same outer bucket, so a concurrent insert cannot be lost to the prune.

      • pollHttp2Connection

        public io.netty.channel.Channel pollHttp2Connection​(Object partitionKey)
        Returns an active, non-draining HTTP/2 connection for the given partition key, or null. Unlike the regular pool, this does NOT remove the connection — it remains available for concurrent multiplexed requests.

      • pollHttp2SiblingConnection

        public io.netty.channel.Channel pollHttp2SiblingConnection​(Object baseKey)
        Round-robin permit-starved fallback (issue #2214): returns an active, non-draining HTTP/2 connection open to ANY IP of the host identified by baseKey, or null if none qualifies. Used only by NettyRequestSender when a request pinned to one IP cannot acquire a per-host connection permit (maxConnectionsPerHost) and its own per-IP connection does not exist — it may then multiplex onto a sibling-IP connection instead of failing. NOT used on the happy path, which polls the exact per-IP key so load keeps spreading across IPs.

        Iterates only the inner map for this host (bounded by the host's resolved-IP count). Per-key validation and dead-entry eviction are delegated to pollHttp2Connection(java.lang.Object); redundant coalescing-losers are never stored, so they are never returned.

      • pollHttp2

        @Deprecated
public io.netty.channel.Channel pollHttp2​(Uri uri,
                                          String virtualHost,
                                          ProxyServer proxy,
                                          ChannelPoolPartitioning connectionPoolPartitioning)
        Deprecated.
        no longer used internally. Compute the partition key at the call site — from the request being dispatched, so it stays correct on the filter-replay path — and call pollHttp2Connection(Object). Kept for binary compatibility; slated for removal in the next major release.
        Polls for an HTTP/2 connection by URI/virtualHost/proxy, using the same partition key logic as the regular pool. Returns the connection without removing it from the registry.

      • poll

        @Deprecated
public io.netty.channel.Channel poll​(Uri uri,
                                     String virtualHost,
                                     ProxyServer proxy,
                                     ChannelPoolPartitioning connectionPoolPartitioning)
        Deprecated.
        no longer used internally. Compute the partition key at the call site — from the request being dispatched, so it stays correct on the filter-replay path — and call poll(Object). Kept for binary compatibility; slated for removal in the next major release.

      • poll

        public io.netty.channel.Channel poll​(Object partitionKey)

      • removeAll

        public void removeAll​(io.netty.channel.Channel connection)

      • close

        public void close()

      • closeChannel

        public void closeChannel​(io.netty.channel.Channel channel)

      • registerOpenChannel

        public void registerOpenChannel​(io.netty.channel.Channel channel)

      • updatePipelineForHttpTunneling

        public io.netty.util.concurrent.Future<io.netty.channel.Channel> updatePipelineForHttpTunneling​(io.netty.channel.ChannelPipeline pipeline,
                                                                                                Uri requestUri)

      • updatePipelineForHttpsTunneling

        public io.netty.util.concurrent.Future<io.netty.channel.Channel> updatePipelineForHttpsTunneling​(io.netty.channel.ChannelPipeline pipeline,
                                                                                                 Uri requestUri,
                                                                                                 ProxyServer proxyServer)

      • addSslHandler

        public io.netty.handler.ssl.SslHandler addSslHandler​(io.netty.channel.ChannelPipeline pipeline,
                                                     Uri uri,
                                                     String virtualHost,
                                                     boolean hasSocksProxyHandler)

      • getBootstrap

        public io.netty.util.concurrent.Future<io.netty.bootstrap.Bootstrap> getBootstrap​(Uri uri,
                                                                                  io.netty.resolver.NameResolver<InetAddress> nameResolver,
                                                                                  ProxyServer proxy)

      • isHttp2

        public static boolean isHttp2​(io.netty.channel.Channel channel)
        Checks whether the given channel is an HTTP/2 connection (i.e. has the HTTP/2 multiplex handler installed).

      • isHttp2StreamChannel

        public static boolean isHttp2StreamChannel​(io.netty.channel.Channel channel)
        Checks whether the given channel is an HTTP/2 stream child channel. Stream channels are single-use and don't support HTTP/1.1 operations like draining or pipeline modification.

      • getHttp2Handler

        public Http2Handler getHttp2Handler()
        Returns the shared Http2Handler instance for use with stream child channels.

      • upgradePipelineToHttp2

        public void upgradePipelineToHttp2​(io.netty.channel.ChannelPipeline pipeline)
        Upgrades the pipeline from HTTP/1.1 to HTTP/2 after ALPN negotiates "h2". Removes HTTP/1.1 handlers and adds Http2FrameCodec + Http2MultiplexHandler. The per-stream Http2Handler is added separately on each stream child channel.

      • upgradePipelineToHttp2AfterProxyConnect

        public void upgradePipelineToHttp2AfterProxyConnect​(io.netty.channel.ChannelPipeline pipeline,
                                                    Object partitionKey)
        Upgrades and registers a proxy tunnel when the target TLS handshake negotiated HTTP/2. The caller controls when this runs so the upgrade can happen immediately before the tunneled request is sent.

      • upgradePipelineForWebSockets

        public void upgradePipelineForWebSockets​(io.netty.channel.ChannelPipeline pipeline)

      • drainChannelAndOffer

        public void drainChannelAndOffer​(io.netty.channel.Channel channel,
                                 NettyResponseFuture<?> future)

      • drainChannelAndOffer

        public void drainChannelAndOffer​(io.netty.channel.Channel channel,
                                 NettyResponseFuture<?> future,
                                 boolean keepAlive,
                                 Object partitionKey)

      • getEventLoopGroup

        public io.netty.channel.EventLoopGroup getEventLoopGroup()

      • getAddressResolverGroup

        @Nullable
public @Nullable io.netty.resolver.AddressResolverGroup<InetSocketAddress> getAddressResolverGroup()
        Return the AddressResolverGroup used for async DNS resolution, or null if per-request name resolvers should be used (legacy behavior).

      • getClientStats

        public ClientStats getClientStats()
        Builds a point-in-time stats snapshot, scanning open channels and idle pooled channels once each.

      • isOpen

        public boolean isOpen()

      • isHttp2CleartextEnabled

        public boolean isHttp2CleartextEnabled()