Barrel
EN GitHub

É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.

Mettre en place la réplicationLire les preuves

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.

    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.

    • Deux sites, dans les deux sens

      Les deux acceptent des écritures ; une tâche dans chaque sens les garde proches.

    • 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.

    • Un sous-ensemble par appareil

      Un canal ou un filtre de requête décide de ce que reçoit chaque copie.

    • 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. 1

      Lire le point de reprise pour trouver le dernier changement envoyé.

    2. 2

      Récupérer les changements depuis, filtrés à la source.

    3. 3

      Demander à la cible les versions qui lui manquent, en un seul aller-retour.

    4. 4

      Envoyer les états de documents manquants ; en appliquer un deux fois est sans effet.

    5. 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}).

    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}).
    Sortie de get_conflicts et resolve_conflict, enregistrée sur barrel_docdb 2.1.0
    {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_rep et barrel_rep_tasks avec 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.

    Les bibliothèques derrière

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