Partage de document
Bonjour,
Je suis sur le développement d'un logiciel qui ordonne un graphe avec exécution des nœuds en local ou à distance.
Ce logiciel est développé en Python et j'utilise ZMQ pour les briques réseau.
Je cherche des ressources sur le partage de documents - ala Google docs ou équivalent. Mais je ne trouve rien, d'où la tentative sur ce forum, en espérant être dans la bonne rubrique.
Il doit sûrement y avoir de l'information quelque part, mais je n'ai pas encore trouvé les mots clés magiques.
Pour être plus précis sur mes intentions :
J'ai un logiciel pour éditer des graphes.
Je cherche à partager l'état du graphe quand d'autres personnes éditent le même graphe de leurs côtés, en "temps réels".
Dans mes premières implémentations, je modifie directement le graphe :
- l'UI détecte le changement et se met à jour entièrement
- pour l'undo/redo, je sauvegarde le graph dans son intégralité
Même avec des graphes complexes pour notre usage, la sérialisation ASCII en JSON ne dépasse pas les 500 ko.
La réactivité de l'UI est largement suffisante - quelques millisecondes - et en contrôlant la taille de la pile des undo, je n'ai jamais explosé la mémoire.
Jusque là, la méthode brusque de traiter l'ensemble du graph comme un état est simple et efficace.
Dès que je suis passé sur la fonctionnalité de document partagé, en revanche, cela a commencé à être problématique.
Je n'ai plus un utilisateur hystérique qui clic et déplace ces nœuds dans le graph (2-3 actions par seconde, je n'ai pas de mesures précises sur ce point ), mais 5 ou 6 en même temps, tous sous intraveineuse de caféine.
Sur des petits graphes d'une dizaine de nœuds, tout va bien. Sur des graphes plus complexes d'une centaine de nœuds, je perds en fluidité.
L'UI commence à le ressentir, et je pense surtout que mon goulot d'étranglement est le réseau.
J'arrive aux limites de l'approche "état complet du document".
Car même si l'utilisateur effectue une action sur un couple de nœuds, je me trimballe l'ensemble du graphe.
Idem pour un undo qui me recharge tout.
Je suis donc passé par l'approche Command
Je n'édite plus le graphe directement, je construis une commande qui édite le graphe.
Et je fais passer la commande par le réseau.
Alors en test avec deux utilisateurs, cela va très bien, même avec un graphe volontairement gigantesque.
Je vous épargne les problématiques de débutant : une boucle/ping-pong entre les deux utilisateurs me modifiant le document à l'infini.
Mais dès que je monte le nombre d'utilisateurs, l'ordonnancement des commandes pose problème.
Par exemple : le déplacement d'un nœud d'un utilisateur distant - commande réseau - qui a été supprimé entre l'émission et la réception - commande locale
J'ai envisagé de faire un hashing de mon document, pour être sûr d'avoir le même état avant d'appliquer une commande.
Mais que faire si justement je n'ai plus le même état...
Je pense être sur la bonne piste par rapport à la "performance" réseau, mais il me manque des "briques" sur la partie synchronisation.
Je suis donc à la recherche de documentations, d'exemples à étudier, de pistes sur ce genre de fonctionnalités.
Merci de votre aide
Stéphane
Répondre avec citation
Partager