From b125ee3a6fde7bfcbec34fc8257e86e1bf35fca3 Mon Sep 17 00:00:00 2001 From: Petra Date: Sat, 14 Nov 2026 20:40:13 -0500 Subject: [PATCH] fix(rust): retry join_loro with an empty version on VersionUnknown join_loro returned an error as soon as the receiver answered VersionUnknown, so a plain Loro doc could not rejoin a receiver that no longer recognises its version. Rejoin once with an empty version, as join_with_adaptor and the TS client already do. Refs #16 --- rust/loro-websocket-client/src/lib.rs | 42 +++-- .../tests/join_version_unknown.rs | 172 ++++++++++++++++++ 2 files changed, 198 insertions(+), 16 deletions(-) create mode 100644 rust/loro-websocket-client/tests/join_version_unknown.rs diff --git a/rust/loro-websocket-client/src/lib.rs b/rust/loro-websocket-client/src/lib.rs index fe84dbe..f4940a8 100644 --- a/rust/loro-websocket-client/src/lib.rs +++ b/rust/loro-websocket-client/src/lib.rs @@ -771,24 +771,34 @@ impl LoroWebsocketClient { }, ); - let (tx_done, rx_done) = oneshot::channel::(); - self.pending.lock().await.insert(key.clone(), tx_done); + // Send join with local version/auth. If the receiver cannot interpret + // that version, rejoin once with an empty version, as + // `join_with_adaptor` does. + let mut version = doc.lock().await.oplog_vv().encode(); + let outcome = loop { + let (tx_done, rx_done) = oneshot::channel::(); + self.pending.lock().await.insert(key.clone(), tx_done); + let msg = ProtocolMessage::JoinRequest { + crdt: CrdtType::Loro, + room_id: key.room.clone(), + auth: Vec::new(), + version: version.clone(), + }; + let data = encode(&msg).map_err(ClientError::Protocol)?; + self.tx + .send(Message::Binary(data.into())) + .map_err(|_| ClientError::Protocol("send failed".into()))?; - // Send join with local version/auth - let local_version = doc.lock().await.oplog_vv().encode(); - let msg = ProtocolMessage::JoinRequest { - crdt: CrdtType::Loro, - room_id: key.room.clone(), - auth: Vec::new(), - version: local_version, + // Await join result + match rx_done.await { + Ok(JoinOutcome::Err { + code: protocol::JoinErrorCode::VersionUnknown, + .. + }) if !version.is_empty() => version = Vec::new(), + outcome => break outcome, + } }; - let data = encode(&msg).map_err(ClientError::Protocol)?; - self.tx - .send(Message::Binary(data.into())) - .map_err(|_| ClientError::Protocol("send failed".into()))?; - - // Await join result - match rx_done.await { + match outcome { Ok(JoinOutcome::Ok { permission, .. }) => { // Only subscribe to local updates if we have write permission if matches!(permission, protocol::Permission::Write) { diff --git a/rust/loro-websocket-client/tests/join_version_unknown.rs b/rust/loro-websocket-client/tests/join_version_unknown.rs new file mode 100644 index 0000000..e357e0c --- /dev/null +++ b/rust/loro-websocket-client/tests/join_version_unknown.rs @@ -0,0 +1,172 @@ +//! loro-dev/protocol#16: when the receiver cannot interpret the joining +//! version, `join_loro` should rejoin with an empty version, as +//! `join_with_adaptor` already does, instead of failing the join. + +use futures_util::{SinkExt, StreamExt}; +use loro::{ExportMode, LoroDoc}; +use loro_protocol::{decode, encode, BatchId, JoinErrorCode, Permission, ProtocolMessage}; +use loro_websocket_client::LoroWebsocketClient; +use std::sync::Arc; +use tokio::net::TcpListener; +use tokio::sync::Mutex; +use tokio_tungstenite::tungstenite::Message; + +/// Serves one connection. A join with a non-empty version gets +/// `VersionUnknown`; a join with an empty version gets `JoinResponseOk` +/// followed by the receiver's whole history. Returns the join versions seen. +async fn serve_one(listener: TcpListener, server_doc: LoroDoc, max_joins: usize) -> Vec> { + let (stream, _) = listener.accept().await.unwrap(); + let mut ws = tokio_tungstenite::accept_async(stream).await.unwrap(); + let mut joins = Vec::new(); + while joins.len() < max_joins { + let Some(Ok(Message::Binary(data))) = ws.next().await else { + break; + }; + let ProtocolMessage::JoinRequest { + crdt, + room_id, + version, + .. + } = decode(&data).unwrap() + else { + continue; + }; + joins.push(version.clone()); + let server_version = server_doc.oplog_vv().encode(); + let replies = if version.is_empty() { + vec![ + ProtocolMessage::JoinResponseOk { + crdt, + room_id: room_id.clone(), + permission: Permission::Write, + version: server_version, + extra: None, + }, + ProtocolMessage::DocUpdate { + crdt, + room_id, + updates: vec![server_doc.export(ExportMode::all_updates()).unwrap()], + batch_id: BatchId([0; 8]), + }, + ] + } else { + vec![ProtocolMessage::JoinError { + crdt, + room_id, + code: JoinErrorCode::VersionUnknown, + message: "version unknown".into(), + receiver_version: Some(server_version), + app_code: None, + }] + }; + for reply in replies { + ws.send(Message::Binary(encode(&reply).unwrap().into())) + .await + .unwrap(); + } + } + joins +} + +#[tokio::test(flavor = "current_thread")] +async fn join_loro_rejoins_with_empty_version_on_version_unknown() { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let addr = listener.local_addr().unwrap(); + let server_doc = LoroDoc::new(); + server_doc + .get_text("text") + .insert(0, "from server") + .unwrap(); + server_doc.commit(); + let server = tokio::spawn(serve_one(listener, server_doc, 2)); + + let client = LoroWebsocketClient::connect(&format!("ws://{addr}/")) + .await + .unwrap(); + let doc = LoroDoc::new(); + doc.get_text("local").insert(0, "local edit").unwrap(); + doc.commit(); + let doc = Arc::new(Mutex::new(doc)); + let joined = tokio::time::timeout( + std::time::Duration::from_secs(5), + client.join_loro("room", doc.clone()), + ) + .await + .expect("join timed out"); + assert!(joined.is_ok(), "join failed: {:?}", joined.err()); + + let joins = server.await.unwrap(); + assert_eq!(joins.len(), 2); + assert!(!joins[0].is_empty()); + assert!(joins[1].is_empty()); + + // The history sent after the rejoin is imported into the joined doc. + tokio::time::timeout(std::time::Duration::from_secs(5), async { + loop { + if doc.lock().await.get_text("text").to_string() == "from server" { + break; + } + tokio::time::sleep(std::time::Duration::from_millis(10)).await; + } + }) + .await + .expect("server history was not imported"); + assert_eq!(doc.lock().await.get_text("local").to_string(), "local edit"); +} + +#[tokio::test(flavor = "current_thread")] +async fn join_loro_fails_if_empty_version_is_also_unknown() { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let addr = listener.local_addr().unwrap(); + // This receiver answers every join, including the empty one, with + // VersionUnknown, so the client must give up after one fallback. + let joins = Arc::new(std::sync::Mutex::new(Vec::>::new())); + let seen = joins.clone(); + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut ws = tokio_tungstenite::accept_async(stream).await.unwrap(); + while let Some(Ok(Message::Binary(data))) = ws.next().await { + if let ProtocolMessage::JoinRequest { + crdt, + room_id, + version, + .. + } = decode(&data).unwrap() + { + seen.lock().unwrap().push(version); + let reply = ProtocolMessage::JoinError { + crdt, + room_id, + code: JoinErrorCode::VersionUnknown, + message: "version unknown".into(), + receiver_version: None, + app_code: None, + }; + ws.send(Message::Binary(encode(&reply).unwrap().into())) + .await + .unwrap(); + } + } + }); + + let client = LoroWebsocketClient::connect(&format!("ws://{addr}/")) + .await + .unwrap(); + let doc = LoroDoc::new(); + doc.get_text("local").insert(0, "local edit").unwrap(); + doc.commit(); + let res = tokio::time::timeout( + std::time::Duration::from_secs(5), + client.join_loro("room", Arc::new(Mutex::new(doc))), + ) + .await + .expect("join timed out"); + assert!(res.is_err()); + // Give a third join, which must not be sent, time to arrive. + tokio::time::sleep(std::time::Duration::from_millis(100)).await; + let joins = joins.lock().unwrap().clone(); + assert_eq!(joins.len(), 2, "{joins:?}"); + assert!(!joins[0].is_empty()); + assert!(joins[1].is_empty()); + server.abort(); +}