send queue

This commit is contained in:
yves committed 2026-11-20 23:09:05 +01:00
1 parent a520ddb557
commit 10af480218
10 files changed
+701 -60

No files matched your search

+100
View File
@@ -193,11 +193,16 @@ async fn file_and_server_invitations_then_messaging() {
struct FlakyStore {
inner: MemoryStore,
drop_acks: std::sync::atomic::AtomicBool,
/// Refuse deposits (the server answers with an error).
fail_posts: 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<()> {
if self.fail_posts.load(std::sync::atomic::Ordering::SeqCst) {
return Err(meow_server::store::StoreError::Backend("down".into()));
}
self.inner.post(mb, payload, now).await
}
async fn fetch(
@@ -230,6 +235,27 @@ impl meow_server::store::ServerStore for FlakyStore {
}
}
async fn spawn_flaky_server() -> (String, Arc<FlakyStore>) {
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(),
fail_posts: false.into(),
});
let state = Arc::new(AppState {
card: encode_card(&keys, &url, "flaky", ""),
keys,
store: store.clone(),
notify,
limits: Limits::default(),
});
tokio::spawn(meow_server::serve(listener, state));
(url, store)
}
/// What a client that crashed right after receiving the response would have done:
/// pull without ever acknowledging.
async fn raw_pull(
@@ -266,6 +292,7 @@ async fn no_message_lost_when_the_client_dies() {
let store = Arc::new(FlakyStore {
inner: MemoryStore::new(notify.clone(), 1000),
drop_acks: false.into(),
fail_posts: false.into(),
});
let limits = Limits {
max_pull_messages: 2, // force the "more" path
@@ -415,3 +442,76 @@ async fn hidden_contacts() {
assert_eq!(alice.history("bob").unwrap().len(), 3);
let _ = std::fs::remove_dir_all(&dir);
}
// ───────────── persistent send queue (roadmap lot 5.5) ─────────────
#[tokio::test(flavor = "multi_thread")]
async fn offline_messages_are_queued_and_retried() {
use std::sync::atomic::Ordering::SeqCst;
let (url, store) = spawn_flaky_server().await;
let servers = vec![url];
let dir = tmpdir();
let path = dir.join("bob.mwid2");
let mut alice = client(&dir, "alice", &servers).await;
let mut bob = client(&dir, "bob", &servers).await;
connect(&mut alice, &mut bob, "bob").await;
// Server refuses deposits: sending still succeeds, the message is queued.
store.fail_posts.store(true, SeqCst);
let r1 = bob.send_text("alice", "queued 1").await.unwrap();
let r2 = bob.send_text("alice", "queued 2").await.unwrap();
assert_eq!((r1.delivered_to, r2.delivered_to), (0, 0));
let pending = bob.pending_sends();
assert_eq!(pending.len(), 2);
assert!(pending.iter().all(|p| p.contact == "alice" && p.attempts >= 1));
assert_eq!(pending[0].message_id, r1.message_id);
assert!(alice.sync(Duration::ZERO).await.unwrap().is_empty());
// The queue survives a restart; not yet due (backoff), so a sync does not send.
drop(bob);
let mut bob = MeowClient::open(&path, "pw").await.unwrap();
assert_eq!(bob.pending_sends().len(), 2);
store.fail_posts.store(false, SeqCst);
bob.sync(Duration::ZERO).await.unwrap();
assert_eq!(bob.pending_sends().len(), 2);
// Forced flush: both delivered (in one Post), in order.
assert!(bob.flush_outbox().await.unwrap().is_empty());
assert!(bob.pending_sends().is_empty());
assert_eq!(
texts(&alice.sync(Duration::ZERO).await.unwrap()),
vec!["queued 1", "queued 2"]
);
// Due items are retried by the next send.
bob.set_retry_policy(meow_client::RetryPolicy {
base: Duration::from_secs(1),
..Default::default()
});
store.fail_posts.store(true, SeqCst);
bob.send_text("alice", "late").await.unwrap();
store.fail_posts.store(false, SeqCst);
tokio::time::sleep(Duration::from_millis(2500)).await;
let r = bob.send_text("alice", "now").await.unwrap();
assert_eq!(r.delivered_to, 1);
assert!(bob.pending_sends().is_empty());
assert_eq!(texts(&alice.sync(Duration::ZERO).await.unwrap()), vec!["late", "now"]);
// An item that expires undelivered is reported.
bob.set_retry_policy(meow_client::RetryPolicy {
max_age: Duration::ZERO,
..Default::default()
});
store.fail_posts.store(true, SeqCst);
let r = bob.send_text("alice", "lost").await.unwrap();
assert_eq!(r.delivered_to, 0);
let ev = bob.flush_outbox().await.unwrap();
assert_eq!(
ev,
vec![Event::SendFailed {
contact: "alice".into(),
message_id: r.message_id
}]
);
assert!(bob.pending_sends().is_empty());
let _ = std::fs::remove_dir_all(&dir);
}