Struct ClientBuilder 

pub struct ClientBuilder<S: AppState> { /* private fields */ }

Implementations

impl<S: AppState> ClientBuilder<S>

pub fn new(connector: impl Connector<S> + 'static, state: S) -> Self

Creates a new builder with the essential components.

Examples found in repository

examples/echo_client.rs (line 298)

    pub async fn new(url: String) -> CoreResult<Self> {
        // Use a simple connector (implement your own if needed)
        let connector = DummyConnector::new(url);

        let mut builder = ClientBuilder::new(connector, ());
        builder =
            builder.with_lightweight_handler(|msg, state, _| Box::pin(print_handler(msg, state)));
        let (client, mut runner) = builder
            .with_module::<EchoModule>()
            .with_module::<StreamModule>()
            .with_module::<PeriodicSenderModule>()
            .build()
            .await?;

        // let echo_handle = client.get_handle::<EchoModule>().await.unwrap();
        // let stream_handle = client.get_handle::<StreamModule>().await.unwrap();

        // Start runner in background
        let _runner = tokio::spawn(async move { runner.run().await });

        Ok(Self { client, _runner })
    }

examples/middleware_example.rs (line 227)

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(())
}

examples/testing_echo_client.rs (line 127)

    pub async fn new(url: String) -> CoreResult<Self> {
        let connector = DummyConnector::new(url);

        let builder = ClientBuilder::new(connector, ()).with_module::<EchoModule>();

        // // Create testing wrapper with custom configuration
        // let testing_config = TestingConfig {
        //     stats_interval: Duration::from_secs(10), // Log stats every 10 seconds
        //     log_stats: true,
        //     track_events: true,
        //     max_reconnect_attempts: Some(3),
        //     reconnect_delay: Duration::from_secs(5),
        //     connection_timeout: Duration::from_secs(30),
        //     auto_reconnect: true,
        // };

        let testing_wrapper = TestingWrapperBuilder::new()
            .with_stats_interval(Duration::from_secs(10))
            .with_log_stats(true)
            .with_track_events(true)
            .with_max_reconnect_attempts(Some(3))
            .with_reconnect_delay(Duration::from_secs(5))
            .with_connection_timeout(Duration::from_secs(30))
            .with_auto_reconnect(true)
            .build_with_middleware(builder)
            .await?;

        Ok(Self { testing_wrapper })
    }

pub fn on_connect( self, callback: impl Fn(Arc<S>, &AsyncSender<Message>) -> BoxFuture<'static, CoreResult<()>> + Send + Sync + 'static, ) -> Self

Sets the callback for the initial connection.

pub fn on_reconnect( self, callback: Box<dyn ReconnectCallback<S> + Send + Sync + 'static>, ) -> Self

Sets the callback for subsequent reconnections.

pub fn with_lightweight_handler( self, handler: impl Fn(Arc<Message>, Arc<S>, &AsyncSender<Message>) -> BoxFuture<'static, CoreResult<()>> + Send + Sync + 'static, ) -> Self

Adds a lightweight handler that receives all messages.

Examples found in repository

examples/echo_client.rs (line 300)

    pub async fn new(url: String) -> CoreResult<Self> {
        // Use a simple connector (implement your own if needed)
        let connector = DummyConnector::new(url);

        let mut builder = ClientBuilder::new(connector, ());
        builder =
            builder.with_lightweight_handler(|msg, state, _| Box::pin(print_handler(msg, state)));
        let (client, mut runner) = builder
            .with_module::<EchoModule>()
            .with_module::<StreamModule>()
            .with_module::<PeriodicSenderModule>()
            .build()
            .await?;

        // let echo_handle = client.get_handle::<EchoModule>().await.unwrap();
        // let stream_handle = client.get_handle::<StreamModule>().await.unwrap();

        // Start runner in background
        let _runner = tokio::spawn(async move { runner.run().await });

        Ok(Self { client, _runner })
    }

pub fn with_lightweight_module<M: LightweightModule<S>>(self) -> Self

Registers a lightweight module

pub fn with_module<M: ApiModule<S>>(self) -> Self

Registers a full API module with the client.

Examples found in repository

examples/echo_client.rs (line 302)

    pub async fn new(url: String) -> CoreResult<Self> {
        // Use a simple connector (implement your own if needed)
        let connector = DummyConnector::new(url);

        let mut builder = ClientBuilder::new(connector, ());
        builder =
            builder.with_lightweight_handler(|msg, state, _| Box::pin(print_handler(msg, state)));
        let (client, mut runner) = builder
            .with_module::<EchoModule>()
            .with_module::<StreamModule>()
            .with_module::<PeriodicSenderModule>()
            .build()
            .await?;

        // let echo_handle = client.get_handle::<EchoModule>().await.unwrap();
        // let stream_handle = client.get_handle::<StreamModule>().await.unwrap();

        // Start runner in background
        let _runner = tokio::spawn(async move { runner.run().await });

        Ok(Self { client, _runner })
    }

examples/middleware_example.rs (line 230)

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(())
}

examples/testing_echo_client.rs (line 127)

    pub async fn new(url: String) -> CoreResult<Self> {
        let connector = DummyConnector::new(url);

        let builder = ClientBuilder::new(connector, ()).with_module::<EchoModule>();

        // // Create testing wrapper with custom configuration
        // let testing_config = TestingConfig {
        //     stats_interval: Duration::from_secs(10), // Log stats every 10 seconds
        //     log_stats: true,
        //     track_events: true,
        //     max_reconnect_attempts: Some(3),
        //     reconnect_delay: Duration::from_secs(5),
        //     connection_timeout: Duration::from_secs(30),
        //     auto_reconnect: true,
        // };

        let testing_wrapper = TestingWrapperBuilder::new()
            .with_stats_interval(Duration::from_secs(10))
            .with_log_stats(true)
            .with_track_events(true)
            .with_max_reconnect_attempts(Some(3))
            .with_reconnect_delay(Duration::from_secs(5))
            .with_connection_timeout(Duration::from_secs(30))
            .with_auto_reconnect(true)
            .build_with_middleware(builder)
            .await?;

        Ok(Self { testing_wrapper })
    }

pub fn with_middleware( self, middleware: Box<dyn WebSocketMiddleware<S>>, ) -> Self

Adds a middleware layer to the client.

Middleware will be executed in the order they are added. They will be called for all WebSocket messages sent and received.

Example

let builder = ClientBuilder::new(MyConnector, MyState)
    .with_middleware(Box::new(MyMiddleware));

Examples found in repository

examples/middleware_example.rs (line 228)

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 fn with_middleware_layers( self, middleware: Vec<Box<dyn WebSocketMiddleware<S>>>, ) -> Self

Adds multiple middleware layers at once.

This is a convenience method for adding multiple middleware layers.

Example

let builder = ClientBuilder::new(MyConnector, MyState)
    .with_middleware_layers(vec![
        Box::new(MyMiddleware),
        Box::new(MyMiddleware),
    ]);

pub fn with_middleware_stack(self, stack: MiddlewareStack<S>) -> Self

Applies a middleware stack to the client.

This replaces any existing middleware with the provided stack.

Example

let mut stack = MiddlewareStack::new();
stack.add_layer(Box::new(MyMiddleware));

let builder = ClientBuilder::new(MyConnector, MyState)
    .with_middleware_stack(stack);

pub fn with_max_allowed_loops(self, max_allowed_loops: u32) -> Self

Sets the maximum number of reconnection attempts. 0 means infinite attempts.

pub fn with_reconnect_delay(self, reconnect_delay: Duration) -> Self

Sets the base delay for reconnection attempts.

pub async fn build(self) -> CoreResult<(Client<S>, ClientRunner<S>)>

Assembles and returns the final Client handle and its ClientRunner.

Examples found in repository

examples/echo_client.rs (line 305)

    pub async fn new(url: String) -> CoreResult<Self> {
        // Use a simple connector (implement your own if needed)
        let connector = DummyConnector::new(url);

        let mut builder = ClientBuilder::new(connector, ());
        builder =
            builder.with_lightweight_handler(|msg, state, _| Box::pin(print_handler(msg, state)));
        let (client, mut runner) = builder
            .with_module::<EchoModule>()
            .with_module::<StreamModule>()
            .with_module::<PeriodicSenderModule>()
            .build()
            .await?;

        // let echo_handle = client.get_handle::<EchoModule>().await.unwrap();
        // let stream_handle = client.get_handle::<StreamModule>().await.unwrap();

        // Start runner in background
        let _runner = tokio::spawn(async move { runner.run().await });

        Ok(Self { client, _runner })
    }

examples/middleware_example.rs (line 231)

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(())
}