J'ai commencé à chercher des approches de synchronisation des données parmi un ensemble de pairs. Les pairs doivent pouvoir travailler de manière déconnectée, puis se synchroniser ensemble pour fusionner leurs modifications locales.
Les pairs devraient pouvoir fusionner les mises à jour locales avec une «fusion à trois» . Ainsi, lors de la synchronisation, les pairs doivent savoir quels faits sont les plus récents, mais là où il n'y a pas d'ordre strict, ils devraient pouvoir fusionner les faits en fonction de la racine commune.
Lorsque des pairs indépendants apportent des modifications, ils peuvent les «horodater» avec une «horloge». J'utilise le terme «horloge» et «horodatage» mais je ne parle pas d'une horloge murale. Je veux dire une sorte d'ordre partiel des événements qui rend la causalité claire. C'est la relation «arrivé avant» entre les événements qui forme un graphe acyclique dirigé (DAG).
Il semble que la façon "habituelle" de construire cet ordre partiel consiste à utiliser une horloge vectorielle . Celles-ci peuvent cependant devenir très importantes. Des développements plus récents tels que les horloges d'arbre à intervalles offrent un stockage plus compact des horodatages.
Ce que je ne sais pas du tout, c'est pourquoi les protocoles de synchronisation ne stockent pas "simplement" le DAG de manière explicite. (Ou le font-ils?)
Les pairs peuvent créer indépendamment un horodatage en générant aléatoirement un UUID (ou par d'autres moyens tels que <peer-name> + <local-monotonically-increasing-counter>
). L'ordre de cet horodatage est parfaitement clair pour ce pair.
Lorsque 2 pairs se synchronisent, ils peuvent convenir d'un nouvel horodatage. Encore une fois, l'ordre de cet horodatage est clair pour les deux pairs.
Il est maintenant nécessaire de transmettre les événements avant le DAG entre homologues, mais les exigences de stockage et de bande passante sont faibles. Les points temporels sont des sommets de graphe. En tant que tels, ils ont 1 ou 2 fronts entrants (1 pour un événement sur un client et 2 pour une synchronisation entre les clients). Ceci est limité et indépendant du nombre de pairs dans le réseau.
Pour utiliser un point temporel individuel, vous avez besoin du graphique des points temporels qui y mènent. Cependant, pour autant que je puisse voir, tout homologue capable de connaître un point dans le temps (il l'a généré lui-même, ou l'a généré avec un autre homologue, ou a été informé par un autre homologue lors de la synchronisation avec lui) a également eu une occasion de connaître l'histoire menant à ce moment. Je pense qu'il y a probablement une preuve inductive pour cela.
Étant donné que le stockage et la synchronisation du DAG semblent explicitement simples: est-ce utilisé en pratique? Sinon, pourquoi privilégier les horloges vectorielles?
Remarques
D'égal à égal
Je préfère une solution peer to peer à une solution client-serveur.
La topologie de fin probable sera que de nombreux clients se connectent à un groupe beaucoup plus petit de serveurs qui se répliquent entre eux. Cependant, ce serait bien d'avoir une solution générale qui prend en charge cette topologie particulière plutôt qu'une solution qui nécessite cette topologie spécifique.