send queue
This commit is contained in:
1 parent
a520ddb557
commit
10af480218
10 files changed
+701
-60
No files matched your search
+92
-1
@@ -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
@@ -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
|
||||||
|
|
||||||
|
|||||||
@@ -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(())
|
||||||
|
|||||||
@@ -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)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -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}");
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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);
|
||||||
|
}
|
||||||
@@ -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(())
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -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`].
|
||||||
|
|||||||
@@ -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);
|
||||||
|
}
|
||||||
@@ -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
|
||||||
|
|
||||||
|
|||||||
Reference in new issue
Block a user