Struct ws_stream_tungstenite::WsStream

pub struct WsStream<S: AsyncRead01 + AsyncWrite01> { /* fields omitted */ }

Takes a WebSocketStream from tokio-tungstenite and implements futures 0.3 AsyncRead/AsyncWrite. Please look at the documentation of the impls for those traits below for details (rustdoc will collapse them).

Methods

impl<S: AsyncRead01 + AsyncWrite01> WsStream<S>

pub fn new(inner: TTungSocket<S>) -> Self

Create a new WsStream.

Trait Implementations

impl<S: AsyncRead01 + AsyncWrite01> Debug for WsStream<S>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<S: AsyncRead01 + AsyncWrite01> AsyncWrite for WsStream<S>

Errors

The following errors can be returned when writing to the stream:

• io::ErrorKind::NotConnected: This means that the connection is already closed. You should drop it. It is safe to drop the underlying connection.

• io::ErrorKind::InvalidData: This means that a tungstenite::error::Capacity occurred. This means that you send in a buffer bigger than the maximum message size configured on the underlying websocket connection. If you did not set it manually, the default for tungstenite is 64MB.

• other std::io::Error's generally mean something went wrong on the underlying transport. Consider these fatal and just drop the connection.

fn poll_write(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &[u8]
) -> Poll<Result<usize>>

Will always flush the underlying socket. Will always create an entire Websocket message from every write, so call with a sufficiently large buffer if you have performance problems.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

Attempt to close the object.

fn poll_write_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context,
    bufs: &[IoSlice]
) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<S: AsyncRead01 + AsyncWrite01> AsyncRead for WsStream<S>

When None is returned, it means it is safe to drop the underlying connection.

Errors

The following errors can be returned from this method:

• io::ErrorKind::InvalidData: This means that a protocol error was encountered (eg. the remote did something wrong) Protocol error here means either against the websocket protocol or sending websocket Text messages which don't make sense for AsyncRead/AsyncWrite. When these happen, we start the close handshake for the connection, notifying the remote that they made a protocol violation. You should not drop the connection and keep polling this stream until it returns None. That allows tungstenite to properly handle shutting down the connection. Until the remote confirms the close, we might still receive incoming data and it will be passed on to you. In production code you probably want to stop polling this after a timeout if the remote doesn't acknowledge the close.

• other std::io::Error's generally mean something went wrong on the underlying transport. Consider these fatal and just drop the connection.

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &mut [u8]
) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf.

unsafe fn initializer(&self) -> Initializer

Determines if this AsyncReader can work with buffers of uninitialized memory.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context,
    bufs: &mut [IoSliceMut]
) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.