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

+92 -1
View File
@@ -248,6 +248,25 @@ let mut events = client.subscribe(); // Strea
* Le cœur est asynchrone (`tokio`). La FFI expose les mêmes méthodes via `flutter_rust_bridge` * Le cœur est asynchrone (`tokio`). La FFI expose les mêmes méthodes via `flutter_rust_bridge`
(`Future` ↔ `Future`, `Stream` ↔ `Stream`). (`Future` ↔ `Future`, `Stream` ↔ `Stream`).
### 5.1 File d'envoi persistante
* Chaque dépôt (message utilisateur ou message de handshake) devient d'abord un `OutboxItem`.
Il est enregistré **dans la même sauvegarde** que l'état du ratchet qui l'a produit, puis
déposé chez les serveurs de relève du destinataire. Un message n'est donc jamais chiffré sans
être stocké pour être (re)livré.
* Les serveurs qui acceptent le dépôt sont retirés de l'élément, et les autres sont réessayés avec
un backoff exponentiel : 5 s × 2ⁿ, plafonné à 1 h, avec ±20 % d'aléa. Au bout de 7 jours,
l'élément est abandonné, avec `Event::SendFailed` si aucun serveur ne l'a pris.
* Les dépôts dus en même temps sont regroupés en un `Post` par serveur (64 dépôts et 8 Mio au
maximum). Un lot refusé par le serveur est réessayé élément par élément, pour qu'un dépôt
invalide ne bloque pas les autres.
* La file est vidée à chaque `send`, au début de `sync` et par `flush_outbox()`. Envoyer hors
ligne réussit donc : `SendReport.delivered_to == 0` signifie « en file ».
* La file appartient à l'espace du contact : un contact caché garde ses envois en attente dans
son espace.
* C'est ici que Matriochka se branchera : un élément portera une route et une date de départ
plutôt qu'une simple liste de serveurs.
--- ---
## 6. Stockage client (`meow-store`) ## 6. Stockage client (`meow-store`)
@@ -360,7 +379,79 @@ révèle la longueur des conversations.
--- ---
## 7. Conventions ## 7. Réseau de serveurs et Matriochka (cible, phase 8)
Cette section décrit la cible issue de la vision du projet (site web : *architecture*,
*features*, *why*). Rien n'est encore implémenté, à part les briques déjà présentes : chaque
requête est scellée pour un serveur, et chaque serveur a une carte autosignée.
### 7.1 Rôles
* **Serveurs de relève** (pull servers) : choisis par l'utilisateur, de confiance, le plus
souvent auto-hébergés. C'est là qu'arrivent ses messages. Comme ils sont de confiance,
l'analyse de trafic n'y est pas la menace principale.
* **Serveurs de transit** (publics, d'organisations partenaires) : relaient les couches
Matriochka. Chacun ne connaît que le saut précédent, le saut suivant et une charge opaque.
C'est là que portent la menace d'analyse de trafic et la contrainte de juridiction.
### 7.2 Maillage et propagation de la connaissance du réseau
* Les serveurs **échangent en permanence** des lots entre eux. Chaque lot contient de 0 à n
messages utilisateurs (couches Matriochka à faire suivre) et de 1 à x cartes de serveurs
connus. Le trafic de couverture est donc intrinsèque : un observateur du lien ne distingue pas
un lot vide d'un lot plein (lots de taille fixe, cadence régulière).
* Les échanges entre client et serveur suivent le même modèle : les réponses (pull, post)
embarquent aussi des cartes de serveurs. Le client construit ainsi un **annuaire local** le
plus large possible pour composer ses chaînes. Il n'y a pas d'annuaire central.
* La carte serveur (`ServerCard`, autosignée) s'enrichira de : juridiction ou pays déclaré,
opérateur, rôles (relève et/ou transit), date de validité, éventuelles attestations.
### 7.3 Chaînes Matriochka
```
client ─► S1 ─► S2 ─► … ─► Sk = serveur de relève du destinataire
Requête scellée(S1){ Forward { next: S2, sealed: Requête scellée(S2){ … Post{deposit} } } }
```
* Chaque saut ouvre sa couche (sealed box, §3.1), apprend `next`, attend un **délai aléatoire**
puis transmet dans son prochain lot. Les couches sont complétées par du bourrage à une taille
constante, pour que l'épaisseur restante ne trahisse pas la position dans la chaîne.
* **Politique de juridiction** (choisie par l'utilisateur ou l'organisation) : pays à inclure ou
à exclure, longueur minimale de la chaîne, diversité des opérateurs. Exemple :
`domestique → neutre → externe → relève`.
* Le chemin de réponse est indépendant : le destinataire compose sa propre chaîne vers mes
serveurs de relève, connus par sa `ContactCard`.
### 7.4 Points à trancher
* **Faux serveurs (Sybil).** Les cartes propagées par le maillage sont autosignées, donc
n'importe qui peut injecter des centaines de « serveurs » et capturer une bonne part des
chaînes. Une juridiction déclarée n'est pas vérifiable. Proposition : la propagation sert à
*découvrir* des serveurs, mais un serveur n'entre dans une chaîne que s'il est **approuvé** :
ajouté à la main, attesté par un serveur ou une organisation de confiance (signature sur sa
carte), ou ancien et stable. La politique de juridiction ne s'applique qu'à des attestations,
pas à des déclarations.
* **Couche symétrique pré-partagée** (annoncée par le site, absente de la v2 actuelle). Un
secret échangé hors ligne (QR, `peer_secure`) devrait être **mélangé à la clé initiale du
ratchet** (`SK = HKDF(DH… ‖ PSK)`), et périodiquement à la racine. Un attaquant qui enregistre
tout aujourd'hui pour casser X25519 demain (ordinateur quantique) ne pourrait alors rien
déchiffrer sans le PSK. C'est plus simple et plus sûr qu'une couche de chiffrement
supplémentaire. On pourra ensuite ajouter un KEM post-quantique (ML-KEM) dans l'invitation.
* **« Contenu signé par l'expéditeur »** (site). Le Double Ratchet authentifie déjà
l'expéditeur avec une authentification *répudiable* : le destinataire sait qui a écrit, mais
ne peut pas le prouver à un tiers. Une signature Ed25519 sur chaque message rendrait au
contraire chaque message **non répudiable**, et donc utilisable contre l'expéditeur si
l'appareil du destinataire est saisi. Je recommande de ne pas signer par défaut. Une signature
explicite peut se réserver au profil professionnel, si la non-répudiation y est une exigence.
* **Profils professionnels** (LDAP, déchiffrement côté serveur explicite et signalé). Ce
seraient des identités séparées (fichiers de store distincts), avec un dépôt de clé
(« escrow ») vers l'organisation **visible dans le protocole**, par exemple un destinataire
supplémentaire déclaré dans la `ContactCard`. Le client peut alors afficher l'avertissement
sans pouvoir le cacher. Le sujet est hors du périmètre actuel.
---
## 8. Conventions
* Edition 2021, MSRV = stable courante. `cargo fmt`, `cargo clippy -D warnings`. * Edition 2021, MSRV = stable courante. `cargo fmt`, `cargo clippy -D warnings`.
* `#![forbid(unsafe_code)]` partout, sauf dans `meow-ffi`. * `#![forbid(unsafe_code)]` partout, sauf dans `meow-ffi`.
+11 -4
View File
@@ -16,7 +16,7 @@ Pour reprendre le travail : lire ce fichier, prendre le premier lot ⬜ dont les
1. ~~**3.8** livraison au moins une fois~~ ✅ 1. ~~**3.8** livraison au moins une fois~~ ✅
2. ~~**4.5** brancher `meow-store` dans le client et la CLI~~ ✅ 2. ~~**4.5** brancher `meow-store` dans le client et la CLI~~ ✅
3. **5.5, 5.6, 5.9** file d'envoi, accusés, flux d'événements (prérequis de l'UI). 3. ~~5.5~~ ✅, puis **5.6, 5.9** accusés et flux d'événements (prérequis de l'UI), et **5.10**.
4. **7.1 → 7.3** FFI et intégration dans bastet. 4. **7.1 → 7.3** FFI et intégration dans bastet.
5. Le reste (phases 8–10) selon les priorités. 5. Le reste (phases 8–10) selon les priorités.
@@ -24,6 +24,7 @@ Pour reprendre le travail : lire ce fichier, prendre le premier lot ⬜ dont les
| Date | Lots | Notes | | Date | Lots | Notes |
|---|---|---| |---|---|---|
| 2026-11-20 | 5.5 | `OutboxItem` enregistrés dans le store (un objet par élément et par espace), dans la même sauvegarde que le ratchet. Backoff exponentiel avec aléa, expiration après 7 jours (`Event::SendFailed`), dépôts regroupés par serveur avec repli élément par élément. Les messages de handshake passent aussi par la file. CLI : `outbox [--flush]`, « queued for … ». ARCHITECTURE : §5.1, et §7 (réseau de serveurs et Matriochka, points à trancher). 41 tests, e2e avec une section « file hors ligne ». |
| 2026-11-20 | 4.5 | `meow-client` passe sur `meow-store` (un état par espace, sauvegarde des seuls espaces modifiés, acks par espace) ; API `unlock`, `hide_contact`, `reveal_contact`, `change_password`, `history_page`, `file`. CLI : `-u`, `contact hide/reveal`, `identity password`. Store derrière un `Mutex` pour garder le client `Send + Sync` (requis pour la FFI). Le fichier `.mwid2` provisoire disparaît. 38 tests, e2e avec sections « contact caché » et « changement de mot de passe ». | | 2026-11-20 | 4.5 | `meow-client` passe sur `meow-store` (un état par espace, sauvegarde des seuls espaces modifiés, acks par espace) ; API `unlock`, `hide_contact`, `reveal_contact`, `change_password`, `history_page`, `file`. CLI : `-u`, `contact hide/reveal`, `identity password`. Store derrière un `Mutex` pour garder le client `Send + Sync` (requis pour la FFI). Le fichier `.mwid2` provisoire disparaît. 38 tests, e2e avec sections « contact caché » et « changement de mot de passe ». |
| 2026-11-20 | 4.1–4.3 | `meow-store` repensé après relecture du stockage v1 : objectifs anti-saisie (rien ne relie les blocs sans mot de passe, espaces cachés à un ou plusieurs contacts). Sac de blocs uniformes, espaces, segments. Un premier brouillon avec une colonne `contact` en clair a été abandonné. 6 tests de store. Pas encore branché dans le client. | | 2026-11-20 | 4.1–4.3 | `meow-store` repensé après relecture du stockage v1 : objectifs anti-saisie (rien ne relie les blocs sans mot de passe, espaces cachés à un ou plusieurs contacts). Sac de blocs uniformes, espaces, segments. Un premier brouillon avec une colonne `contact` en clair a été abandonné. 6 tests de store. Pas encore branché dans le client. |
| 2026-11-20 | 3.8 | Pull non destructif + acks signés dans `MailboxAuth`, `PendingAck` enregistrés avec l'état, redélivrances dédupliquées, pagination (`more`), mise en retraite des mailbox disparues. Redis : liste → stream. Profil client au format 2 (les `.mwid2` de format 1 sont refusés). 31 tests, e2e mémoire et Redis verts, et plus aucun message résiduel dans Redis à la fin de l'e2e. | | 2026-11-20 | 3.8 | Pull non destructif + acks signés dans `MailboxAuth`, `PendingAck` enregistrés avec l'état, redélivrances dédupliquées, pagination (`more`), mise en retraite des mailbox disparues. Redis : liste → stream. Profil client au format 2 (les `.mwid2` de format 1 sont refusés). 31 tests, e2e mémoire et Redis verts, et plus aucun message résiduel dans Redis à la fin de l'e2e. |
@@ -94,11 +95,12 @@ Pour reprendre le travail : lire ce fichier, prendre le premier lot ⬜ dont les
| 5.2 | Invitation par fichier et par serveur (shortcode et mot de passe) | e2e | ✅ | | 5.2 | Invitation par fichier et par serveur (shortcode et mot de passe) | e2e | ✅ |
| 5.3 | Envoi : dépôt sur tous les serveurs de pull du contact, repli en cas d'échec | e2e | ✅ | | 5.3 | Envoi : dépôt sur tous les serveurs de pull du contact, repli en cas d'échec | e2e | ✅ |
| 5.4 | Réception : un pull par serveur regroupant toutes les mailbox, long-poll, traitement, événements | e2e | ✅ | | 5.4 | Réception : un pull par serveur regroupant toutes les mailbox, long-poll, traitement, événements | e2e | ✅ |
| 5.5 | File d'envoi persistante avec retries et backoff, envoi hors ligne | Tests | ⬜ | | 5.5 | File d'envoi persistante avec retries et backoff, envoi hors ligne | Tests | ✅ |
| 5.6 | Accusés de réception et de lecture chiffrés (dans le ratchet) | e2e | ⬜ | | 5.6 | Accusés de réception et de lecture chiffrés (dans le ratchet) | e2e | ⬜ |
| 5.7 | Fichiers : découpage en morceaux, reprise, déduplication, limite de taille. Le contenu reçu doit être écrit sur disque **avant** l'ack : aujourd'hui, la CLI écrit les fichiers après `sync`, alors que les acks sont déjà partis | e2e (`send-file`) | 🟡 envoi en un seul morceau | | 5.7 | Fichiers : découpage en morceaux, reprise, déduplication, limite de taille. Le contenu reçu doit être écrit sur disque **avant** l'ack : aujourd'hui, la CLI écrit les fichiers après `sync`, alors que les acks sont déjà partis | e2e (`send-file`) | 🟡 envoi en un seul morceau |
| 5.8 | Trafic leurre : mailbox fictives dans les pulls, ordre aléatoire, padding des requêtes | Tests | ⬜ | | 5.8 | Trafic leurre : mailbox fictives dans les pulls, ordre aléatoire, padding des requêtes | Tests | ⬜ |
| 5.9 | Stream d'événements (`tokio::broadcast`) et tâche de synchronisation en arrière-plan | | ⬜ | | 5.9 | Stream d'événements (`tokio::broadcast`) et tâche de synchronisation en arrière-plan | | ⬜ |
| 5.10 | Inviter directement dans un espace caché (le contact ne passe jamais par l'espace principal) | Tests | ⬜ |
## Phase 6 — `meow-cli` (`meow`) ## Phase 6 — `meow-cli` (`meow`)
@@ -128,13 +130,18 @@ Correspondance des 63 exports actuels de `meowjsonlib` → API v2 : voir l'annex
| Lot | Contenu | État | | Lot | Contenu | État |
|---|---|---| |---|---|---|
| 8.1 | Chiffrement des en-têtes DR (variante « header encryption » de Signal) | ⬜ | | 8.1 | Chiffrement des en-têtes DR (variante « header encryption » de Signal) | ⬜ |
| 8.2 | Matriochka (multi-saut) : `Forward { next_server, sealed }`, délais aléatoires | ⬜ | | 8.2 | Matriochka (multi-saut) : `Forward { next_server, sealed }`, couches de taille constante, délais aléatoires, politique de juridiction (ARCHITECTURE §7.3) | ⬜ |
| 8.2a | `ServerCard` enrichie (juridiction, opérateur, rôles, validité) + annuaire local du client alimenté par les réponses des serveurs | ⬜ |
| 8.2b | Maillage entre serveurs : lots de taille fixe à cadence régulière (0 à n messages, 1 à x cartes), trafic de couverture | ⬜ |
| 8.2c | Approbation des serveurs (anti-Sybil) : approbation manuelle, attestations signées, ancienneté (ARCHITECTURE §7.4) | ⬜ |
| 8.3 | Multi-appareils (mailbox d'appareil, synchronisation chiffrée) | ⬜ | | 8.3 | Multi-appareils (mailbox d'appareil, synchronisation chiffrée) | ⬜ |
| 8.4 | Push WebSocket (`/v2/ws`) en plus du long-poll | ⬜ | | 8.4 | Push WebSocket (`/v2/ws`) en plus du long-poll | ⬜ |
| 8.5 | Visio : émission de jetons LiveKit côté serveur (`VideoRoomRequest`) | ⬜ | | 8.5 | Visio : émission de jetons LiveKit côté serveur (`VideoRoomRequest`) | ⬜ |
| 8.6 | Groupes (fan-out par paire, puis évaluation de MLS / `openmls`) | ⬜ | | 8.6 | Groupes (fan-out par paire, puis évaluation de MLS / `openmls`) | ⬜ |
| 8.7 | Portage de `peer_secure` (SAS) : canal Rust + vérification de l'empreinte `transcript` | ⬜ | | 8.7 | Portage de `peer_secure` (SAS) : canal Rust + vérification de l'empreinte `transcript` | ⬜ |
| 8.8 | Liste de serveurs connus, échange de cartes, fédération | ⬜ | | 8.8 | Fédération entre organisations (voir 8.2a à 8.2c pour l'échange de cartes) | ⬜ |
| 8.9 | Secret pré-partagé hors ligne mélangé au ratchet (`SK = HKDF(DH ‖ PSK)`), puis KEM post-quantique (ML-KEM) dans l'invitation | ⬜ |
| 8.10 | Profils professionnels : LDAP, dépôt de clé vers l'organisation visible dans le protocole et signalé dans l'UI (ARCHITECTURE §7.4) | ⬜ |
## Phase 9 — Durcissement et livraison ## Phase 9 — Durcissement et livraison
+40 -2
View File
@@ -77,6 +77,12 @@ enum Cmd {
#[arg(short, long)] #[arg(short, long)]
exit: bool, exit: bool,
}, },
/// Show the send queue (messages not yet accepted by every server).
Outbox {
/// Try to deliver everything now.
#[arg(long)]
flush: bool,
},
/// Show the conversation with a contact. /// Show the conversation with a contact.
History { contact: String }, History { contact: String },
} }
@@ -376,11 +382,11 @@ async fn run() -> Result<()> {
} }
Cmd::Send { contact, text } => { Cmd::Send { contact, text } => {
let r = ctx.open().await?.send_text(&contact, &text.join(" ")).await?; let r = ctx.open().await?.send_text(&contact, &text.join(" ")).await?;
println!("sent to {contact} ({} server(s))", r.delivered_to); print_sent(&contact, None, r.delivered_to);
} }
Cmd::SendFile { contact, file } => { Cmd::SendFile { contact, file } => {
let r = ctx.open().await?.send_file(&contact, &file).await?; let r = ctx.open().await?.send_file(&contact, &file).await?;
println!("sent {} to {contact} ({} server(s))", file.display(), r.delivered_to); print_sent(&contact, Some(&file), r.delivered_to);
} }
Cmd::Sync { wait } => { Cmd::Sync { wait } => {
let mut c = ctx.open().await?; let mut c = ctx.open().await?;
@@ -397,6 +403,28 @@ async fn run() -> Result<()> {
} }
} }
} }
Cmd::Outbox { flush } => {
let mut c = ctx.open().await?;
if flush {
let ev = c.flush_outbox().await?;
print_events(&ctx, &ev)?;
}
let pending = c.pending_sends();
if pending.is_empty() {
println!("outbox empty");
}
for p in pending {
let what = if p.message_id.is_empty() {
"handshake"
} else {
"message"
};
println!(
"{}\t{what}\taccepted by {} server(s)\t{} attempt(s)\tnext at {}",
p.contact, p.accepted, p.attempts, p.next_attempt
);
}
}
Cmd::History { contact } => { Cmd::History { contact } => {
let c = ctx.open().await?; let c = ctx.open().await?;
for h in c.history(&contact)? { for h in c.history(&contact)? {
@@ -494,6 +522,15 @@ fn safe_name(name: &str) -> String {
} }
} }
fn print_sent(contact: &str, file: Option<&Path>, delivered_to: usize) {
let what = file.map(|f| format!("{} ", f.display())).unwrap_or_default();
if delivered_to == 0 {
println!("queued {what}for {contact} (no server reachable, will retry)");
} else {
println!("sent {what}to {contact} ({delivered_to} server(s))");
}
}
fn print_events(ctx: &Ctx, events: &[Event]) -> Result<()> { fn print_events(ctx: &Ctx, events: &[Event]) -> Result<()> {
for e in events { for e in events {
match e { match e {
@@ -508,6 +545,7 @@ fn print_events(ctx: &Ctx, events: &[Event]) -> Result<()> {
} }
Event::InvitationAccepted { contact } => println!("invitation accepted by {contact}, confirmation sent"), Event::InvitationAccepted { contact } => println!("invitation accepted by {contact}, confirmation sent"),
Event::ContactActivated { contact } => println!("contact {contact} is active"), Event::ContactActivated { contact } => println!("contact {contact} is active"),
Event::SendFailed { contact, .. } => println!("a message to {contact} could not be delivered (expired)"),
} }
} }
Ok(()) Ok(())
+60 -50
View File
@@ -17,6 +17,7 @@
#![forbid(unsafe_code)] #![forbid(unsafe_code)]
#![cfg_attr(not(test), warn(clippy::unwrap_used, clippy::expect_used))] #![cfg_attr(not(test), warn(clippy::unwrap_used, clippy::expect_used))]
pub mod outbox;
pub mod transport; pub mod transport;
use std::collections::BTreeMap; use std::collections::BTreeMap;
@@ -36,6 +37,7 @@ use meow_store::{Batch, RetiredMailbox, SpaceId, State as SpaceState, Store};
pub use meow_core::contact::ContactState as State; pub use meow_core::contact::ContactState as State;
pub use meow_store::{Content, HistoryEntry, HistoryPage, PendingAck}; pub use meow_store::{Content, HistoryEntry, HistoryPage, PendingAck};
pub use outbox::{PendingSend, RetryPolicy};
/// Maximum file size sent in a single message (chunking: roadmap 5.7). /// Maximum file size sent in a single message (chunking: roadmap 5.7).
pub const MAX_FILE_BYTES: usize = 4 * 1024 * 1024; pub const MAX_FILE_BYTES: usize = 4 * 1024 * 1024;
@@ -119,13 +121,16 @@ pub enum Event {
name: String, name: String,
data: Vec<u8>, data: Vec<u8>,
}, },
/// A queued message expired before any server accepted it.
SendFailed { contact: String, message_id: Vec<u8> },
} }
/// Outcome of a send. /// Outcome of a send.
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub struct SendReport { pub struct SendReport {
pub message_id: Vec<u8>, pub message_id: Vec<u8>,
/// Number of servers that accepted the deposit. /// Number of servers that accepted the deposit right away. `0` means queued: it is
/// retried by later sends, syncs and [`MeowClient::flush_outbox`].
pub delivered_to: usize, pub delivered_to: usize,
} }
@@ -157,6 +162,10 @@ pub struct MeowClient {
store: std::sync::Mutex<Store>, store: std::sync::Mutex<Store>,
spaces: Vec<Space>, spaces: Vec<Space>,
transport: transport::Transport, transport: transport::Transport,
retry: RetryPolicy,
/// Events produced outside `sync` (e.g. an expiry noticed while sending), handed
/// out by the next `sync` or `flush_outbox`.
pending_events: Vec<Event>,
} }
type Mailboxes = Vec<(SigningKeyPair, Vec<ServerInfo>)>; type Mailboxes = Vec<(SigningKeyPair, Vec<ServerInfo>)>;
@@ -190,6 +199,8 @@ impl MeowClient {
dirty: false, dirty: false,
}], }],
transport: transport::Transport::new()?, transport: transport::Transport::new()?,
retry: RetryPolicy::default(),
pending_events: Vec::new(),
}) })
} }
@@ -300,6 +311,13 @@ impl MeowClient {
.iter() .iter()
.map(|(kp, _)| kp.public().as_bytes().to_vec()) .map(|(kp, _)| kp.public().as_bytes().to_vec())
.collect(); .collect();
let queued: Vec<meow_store::OutboxItem> = self.spaces[si]
.state
.outbox
.iter()
.filter(|o| o.contact == contact.id)
.cloned()
.collect();
let acks: Vec<PendingAck> = self.spaces[si] let acks: Vec<PendingAck> = self.spaces[si]
.state .state
.pending_acks .pending_acks
@@ -311,12 +329,14 @@ impl MeowClient {
let t = &mut self.spaces[target]; let t = &mut self.spaces[target];
t.state.contacts.push(contact); t.state.contacts.push(contact);
t.state.pending_acks.extend(acks); t.state.pending_acks.extend(acks);
t.state.outbox.extend(queued);
t.batch.history.extend(history); t.batch.history.extend(history);
t.batch.files.extend(files); t.batch.files.extend(files);
self.save_space(target)?; self.save_space(target)?;
let s = &mut self.spaces[si]; let s = &mut self.spaces[si];
s.state.contacts.remove(ci); let cid = s.state.contacts.remove(ci).id;
s.state.pending_acks.retain(|a| !mailboxes.contains(&a.mailbox)); s.state.pending_acks.retain(|a| !mailboxes.contains(&a.mailbox));
s.state.outbox.retain(|o| o.contact != cid);
self.save_space(si) self.save_space(si)
} }
@@ -416,7 +436,8 @@ impl MeowClient {
pub async fn remove_contact(&mut self, name: &str) -> Result<()> { pub async fn remove_contact(&mut self, name: &str) -> Result<()> {
let (si, ci) = self.locate(name)?; let (si, ci) = self.locate(name)?;
let before = self.space_mailboxes(si); let before = self.space_mailboxes(si);
self.spaces[si].state.contacts.remove(ci); let cid = self.spaces[si].state.contacts.remove(ci).id;
self.spaces[si].state.outbox.retain(|o| o.contact != cid);
self.retire_mailboxes(si, before); self.retire_mailboxes(si, before);
self.save_space(si) self.save_space(si)
} }
@@ -506,10 +527,11 @@ impl MeowClient {
let contact = &mut self.spaces[si].state.contacts[ci]; let contact = &mut self.spaces[si].state.contacts[ci];
let ack = invitation::finalize(contact, &msg)?; let ack = invitation::finalize(contact, &msg)?;
let deposit = messaging::deposit_for(contact, &ack)?; let deposit = messaging::deposit_for(contact, &ack)?;
let servers = peer_servers(contact); let queued = outbox::item(&contact.id, vec![], &deposit, peer_servers(contact));
let name = contact.name.clone(); let name = contact.name.clone();
self.spaces[si].state.outbox.push(queued);
self.save_space(si)?; self.save_space(si)?;
self.deliver(&servers, vec![deposit]).await?; self.flush(false).await?;
Ok(name) Ok(name)
} }
@@ -574,8 +596,16 @@ impl MeowClient {
let info = self.inspect_invitation(&f.payload)?; let info = self.inspect_invitation(&f.payload)?;
let answer_bytes = self.answer_invitation(&f.payload, contact_name, server_urls).await?; let answer_bytes = self.answer_invitation(&f.payload, contact_name, server_urls).await?;
let answer = v2::InvitationMessage::decode(answer_bytes.as_slice()).map_err(meow_core::Error::from)?; let answer = v2::InvitationMessage::decode(answer_bytes.as_slice()).map_err(meow_core::Error::from)?;
self.deliver(&info.answer_servers, vec![invitation::answer_deposit(&info, &answer)]) let (si, ci) = self.by_invitation(&info.invitation_id)?;
.await?; let queued = outbox::item(
&self.spaces[si].state.contacts[ci].id,
vec![],
&invitation::answer_deposit(&info, &answer),
info.answer_servers.clone(),
);
self.spaces[si].state.outbox.push(queued);
self.save_space(si)?;
self.flush(false).await?;
Ok(info.initiator_name) Ok(info.initiator_name)
} }
@@ -619,6 +649,12 @@ impl MeowClient {
let env = messaging::encrypt(contact, &msg)?; let env = messaging::encrypt(contact, &msg)?;
let deposit = messaging::deposit_for(contact, &env)?; let deposit = messaging::deposit_for(contact, &env)?;
let servers = peer_servers(contact); let servers = peer_servers(contact);
if servers.is_empty() {
return Err(Error::Invalid("contact has no server".into()));
}
let queued = outbox::item(&contact.id, msg.id.clone(), &deposit, servers);
let item_id = queued.id.clone();
sp.state.outbox.push(queued);
sp.batch.history.push(HistoryEntry { sp.batch.history.push(HistoryEntry {
id: msg.id.clone(), id: msg.id.clone(),
contact: contact.id.clone(), contact: contact.id.clone(),
@@ -627,46 +663,16 @@ impl MeowClient {
received_at: now(), received_at: now(),
content, content,
}); });
// Persisted (ratchet + queue) before anything is sent.
self.save_space(si)?; self.save_space(si)?;
let delivered_to = self.deliver(&servers, vec![deposit]).await?; let accepted = self.flush(false).await?;
let delivered_to = accepted.get(&item_id).copied().unwrap_or(0);
Ok(SendReport { Ok(SendReport {
message_id: msg.id, message_id: msg.id,
delivered_to, delivered_to,
}) })
} }
/// Post deposits to every server; succeeds if at least one accepted them.
async fn deliver(&self, servers: &[ServerInfo], deposits: Vec<v2::Deposit>) -> Result<usize> {
if servers.is_empty() {
return Err(Error::Invalid("contact has no server".into()));
}
let calls = servers.iter().map(|s| {
self.transport.call(
s,
Req::Post(v2::Post {
deposits: deposits.clone(),
}),
Duration::ZERO,
)
});
let mut ok = 0;
let mut last_err = None;
for (s, r) in servers.iter().zip(join_all(calls).await) {
match r {
Ok(Resp::PostAck(_)) => ok += 1,
Ok(_) => last_err = Some(Error::Network(format!("{}: unexpected response", s.url))),
Err(e) => {
tracing::warn!("deposit on {} failed: {e}", s.url);
last_err = Some(e);
}
}
}
match (ok, last_err) {
(0, Some(e)) => Err(e),
(n, _) => Ok(n),
}
}
// ───────────────────────── sync ───────────────────────── // ───────────────────────── sync ─────────────────────────
/// Pull every mailbox of every unlocked space on every server (one request per /// Pull every mailbox of every unlocked space on every server (one request per
@@ -680,7 +686,9 @@ impl MeowClient {
/// sends the acknowledgements and fetches what the servers held back. /// sends the acknowledgements and fetches what the servers held back.
pub async fn sync(&mut self, wait: Duration) -> Result<Vec<Event>> { pub async fn sync(&mut self, wait: Duration) -> Result<Vec<Event>> {
const MAX_ROUNDS: usize = 16; const MAX_ROUNDS: usize = 16;
let mut events = Vec::new(); // Messages queued while offline go first.
self.flush(false).await?;
let mut events = std::mem::take(&mut self.pending_events);
let mut wait = wait; let mut wait = wait;
for round in 0..MAX_ROUNDS { for round in 0..MAX_ROUNDS {
let r = match self.pull_round(wait).await { let r = match self.pull_round(wait).await {
@@ -880,7 +888,6 @@ impl MeowClient {
envs.sort_by_key(|(rank, at, _, _, _)| (*rank, *at)); envs.sort_by_key(|(rank, at, _, _, _)| (*rank, *at));
let mut events = Vec::new(); let mut events = Vec::new();
let mut outgoing: Vec<(Vec<ServerInfo>, v2::Deposit)> = Vec::new();
for (_, received_at, si, mailbox, env) in envs { for (_, received_at, si, mailbox, env) in envs {
let sp = &mut self.spaces[si]; let sp = &mut self.spaces[si];
let Some(ci) = sp.state.contacts.iter().position(|c| { let Some(ci) = sp.state.contacts.iter().position(|c| {
@@ -896,7 +903,10 @@ impl MeowClient {
Some(v2::peer_envelope::Body::Invitation(inv)) if inv.step == 2 => { Some(v2::peer_envelope::Body::Invitation(inv)) if inv.step == 2 => {
match invitation::accept(contact, &inv, now()) { match invitation::accept(contact, &inv, now()) {
Ok(confirm) => { Ok(confirm) => {
outgoing.push((peer_servers(contact), invitation::confirm_deposit(contact, &confirm)?)); let d = invitation::confirm_deposit(contact, &confirm)?;
sp.state
.outbox
.push(outbox::item(&contact.id, vec![], &d, peer_servers(contact)));
events.push(Event::InvitationAccepted { events.push(Event::InvitationAccepted {
contact: contact.name.clone(), contact: contact.name.clone(),
}); });
@@ -907,7 +917,10 @@ impl MeowClient {
Some(v2::peer_envelope::Body::Invitation(inv)) if inv.step == 3 => { Some(v2::peer_envelope::Body::Invitation(inv)) if inv.step == 3 => {
match invitation::finalize(contact, &inv) { match invitation::finalize(contact, &inv) {
Ok(ack) => { Ok(ack) => {
outgoing.push((peer_servers(contact), messaging::deposit_for(contact, &ack)?)); let d = messaging::deposit_for(contact, &ack)?;
sp.state
.outbox
.push(outbox::item(&contact.id, vec![], &d, peer_servers(contact)));
events.push(Event::ContactActivated { events.push(Event::ContactActivated {
contact: contact.name.clone(), contact: contact.name.clone(),
}); });
@@ -973,13 +986,10 @@ impl MeowClient {
self.retire_mailboxes(si, before); self.retire_mailboxes(si, before);
} }
} }
// Persist before anything leaves the device. // Persist (state, history, acks, queued replies) before anything leaves the device.
self.save().await?; self.save().await?;
for (servers, deposit) in outgoing { self.flush(false).await?;
if let Err(e) = self.deliver(&servers, vec![deposit]).await { events.append(&mut self.pending_events);
tracing::warn!("could not deliver handshake message: {e}");
}
}
Ok(events) Ok(events)
} }
} }
+274
View File
@@ -0,0 +1,274 @@
//! Persistent send queue (roadmap lot 5.5).
//!
//! Every deposit (user message or handshake message) is first stored as an
//! [`OutboxItem`] in the same save as the ratchet state that produced it, then posted
//! to the recipient's pull servers. Servers that accept it are removed from the item;
//! the others are retried with exponential backoff until the item expires. Deposits due
//! at the same time are grouped into one `Post` per server.
//!
//! This is also where Matriochka routing will plug in (roadmap 8.2): an item will carry
//! a route and a release time instead of a plain list of servers.
use std::collections::{BTreeMap, HashMap};
use std::time::Duration;
use futures_util::future::join_all;
use meow_core::contact::ContactId;
use meow_core::server::ServerInfo;
use meow_crypto::SignPublic;
use meow_proto::v2::{self, request::Body as Req, response::Body as Resp};
use meow_proto::Message;
use meow_store::OutboxItem;
use crate::{now, Error, Event, MeowClient, Result};
/// When to retry and when to give up.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct RetryPolicy {
/// Delay before the first retry; doubled at each attempt.
pub base: Duration,
/// Upper bound of the delay between two attempts.
pub max_delay: Duration,
/// An item older than this is dropped ([`Event::SendFailed`] if no server took it).
pub max_age: Duration,
}
impl Default for RetryPolicy {
fn default() -> Self {
Self {
base: Duration::from_secs(5),
max_delay: Duration::from_secs(3600),
max_age: Duration::from_secs(7 * 86_400),
}
}
}
impl RetryPolicy {
/// Delay after `attempts` failed attempts, with ±20 % jitter.
fn delay(&self, attempts: u32) -> u64 {
let base = self.base.as_secs().max(1);
let d = base
.saturating_mul(1u64 << attempts.saturating_sub(1).min(32))
.min(self.max_delay.as_secs().max(base));
let spread = (d * 2 / 5).max(1);
let r = u64::from_le_bytes(meow_crypto::random_bytes::<8>()) % (spread + 1);
d - d / 5 + r
}
}
/// A queued deposit, as shown to the user.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PendingSend {
pub contact: String,
/// Empty for handshake messages.
pub message_id: Vec<u8>,
/// Servers that already accepted it (it is still retried on the others).
pub accepted: u32,
pub attempts: u32,
pub next_attempt: u64,
}
/// Deposits per `Post` and their total payload size.
const MAX_BATCH: usize = 64;
const MAX_BATCH_BYTES: usize = 8 * 1024 * 1024;
pub(crate) fn item(
contact: &ContactId,
message_id: Vec<u8>,
deposit: &v2::Deposit,
servers: Vec<ServerInfo>,
) -> OutboxItem {
let t = now();
OutboxItem {
id: meow_crypto::random_bytes::<16>().to_vec(),
contact: contact.clone(),
message_id,
deposit: deposit.encode_to_vec(),
pending: servers,
accepted: 0,
attempts: 0,
created_at: t,
next_attempt: t,
}
}
type Batch = Vec<(usize, Vec<u8>, v2::Deposit)>; // (space, item id, deposit)
impl MeowClient {
/// Change the retry policy of the send queue.
pub fn set_retry_policy(&mut self, policy: RetryPolicy) {
self.retry = policy;
}
/// Deposits not yet accepted by every server.
pub fn pending_sends(&self) -> Vec<PendingSend> {
self.spaces
.iter()
.flat_map(|sp| {
sp.state.outbox.iter().map(|o| PendingSend {
contact: sp
.state
.contacts
.iter()
.find(|c| c.id == o.contact)
.map(|c| c.name.clone())
.unwrap_or_default(),
message_id: o.message_id.clone(),
accepted: o.accepted,
attempts: o.attempts,
next_attempt: o.next_attempt,
})
})
.collect()
}
/// Try to deliver queued deposits: those due (or all, with `force`). Returns, per
/// item id, how many servers accepted it now. Expiries go to `pending_events`.
pub(crate) async fn flush(&mut self, force: bool) -> Result<HashMap<Vec<u8>, usize>> {
let t = now();
let events = &mut self.pending_events;
// Expired items.
let max_age = self.retry.max_age.as_secs();
for sp in &mut self.spaces {
let before = sp.state.outbox.len();
let contacts = &sp.state.contacts;
sp.state.outbox.retain(|o| {
let expired = t >= o.created_at.saturating_add(max_age);
if expired && o.accepted == 0 {
events.push(Event::SendFailed {
contact: contacts
.iter()
.find(|c| c.id == o.contact)
.map(|c| c.name.clone())
.unwrap_or_default(),
message_id: o.message_id.clone(),
});
}
!expired
});
sp.dirty |= sp.state.outbox.len() != before;
}
// Due deposits grouped by server, in queue order.
let mut by_server: BTreeMap<SignPublic, (ServerInfo, Batch)> = BTreeMap::new();
let mut due: Vec<(usize, Vec<u8>)> = Vec::new();
for (si, sp) in self.spaces.iter().enumerate() {
for o in sp.state.outbox.iter().filter(|o| force || o.next_attempt <= t) {
let deposit = match v2::Deposit::decode(o.deposit.as_slice()) {
Ok(d) => d,
Err(e) => {
tracing::warn!("dropping corrupted queued deposit: {e}");
continue;
}
};
due.push((si, o.id.clone()));
for s in &o.pending {
by_server
.entry(s.sign_key)
.or_insert_with(|| (s.clone(), Vec::new()))
.1
.push((si, o.id.clone(), deposit.clone()));
}
}
}
if due.is_empty() {
self.save().await?;
return Ok(HashMap::new());
}
// One Post per server and batch; a rejected batch is retried item by item, so
// one bad deposit cannot block the others.
let mut batches: Vec<(ServerInfo, Batch)> = Vec::new();
for (server, items) in by_server.into_values() {
let mut cur: Batch = Vec::new();
let mut size = 0;
for it in items {
let n = it.2.payload.len();
if !cur.is_empty() && (cur.len() >= MAX_BATCH || size + n > MAX_BATCH_BYTES) {
batches.push((server.clone(), std::mem::take(&mut cur)));
size = 0;
}
size += n;
cur.push(it);
}
if !cur.is_empty() {
batches.push((server, cur));
}
}
let results = join_all(batches.iter().map(|(s, b)| self.post(s, b))).await;
let mut accepted: Vec<(usize, Vec<u8>, SignPublic)> = Vec::new();
for ((server, batch), r) in batches.iter().zip(results) {
match r {
Ok(()) => accepted.extend(batch.iter().map(|(si, id, _)| (*si, id.clone(), server.sign_key))),
Err(Error::Network(e)) => tracing::warn!("deposit on {} failed: {e}", server.url),
Err(e) if batch.len() > 1 => {
tracing::warn!("{} rejected a batch ({e}): retrying one by one", server.url);
for one in batch {
match self.post(server, std::slice::from_ref(one)).await {
Ok(()) => accepted.push((one.0, one.1.clone(), server.sign_key)),
Err(e) => tracing::warn!("{} rejected a deposit: {e}", server.url),
}
}
}
Err(e) => tracing::warn!("{} rejected a deposit: {e}", server.url),
}
}
// Update the items.
let mut now_accepted: HashMap<Vec<u8>, usize> = HashMap::new();
for (si, id, key) in accepted {
if let Some(o) = self.spaces[si].state.outbox.iter_mut().find(|o| o.id == id) {
o.pending.retain(|s| s.sign_key != key);
o.accepted += 1;
*now_accepted.entry(id).or_default() += 1;
}
}
for (si, id) in due {
let retry = self.retry;
let sp = &mut self.spaces[si];
if let Some(o) = sp.state.outbox.iter_mut().find(|o| o.id == id) {
o.attempts += 1;
o.next_attempt = t + retry.delay(o.attempts);
}
sp.state.outbox.retain(|o| !o.pending.is_empty());
sp.dirty = true;
}
self.save().await?;
Ok(now_accepted)
}
/// Deliver queued deposits now, without waiting for their retry time. Returns the
/// pending events (e.g. [`Event::SendFailed`]).
pub async fn flush_outbox(&mut self) -> Result<Vec<Event>> {
self.flush(true).await?;
Ok(std::mem::take(&mut self.pending_events))
}
async fn post(&self, server: &ServerInfo, batch: &[(usize, Vec<u8>, v2::Deposit)]) -> Result<()> {
let deposits = batch.iter().map(|(_, _, d)| d.clone()).collect();
match self
.transport
.call(server, Req::Post(v2::Post { deposits }), Duration::ZERO)
.await?
{
Resp::PostAck(_) => Ok(()),
_ => Err(Error::Invalid("unexpected response".into())),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn backoff_grows_and_is_capped() {
let p = RetryPolicy::default();
let d1 = p.delay(1);
assert!((4..=6).contains(&d1), "{d1}");
let d4 = p.delay(4);
assert!((32..=48).contains(&d4), "{d4}");
let d30 = p.delay(30);
assert!((2880..=4320).contains(&d30), "{d30}");
}
}
+100
View File
@@ -193,11 +193,16 @@ async fn file_and_server_invitations_then_messaging() {
struct FlakyStore { struct FlakyStore {
inner: MemoryStore, inner: MemoryStore,
drop_acks: std::sync::atomic::AtomicBool, drop_acks: std::sync::atomic::AtomicBool,
/// Refuse deposits (the server answers with an error).
fail_posts: std::sync::atomic::AtomicBool,
} }
#[async_trait::async_trait] #[async_trait::async_trait]
impl meow_server::store::ServerStore for FlakyStore { impl meow_server::store::ServerStore for FlakyStore {
async fn post(&self, mb: [u8; 32], payload: Vec<u8>, now: u64) -> meow_server::store::StoreResult<()> { 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 self.inner.post(mb, payload, now).await
} }
async fn fetch( 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: /// What a client that crashed right after receiving the response would have done:
/// pull without ever acknowledging. /// pull without ever acknowledging.
async fn raw_pull( async fn raw_pull(
@@ -266,6 +292,7 @@ async fn no_message_lost_when_the_client_dies() {
let store = Arc::new(FlakyStore { let store = Arc::new(FlakyStore {
inner: MemoryStore::new(notify.clone(), 1000), inner: MemoryStore::new(notify.clone(), 1000),
drop_acks: false.into(), drop_acks: false.into(),
fail_posts: false.into(),
}); });
let limits = Limits { let limits = Limits {
max_pull_messages: 2, // force the "more" path max_pull_messages: 2, // force the "more" path
@@ -415,3 +442,76 @@ async fn hidden_contacts() {
assert_eq!(alice.history("bob").unwrap().len(), 3); assert_eq!(alice.history("bob").unwrap().len(), 3);
let _ = std::fs::remove_dir_all(&dir); 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);
}
+45 -3
View File
@@ -44,7 +44,7 @@ use meow_crypto::password::KdfParams;
use rusqlite::{Connection, OptionalExtension}; use rusqlite::{Connection, OptionalExtension};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
pub use model::{Batch, Content, HistoryEntry, HistoryPage, PendingAck, RetiredMailbox, SpaceId, State}; pub use model::{Batch, Content, HistoryEntry, HistoryPage, OutboxItem, PendingAck, RetiredMailbox, SpaceId, State};
#[derive(Debug, thiserror::Error)] #[derive(Debug, thiserror::Error)]
pub enum Error { pub enum Error {
@@ -101,9 +101,15 @@ struct Root {
struct Index { struct Index {
meta: Option<ObjectRef>, meta: Option<ObjectRef>,
contacts: Vec<ContactEntry>, contacts: Vec<ContactEntry>,
outbox: Vec<(Vec<u8>, ObjectRef)>,
free: Vec<BlockId>, free: Vec<BlockId>,
} }
fn outbox_key(id: &[u8]) -> String {
let hex: String = id.iter().map(|b| format!("{b:02x}")).collect();
format!("outbox/{hex}")
}
#[derive(Clone, Serialize, Deserialize)] #[derive(Clone, Serialize, Deserialize)]
struct ContactEntry { struct ContactEntry {
id: ContactId, id: ContactId,
@@ -453,6 +459,13 @@ impl Store {
} }
state.contacts.push(c); state.contacts.push(c);
} }
for (id, r) in &sp.index.outbox {
let bytes = blocks::get(&self.conn, &sp.key, r)?;
sp.written.insert(outbox_key(id), meow_crypto::sha256(&[&bytes]));
let item: model::OutboxItem =
postcard::from_bytes(&bytes).map_err(|e| Error::Corrupted(format!("outbox: {e}")))?;
state.outbox.push(item);
}
Ok(state) Ok(state)
} }
@@ -466,6 +479,7 @@ impl Store {
let new_index_ref; let new_index_ref;
let new_free; let new_free;
let new_contacts; let new_contacts;
let new_outbox;
let new_meta; let new_meta;
{ {
let mut w = Writer::new(&tx, &sp.key, sp.index.free.clone()); let mut w = Writer::new(&tx, &sp.key, sp.index.free.clone());
@@ -527,6 +541,28 @@ impl Store {
} }
contacts_idx = entries; contacts_idx = entries;
// Send queue: one object per item, rewritten only when it changed.
let mut outbox_idx = Vec::with_capacity(state.outbox.len());
for (id, r) in &sp.index.outbox {
if !state.outbox.iter().any(|o| o.id == *id) {
w.release(r);
}
}
for item in &state.outbox {
let bytes = encode(item)?;
let h = meow_crypto::sha256(&[&bytes]);
let key = outbox_key(&item.id);
let old = sp.index.outbox.iter().find(|(id, _)| *id == item.id).map(|(_, r)| r);
let r = match old {
Some(r) if sp.written.get(&key) == Some(&h) => r.clone(),
old => {
written.push((key, h));
w.put(&bytes, old)?
}
};
outbox_idx.push((item.id.clone(), r));
}
// History and files, per conversation. // History and files, per conversation.
type Pending = (ContactId, Vec<HistoryEntry>, Vec<(Vec<u8>, Vec<u8>)>); type Pending = (ContactId, Vec<HistoryEntry>, Vec<(Vec<u8>, Vec<u8>)>);
let mut by_contact: Vec<Pending> = Vec::new(); let mut by_contact: Vec<Pending> = Vec::new();
@@ -565,6 +601,7 @@ impl Store {
encode(&Index { encode(&Index {
meta: meta_ref.clone(), meta: meta_ref.clone(),
contacts: contacts_idx.clone(), contacts: contacts_idx.clone(),
outbox: outbox_idx.clone(),
free: free.to_vec(), free: free.to_vec(),
}) })
})?; })?;
@@ -581,6 +618,7 @@ impl Store {
new_index_ref = r; new_index_ref = r;
new_free = w.free; new_free = w.free;
new_contacts = contacts_idx; new_contacts = contacts_idx;
new_outbox = outbox_idx;
new_meta = meta_ref; new_meta = meta_ref;
} }
tx.commit()?; tx.commit()?;
@@ -590,10 +628,14 @@ impl Store {
sp.index = Index { sp.index = Index {
meta: new_meta, meta: new_meta,
contacts: new_contacts, contacts: new_contacts,
outbox: new_outbox,
free: new_free, free: new_free,
}; };
sp.written sp.written.retain(|k, _| {
.retain(|k, _| k == "meta" || state.contacts.iter().any(|c| *k == format!("contact/{}", c.id.0))); k == "meta"
|| state.contacts.iter().any(|c| *k == format!("contact/{}", c.id.0))
|| state.outbox.iter().any(|o| *k == outbox_key(&o.id))
});
sp.written.extend(written); sp.written.extend(written);
Ok(()) Ok(())
} }
+24
View File
@@ -65,6 +65,29 @@ pub struct RetiredMailbox {
pub servers: Vec<ServerInfo>, pub servers: Vec<ServerInfo>,
} }
/// A deposit waiting to be accepted by servers (persistent send queue).
///
/// Written in the same save as the ratchet state that produced it, so a message is
/// never encrypted without being stored for (re)delivery.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct OutboxItem {
/// Random queue id (16 bytes).
pub id: Vec<u8>,
pub contact: ContactId,
/// Id of the user message, empty for handshake messages.
pub message_id: Vec<u8>,
/// Encoded `meow.v2.Deposit`.
pub deposit: Vec<u8>,
/// Servers that have not accepted the deposit yet.
pub pending: Vec<ServerInfo>,
/// Servers that accepted it.
pub accepted: u32,
pub attempts: u32,
pub created_at: u64,
/// Unix time before which no new attempt is made.
pub next_attempt: u64,
}
/// What the client keeps in memory for one space. Saved as a whole by /// What the client keeps in memory for one space. Saved as a whole by
/// [`crate::Store::save`]; unchanged objects are not rewritten. `nickname` and /// [`crate::Store::save`]; unchanged objects are not rewritten. `nickname` and
/// `servers` are only meaningful in the main space. /// `servers` are only meaningful in the main space.
@@ -75,6 +98,7 @@ pub struct State {
pub contacts: Vec<Contact>, pub contacts: Vec<Contact>,
pub pending_acks: Vec<PendingAck>, pub pending_acks: Vec<PendingAck>,
pub retired_mailboxes: Vec<RetiredMailbox>, pub retired_mailboxes: Vec<RetiredMailbox>,
pub outbox: Vec<OutboxItem>,
} }
/// Append-only data written in the same transaction as a [`State`]. /// Append-only data written in the same transaction as a [`State`].
+46
View File
@@ -371,3 +371,49 @@ fn schema_versions_and_foreign_files() {
)); ));
let _ = std::fs::remove_dir_all(dir); let _ = std::fs::remove_dir_all(dir);
} }
#[test]
fn outbox_items_persist_per_space() {
let (path, dir) = tmp();
let s = server();
let bob = contact("bob", &s);
let item = |n: u8, data: Vec<u8>| meow_store::OutboxItem {
id: vec![n; 16],
contact: bob.id.clone(),
message_id: vec![n; 16],
deposit: data,
pending: vec![s.clone()],
accepted: 0,
attempts: 0,
created_at: 1,
next_attempt: 1,
};
let mut store = Store::create(&path, "alice", "pw", KDF, false).unwrap();
let mut state = store.load(MAIN).unwrap();
state.contacts.push(bob.clone());
// A large deposit spans several blocks.
state.outbox = vec![item(1, vec![7; 10_000]), item(2, b"small".to_vec())];
store.save(MAIN, &state, Batch::default()).unwrap();
let h = store.create_space("hidden").unwrap();
drop(store);
let mut store = Store::open(&path, "pw").unwrap();
let mut loaded = store.load(MAIN).unwrap();
assert_eq!(loaded.outbox, state.outbox);
// Update one, drop the other.
loaded.outbox.retain(|o| o.id[0] == 1);
loaded.outbox[0].attempts = 3;
store.save(MAIN, &loaded, Batch::default()).unwrap();
drop(store);
let mut store = Store::open(&path, "pw").unwrap();
let again = store.load(MAIN).unwrap();
assert_eq!(again.outbox.len(), 1);
assert_eq!(again.outbox[0].attempts, 3);
assert_eq!(again.outbox[0].deposit, vec![7; 10_000]);
// Other spaces have their own queue.
let h2 = store.unlock("hidden").unwrap().unwrap();
assert_eq!(h2, h);
assert!(store.load(h2).unwrap().outbox.is_empty());
let _ = std::fs::remove_dir_all(dir);
}
+9
View File
@@ -181,6 +181,15 @@ kill "${PIDS[1]}"; wait "${PIDS[1]}" 2>/dev/null || true; PIDS[1]=""
expect "send with one server down" "(1 server(s))" meow bob send alice "still here" expect "send with one server down" "(1 server(s))" meow bob send alice "still here"
expect "receive with one server down" "[bob] still here" meow alice 2>/dev/null expect "receive with one server down" "[bob] still here" meow alice 2>/dev/null
step "OFFLINE QUEUE"
kill "${PIDS[0]}"; wait "${PIDS[0]}" 2>/dev/null || true; PIDS[0]=""
expect "send with every server down" "queued for alice" meow bob send alice "written offline"
expect "queued" "alice message accepted by 0 server(s)" meow bob outbox
start_server "$PORT1" srv1
for _ in $(seq 50); do curl -fs "$S1/healthz" >/dev/null 2>&1 && break; sleep 0.1; done
expect "flushed when back (srv2 still down)" "accepted by 1 server(s)" meow bob outbox --flush
expect "received" "[bob] written offline" meow alice 2>/dev/null
step "HISTORY" step "HISTORY"
expect "history" "[alice] hi bob" meow bob history alice expect "history" "[alice] hi bob" meow bob history alice