serverSocketChannel.configureBlocking(true);
      serverSocketChannel.socket().bind(address);
    }

    @Override public int getLocalPort() {
      return 1; // A white lie. There is no local port.
    }

    @Override public SocketAddress getLocalSocketAddress() {
      return endpoint;
    }

    @Override public Socket accept() throws IOException {
      try {

For a quick installation, docker-compose reference configs are also available on the [Keycloak GitHub](https://github.com/keycloak/keycloak-containers/tree/main/docker-compose-examples).

### Configure Keycloak Realm

- Go to Clients
  - Click on account
    - Settings
    - Change `Access Type` to `confidential`.

  ): RealConnection {
    val result =
      RealConnection.newTestConnection(
        taskRunner = taskRunner,
        connectionPool = pool,
        route = route,
        socket = Socket(),
        idleAtNs = idleAtNanos,
      )
    result.withLock { pool.put(result) }
    return result
  }

  fun newConnectionPool(
    taskRunner: TaskRunner = this.taskRunner,

  /** Returns the route used by this connection. */
  fun route(): Route

  /**
   * Returns the socket that this connection is using. Returns an
   * [SSL socket][javax.net.ssl.SSLSocket] if this connection is HTTPS. If this is an HTTP/2
   * connection the socket may be shared by multiple concurrent calls.
   */
  fun socket(): Socket

  /**
   * Returns the TLS handshake used to establish this connection, or null if the connection is not

]; then if [ $OBJECTLOCKING = true ]; then echo "Creating bucket with OBJECTLOCKING '$BUCKET'" ${MC} mb --with-lock myminio/$BUCKET elif [ $OBJECTLOCKING = false ]; then echo "Creating bucket '$BUCKET'" ${MC} mb myminio/$BUCKET fi elif [ -z $OBJECTLOCKING ]; then echo "Creating bucket '$BUCKET'" ${MC} mb myminio/$BUCKET else echo "Bucket '$BUCKET' already exists." fi fi # set versioning for bucket if objectlocking is disabled or not set if [ $OBJECTLOCKING = false ]; then if [ ! -z $VERSIONING ]; then...

                final boolean closed = msg != null && msg.equals("Socket closed");

                if (closed) {
                    log.trace("Remote closed connection");
                } else if (timeout) {
                    log.debug("socket timeout in non peek state", ex);
                } else {
                    log.debug("recv failed", ex);
                }

      }

    /**
     * Sets the socket factory used to create connections. OkHttp only uses the parameterless
     * [SocketFactory.createSocket] method to create unconnected sockets. Overriding this method,
     * e. g., allows the socket to be bound to a specific local address.
     *
     * If unset, the [system-wide default][SocketFactory.getDefault] socket factory will be used.
     */

      }
    }

    val result = timeoutExit(e)
    if (e != null) {
      eventListener.callFailed(this, result!!)
    } else {
      eventListener.callEnd(this)
    }
    return result
  }

  /**
   * Remove this call from the connection's list of allocations. Returns a socket that the caller
   * should close.
   */

            this.closeTimeout = Math.max(this.transportContext.getConfig().getNetbiosSoTimeout(), timeout);
        }
        // If socket is still good, the new closeTimeout will
        // be ignored; see tryClose comment.
        if (this.socket == null) {
            this.socket = new DatagramSocket(this.lport, this.laddr);
            this.thread = new Thread(this, "JCIFS-NameServiceClient");

      RecordedRequest(
        "",
        headersOf(),
        listOf(),
        0L,
        Buffer(),
        0,
        Socket(),
      )
    recordedRequest = RecordedRequest("", headersOf(), listOf(), 0L, Buffer(), 0, Socket())
    var requestUrl: HttpUrl? = recordedRequest.requestUrl
    var requestLine: String = recordedRequest.requestLine
    var method: String? = recordedRequest.method