Struct Socket

pub struct Socket<D>
where
    D: Default + Send + Sync + 'static,
{
    pub id: Sid,
    pub protocol: ProtocolVersion,
    pub data: D,
    pub req_parts: Parts,
    /* private fields */
}

A Socket represents a client connection to the server. It is agnostic to the TransportType.

It handles :

• the packet communication between with the Engine and the user defined Handler.
• the user defined Data bound to the socket.
• the heartbeat job that verify that the connection is still up by sending packets periodically.

Fields

id: Sid

The socket id

protocol: ProtocolVersion

The protocol version used by the socket

data: D

User data bound to the socket

req_parts: Parts

Http Request data used to create a socket

Implementations

impl<D> Socket<D>

where D: Default + Send + Sync + 'static,

pub fn transport_type(&self) -> TransportType

Returns the current TransportType of the Socket

pub fn reserve(&self) -> Result<Permit<'_>, TrySendError<()>>

Reserve n permits to emit multiple messages and ensure that there is enough space in the internal chan.

If the internal chan is full, the function will return a TrySendError::Full error. If the socket is closed, the function will return a TrySendError::Closed error.

pub fn emit(&self, msg: impl Into<Str>) -> Result<(), TrySendError<Str>>

Emits a message to the client.

If the transport is in websocket mode, the message is directly sent as a text frame.

If the transport is in polling mode, the message is buffered and sent as a text frame to the next polling request.

⚠️ If the buffer is full or the socket is disconnected, an error will be returned with the original data

pub fn close(&self, reason: DisconnectReason)

Immediately closes the socket and the underlying connection. The socket will be removed from the Engine and the Handler will be notified.

pub fn is_closed(&self) -> bool

Returns true if the socket is closed It means that no more packets can be sent to the client

pub async fn closed(&self)

Wait for the socket to be fully closed

pub fn emit_binary<B: Into<Bytes>>( &self, data: B, ) -> Result<(), TrySendError<Bytes>>

Emits a binary message to the client.

If the transport is in websocket mode, the message is directly sent as a binary frame.

If the transport is in polling mode, the message is buffered and sent as a text frame encoded in base64 to the next polling request.

⚠️ If the buffer is full or the socket is disconnected, an error will be returned with the original data

Trait Implementations

impl<D: Default + Send + Sync + 'static> Debug for Socket<D>

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

Formats the value using the given formatter.