Struct websocket::server::upgrade::sync::HyperRequest

pub struct HyperRequest<'a, 'b: 'a>(pub Request<'a, 'b>);

Upgrade a hyper connection to a websocket one.

A hyper request is implicitly defined as a stream from other impls of Stream. Until trait impl specialization comes along, we use this struct to differentiate a hyper request (which already has parsed headers) from a normal stream.

Using this method, one can start a hyper server and check if each request is a websocket upgrade request, if so you can use websockets and hyper on the same port!

use hyper::server::{Server, Request, Response};
use websocket::Message;
use websocket::sync::server::upgrade::IntoWs;
use websocket::sync::server::upgrade::HyperRequest;

Server::http("0.0.0.0:80").unwrap().handle(move |req: Request, res: Response| {
    match HyperRequest(req).into_ws() {
        Ok(upgrade) => {
            // `accept` sends a successful handshake, no need to worry about res
            let mut client = match upgrade.accept() {
                Ok(c) => c,
                Err(_) => panic!(),
            };

            client.send_message(&Message::text("its free real estate"));
        },

        Err((request, err)) => {
            // continue using the request as normal, "echo uri"
            res.send(b"Try connecting over ws instead.").unwrap();
        },
    };
})
.unwrap();

Trait Implementations

impl<'a, 'b> IntoWs for HyperRequest<'a, 'b>

type Stream = &'a mut &'b mut dyn NetworkStream

The type of stream this upgrade process is working with (TcpStream, etc.)

type Error = (Request<'a, 'b>, HyperIntoWsError)

An error value in case the stream is not asking for a websocket connection or something went wrong. It is common to also include the stream here.

fn into_ws(self) -> Result<Upgrade<Self::Stream>, Self::Error>

Attempt to parse the start of a Websocket handshake, later with the returned WsUpgrade struct, call accept to start a websocket client, and reject to send a handshake rejection response.