Struct meio_connect::client::WsClient

pub struct WsClient<P, A> where
    A: Actor,  { /* fields omitted */ }

The client to connect to a WebSocket server.

It’s a LiteTask attached to an Actor that recieves incoming messages and a WsSender instance and uses it send outgoing messages back to a server.

Implementations

impl<P, A> WsClient<P, A> where
    P: Protocol,
    A: Actor + InstantActionHandler<WsClientStatus<P>> + ActionHandler<WsIncoming<P::ToClient>>, 

pub fn new(
    url: String,
    repeat_interval: Option<Duration>,
    address: Address<A>
) -> Self

Created a new client.

The client connects to url, but if connection failed it retries to connect in repeat_interval. When connection espablished it send incoming data to an actor using the address.

Trait Implementations

impl<P, A> LiteTask for WsClient<P, A> where
    P: Protocol,
    A: Actor + InstantActionHandler<WsClientStatus<P>> + ActionHandler<WsIncoming<P::ToClient>>, 

type Output = ()

The result of a finished task.

fn log_target(&self) -> &str

The log target for the LiteTask.

fn routine<'async_trait>(
    self,
    stop: StopReceiver
) -> Pin<Box<dyn Future<Output = Result<Self::Output, Error>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Routine of the task that can contain loops. It can taks into accout provided receiver to implement graceful interruption.

fn interruptable_routine<'async_trait>(
    self
) -> Pin<Box<dyn Future<Output = Result<Self::Output, Error>> + Send + 'async_trait, Global>> where
    Self: 'async_trait, 

Routine that can be unconditionally interrupted.

fn pre_repeatable_routine<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Called before repeatable_routine for initialization. The routine will be interrupted if this method failed.

fn repeatable_routine<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Option<Self::Output>, Error>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Routine that will be repeated till fail or success.

fn routine_wait<'life0, 'async_trait>(
    &'life0 mut self,
    _last_attempt: Instant,
    _succeed: bool
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Check of the every intaration of a routine.