Struct Client 

pub struct Client<S: AppState> {
    pub signal: Signals,
    pub state: Arc<S>,
    pub module_handles: Arc<RwLock<HashMap<TypeId, Box<dyn Any + Send + Sync>>>>,
    pub to_ws_sender: AsyncSender<Message>,
    /* private fields */
}

Fields

signal: Signals

state: Arc<S>

The shared application state, which can be used by modules and handlers.

module_handles: Arc<RwLock<HashMap<TypeId, Box<dyn Any + Send + Sync>>>>

to_ws_sender: AsyncSender<Message>

Implementations

impl<S: AppState> Client<S>

pub fn new( signal: Signals, runner_command_tx: AsyncSender<RunnerCommand>, state: Arc<S>, sender: AsyncSender<Message>, ) -> Self

pub async fn wait_connected(&self)

Waits until the client is connected to the WebSocket server. This method will block until the connection is established. It is useful for ensuring that the client is ready to send and receive messages.

pub fn is_connected(&self) -> bool

Checks if the client is connected to the WebSocket server.

pub async fn get_handle<M: ApiModule<S>>(&self) -> Option<M::Handle>

Retrieves a clonable, typed handle to an already-registered module.

Examples found in repository

examples/echo_client.rs (line 318)

    pub async fn echo(&self, msg: String) -> CoreResult<String> {
        match self.client.get_handle::<EchoModule>().await {
            Some(echo_handle) => echo_handle.echo(msg).await,
            None => Err(CoreError::ModuleNotFound("EchoModule".to_string())),
        }
    }

    pub async fn stream(&self) -> CoreResult<impl Stream<Item = CoreResult<String>>> {
        let stream_handle = self.client.get_handle::<StreamModule>().await.unwrap();
        println!("Starting stream...");
        stream_handle.stream().await
    }

    pub async fn start(&self) -> CoreResult<()> {
        match self.client.get_handle::<PeriodicSenderModule>().await {
            Some(handle) => {
                handle.start().await;
                Ok(())
            }
            None => Err(CoreError::ModuleNotFound(
                stringify!(PeriodicSenderModule).to_string(),
            )),
        }
    }

examples/testing_echo_client.rs (line 167)

    pub async fn echo(&self, msg: String) -> CoreResult<String> {
        match self
            .testing_wrapper
            .client()
            .get_handle::<EchoModule>()
            .await
        {
            Some(echo_handle) => echo_handle.echo(msg).await,
            None => Err(CoreError::ModuleNotFound("EchoModule".to_string())),
        }
    }

pub async fn disconnect(&self) -> CoreResult<()>

Commands the runner to disconnect, clear state, and perform a “hard” reconnect.

pub async fn reconnect(&self) -> CoreResult<()>

Commands the runner to disconnect, and perform a “soft” reconnect.

pub async fn shutdown(self) -> CoreResult<()>

Commands the runner to shutdown, this action is final as the runner and client will stop working and will be dropped.

Examples found in repository

examples/middleware_example.rs (line 236)

async fn main() -> CoreResult<()> {
    // Initialize tracing
    tracing_subscriber::fmt::init();

    // Create statistics middleware
    let stats_middleware = Arc::new(StatisticsMiddleware::new());

    // Build the client with middleware
    let (client, _) = ClientBuilder::new(MockConnector, ExampleState)
        .with_middleware(Box::new(LoggingMiddleware))
        .with_middleware(Box::new(StatisticsMiddleware::new()))
        .with_module::<ExampleModule>()
        .build()
        .await?;

    info!("Client built with middleware layers");
    tokio::time::sleep(Duration::from_secs(10)).await;
    client.shutdown().await?;
    // In a real application, you would:
    // 1. Start the runner in a background task
    // 2. Use the client to send messages
    // 3. Check statistics periodically

    // For demonstration, we'll just show the statistics
    let stats = stats_middleware.get_stats();
    info!("Current statistics: {:?}", stats);

    Ok(())
}

pub async fn shutdown_ref(&self) -> CoreResult<()>

Commands the runner to shutdown without consuming the client.

pub async fn send_message(&self, message: Message) -> CoreResult<()>

Send a message to the WebSocket

pub async fn send_text(&self, text: String) -> CoreResult<()>

Send a text message to the WebSocket

pub async fn send_binary(&self, data: Vec<u8>) -> CoreResult<()>

Send a binary message to the WebSocket

Trait Implementations

impl<S: AppState> Clone for Client<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug + AppState> Debug for Client<S>

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

Formats the value using the given formatter.