Struct WebsocketContext

pub struct WebsocketContext<A>
where
    A: Actor<Context = WebsocketContext<A>>,
{ /* private fields */ }

Execution context for WebSockets actors

Implementations

impl<A> WebsocketContext<A>

where A: Actor<Context = Self>,

pub fn create<S>( actor: A, stream: S, ) -> impl Stream<Item = Result<Bytes, Error>>

where A: StreamHandler<Result<Message, ProtocolError>>, S: Stream<Item = Result<Bytes, PayloadError>> + 'static,

Create a new Websocket context from a request and an actor.

pub fn create_with_addr<S>( actor: A, stream: S, ) -> (Addr<A>, impl Stream<Item = Result<Bytes, Error>>)

where A: StreamHandler<Result<Message, ProtocolError>>, S: Stream<Item = Result<Bytes, PayloadError>> + 'static,

Create a new Websocket context from a request and an actor.

Returns a pair, where the first item is an addr for the created actor, and the second item is a stream intended to be set as part of the response via HttpResponseBuilder::streaming().

pub fn with_codec<S>( actor: A, stream: S, codec: Codec, ) -> impl Stream<Item = Result<Bytes, Error>>

where A: StreamHandler<Result<Message, ProtocolError>>, S: Stream<Item = Result<Bytes, PayloadError>> + 'static,

Create a new Websocket context from a request, an actor, and a codec

pub fn with_factory<S, F>( stream: S, f: F, ) -> impl Stream<Item = Result<Bytes, Error>>

where F: FnOnce(&mut Self) -> A + 'static, A: StreamHandler<Result<Message, ProtocolError>>, S: Stream<Item = Result<Bytes, PayloadError>> + 'static,

Create a new Websocket context

impl<A> WebsocketContext<A>

where A: Actor<Context = Self>,

pub fn write_raw(&mut self, msg: Message)

Write payload

This is a low-level function that accepts framed messages that should be created using Frame::message(). If you want to send text or binary data you should prefer the text() or binary() convenience functions that handle the framing for you.

pub fn text(&mut self, text: impl Into<ByteString>)

Send text frame

pub fn binary(&mut self, data: impl Into<Bytes>)

Send binary frame

pub fn ping(&mut self, message: &[u8])

Send ping frame

pub fn pong(&mut self, message: &[u8])

Send pong frame

pub fn close(&mut self, reason: Option<CloseReason>)

Send close frame

pub fn handle(&self) -> SpawnHandle

Handle of the running future

SpawnHandle is the handle returned by AsyncContext::spawn() method.

pub fn set_mailbox_capacity(&mut self, cap: usize)

Set mailbox capacity

By default mailbox capacity is 16 messages.

Trait Implementations

impl<A> ActorContext for WebsocketContext<A>

where A: Actor<Context = Self>,

fn stop(&mut self)

Immediately stop processing incoming messages and switch to a stopping state. This only affects actors that are currently running. Future attempts to queue messages will fail.

fn terminate(&mut self)

Terminate actor execution unconditionally. This sets the actor into the stopped state. This causes future attempts to queue messages to fail.

fn state(&self) -> ActorState

Retrieve the current Actor execution state.

impl<A> AsyncContext<A> for WebsocketContext<A>

where A: Actor<Context = Self>,

fn spawn<F>(&mut self, fut: F) -> SpawnHandle

where F: ActorFuture<A, Output = ()> + 'static,

Spawns a future into the context.

fn wait<F>(&mut self, fut: F)

where F: ActorFuture<A, Output = ()> + 'static,

Spawns a future into the context, waiting for it to resolve.

fn cancel_future(&mut self, handle: SpawnHandle) -> bool

Cancels a spawned future.

fn address(&self) -> Addr<A>

Returns the address of the context.

fn waiting(&self) -> bool

Checks if the context is paused (waiting for future completion or stopping).

fn add_stream<S>(&mut self, fut: S) -> SpawnHandle

where S: Stream + 'static, A: StreamHandler<<S as Stream>::Item>,

Registers a stream with the context.

fn add_message_stream<S>(&mut self, fut: S)

where S: Stream + 'static, <S as Stream>::Item: Message, A: Handler<<S as Stream>::Item>,

Registers a stream with the context, ignoring errors.

fn notify<M>(&mut self, msg: M)

where A: Handler<M>, M: Message + 'static,

Sends the message msg to self. This bypasses the mailbox capacity, and will always queue the message. If the actor is in the stopped state, an error will be raised.

fn notify_later<M>(&mut self, msg: M, after: Duration) -> SpawnHandle

where A: Handler<M>, M: Message + 'static,

Sends the message msg to self after a specified period of time.

fn run_later<F>(&mut self, dur: Duration, f: F) -> SpawnHandle

where F: FnOnce(&mut A, &mut <A as Actor>::Context) + 'static,

Executes a closure after a specified period of time.

fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandle

where F: FnMut(&mut A, &mut <A as Actor>::Context) + 'static,

Spawns a job to execute the given closure periodically, at a specified fixed interval.

fn run_interval_at<F>( &mut self, start: Instant, interval: Duration, task: F, ) -> SpawnHandle

where F: FnMut(&mut A, &mut <A as Actor>::Context) + 'static,

Spawns a periodic task function to begin executing at the given start time, and with the given interval duration.

impl<A> AsyncContextParts<A> for WebsocketContext<A>

where A: Actor<Context = Self>,

fn parts(&mut self) -> &mut ContextParts<A>

impl<A, M> ToEnvelope<A, M> for WebsocketContext<A>

where A: Actor<Context = WebsocketContext<A>> + Handler<M>, M: ActixMessage + Send + 'static, M::Result: Send,

fn pack(msg: M, tx: Option<Sender<M::Result>>) -> Envelope<A>

Pack message into suitable envelope