Struct LoroWebsocketClient 

pub struct LoroWebsocketClient { /* private fields */ }

A higher-level WebSocket client that manages rooms and applies updates to a LoroDoc.

Implementations

impl LoroWebsocketClient

pub async fn connect(url: &str) -> Result<Self, ClientError>

Connect and spawn reader/writer tasks with default config.

Examples found in repository

examples/elo_index_client.rs (line 23)

async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Args: role receiver|sender, url, room
    let mut args = std::env::args().skip(1).collect::<Vec<_>>();
    if args.len() < 3 {
        eprintln!("usage: elo_index_client <receiver|sender> <ws_url> <room_id>");
        std::process::exit(2);
    }
    let role = args.remove(0);
    let url = args.remove(0);
    let room = args.remove(0);

    let client = LoroWebsocketClient::connect(&url).await?;
    let doc = Arc::new(tokio::sync::Mutex::new(LoroDoc::new()));

    match role.as_str() {
        "sender" => {
            // Prepare desired state before join so adaptor sends it as initial snapshot
            {
                let d = doc.lock().await;
                d.get_text("t").insert(0, "hi").unwrap();
                d.commit();
            }
            let _room = client
                .join_elo_with_adaptor(&room, doc.clone(), "k1".to_string(), KEY)
                .await?;
            // Allow time for the async writer and server broadcast to complete.
            // Align with JS wrapper's 800ms flush to avoid flakiness in cross-lang tests.
            sleep(Duration::from_millis(800)).await;
            Ok(())
        }
        "receiver" => {
            let _room = client
                .join_elo_with_adaptor(&room, doc.clone(), "k1".to_string(), KEY)
                .await?;
            // Poll document until expected content arrives
            let deadline = tokio::time::Instant::now() + Duration::from_secs(10);
            loop {
                {
                    let d = doc.lock().await;
                    let s = d.get_text("t").to_string();
                    if s == "hi" {
                        println!("INDEXED 1");
                        return Ok(());
                    }
                }
                if tokio::time::Instant::now() > deadline {
                    eprintln!("timeout waiting for content");
                    std::process::exit(1);
                }
                sleep(Duration::from_millis(50)).await;
            }
        }
        _ => {
            eprintln!("usage: elo_index_client <receiver|sender> <ws_url> <room_id>");
            std::process::exit(2);
        }
    }
}

pub async fn connect_with_config( url: &str, config: ClientConfig, ) -> Result<Self, ClientError>

Connect and spawn reader/writer tasks with custom config.

pub async fn join_loro( &self, room_id: &str, doc: Arc<Mutex<LoroDoc>>, ) -> Result<LoroWebsocketClientRoom, ClientError>

Join a Loro room for the given document. Returns a handle for sending updates.

pub fn ping(&self) -> Result<(), ClientError>

Send a keepalive ping.

pub async fn join_with_adaptor( &self, room_id: &str, adaptor: Box<dyn CrdtDocAdaptor + Send + Sync>, ) -> Result<LoroWebsocketClientRoom, ClientError>

Generic join with a CRDT adaptor. Returns a room handle.

pub async fn join_loro_with_adaptor( &self, room_id: &str, doc: Arc<Mutex<LoroDoc>>, ) -> Result<LoroWebsocketClientRoom, ClientError>

Convenience: join a Loro room using LoroDocAdaptor.

pub async fn join_elo_with_adaptor( &self, room_id: &str, doc: Arc<Mutex<LoroDoc>>, key_id: impl Into<String>, key: [u8; 32], ) -> Result<LoroWebsocketClientRoom, ClientError>

Convenience: join an %ELO room using EloDocAdaptor (AES-256-GCM key).

Examples found in repository

examples/elo_index_client.rs (line 35)

async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // Args: role receiver|sender, url, room
    let mut args = std::env::args().skip(1).collect::<Vec<_>>();
    if args.len() < 3 {
        eprintln!("usage: elo_index_client <receiver|sender> <ws_url> <room_id>");
        std::process::exit(2);
    }
    let role = args.remove(0);
    let url = args.remove(0);
    let room = args.remove(0);

    let client = LoroWebsocketClient::connect(&url).await?;
    let doc = Arc::new(tokio::sync::Mutex::new(LoroDoc::new()));

    match role.as_str() {
        "sender" => {
            // Prepare desired state before join so adaptor sends it as initial snapshot
            {
                let d = doc.lock().await;
                d.get_text("t").insert(0, "hi").unwrap();
                d.commit();
            }
            let _room = client
                .join_elo_with_adaptor(&room, doc.clone(), "k1".to_string(), KEY)
                .await?;
            // Allow time for the async writer and server broadcast to complete.
            // Align with JS wrapper's 800ms flush to avoid flakiness in cross-lang tests.
            sleep(Duration::from_millis(800)).await;
            Ok(())
        }
        "receiver" => {
            let _room = client
                .join_elo_with_adaptor(&room, doc.clone(), "k1".to_string(), KEY)
                .await?;
            // Poll document until expected content arrives
            let deadline = tokio::time::Instant::now() + Duration::from_secs(10);
            loop {
                {
                    let d = doc.lock().await;
                    let s = d.get_text("t").to_string();
                    if s == "hi" {
                        println!("INDEXED 1");
                        return Ok(());
                    }
                }
                if tokio::time::Instant::now() > deadline {
                    eprintln!("timeout waiting for content");
                    std::process::exit(1);
                }
                sleep(Duration::from_millis(50)).await;
            }
        }
        _ => {
            eprintln!("usage: elo_index_client <receiver|sender> <ws_url> <room_id>");
            std::process::exit(2);
        }
    }
}

Trait Implementations

impl Clone for LoroWebsocketClient

fn clone(&self) -> LoroWebsocketClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.