*/
    fun dispatcher(dispatcher: Dispatcher) =
      apply {
        this.dispatcher = dispatcher
      }

    /**
     * Sets the connection pool used to recycle HTTP and HTTPS connections.
     *
     * If unset, a new connection pool will be used.
     */
    fun connectionPool(connectionPool: ConnectionPool) =
      apply {
        this.connectionPool = connectionPool
      }

 *  **There is no longer a global singleton connection pool.** In OkHttp 2.x,
    all `OkHttpClient` instances shared a common connection pool by default.
    In OkHttp 3.x, each new `OkHttpClient` gets its own private connection pool.
    Applications should avoid creating many connection pools as doing so
    prevents connection reuse. Each connection pool holds its own set of

            // Log circuit breaker rejection
            auditLogger.logSecurityViolation("Circuit breaker open for SMB connection",
                    java.util.Map.of("address", address.getHostAddress(), "port", String.valueOf(port)));
            throw new IOException("Connection rejected by circuit breaker: " + e.getMessage(), e);
        } catch (RuntimeException e) {
            // Unwrap IOException from RuntimeException

/**
 *
 */
final class SmbSessionImpl implements SmbSessionInternal {

    private static final Logger log = LoggerFactory.getLogger(SmbSessionImpl.class);

    /*
     * 0 - not connected
     * 1 - connecting
     * 2 - connected
     * 3 - disconnecting
     */
    private final AtomicInteger connectionState = new AtomicInteger();
    private int uid;
    private List<SmbTreeImpl> trees;

 *
 * Usually a webserver is reachable with multiple identifiers: its IP addresses, registered
 * domain names, and even `localhost` when connecting from the server itself. Each of a web server's
 * names is a distinct URL and they are not interchangeable. For example, even if
 * `http://square.github.io/dagger` and `http://google.github.io/dagger` are served by the same IP

    assertThat(connectStart.proxy).isEqualTo(Proxy.NO_PROXY)
    val connectEnd = listener.removeUpToEvent<CallEvent.ConnectEnd>()
    assertThat(connectEnd.call).isSameAs(call)
    assertThat(connectEnd.inetSocketAddress).isEqualTo(expectedAddress)
    assertThat(connectEnd.protocol).isEqualTo(Protocol.HTTP_1_1)
  }

  @Test
  fun failedConnect() {
    enableTlsWithTunnel()

    )
    val connections: MutableList<RealConnection?> = ArrayList()
    val localClient =
      client
        .newBuilder()
        .eventListener(
          object : EventListener() {
            override fun connectionAcquired(
              call: Call,
              connection: Connection,
            ) {
              connections.add(connection as RealConnection)
            }

```py
#!/usr/bin/env python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='bucketevents',
                         exchange_type='fanout')

result = channel.queue_declare(exclusive=False)

    // Play it back.
    val connection = connect(peer)
    connection.newStream(headerEntries("a", "android"), false)
    connection.withLock {
      if (!connection.isHealthy(System.nanoTime())) {
        throw ConnectionShutdownException()
      }
    }
    connection.writePing()
    connection.shutdown(ErrorCode.PROTOCOL_ERROR)
    assertThat(connection.openStreamCount()).isEqualTo(1)

/**
 * Manages LDAP connections and operations.
 */
public class LdapManager {
    private static final Logger logger = LogManager.getLogger(LdapManager.class);

    /** A thread-local variable to hold the directory context. */
    protected ThreadLocal<DirContextHolder> contextLocal = new ThreadLocal<>();

    /** A flag to indicate if the LDAP connection is bound. */
    protected volatile boolean isBind = false;