}

  fun withWebSocketUpgrade(listener: WebSocketListener) =
    apply {
      status = "HTTP/1.1 101 Switching Protocols"
      setHeader("Connection", "Upgrade")
      setHeader("Upgrade", "websocket")
      body = null
      webSocketListener = listener
    }

  override fun toString(): String = status

  companion object {
    private const val CHUNKED_BODY_HEADER = "Transfer-encoding: chunked"

// 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
}

// LastConn - returns when the disk is seen to be connected the last time

	Trace       func(msg string) // Trace when starting.
	IdleTimeout time.Duration    // Incoming TCP read/write timeout
}

// ForWebsocket returns TCPOptions valid for websocket net.Conn
func (t TCPOptions) ForWebsocket() TCPOptions {
	return TCPOptions{
		UserTimeout: t.UserTimeout,
		Interface:   t.Interface,
		SendBufSize: t.SendBufSize,
		RecvBufSize: t.RecvBufSize,

   *
   * If more than [maxRequestsPerHost] requests are in flight when this is invoked, those requests
   * will remain in flight.
   *
   * WebSocket connections to hosts **do not** count against this limit.
   */
  @get:Synchronized
  var maxRequestsPerHost = 5
    set(maxRequestsPerHost) {
      require(maxRequestsPerHost >= 1) { "max < 1: $maxRequestsPerHost" }

import okhttp3.internal.ws.WebSocketProtocol.toggleMask
import okio.Buffer
import okio.BufferedSource
import okio.ByteString

/**
 * An [RFC 6455][rfc_6455]-compatible WebSocket frame reader.
 *
 * This class is not thread safe.
 *
 * [rfc_6455]: http://tools.ietf.org/html/rfc6455
 */
class WebSocketReader(
  private val isClient: Boolean,
  val source: BufferedSource,

		}
		dialer.TLSConfig = tls

		conn, br, _, err := dialer.Dial(ctx, toDial)
		if br != nil {
			ws.PutReader(br)
		}
		return conn, err
	}
}

// ConnectWS returns a function that dials a websocket connection to the given address.
// Route and auth are added to the connection.
func ConnectWS(dial ContextDialer, auth AuthFn, tls *tls.Config) func(ctx context.Context, remote string) (net.Conn, error) {

        **Example**

        ```python
        from fastapi import FastAPI, WebSocket

        app = FastAPI()

        @app.websocket("/ws")
        async def websocket_endpoint(websocket: WebSocket):
            await websocket.accept()
            while True:
                data = await websocket.receive_text()

  /** Uses [request] to connect a new web socket. */
  override fun newWebSocket(
    request: Request,
    listener: WebSocketListener,
  ): WebSocket {
    val webSocket =
      RealWebSocket(
        taskRunner = taskRunner,
        originalRequest = request,
        listener = listener,
        random = Random(),

 [fun_interface]: https://kotlinlang.org/docs/reference/fun-interfaces.html
 [iana_websocket]: https://www.iana.org/assignments/websocket/websocket.txt
 [jetty_8_252]: https://webtide.com/jetty-alpn-java-8u252/
 [kotlin_1_3_71]: https://github.com/JetBrains/kotlin/releases/tag/v1.3.71
 [kotlin_1_4_10]: https://github.com/JetBrains/kotlin/releases/tag/v1.4.10

* Seriously impressive performance. It is [one of the fastest Python frameworks available, on par with **NodeJS** and **Go**](https://github.com/encode/starlette#performance).
* **WebSocket** support.
* In-process background tasks.
* Startup and shutdown events.
* Test client built on HTTPX.
* **CORS**, GZip, Static Files, Streaming responses.
* **Session and Cookie** support.
* 100% test coverage.