Écrivez sur chaque copie.
Chaque base Barrel accepte les écritures : sur un serveur, sur un nœud en périphérie, dans un navigateur. La réplication garde les copies d’accord. Elles choisissent partout le même gagnant, gardent chaque modification concurrente jusqu’à ce que vous la résolviez, et reprennent là où elles s’étaient arrêtées après une panne.
Pas de leader, pas de primaire, pas de quorum à attendre. Chaque copie travaille seule et se met à jour dès qu’elle peut joindre les autres.
Deux sites modifient la même tâche
Coupez la liaison, modifiez des deux côtés, synchronisez. Aucune modification n’est perdue : les deux copies choisissent la même gagnante et gardent l’autre modification comme conflit jusqu’à ce que quelqu’un le résolve.
L’appel derrière votre dernière actionDémonstration dans votre navigateur, selon les règles de barrel
Ce qu’elle garantit, et comment nous le vérifions
Chaque propriété indique ce qui la teste. Les preuves et les scripts de bout en bout sont dans le dépôt ; vous pouvez les exécuter vous-même.
Toutes les copies sont d’accord
Les copies convergent vers le même gagnant, le même corps et le même état de suppression pour chaque document, quel que soit l’ordre d’arrivée des écritures.
Vérifié par un modèle TLA+ de trois répliques avec pannes, des preuves Lean des lois de fusion, et le script active-active à trois pairs.
Aucune écriture n’est perdue
Une écriture ne remplace que les versions qu’elle a lues. Les modifications concurrentes restent côte à côte, en conflit, jusqu’à ce que quelqu’un les résolve.
Vérifié par une preuve Ivy pour un nombre quelconque de répliques et d’écrivains, et le script active-active (neuf modifications sur le gagnant, l’écriture perdante reste).
Sans risque à rejouer
La livraison est idempotente : un lot envoyé deux fois ne change rien. Un point de reprise après chaque lot permet à une exécution de reprendre là où elle s’est arrêtée.
Vérifié par le script de panne, qui tue la cible au milieu d’un lot, puis le pair qui exécute la tâche.
Résiste aux coupures de courant
Les écritures faites avec sync => true survivent à une coupure de courant. Une copie qui perd un lot qu’elle avait acquitté le reçoit de nouveau à l’exécution suivante.
Vérifié par le script de coupure de courant sur LazyFS, qui jette toute écriture non vidée sur disque.
Les fichiers voyagent avec les documents
Les pièces jointes se répliquent dans leur propre phase, envoyées par morceaux, et le point de reprise n’avance qu’au-delà de ce que la cible a confirmé avoir stocké.
Vérifié par le script de réplication, y compris une pièce jointe ajoutée sans changement du document.
Mises à jour progressives
Un pair resté sur la version précédente continue de répliquer avec les pairs mis à jour, dans les deux sens. Ses modifications apparaissent comme des conflits, jamais comme des écritures perdues.
Vérifié par le script multiversion contre barrel_server 1.11.1.
Un maillage, et un navigateur qui passe hors ligne
Coupez le lien entre Paris et Berlin, leurs modifications se rejoignent quand même, relayées par Lyon. Mettez le navigateur hors ligne : il continue de lire et d’écrire, compte ce qu’il n’a pas encore poussé, et se met à jour en une synchronisation.
Trois sites et un navigateur
Coupez des liens, mettez le navigateur hors ligne, modifiez où vous voulez, puis synchronisez. Les modifications passent par les pairs joignables, et chaque copie finit sur le même gagnant avec les mêmes conflits.
Liens
Démonstration dans votre navigateur, selon les règles de réplication de barrel
Topologies
Un seul protocole, dans la même VM ou en HTTP. Disposez les copies comme l’est votre réseau.
- ParisLyon push et pull
Deux sites, dans les deux sens
Les deux acceptent des écritures ; une tâche dans chaque sens les garde proches.
- hubnœud 1nœud 2nœud 3 tâches continues
Un hub et des nœuds en périphérie
Les nœuds poussent vers un hub et récupèrent ce que les autres ont écrit.
- centralcanal mobile filtre à la source
Un sous-ensemble par appareil
Un canal ou un filtre de requête décide de ce que reçoit chaque copie.
- barrel_serveronglet Aonglet B /db/:db/_sync
Navigateurs
barrel-lite garde une copie dans le navigateur et se synchronise par le même protocole.
Une exécution, étape par étape
Une exécution ponctuelle et une tâche continue font la même chose ; une tâche continue simplement de le faire.
- 1
Lire le point de reprise pour trouver le dernier changement envoyé.
- 2
Récupérer les changements depuis, filtrés à la source.
- 3
Demander à la cible les versions qui lui manquent, en un seul aller-retour.
- 4
Envoyer les états de documents manquants ; en appliquer un deux fois est sans effet.
- 5
Enregistrer le point de reprise du lot, puis envoyer les pièces jointes.
La mettre en place
Entre deux bases sur un même nœud
Relancez-la plus tard pour récupérer les nouveaux changements ; elle reprend depuis son point de reprise.
{ok, Result} = barrel_rep:replicate(<<"paris">>, <<"lyon">>),
#{docs_written := N} = Result. Vers un autre nœud, en HTTP
L’autre côté est une base servie par un barrel_server en marche.
Lyon = barrel_rep_transport_http:endpoint(
<<"http://lyon.example:8080/db/tasks">>),
%% push, puis pull
{ok, _} = barrel_rep:replicate(<<"tasks">>, Lyon,
#{target_transport => barrel_rep_transport_http}),
{ok, _} = barrel_rep:replicate(Lyon, <<"tasks">>,
#{source_transport => barrel_rep_transport_http}). La garder en marche
Une tâche survit aux redémarrages et rattrape son retard après une interruption. Dans le navigateur, barrel-lite se synchronise par le même protocole.
{ok, TaskId} = barrel_rep_tasks:start_task(#{
source => <<"tasks">>,
target => <<"http://lyon.example:8080/db/tasks">>,
mode => continuous,
direction => both}). import { Database } from "barrel-lite";
const db = await Database.open("tasks", {
remote: { url: "https://lyon.example:8080",
db: "sp_...", token: "bsp_..." },
});
const live = db.liveSync(); // push et pull, adaptatif
// live.stop(); Les identifiants viennent de la configuration du serveur, jamais de la tâche elle-même.
Un conflit, d’après une exécution enregistrée
Les deux sites ont modifié task:1 pendant qu’ils étaient séparés, puis ont répliqué dans les deux sens.
barrel_docdb:get_conflicts(<<"edge_a">>, <<"task:1">>).
{ok, #{<<"_observed">> := Seen}} =
barrel_docdb:get_doc(<<"edge_a">>, <<"task:1">>,
#{conflicts => true}).
barrel_docdb:resolve_conflict(<<"edge_a">>, <<"task:1">>,
Seen, {merge, Merged}). {ok,[<<"000001a1b879d59100000000@w7bcb971434496877">>]}
{ok,#{id => <<"task:1">>, conflicts_resolved => 1,
rev => <<"000001a1b879d59500000000@w7bcb971434496877">>}} Après une réplication de plus, edge_b détient la version résolue et plus aucun conflit.
Ce qui ne se réplique pas encore
- Les index vectoriels. En mode enregistrement, le texte et les métadonnées se répliquent et chaque copie reconstruit son index ; un client peut récupérer les vecteurs stockés avec les documents.
- La provenance. L’auteur d’un document reste dans l’historique de l’origine ; sur les autres copies, l’arrivée est enregistrée comme répliquée, depuis cette origine.
- L’API barrel. La réplication fonctionne sur la couche documents : appelez
barrel_repetbarrel_rep_tasksavec le nom de la base. - Les certificats client en HTTP/3. Utilisez HTTP/1.1 ou HTTP/2 avec TLS si vous avez besoin de mTLS entre les nœuds.
- Les canaux ne suppriment pas, des répliques qui les détiennent déjà, les documents qui quittent un canal.