}
        }

        else -> throw ProtocolException("unsupported address type: $addressType")
      }

    val port = fromSource.readShort() and 0xffff

    when (command) {
      COMMAND_CONNECT -> {
        val toSocket = Socket(toAddress, port)
        val localAddress = toSocket.localAddress.address
        if (localAddress.size != 4) {

//// tab | Uvicorn

<div class="termy">

```console
$ uvicorn main:app --host 0.0.0.0 --port 80

<span style="color: green;">INFO</span>:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
```

</div>

////

//// tab | Hypercorn

<div class="termy">

```console

 * - rdma.test.port=445 (target port, defaults to 445)
 */
public class RdmaIntegrationTest {

    private String testServer;
    private int testPort;
    private CIFSContext testContext;

    @BeforeEach
    public void setUp() throws Exception {
        testServer = System.getProperty("rdma.test.server");
        String portStr = System.getProperty("rdma.test.port", "445");

#                                                     ------
# Does it send mock mail? (true: no send actually, logging only)
mail.send.mock = false

# SMTP server settings for main: host:port
mail.smtp.server.main.host.and.port = localhost:25

# The prefix of subject to show test environment or not
mail.subject.test.prefix = 

# The common return path of all mail
mail.return.path = root@localhost

  env_file:
    - ./minio.env
  expose:
    - "9000"
    - "9001"

# starts 4 docker containers running minio server instances.
# using nginx reverse proxy, load balancing, you can access
# it through port 9000.
services:
  minio1:
    <<: *minio-common
    hostname: minio1
    volumes:
      - data1-1:/data1
      - data1-2:/data2
      - data1-3:/data3

  minio2:
    <<: *minio-common

TFCI_OUTPUT_WIN_DOCKER_DIR='C:/drive_t'

# Docker on Windows doesn't support the `host` networking mode, and so
# port-forwarding is required for the container to detect it's running on GCE.
export IP_ADDR=$(powershell -command "(Get-NetIPAddress -AddressFamily IPv4 -InterfaceAlias 'vEthernet (nat)').IPAddress")

  environment:
    - MINIO_PROMETHEUS_AUTH_TYPE=public
    - CI=true

# starts 4 docker containers running minio server instances.
# using nginx reverse proxy, load balancing, you can access
# it through port 9000.
services:
  site2-minio1:
    <<: *minio-common
    hostname: site2-minio1
    volumes:
      - site2-data1-1:/data1
      - site2-data1-2:/data2

  site2-minio2:
    <<: *minio-common

    val username: String = httpUrl.username
    val encodedPassword: String = httpUrl.encodedPassword
    val password: String = httpUrl.password
    val host: String = httpUrl.host
    val port: Int = httpUrl.port
    val pathSize: Int = httpUrl.pathSize
    val encodedPath: String = httpUrl.encodedPath
    val encodedPathSegments: List<String> = httpUrl.encodedPathSegments

        append(request.url)
      } else {
        append(requestPath(request.url))
      }
      append(" HTTP/1.1")
    }

  /**
   * Returns true if the request line should contain the full URL with host and port (like "GET
   * http://android.com/foo HTTP/1.1") or only the path (like "GET /foo HTTP/1.1").
   */
  private fun includeAuthorityInRequestLine(
    request: Request,
    proxyType: Proxy.Type,

    interval: 5s
    timeout: 5s
    retries: 5

# starts 4 docker containers running minio server instances.
# using nginx reverse proxy, load balancing, you can access
# it through port 9000.
services:
  minio1:
    <<: *minio-common
    hostname: minio1
    volumes:
      - pdata1-1:/pdata1
      - pdata1-2:/pdata2

  minio2:
    <<: *minio-common
    hostname: minio2
    volumes: