1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

use crate::{ import::*, WsErr };


/// Events that can happen on the websocket. These are returned through the stream you can obtain
/// from `WsStream::observe`. These include close, ping and pong events which can not be returned
/// through AsyncRead/AsyncWrite, and non-fatal errors.
//
#[ derive( Debug, Clone ) ]
//
pub enum WsEvent
{
	/// Non fatal error that happened on the websocket. Non-fatal here doesn't mean the websocket is still
	/// usable, but at least is still usable enough to initiate a close handshake. If we bubble up errors
	/// through `AsyncRead`/`AsyncWrite`, codecs will always return `None` on subsequent polls, which would prevent
	/// from driving the close handshake to completion. Hence they are returned out of band.
	//
	Error( Arc<WsErr> ),

	/// We received a close frame from the remote. Just keep polling the stream. The close handshake will be
	/// completed for you. Once the stream returns `None`, you can drop the [`WsStream`](crate::WsStream).
	/// This is mainly useful in order to recover the close code and reason for debugging purposes.
	//
	CloseFrame( Option< CloseFrame<'static> > ),

	/// The remote sent a Ping message. It will automatically be answered as long as you keep polling the
	/// `AsyncRead`. This is returned as an event in case you want to analyze the payload, since only bytes
	/// from Binary websocket messages are passed through the `AsyncRead`.
	//
	Ping(Vec<u8>),

	/// The remote send us a Pong. Since we never send Pings, this is a unidirectional heartbeat.
	//
	Pong(Vec<u8>),

	/// The connection is closed. Polling `WsStream` will return `None` on read and `io::ErrorKind::NotConnected`
	/// on write soon. It's provided here for convenience so the task listening to these events know that
	/// the connection closed.
	/// You should not see any events after this one, so you can drop the Events stream.
	//
	Closed,
}