@Override
    public Promise<PooledConnection> acquire(
            EventLoop eventLoop,
            @Nullable Object key,
            CurrentPassport passport,
            AtomicReference<DiscoveryResult> selectedServer,
            AtomicReference<? super InetAddress> selectedHostAddr) {

        if (shuttingDown) {
            Promise<PooledConnection> promise = eventLoop.newPromise();
            promise.setFailure(new IllegalStateException("ConnectionPool is shutting down now."));
            return promise;
        }

        // Choose the next load-balanced server.
        DiscoveryResult chosenServer = dynamicServerResolver.resolve(key);

        // (argha-c): Always ensure the selected server is updated, since the call chain relies on this mutation.
        selectedServer.set(chosenServer);
        if (Objects.equals(chosenServer, DiscoveryResult.EMPTY)) {
            Promise<PooledConnection> promise = eventLoop.newPromise();
            promise.setFailure(
                    new OriginConnectException("No servers available", OutboundErrorType.NO_AVAILABLE_SERVERS));
            return promise;
        }

        // Now get the connection-pool for this server.
        IConnectionPool pool = perServerPools.computeIfAbsent(chosenServer, s -> {
            SocketAddress finalServerAddr = pickAddress(chosenServer);
            ClientChannelManager clientChannelMgr = this;
            PooledConnectionFactory pcf = createPooledConnectionFactory(
                    chosenServer, clientChannelMgr, metrics.closeConnCounter(), metrics.closeWrtBusyConnCounter());

            // Create a new pool for this server.
            return createConnectionPool(
                    chosenServer,
                    finalServerAddr,
                    clientConnFactory,
                    pcf,
                    connPoolConfig,
                    clientConfig,
                    metrics.createNewConnCounter(),
                    metrics.createConnSucceededCounter(),
                    metrics.createConnFailedCounter(),
                    metrics.requestConnCounter(),
                    metrics.reuseConnCounter(),
                    metrics.connTakenFromPoolIsNotOpen(),
                    metrics.closeAbovePoolHighWaterMarkCounter(),
                    metrics.maxConnsPerHostExceededCounter(),
                    metrics.connEstablishTimer(),
                    metrics.connsInPool(),
                    metrics.connsInUse());
        });

        return pool.acquire(eventLoop, passport, selectedHostAddr);
    }
Gracefully shuts down a DefaultClientChannelManager by allowing in-flight requests to finish before closing the connections.
Idle connections in the connection pools are closed, and any connections associated with an in-flight request
will be closed upon trying to return the connection to the pool
zuul-core/src/main/java/com/netflix/zuul/netty/connectionpool/DefaultClientChannelManager.java