Struct websocket::server::upgrade::WsUpgrade

pub struct WsUpgrade<S, B> where
    S: Stream,  {
    pub headers: Headers,
    pub stream: S,
    pub request: Request,
    pub buffer: B,
}

Intermediate representation of a half created websocket session. Should be used to examine the client's handshake accept the protocols requested, route the path, etc.

Users should then call accept or reject to complete the handshake and start a session. Note: if the stream in use is AsyncRead + AsyncWrite, then asynchronous functions will be available when completing the handshake. Otherwise if the stream is simply Read + Write blocking functions will be available to complete the handshake.

Fields

headers: Headers

The headers that will be used in the handshake response.

stream: S

The stream that will be used to read from / write to.

request: Request

The handshake request, filled with useful metadata.

buffer: B

Some buffered data from the stream, if it exists.

Methods

impl<S> WsUpgrade<S, BytesMut> where
    S: Stream + 'static, 

These are the extra functions given to WsUpgrade with the async feature turned on. A type alias for this specialization of WsUpgrade lives in this module under the name Upgrade.

fn accept(self) -> ClientNew<S>

Asynchronously accept the websocket handshake, then create a client. This will asynchronously send a response accepting the connection and create a websocket client.

fn accept_with(self, custom_headers: &Headers) -> ClientNew<S>

Asynchronously accept the websocket handshake, then create a client. This will asynchronously send a response accepting the connection with custom headers in the response and create a websocket client.

fn reject(self) -> Send<Framed<S, HttpServerCodec>>

Asynchronously send a rejection message and deconstruct self into it's original stream. The stream being returned is framed with the HttpServerCodec since that was used to send the rejection message.

fn reject_with(self, headers: &Headers) -> Send<Framed<S, HttpServerCodec>>

Asynchronously send a rejection message with custom headers and deconstruct self into it's original stream. The stream being returned is framed with the HttpServerCodec since that was used to send the rejection message.

impl<S> WsUpgrade<S, Option<Buffer>> where
    S: Stream, 

These methods are the synchronous ways of accepting and rejecting a websocket handshake.

fn accept(self) -> Result<Client<S>, (S, Error)>

Accept the handshake request and send a response, if nothing goes wrong a client will be created.

fn accept_with(self, custom_headers: &Headers) -> Result<Client<S>, (S, Error)>

Accept the handshake request and send a response while adding on a few headers. These headers are added before the required headers are, so some might be overwritten.

fn reject(self) -> Result<S, (S, Error)>

Reject the client's request to make a websocket connection.

fn reject_with(self, headers: &Headers) -> Result<S, (S, Error)>

Reject the client's request to make a websocket connection and send extra headers.

impl<S, B> WsUpgrade<S, B> where
    S: Stream + AsTcpStream, 

fn tcp_stream(&self) -> &TcpStream

Get a handle to the underlying TCP stream, useful to be able to set TCP options, etc.

impl<S, B> WsUpgrade<S, B> where
    S: Stream, 

fn use_protocol<P>(self, protocol: P) -> Self where
    P: Into<String>, 

Select a protocol to use in the handshake response.

fn use_extension(self, extension: Extension) -> Self

Select an extension to use in the handshake response.

fn use_extensions<I>(self, extensions: I) -> Self where
    I: IntoIterator<Item = Extension>, 

Select multiple extensions to use in the connection

fn drop(self)

Drop the connection without saying anything.

fn protocols(&self) -> &[String]

A list of protocols requested from the client.

fn extensions(&self) -> &[Extension]

A list of extensions requested from the client.

fn key(&self) -> Option<&[u8; 16]>

The client's websocket accept key.

fn version(&self) -> Option<&WebSocketVersion>

The client's websocket version.

fn origin(&self) -> Option<&str>

Origin of the client