serverAddress: InetSocketAddress,
  ): Future<Handshake> {
    return executorService.submit<Handshake> {
      SocketFactory.getDefault().createSocket().use { rawSocket ->
        rawSocket.connect(serverAddress)
        val sslSocket =
          client.sslSocketFactory().createSocket(
            rawSocket,
            rawSocket.inetAddress.hostAddress,
            rawSocket.port,
            true,

### Configure MinIO

```
export MINIO_ROOT_USER=minio
export MINIO_ROOT_PASSWORD=minio123
minio server /mnt/export
```

Here are all the available options to configure OpenID connect

```
mc admin config set myminio/ identity_openid

KEY:
identity_openid  enable OpenID SSO support

ARGS:

    }
  }

  /**
   * This test reproduces a crash where OkHttp attempted to use a deferred connection when the call
   * already had a healthy connection. It sets up a deferred connection by stalling the IPv6
   * connect, and it sets up a same-connection retry with [ErrorCode.REFUSED_STREAM].
   *
   * https://github.com/square/okhttp/pull/7190
   */
  @Test
  fun preferCallConnectionOverDeferredConnection() {

   * the behavior described in {@link #put(Range, Object) put(range, value)}, however the ranges
   * returned from {@link #asMapOfRanges} will be different if there were existing entries which
   * connect to the given range and value.
   *
   * <p>Even if the input range is empty, if it is connected on both sides by ranges mapped to the
   * same value those two ranges will be coalesced.
   *

 * <code>WriteFile</code>, and <code>CloseFile</code> interface was
 * being used.
 * </td></tr>
 * </table>
 *
 * <p>See <a href="../../../pipes.html">Using jCIFS to Connect to Win32
 * Named Pipes</a> for a detailed description of how to use jCIFS with
 * Win32 Named Pipe server processes.
 *
 */

public class SmbNamedPipe extends SmbFile {

    /**

                    /* Technically we should also try to authenticate here but that means doing the session setup and tree connect separately. For now a simple connect will at least tell us if the host is alive. That should be sufficient for 99% of the cases. We can revisit this again for 2.0.
                     */
                    trans.connect();
                    tree = trans.getSmbSession(auth).getSmbTree(dr.share, service);

}

// Legacy returns 'true' if distribution algo is CRCMOD
func (s *erasureSets) Legacy() (ok bool) {
	return s.distributionAlgo == formatErasureVersionV2DistributionAlgoV1
}

// connectDisks - attempt to connect all the endpoints, loads format
// and re-arranges the disks in proper position.
func (s *erasureSets) connectDisks(log bool) {
	defer func() {
		s.lastConnectDisksOpTime = time.Now()
	}()

	return client.endpoint.String()
}

// IsOnline - returns whether client failed to connect or not.
func (client *storageRESTClient) IsOnline() bool {
	return client.restClient.IsOnline() || client.IsOnlineWS()
}

// IsOnlineWS - returns whether websocket client failed to connect or not.
func (client *storageRESTClient) IsOnlineWS() bool {
	return client.gridConn.State() == grid.StateConnected
}

 *  **Proxy authenticators are now asked for preemptive authentication.** OkHttp will now request
    authentication credentials before creating TLS tunnels through HTTP proxies (HTTP `CONNECT`).
    Authenticators should identify preemptive authentications by the presence of a challenge whose
    scheme is "OkHttp-Preemptive".

      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates2.sslSocketFactory(),
          handshakeCertificates2.trustManager,
        ).build()

    // This client fails to connect because the new SSL socket factory refuses.
    assertFailsWith<IOException> {
      anotherClient.newCall(request).execute()
    }.also { expected ->
      when (expected) {