Barrel
EN GitHub

Tests de bout en bout

Des tests qui exécutent la vraie release dans des processus séparés, pas dans une seule VM.

Réplication

replication.sh lance deux conteneurs barrel_server sur un même réseau et réplique entre eux en HTTP. Contrairement à barrel_server_rep_SUITE, qui exécute les deux pairs dans une seule VM (le serveur est un singleton enregistré), ce sont ici de vrais processus OS séparés : le chemin sur le protocole, l’isolation des processus et le réseau sont tous réels.

$ test/e2e/replication.sh

Le script construit l’image, démarre peer-a et peer-b, puis :

  • écrit des documents sur peer-a et les pousse vers peer-b, en vérifiant la convergence ;
  • écrit sur peer-b et tire vers peer-a ;
  • supprime un document sur peer-a et pousse à nouveau, en vérifiant que la suppression se propage ;
  • démarre une tâche de push continue barrel_rep_tasks entre les pairs, écrit un document et vérifie qu’il converge, puis ajoute une pièce jointe à ce même document sans autre modification du document et vérifie qu’elle converge aussi. Les pièces jointes ont leur propre flux, indépendant du flux de changements des documents : ce scénario ne passe donc que si une tâche continue remarque d’elle-même une activité limitée aux pièces jointes (réveil borné), et non parce qu’une écriture de document vient la relancer par hasard.

Un code de sortie 0 signifie que toutes les vérifications ont réussi. Le script démonte la pile en sortant.

La réplication est déclenchée dans un pair avec barrel_server eval, qui évalue sur le nœud en cours d’exécution : elle exécute donc le vrai algorithme barrel_rep (ou, pour le scénario de tâche continue, barrel_rep_tasks:start_task/1) contre les points d’accès _sync de l’autre pair.

Réplication active-active

active-active.sh lance trois pairs qui acceptent tous des écritures et vérifie qu’ils convergent sans perdre d’écriture :

$ test/e2e/active-active.sh

Il couvre des modifications concurrentes sur deux pairs, neuf modifications par-dessus la version gagnante (l’écriture perdante reste), une suppression face à une modification, une résolution en HTTP avec _observed, l’arrivée d’un nouveau pair vide, un pair qui s’arrête puis revient avec sa propre modification (en apprenant celles des autres par un relais), deux pairs qui résolvent en même temps, une réplication filtrée qui transporte une suppression, et une tâche continue dans les deux sens avec des écritures concurrentes. Chaque scénario compare le digest d’état des documents (_sync/state) sur chaque pair.

Versions mélangées

mixed-version.sh construit un pair à partir d’une release plus ancienne (OLD_REF, par défaut barrel_server-v1.11.1, la dernière release avant la réplication par état complet) et le réplique avec deux pairs mis à niveau, dans les deux sens, avec le réplicateur d’un côté ou de l’autre :

$ test/e2e/mixed-version.sh

L’ancien pair reçoit la version gagnante de chaque document. Ses modifications et suppressions atteignent les pairs mis à niveau comme de nouvelles versions à côté de celles qu’elles remplaçaient : elles y apparaissent comme des conflits et rien n’est perdu ; une résolution faite sur un pair mis à niveau atteint l’ancien pair et n’est pas défaite par lui.

Vecteurs client

client-vectors.sh vérifie que le vecteur que vous fournissez avec un document reste attaché à sa version sur trois pairs et un pair de la release précédente (OLD_REF, par défaut barrel_server-v1.14.2 ; OLD_PORT, par défaut 8094, est son port sur l’hôte) :

$ test/e2e/client-vectors.sh

Deux pairs écrivent le même document avec leurs propres vecteurs. Chaque pair garde le vecteur du gagnant et celui de la version perdante, une résolution qui revient à la version perdante atteint chaque pair avec son vecteur, et une résolution envoyée avec _observed et _embedding porte le sien. Une version relayée par l’ancien pair y perd son vecteur et le retrouve à la prochaine synchronisation directe depuis un pair mis à niveau.

Crashs

crash.sh tue des pairs avec SIGKILL pendant la réplication :

$ test/e2e/crash.sh

Il tue la cible d’un push continu au milieu d’un lot, puis le pair qui exécute la tâche (les écritures acquittées doivent survivre et la tâche restaurée doit aller au bout), puis l’un de deux pairs qui écrivent les mêmes identifiants pendant qu’une tâche bidirectionnelle tourne. Chaque écriture acquittée doit se trouver sur les deux pairs une fois qu’ils ont convergé.

Coupures de courant

power-fail.sh place le répertoire de données de chaque pair sur LazyFS, un système de fichiers FUSE qui garde dans sa propre mémoire chaque écriture qui n’a pas été synchronisée par fsync. Une coupure de courant tue le serveur, efface cette mémoire et redémarre le conteneur : ce qui n’était pas synchronisé disparaît, comme après une vraie perte d’alimentation. Les conteneurs tournent en mode privilégié (FUSE).

$ test/e2e/power-fail.sh

Il vérifie d’abord le harnais (un fichier non synchronisé perd ses données, un fichier synchronisé les garde), puis : les écritures faites avec sync => true survivent ; une cible qui perd un lot qu’elle avait acquitté le reçoit à nouveau, depuis une exécution ponctuelle comme depuis une tâche continue ; et un pair qui perd des écritures ayant déjà atteint l’autre pair les récupère par une tâche bidirectionnelle.

Backend de pièces jointes S3

attachments-s3.sh lance de vrais conteneurs RustFS et Garage ainsi que deux pairs barrel_server construits avec le backend de pièces jointes S3 (le profil rebar3 s3_server), et l’exerce par de vraies routes HTTP et un vrai réseau, et non par la suite CT directement contre le module du backend (celle-ci est apps/barrel_att_s3/test/barrel_att_s3_SUITE.erl).

$ test/e2e/attachments-s3.sh

peer-a garde le backend de pièces jointes par défaut (RocksDB) ; les bases de peer-b pointent leurs att_opts vers RustFS ou Garage. Le script :

  • provisionne RustFS et Garage (attachments-s3-setup.sh, voir plus bas), puis fait l’aller-retour d’une petite pièce jointe et d’une grande (qui passe en multipart) sur chaque stockage, et confirme qu’une suppression renvoie bien 404 ensuite ;
  • exerce la détection de conflit d’écriture create_only directement sur le nœud en cours d’exécution avec barrel_server eval (il n’y a pas encore de câblage If-Match/If-None-Match au niveau HTTP : c’est donc limité à l’API Erlang, comme aujourd’hui en dehors de HTTP) ; il confirme que RustFS rejette réellement une écriture en collision, et que Garage refuse vite avec conditional_writes_unsupported au lieu d’accepter en silence une écriture non protégée. Garage ne peut pas garantir cela, par conception documentée, et tout l’intérêt de la sonde de capacité dans barrel_att_s3_store:open/2 est d’échouer bruyamment au lieu de faire semblant ;
  • réplique un document et sa pièce jointe de peer-a (RocksDB) vers peer-b (S3/RustFS) par le vrai transport HTTP barrel_rep, en confirmant que l’asymétrie documentée (la source a un flux, la cible n’en a pas) n’empêche pas les écritures d’arriver.

attachments-s3-setup.sh

Démarre docker-compose.attachments-s3.yml (RustFS + Garage + deux images de pairs) et provisionne les deux stockages : barrel_att_s3_store:open/2 ne crée jamais de bucket lui-même, et Garage demande en plus une affectation de layout unique avant de servir la moindre requête S3. Utilisé à la fois par attachments-s3.sh et par la branche s3 de la CI ; vous pouvez le lancer seul pour itérer en local contre la suite CT :

$ eval "$(test/e2e/attachments-s3-setup.sh)"
$ rebar3 as s3 ct --suite apps/barrel_att_s3/test/barrel_att_s3_SUITE

Idempotent pour RustFS. Pas idempotent pour Garage après la première exécution : Garage ne révèle plus jamais le secret d’une clé après sa création, donc relancer sur un volume déjà provisionné échoue bruyamment plutôt que de réutiliser en silence une clé dont le secret est perdu. Lancez d’abord docker compose -f test/e2e/docker-compose.attachments-s3.yml down -v pour repartir de zéro.

Prérequis

Docker et le plugin Compose. L’image construit la release barrel_server sur Debian (en compilant rocksdb et la NIF vectorielle) : la première exécution prend donc quelques minutes ; les suivantes réutilisent l’image en cache. attachments-s3.sh tire en plus les images épinglées rustfs/rustfs et dxflrs/garage ; le script de configuration sort avec un code non nul, sans rien afficher, si un tirage ou une étape de provisionnement échoue.

Traduit de la page anglaise: /docs/contribute/end-to-end-tests/ (test/e2e/README.md) Modifier cette page Voir en Markdown

Haut et bas pour se déplacerEntrée pour ouvrir