Application Sb : Antimony

L'application Sb : Antimony

Introduction

XWoot est le premier prototype résultant du projet XWiki-Concerto. Celui-ci ajoute à l'application XWiki une fonction d'édition collaborative grâce à la réplication des données sur un réseau P2P, dont chaque nœud est un serveur XWiki.

Au début du développement de ce prototype, de nombreuses contraintes fortes ont été posées :

• contrainte de temps
• contrainte de modularité : l'application XWoot devant restée indépendante de l'application XWiki, il a fallut utiliser une interface de communication entre les deux applications
• évolution de l'interface de communication non prévue à cette effet
• réutilisation du code de Wooki
• l'utilisation de l'algorithme WOOT contraint l'application XWoot à maintenir un modèle de chacune des pages répliquées ; la maintenance de ce modèle a un cout très élevé (en place puisque chaque page est stockée une fois dans le server XWiki et une seconde fois dans le modèle de XWoot ; en temps d'exécution puisqu'à chaque synchronisation il est nécessaire vérifier chaque page)

Ainsi, XWiki doit fournir un service de patch ; ceux-ci seront pré-calculés en fonction des modifications effectuées par les clients directement par le serveur (ou en charge par). Sb aura pour fonction le traitement de ces patchs afin de les intégrer dans un contexte P2P de travail collaboratif.

De plus, le middleware sera géré par l'application P2P-LTR qui aura comme objectif de fournir les patchs émis par les différents nœuds du réseau P2P, à chacun des autres nœuds.

On aura alors une architecture en composants :

• fonction d'édition par l'application XWiki
• fonction de génération des patchs par le service de Patch XWiki
• fonction de traitement des patchs par Sb
• fonction de gestion du middleware P2P avec transmission des patchs entre les différents nœuds par P2P-LTR

Travaux en cours

En l'état actuel des choses, le noyau de l'application Sb est en cours de développement. Pour ce faire, nous avons utilisé des MocksObjects représentants le service de génération des patchs, ainsi que le service P2P-LTR.

L'objet représentant le composant de génération des patchs utilise l'interface suivante :

public interface PatchDiffusionManager {
/**
* To give a patch to diffuse on other nodes
* @param key : the unique page id 
* @param timestamp : the local timestamp
* @param p : the patch to diffuse
* @return : the last timestamp (0 if patch is send)
*/
public long sendToPublish(String key,long timestamp,Serializable p);

/**
* to get the patch associated to the given timestamp
* @param key : the unique page id 
* @param timestamp : the timestamp of the wanted patch
* @return : the wanted patch
*/
public Serializable retrieve(String key,Integer timestamp);

/**
* To get the timestamp of the last diffused patch 
* @param key : the unique page id 
* @return : the wanted timestamp
*/
public long getLastTicket(String key);

L'objet représentant le composant de gestion du P2P (i.e P2P-LTR) utilise l'interface suivante :

public interface PatchProcessor {

	/**
	 * To push a patch. The given patch will be integrated.
	 * @param p : the patch to push.
	 * @return : true if integration is OK.
	 */
	public boolean push(Patch p);

	/**
	 * To pull patch of patch processor component. The return patch is deleted from the patch processor
	 * component. To get a already pulled patch, use the function getOldPatchWithId(Object patchId).
	 * @return null if no patch is generated by patch processor. The older generated patch is return.
	 */
	public Patch pull();

	/**
	 * For test. Us it to simulate patch generation by patch processor component. The given patch 
	 * will be the next pulled patch with pull function.
	 * @param p : the result patch of the next pull() call.
	 */
	public void simulatePatchGeneration(Patch p);

	/**
	 * To get an already pulled patch.
	 * @param patchId : the id of the wanted patch
	 * @return the wanted patch (or null if it don't exist in patch processor.
	 */
	public Patch getOldPatchWithId(Object patchId);

	/**
	 * To get an object corresponding of the current state of the view.
	 * @return : the wanted state.
	 */
	public Object getState();

	
	/**
	 * To set the current state of the view.
	 * @param state : the state to set.
	 */
	public void setState(Object state);

	/**
	 * To get a string representation of the patch processor.
	 * @return : the wanted string representation
	 */
	public String toString();

	/**
	 * Ask to Patch processor, to create a new Patch object with given pageName and id.
	 * @param pageName : the name of the page concerning by the wanted patch
	 * @param id : the id of the wanted patch
	 * @return : a new patch
	 */
	public Patch createNewPatch(String pageName,Object id);

Enfin, l'application Antimony utilise l'interface suivante :

ClockEngine

Le composant clockEngine est utilisé par l'application Antimony pour sauvegarder le "timestamp" du dernier patch integré.

Buffer

Le composant Buffer est utilisé lors de la manipulation des patchs. En effet, durant les transformées, les patchs sont bufferisés pour permettre leurs récupérations en cas d'arrêt involontaire du programme. Ainsi, à chaque lecture d'un patch dans la file RSS du service de patch XWiki, ou lors de l'accès dans la DHT, il est stocké dans un buffer sérialisé.

Soct4

Le composant Soct4 (en cours de développement ; en attente d'une documentation détaillée du service de Patch XWiki (modèle détaillé des opérations utilisées)) est utilisé pour gérer la concurrence des patchs. Il agit sur les opérations contenues dans les patchs, en les transformants si besoin est (intégration d'opérations concurrentes). Pour cela un certain nombre de fonctions de transformation ont été écrites et sont fournies.

Architecture de Sb