Struct websocket::server::upgrade::WsUpgrade
[−]
[src]
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,
[src]
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,
[src]
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,
[src]
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,
[src]
S: Stream,
fn use_protocol<P>(self, protocol: P) -> Self where
P: Into<String>,
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>,
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