message saved if client crashes on retreival

This commit is contained in:
yves committed 2026-11-20 22:00:54 +01:00
1 parent 6d3ea3e2a6
commit 006bedc728
11 files changed
+591 -72

No files matched your search

+157
View File
@@ -180,3 +180,160 @@ async fn file_and_server_invitations_then_messaging() {
let _ = std::fs::remove_dir_all(&dir);
}
// ───────────── at-least-once delivery (roadmap lot 3.8) ─────────────
/// Memory store whose acknowledgements can be "lost" on demand.
struct FlakyStore {
inner: MemoryStore,
drop_acks: std::sync::atomic::AtomicBool,
}
#[async_trait::async_trait]
impl meow_server::store::ServerStore for FlakyStore {
async fn post(&self, mb: [u8; 32], payload: Vec<u8>, now: u64) -> meow_server::store::StoreResult<()> {
self.inner.post(mb, payload, now).await
}
async fn fetch(
&self,
mbs: &[[u8; 32]],
limit: usize,
) -> meow_server::store::StoreResult<Vec<meow_proto::v2::StoredMessage>> {
self.inner.fetch(mbs, limit).await
}
async fn ack(&self, mb: [u8; 32], ids: &[Vec<u8>]) -> meow_server::store::StoreResult<()> {
if self.drop_acks.load(std::sync::atomic::Ordering::SeqCst) {
return Ok(());
}
self.inner.ack(mb, ids).await
}
async fn mark_request(&self, id: &[u8], ttl: Duration) -> meow_server::store::StoreResult<bool> {
self.inner.mark_request(id, ttl).await
}
async fn put_invitation(
&self,
payload: Vec<u8>,
password: &str,
ttl: Duration,
code_len: usize,
) -> meow_server::store::StoreResult<String> {
self.inner.put_invitation(payload, password, ttl, code_len).await
}
async fn get_invitation(&self, code: &str, password: &str) -> meow_server::store::StoreResult<Vec<u8>> {
self.inner.get_invitation(code, password).await
}
}
/// What a client that crashed right after receiving the response would have done:
/// pull without ever acknowledging.
async fn raw_pull(
server: &meow_core::server::ServerInfo,
mailbox: &meow_crypto::SigningKeyPair,
) -> Vec<meow_proto::v2::StoredMessage> {
use meow_proto::v2::{self, request::Body as Req, response::Body as Resp};
let rid = meow_crypto::random_bytes::<16>().to_vec();
let ts = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs();
let req = v2::Request {
request_id: rid.clone(),
timestamp: ts,
body: Some(Req::Pull(v2::Pull {
auths: vec![meow_core::rpc::mailbox_auth(mailbox, server, &rid, vec![], ts)],
wait_seconds: 0,
})),
};
let t = meow_client::transport::Transport::new().unwrap();
match t.call_request(server, req, Duration::ZERO).await.unwrap() {
Resp::PullResult(p) => p.messages,
other => panic!("unexpected {other:?}"),
}
}
#[tokio::test(flavor = "multi_thread")]
async fn no_message_lost_when_the_client_dies() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!("http://{}", listener.local_addr().unwrap());
let keys = meow_core::server::ServerKeys::generate();
let (notify, _) = broadcast::channel(1024);
let store = Arc::new(FlakyStore {
inner: MemoryStore::new(notify.clone(), 1000),
drop_acks: false.into(),
});
let limits = Limits {
max_pull_messages: 2, // force the "more" path
..Limits::default()
};
let state = Arc::new(AppState {
card: encode_card(&keys, &url, "flaky", ""),
keys,
store: store.clone(),
notify,
limits,
});
tokio::spawn(meow_server::serve(listener, state));
let dir = tmpdir();
let servers = vec![url];
let mut bob = client(&dir, "bob", &servers).await;
let mut alice = client(&dir, "alice", &servers).await;
let offer = bob.create_invitation("alice", &[], "", 3600).await.unwrap();
let answer = alice.answer_invitation(&offer, None, &[]).await.unwrap();
let confirm = bob.accept_answer(&answer).await.unwrap();
alice.finalize_invitation(&confirm).await.unwrap();
bob.sync(Duration::ZERO).await.unwrap();
let server = alice.servers()[0].clone();
let mailbox = alice.contact("bob").unwrap().keys.as_ref().unwrap().mailbox.clone();
// 1. A client receives messages then dies before saving: nothing is lost.
for t in ["m1", "m2", "m3"] {
bob.send_text("alice", t).await.unwrap();
}
assert_eq!(raw_pull(&server, &mailbox).await.len(), 2); // limit 2, more = true
let ev = alice.sync(Duration::ZERO).await.unwrap();
assert_eq!(texts(&ev), vec!["m1", "m2", "m3"]); // several rounds ("more")
// Everything processed has been acknowledged and deleted.
assert!(raw_pull(&server, &mailbox).await.is_empty());
assert!(alice.sync(Duration::ZERO).await.unwrap().is_empty());
// 2. The acknowledgement is lost: the redelivered message is not processed twice,
// even after a restart (pending acks are persisted with the state).
store.drop_acks.store(true, std::sync::atomic::Ordering::SeqCst);
bob.send_text("alice", "m4").await.unwrap();
assert_eq!(texts(&alice.sync(Duration::ZERO).await.unwrap()), vec!["m4"]);
assert_eq!(raw_pull(&server, &mailbox).await.len(), 1);
let path = dir.join("alice.mwid2");
drop(alice);
let mut alice = MeowClient::open(&path, "pw", KdfParams::INSECURE_TEST).await.unwrap();
assert!(alice.sync(Duration::ZERO).await.unwrap().is_empty());
store.drop_acks.store(false, std::sync::atomic::Ordering::SeqCst);
assert!(alice.sync(Duration::ZERO).await.unwrap().is_empty());
assert!(raw_pull(&server, &mailbox).await.is_empty());
assert_eq!(alice.history("bob").unwrap().len(), 4);
assert_eq!(store.inner.stored_messages(), 0);
// 3. Mailboxes that disappear still get their last messages acknowledged:
// the temporary answer mailbox of a server invitation...
let mut carol = client(&dir, "carol", &servers).await;
let link = bob.publish_invitation("carol", &[], "", "", 3600).await.unwrap();
carol.accept_published_invitation(&link, "", None, &[]).await.unwrap();
bob.sync(Duration::ZERO).await.unwrap(); // step 2 → 3, answer mailbox retired
carol.sync(Duration::ZERO).await.unwrap(); // step 3 → 4
bob.sync(Duration::ZERO).await.unwrap(); // ack
carol.send_text("bob", "hi").await.unwrap();
assert_eq!(texts(&bob.sync(Duration::ZERO).await.unwrap()), vec!["hi"]);
assert_eq!(store.inner.stored_messages(), 0);
// ...and a contact removed while an ack is still pending.
store.drop_acks.store(true, std::sync::atomic::Ordering::SeqCst);
bob.send_text("alice", "bye").await.unwrap();
assert_eq!(texts(&alice.sync(Duration::ZERO).await.unwrap()), vec!["bye"]);
store.drop_acks.store(false, std::sync::atomic::Ordering::SeqCst);
alice.remove_contact("bob").await.unwrap();
assert_eq!(store.inner.stored_messages(), 1);
assert!(alice.sync(Duration::ZERO).await.unwrap().is_empty());
assert_eq!(store.inner.stored_messages(), 0);
let _ = std::fs::remove_dir_all(&dir);
}