imagePullPolicy: {{ .Values.image.pullPolicy }}
          command: [
            "/bin/sh",
            "-ce",

     *   <li>DELETE - Deletes the specified resource.</li>
     *   <li>HEAD - Same as GET but returns only HTTP headers and no document body.</li>
     *   <li>OPTIONS - Returns the HTTP methods that the server supports.</li>
     *   <li>TRACE - Echoes back the received request, used for debugging.</li>
     *   <li>CONNECT - Converts the request connection to a transparent TCP/IP tunnel.</li>
     * </ul>
     */

) {
  fun noContextTakeover(clientOriginated: Boolean): Boolean =
    if (clientOriginated) {
      clientNoContextTakeover // Client is deflating.
    } else {
      serverNoContextTakeover // Server is deflating.
    }

  companion object {
    private const val HEADER_WEB_SOCKET_EXTENSION = "Sec-WebSocket-Extensions"

    @Throws(IOException::class)
    fun parse(responseHeaders: Headers): WebSocketExtensions {

 *
 *
 *  * <b>About NetBIOS:</b> The NetBIOS name
 * service is a dynamic distributed service that allows hosts to resolve
 * names by broadcasting a query, directing queries to a server such as
 * Samba or WINS. NetBIOS is currently the primary networking layer for
 * providing name service, datagram service, and session service to the
 * Microsoft Windows platform. A NetBIOS name can be 15 characters long

This, of course, is not optimal and you wouldn't use it for production.

In production you would have one of the options above.

But it's the simplest way to focus on the server-side of WebSockets and have a working example:

{* ../../docs_src/websockets_/tutorial001_py310.py hl[2,6:38,41:43] *}

## Create a `websocket` { #create-a-websocket }

}

func main() {
	var node, args string

	flag.StringVar(&node, "local-node-name", "", "the name of the local node")
	flag.StringVar(&args, "args", "", "arguments passed to MinIO server")

	flag.Parse()

	localDisks, err := filterLocalDisks(node, args)
	if err != nil {
		log.Fatal(err)
	}

	if len(localDisks) == 0 {

            assertThat(isDefaultValue(chain.value())).isFalse()
            chain.proceed(chain.request())
          }.build()

      server.enqueue(
        MockResponse(),
      )
      val response = client.newCall(Request(server.url("/"))).execute()
      response.close()
    }
  }

  /**
   * Test that we can't override in a Network Interceptor, which will throw an exception.
   */

labels.ldap_initial_context_factory=Initial Context Factory
labels.general_menu_oic=OpenID Connect
labels.oic_client_id=Client ID
labels.oic_client_secret=Client Secret
labels.oic_auth_server_url=Authorization Server URL
labels.oic_token_server_url=Token Server URL
labels.oic_redirect_url=Redirect URL
labels.oic_scope=Scope
labels.oic_base_url=Base URL
labels.oic_default_groups=Default Groups
labels.oic_default_roles=Default Roles

    def __init__(
        self: AppType,
        *,
        debug: Annotated[
            bool,
            Doc(
                """
                Boolean indicating if debug tracebacks should be returned on server
                errors.

                Read more in the
                [Starlette docs for Applications](https://www.starlette.dev/applications/#instantiating-the-application).
                """
            ),

	}

	if err := target.send(eventData); err != nil {
		return err
	}

	// Delete the event from store.
	return target.store.Del(key)
}

// Close - closes underneath connections to NSQD server.
func (target *NSQTarget) Close() (err error) {
	close(target.quitCh)
	if target.producer != nil {
		// this blocks until complete:
		target.producer.Stop()
	}
	return nil
}