assertThat(request.requestLine).isEqualTo("GET /foo HTTP/1.1")
    assertThat(request.headers[":scheme"]).isEqualTo(scheme)
    assertThat(request.headers[":authority"]).isEqualTo("${server.hostName}:${server.port}")
  }

  @ParameterizedTest
  @ArgumentsSource(ProtocolParamProvider::class)
  fun get204Response(
    protocol: Protocol,
    mockWebServer: MockWebServer,
  ) {

                        "stat_prefix": "connect_originate",
                        "cluster": "connect_originate",
                        "tunneling_config": {
                          "hostname": "%DOWNSTREAM_LOCAL_ADDRESS%"
                        }
                      }
                    }
                  ]
                }
              ],
              "use_original_dst": false,

  }

  private fun urlWithIpAddress(
    server: MockWebServer,
    path: String,
  ): HttpUrl {
    return server.url(path)
      .newBuilder()
      .host(InetAddress.getByName(server.hostName).hostAddress)
      .build()
  }

  private operator fun get(url: HttpUrl) {
    val call =
      client.newCall(
        Request.Builder()
          .url(url)
          .build(),
      )

    this.skipAll(timeout, timeUnit)
  } catch (_: IOException) {
    false
  }

internal fun Socket.peerName(): String {
  val address = remoteSocketAddress
  return if (address is InetSocketAddress) address.hostName else address.toString()
}

/**
 * Returns true if new reads and writes should be attempted on this.
 *
 * Unfortunately Java's networking APIs don't offer a good health check, so we go on our own by

//
// For example this can express things like:
// - StorageClass "standard" has "1234 GiB" available in "topology.kubernetes.io/zone=us-east1"
// - StorageClass "localssd" has "10 GiB" available in "kubernetes.io/hostname=knode-abc123"
//
// The following three cases all imply that no capacity is available for
// a certain combination:
// - no object exists with suitable topology and storage class name

`127.0.0.1:9000`) to the configured Console port. MinIO uses the hostname or IP address specified in the request when building the redirect URL. The URL and port *must* be accessible by the client for the redirection to work.

For deployments behind a load balancer, proxy, or ingress rule where the MinIO host IP address or port is not public, use the `MINIO_BROWSER_REDIRECT_URL` environment variable to specify the external hostname for the redirect. The LB/Proxy must have rules for directing...

     * expired because under normal circumstances SID information never changes.
     *

    assertContent("This is the 2nd server, again!", getResponse(Request(server2.url("/"))))
    val server1Host = server.hostName + ":" + server.port
    val server2Host = server2.hostName + ":" + server2.port
    assertThat(server.takeRequest().headers["Host"]).isEqualTo(server1Host)
    assertThat(server2.takeRequest().headers["Host"]).isEqualTo(server2Host)

                    getTestUser(),
                    getTestUserPassword(),
                    getTestUserDomain());
            }
        }
        catch ( SmbException e ) {
            // no setup to resolve hostname if netbios is used
            if ( e.getCause() instanceof UnknownHostException ) {
                Assume.assumeTrue(false);
            }
            throw e;
        }
    }

```

## Publish MinIO events via PostgreSQL

> NOTE: Until release RELEASE.2020-04-10T03-34-42Z PostgreSQL notification used to support following options:
>
> ```
> host                (hostname)           Postgres server hostname (used only if `connection_string` is empty)
> port                (port)               Postgres server port, defaults to `5432` (used only if `connection_string` is empty)