Show the crate…
2 unstable releases
0.4.2 | Mar 3, 2021 |
---|---|
0.0.0 | Mar 3, 2021 |
#484 in #client-server
105KB
2K
SLoC
Soket
An implementation of the RFC 6455 websocket protocol. This crate is a heavily modified fork of the twist crate.
lib.rs
:
An implementation of the RFC 6455 websocket protocol.
To begin a websocket connection one first needs to perform a handshake, either as client or server, in order to upgrade from HTTP. Once successful, the client or server can transition to a connection, i.e. a Sender/Receiver pair and send and receive textual or binary data.
Note: While it is possible to only receive websocket messages it is
not possible to only send websocket messages. Receiving data is required
in order to react to control frames such as PING or CLOSE. While those will be
answered transparently they have to be received in the first place, so
calling connection::Receiver::receive
is imperative.
Note: None of the async
methods are safe to cancel so their Future
s
must not be dropped unless they return Poll::Ready
.
Client example
use soket::handshake::{Client, ServerResponse};
// First, we need to establish a TCP connection.
let socket = tokio::net::TcpStream::connect("...").await?;
// Then we configure the client handshake.
let mut client = Client::new(socket.compat(), "...", "/");
// And finally we perform the handshake and handle the result.
let (mut sender, mut receiver) = match client.handshake().await? {
ServerResponse::Accepted { .. } => client.into_builder().finish(),
ServerResponse::Redirect { status_code, location } => unimplemented!("follow location URL"),
ServerResponse::Rejected { status_code } => unimplemented!("handle failure")
};
// Over the established websocket connection we can send
sender.send_text("some text").await?;
sender.send_text("some more text").await?;
sender.flush().await?;
// ... and receive data.
let mut data = Vec::new();
receiver.receive_data(&mut data).await?;
Server example
use soket::{handshake::{Server, ClientRequest, server::Response}};
// First, we listen for incoming connections.
let mut listener = tokio::net::TcpListener::bind("...").await?;
let mut incoming = listener.incoming();
while let Some(socket) = incoming.next().await {
// For each incoming connection we perform a handshake.
let mut server = Server::new(socket?.compat());
let websocket_key = {
let req = server.receive_request().await?;
req.into_key()
};
// Here we accept the client unconditionally.
let accept = Response::Accept { key: &websocket_key, protocol: None };
server.send_response(&accept).await?;
// And we can finally transition to a websocket connection.
let (mut sender, mut receiver) = server.into_builder().finish();
let mut data = Vec::new();
let data_type = receiver.receive_data(&mut data).await?;
if data_type.is_text() {
sender.send_text(std::str::from_utf8(&data)?).await?
} else {
sender.send_binary(&data).await?
}
sender.close().await?
}
Dependencies
~3–4MB
~78K SLoC