Les API de gestion et d'affichage de l'état de synchronisation entre les ressources de l'espace de travail et les ressources situées à un autre emplacement. Les ressources situées en dehors de l'espace de travail sont appelées variantes. La synchronisation consiste à afficher les modifications entre les ressources des différents emplacements et offre à l'utilisateur la possibilité d'affecter l'état de synchronisation en réalisant une action. Les API de synchronisation sont orthogonales par rapport aux API de fournisseur de référentiel et peuvent être utilisées sans fournisseur de référentiel. L'objectif de l'API de synchronisation est de faciliter la tâche d'implémentation des différents modes de présentation de l'état de synchronisation des ressources. En tant que telle, l'API nécessite un moyen d'interroger l'état de synchronisation des ressources mais n'a pas besoin de disposer d'un moyen d'affecter l'état. Le moyen d'affecter l'état est de la responsabilité de l'implémenteur (même si l'interface utilisateur fournit des points d'ancrage pour ajouter aux menus des options de menus spécifiques au fournisseur).
Avant de décrire l'API de synchronisation, il est utile de présenter la terminologie et les concepts liés à la synchronisation de l'espace de travail.
variante de ressource : Une ressource locale mappé vers une ressource qui se trouve à un autre emplacement peut être appelée variante de cette ressource. En d'autres termes, les ressources sont généralement assez similaires mais peuvent différer légèrement (en raison de modifications de la ressource locale ou de modifications apportées par d'autres utilisateurs à la copie distante). Nous partons d'une vue centrique de l'espace de travail local. La copie locale est considérée comme la ressource et la copie distante comme la variante de la ressource.
synchroniser : Le terme "synchroniser" renvoie à l'action d'afficher les différences entre les variantes de ressource à l'attention de l'utilisateur à l'attention de l'utilisateur. La synchronisation n'affecte pas l'état des variantes, mais au lieu de cela propose une vue permettant à l'utilisateur de comprend les différences entre les divers ensembles de variantes. Il est courant, cependant, de permettre aux utilisateurs d'affecter les états des variantes (par exemple, pour autoriser la libération ou l'inversion) au cours de la synchronisation.
synchronisation bidirectionnelle et synchronisation tridirectionnelle : Il existe deux types principaux pour déterminer l'état de synchronisation, la synchronisation bidirectionnelle et la synchronisation tridirectionnelle. Une comparaison bidirectionnelle ne prend en compte que la ressource locale et une seule variante de ressource, appelée variante de ressource distante. Ce type de comparaison ne peut afficher que les différences entre les deux ressources mais ne peut pas renseigner sur la relation entre les modifications. La plupart des systèmes de référentiel de code prennent en charge un comparaison tridirectionnelle pour déterminer l'état de synchronisation. Ce type de comparaison implique la ressource locale, une variante de ressource distante et une variante de ressource standard. La variante de ressource standard représente un ancêtre commun de la ressource locale et de la ressource distante. Cela permet de définit des état de synchronisation plus élaborés pour indiquer la direction de la modification.
Tableau 1 : les états de synchronisation
Bidirectionnel Tridirectionnel Modifié
Supprimé
AjoutéModification en sortie
Modification en entrée
Suppression en sortie
Suppression en entrée
Ajout en sortie
Ajout en entrée
Modification conflictuelle
Suppression conflictuelle
Ajout conflictuel
Les classes de org.eclipse.team.core.synchronize sont utilisées pour décrire l'état de synchronisation. La classe la plus importante est SyncInfo car il s'agit de la classe qui définit de fait l'état de synchronisation. Elle peut être utilisée de la manière suivante :
SyncInfo info = getSyncInfo(resource); // c'est une simulation de méthode pour obtenir les informations de synchronisation d'une ressource
int changekind = info.getKind();
if(info.getResourceComparator().isThreeWay()) {
if((changeKind & SyncInfo.DIRECTION_MASK) == SyncInfo.INCOMING) {
// pour effectuer une action
}
} else if(changeKind == SyncInfo.CHANGE) {
// pour effecuer une autre action
}
La classe SyncInfo propose des algorithmes de comparaison bidirectionnelle et tridirectionnelle. Un client doit fournir les ressources et une classe pour pouvoir comparer les ressources (IResourceVariantComparator). Voici un exemple de comparateur de variante :
public class TimestampVariantComparator implements IResourceVariantComparator {
protected boolean compare(IResourceVariant e1, IResourceVariant e2) {
if(e1.isContainer()) {
if(e2.isContainer()) {
return true;
}
return false;
}
if(e1 instanceof MyResourceVariant && e2 instanceof MyResourceVariant) {
MyResourceVariant myE1 = (MyResourceVariant)e1;
MyResourceVariant myE2 = (MyResourceVariant)e2;
return myE1.getTimestamp().equals(myE2.getTimestamp());
}
return false;
}
protected boolean compare(IResource e1, IResourceVariant e2) {
}
public boolean isThreeWay() {
return true;
}
}
SyncInfo info = new SyncInfo(resource, variant1, variant2, new TimestampComparator());
info.init(); // pour calculer les informations de synchronisation
Ce package contient également les collections conçues spécifiquement pour contenir la classe SyncInfo et les filtres à appliquer aux instances de SyncInfo.
Comme vous l'avez découvert dans les exemples ci-dessus, les classes SyncInfo et IResourceVariantComparator permettent d'accéder à l'état de synchronisation des ressources. Mais nous n'avons pas encore abordé le mode de gestion de l'état. Un abonné permet d'accéder à l'état de synchronisation entre les ressources de l'espace de travail local et un ensemble de variantes de ressource pour ces ressources à l'aide de la comparaison bidirectionnelle ou tridirectionnelle, en fonction de la nature de l'abonné. Un abonné offre les fonctions suivantes :
Les API ne définissent le mode de création d'un abonné. Cette opération est laissée aux implémentations spécifiques. Par exemple, le plug-in CVS crée un abonné lorsqu'une fusion est réalisée, un autre pour la comparaison et un autre pour la synchronisation de l'espace de travail local avec la branche actuelle.
Revenons au premier exemple d'utilisation de la classe SyncInfo et découvrons la manière dont un abonné peut être utilisé pour accéder à SyncInfo.
// Pour créer un abonné de système de fichiers et spécifier que
// l'abonné va procéder à la synchronisation avec l'emplacement de système de fichiers fourni
Subscriber subscriber = new FileSystemSubscriber("c:\temp\repo");
// Pour permettre à l'abonné de régénérer son état
subscriber.refresh(subscriber.roots(), IResource.DEPTH_INFINITE, monitor);
// Pour recueillir tous les états de synchronisation et les imprimer
IResource[] children = subscriber.roots();
for (int i = 0; i < children.length; i++) {
printSyncState(children[i]);
}
...
void printSyncState(Subscriber subscriber, IResource resource) {
System.out.println(subscriber.getSyncInfo(resource).toString());
IResource[] children = subscriber.members(resource);
for (int i = 0; i < children.length; i++) {
IResource child = children[i];
if(! child.exists()) {
System.out.println(resource.getFullPath() + " n'existe pas dans l'espace de travail");
}
printSyncState(subscriber, children[i]);
}
}
Le point important à ne pas oublier est que l'abonné connaît les ressources qui ne se trouvent pas dans l'espace de travail et les ressources inexistantes qui peuvent être renvoyées à partir de Subscriber#members() et de SyncInfo#getLocal().
Nous pourrions passer plus de temps à expliquer comment gérer l'état de synchronisation mais au lieu de cela découvrons plutôt comment extraire réellement l'état affiché à l'attention de l'utilisateur. ISynchronizeParticipant est le composant d'interface utilisateur qui affiche l'état de synchronisation et permet à l'utilisateur d'affecter son état. La vue de synchronisation affiche les participants à la synchronisation, mais il est également possible de les afficher dans des boîtes de dialogue ou des assistants. Pour proposer une prise en charge aux utilisateurs pour afficher un type d'état de synchronisation à l'attention de l'utilisateur, même ceux qui ne sont pas basés sur les classes SyncInfo et Subscribers, un participant est un composant très générique.
Il existe également un point d'extension appelé org.eclipse.team.ui.synchronizeWizards pour ajouter un assistant de création de synchronisation. Cette opération place l'assistant en synchronisation globale et dans la vue de synchronisation, afin que les utilisateurs puissent facilement créer une synchronisation de ce type.
Cependant, si vous avez implémenté un abonné, vous pouvez bénéficier d'un participant concret appelé SubscriberParticipant qui contient la fonction suivante :
La manière la plus approprié d'expliquer ces concepts est de les voir en situation dans le cadre d'un exemple simple. Accédez à l'exemple synchronisation de l'historique local pour découvrir toutes ces portions de code qui peuvent être utilisées ensemble. Ou, si vous souhaitez des pointeurs sur l'utilisation des API plus avancées, accédez à la section Au-delà des bases.