Synchronisation d'objets entre deux systèmes disparates, meilleure approche?

Question

Je travaille sur la synchronisation de deux objets de gestion entre un iPhone et un site Web en utilisant une charge utile basée sur XML et aimerais solliciter quelques idées pour une routine optimale.

La nature de cette question est assez bien générique et je peux voir qu'il soit applicable à une variété de systèmes différents qui ont besoin de synchroniser des objets d'affaires entre une entité et un client Web (ordinateur de bureau, téléphone portable, etc.)

Les objets métier peuvent être modifiés, supprimés et mis à jour des deux côtés. Les deux côtés peuvent stocker l'objet localement, mais la synchronisation n'est initiée que sur le côté de l'iPhone pour une visualisation déconnectée. Tous les objets ont un horodatage updated_at et created_at et sont soutenus par un SGBDR des deux côtés (SQLite côté iPhone et MySQL sur le web ... encore une fois je ne pense pas que cela soit important) et le téléphone enregistre la dernière fois la synchronisation a été tentée. Sinon, aucune autre donnée n'est stockée (pour le moment).

Quel algorithme utiliseriez-vous pour minimiser les bavardages réseau entre les systèmes de synchronisation? Comment géreriez-vous les suppressions si "soft-deletes" ne sont pas une option? Quels changements de modèle de données ajouteriez-vous pour faciliter cela?

Answer 1

L'approche la plus simple: lors de la synchronisation, transférer tous les enregistrements where updated_at >= @last_sync_at. Inconvénient: cette approche ne tolère pas très bien l'asymétrie de l'horloge. Il est probablement plus sûr de garder une colonne de numéro de version incrémentée chaque fois qu'une ligne est mise à jour (de sorte que l'asymétrie de l'horloge ne gêne pas votre processus de synchronisation) et un numéro de version synchronisé en dernier être indentifié). Pour rendre cette bande passante efficace, conservez un cache dans chaque base de données de la dernière version envoyée à chaque homologue de réplication afin que seules les lignes modifiées soient transmises. Si cela doit être une topologie en étoile, les feuilles peuvent utiliser un schéma simplifié où la dernière version synchronisée est stockée dans chaque table.

Certaines formes de suppressions progressives sont nécessaires pour prendre en charge la synchronisation des suppressions, mais elles peuvent prendre la forme d'un enregistrement "tombstone" qui contient uniquement la clé de la ligne supprimée. Les pierres tombales ne peuvent être supprimées en toute sécurité qu'une fois que vous êtes sûr que toutes les répliques les ont traitées, sinon il est possible qu'une réplique éparse ressuscite un enregistrement que vous pensiez avoir été supprimé.

Answer 2

Donc je pense en résumé que vos questions se rapportent à la synchronisation déconnectée.

Voici donc ce que je pense devrait se produire:

Sync initiale Vous récupérer les données et toutes les informations qui lui sont associés (versions de ligne, de contrôle des fichiers, etc.). Il est important de stocker ces informations et de les laisser intactes jusqu'à la prochaine synchronisation réussie. Les modifications doivent être effectuées sur une COPIE de ces données.

Suivi des modifications Si vous traitez avec des lignes de base de données, l'idée est, vous avez essentiellement pour suivre insérer, mettre à jour et de suppression. Si vous traitez avec des fichiers texte comme xml, alors c'est un peu plus compliqué. S'il est probable que plusieurs utilisateurs éditeront ce fichier en même temps, alors vous devrez avoir un outil de comparaison, ainsi les conflits peuvent être détectés à un niveau plus granulaire (au lieu du fichier entier).

Vérification des conflits Encore une fois, si vous traitez des lignes de base de données, les conflits sont faciles à détecter. Vous pouvez avoir une autre colonne qui s'incrémente chaque fois que la ligne est mise à jour (je pense que mssql a ce builtin pas sûr de mysql). Donc, si la copie que vous avez a un numéro différent de ce qui est sur le serveur, alors vous avez un conflit. Pour les fichiers ou les chaînes, une somme de contrôle fera l'affaire. Je suppose que vous pouvez également utiliser une date modifiée, mais assurez-vous que vous avez une mesure très précise et précise pour éviter les échecs.par exemple: disons que je récupère un fichier et que vous l'enregistrez dès que je l'ai récupéré. Disons que la différence de temps est de 1 milliseconde. Je fais ensuite des modifications au fichier puis j'essaie de le sauvegarder. Si l'heure de la dernière modification enregistrée n'est précise qu'à 10 millisecondes, il y a de fortes chances que le fichier que j'ai récupéré ait la même date que celle que vous avez sauvegardée pour que le programme pense qu'il n'y a pas de conflit et écrase vos modifications. Donc, je n'utilise généralement pas cette méthode juste pour être du bon côté. D'un autre côté, les chances d'une collision checksum/hash après une modification mineure sont proches de zéro.

Résolution de conflits Voici la partie délicate. S'il s'agit d'un processus automatisé, vous devrez alors évaluer la situation et décider si vous souhaitez remplacer les modifications, perdre vos modifications ou récupérer les données du serveur et tenter de rétablir les modifications. Heureusement pour vous, il semble qu'il y aura une interaction humaine. Mais c'est toujours beaucoup de douleur à coder. Si vous traitez des lignes de base de données, vous pouvez vérifier chaque colonne et la comparer aux données du serveur et les présenter à l'utilisateur. L'idée est de présenter les conflits à l'utilisateur de manière très granulaire afin de ne pas les submerger. La plupart des conflits ont de très petites différences dans beaucoup d'endroits différents, alors présentez-les à l'utilisateur une petite différence à la fois. Donc, pour les fichiers texte, c'est presque le même mais plus de cent fois plus compliqué. Donc, fondamentalement, vous devez créer ou utiliser un outil de comparaison (la comparaison de texte est un sujet complètement différent et est trop large pour être mentionné ici) qui vous permet de connaître les petits changements dans le fichier et où ils sont d'une manière similaire à base de données: où le texte a été inséré, supprimé ou modifié. Présentez ensuite cela à l'utilisateur de la même manière. Donc, fondamentalement, pour chaque petit conflit, l'utilisateur devrait choisir de rejeter ses modifications, d'écraser les changements dans le serveur ou d'effectuer une modification manuelle avant de les envoyer au serveur. Donc, si vous avez fait les choses correctement, l'utilisateur devrait recevoir une liste de conflits s'il y en a. Ces conflits doivent être assez granulaires pour que l'utilisateur puisse décider rapidement. Ainsi, par exemple, le conflit est un changement d'orthographe, il serait plus facile pour l'utilisateur de choisir parmi les mots orthographiés contrairement à donner à l'utilisateur tout le paragraphe et lui dire qu'il y avait un changement et qu'ils doivent décider quoi faire , l'utilisateur devrait alors chercher cette petite faute d'orthographe. Autres considérations: Validation des données - Gardez à l'esprit que vous devez effectuer la validation après la résolution des conflits, car les données peuvent avoir changé la comparaison de texte - comme je l'ai dit, c'est un grand sujet. Alors, google! Synchronisation déconnectée - Je pense qu'il y a quelques articles là-bas.

Source: https://softwareengineering.stackexchange.com/questions/94634/synchronization-web-service-methodologies-or-papers