Extension de la fonction push-to-client

Un fournisseur indépendant de logiciels (ISV) peut proposer des extensions complémentaires, ce qui permet de propager d'autres types de configurations IDE. Les informations ci-après indiquent comment obtenir une extension de la fonction push-to-client.

La fonction push-to-client permet de partager des configurations entre les utilisateurs. Les développeurs peuvent exporter leurs propres configurations localement afin de pouvoir restaurer ultérieurement un précédent environnement IDE. Pour une équipe de développeurs, un environnement IDE unique peut être configuré puis partagé sur un serveur commun à l'aide de la fonction push-to-client. Lorsque les développeurs se connectent à ce serveur, leur environnement IDE est automatiquement synchronisé avec la configuration précédemment exportée. De cette façon, les paramètres communs peuvent être partagés entre les équipes.

Ce mécanisme comprend une structure de base pour gérer l'interface utilisateur et la majeure partie du traitement et des extensions pour gérer les types de configuration spécifiques. La fonction push-to-client est prête à l'emploi et offre les possibilités suivantes :

Contribution à la fonction push-to-client

Vous voudrez très certainement créer un nouveau projet de plug-in pour l'extension. Dans le manifeste, vous devrez inclure au moins les dépendances suivantes :
com.ibm.etools.systems.pushtoclient.core
org.eclipse.core.resources
org.eclipse.core.runtime
org.eclipse.ui
Ensuite, un point d'extension configurationExtension doit être défini dans le fichier de projet plugin.xml. Par exemple :
<extension
      point="com.ibm.etools.systems.pushtoclient.core.configurationExtensions">
   <configurationExtension
         class="p2c.test.ConfigurationExtension1"
         description="Custom Elements"
         icon="icons/obj.gif"
         id="p2c.test.configurationExtension1"
         name="Test Extension">
   </configurationExtension>
</extension>
Chaque extension doit avoir une classe, une description, une icône, un identifiant et un nom. La fonctionnalité de la contribution est intégrée à la classe. La classe doit implémenter IConfigurationExtension. Dans la plupart des cas, il est préférable d'étendre l'implémentation ConfigurationExtension.
Au départ, votre code ressemble à cela :
package p2c.test;

import com.ibm.etools.systems.pushtoclient.core.extensions.IConfigurationElement;
import com.ibm.etools.systems.pushtoclient.core.extensions.ConfigurationElement;
import com.ibm.etools.systems.pushtoclient.core.extensions.ConfigurationExtension;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.runtime.IProgressMonitor;

public class ConfigurationExtension1 extends ConfigurationExtension {

	public ConfigurationExtension1(String id, String name, String description){
		super(id, name, description);
	}
Dans une extension de configuration, l'objet de modèle à utiliser est IConfigurationElement et son implémentation par défaut est ConfigurationElement. Ces éléments représentent des unités d'informations visibles par les utilisateurs à des fins de sélection ou de désélection des cases à cocher avoisinantes. Chaque élément possède des informations descriptives et des enfants en option. A l'aide des éléments de configuration, vous devrez définir chacune des quatre méthodes suivantes :
  • public void populateExportElements(IConfigurationElement parent)
  • public void exportToCache(IConfigurationElement element,IFolder cacheFolder, IProgressMonitor monitor)
  • public void populateImportElements(IConfigurationElement parent)
  • public void importToWorkspace(IConfigurationElement element, IProgressMonitor monitor)
La méthode populateExportElements() permet à un utilisateur de déterminer les éléments d'une configuration à exporter dans un assistant. Dans le cas le plus simple, vous n'avez qu'à indiquer si le parent doit être configuré ou non par défaut pour l'exportation. Par exemple :
public void populateExportElements(IConfigurationElement parent){
	parent.setToExport(true);
}
Dans ce cas, les utilisateurs auront la possibilité de récupérer l'ensemble des informations de configuration ou de ne pas récupérer ces informations.
Dans l'exemple ci-après légèrement plus compliqué, les éléments sont créés pour représenter des artefacts discrets en vue de l'exportation :
@Override
public void populateExportElements(
		IConfigurationElement parent) {
	// dossier représentant une catégorie d'éléments
	ConfigurationElement folderElement = new ConfigurationElement("Element X", "Custom properties X");
	parent.add(folderElement);

	// contenu de la première catégorie
	ConfigurationElement stuff = new ConfigurationElement("X child element", "");
	stuff.setToExport(true);
	folderElement.add(stuff);
	folderElement.setToExport(true);

	// dossier représentant une autre catégorie d'éléments
	ConfigurationElement folderElement2 = new ConfigurationElement("Element Y", "Custom properties Y");
	parent.add(folderElement2);

	// contenu de la deuxième catégorie
	ConfigurationElement thing1 = new ConfigurationElement("Y child element 1", "");
	folderElement2.add(thing1);
	thing1.setToExport(true);

	ConfigurationElement thing2 = new ConfigurationElement("Y child element 2", "");
	folderElement2.add(thing2);
	folderElement2.setToExport(true);

	parent.setToExport(true);
}

Lors de l'exportation via un client push-to-client, les éléments apparaîtront comme suit :

Personnalisation de l'assistant d'exportation

Le nom et la description de l'élément racine pour cette extension, Test Extension, proviennent du point d'extension, alors que les éléments enfant sont générés via l'implémentation de populateExportElements().

La méthode exportToCache() est appelée lorsqu'un utilisateur a terminé d'utiliser l'assistant d'exportation. Les éléments de l'extension de configuration sont transmis et, selon les éléments sélectionnés, les artefacts de configuration correspondants sont sauvegardés dans un format sous le répertoire cachedFolder. Le format est déterminé par l'implémenteur. Ce répertoire cachedFolder est unique pour chaque extension de configuration et utilise l'identifiant de configuration comme nom.

Vous trouverez ci-dessous un exemple d'implémentation de exportToCache() :
@Override
public void exportToCache(IConfigurationElement element,
		IFolder cacheFolder, IProgressMonitor monitor) {			
	// rechercher tous les éléments qui sont configurés pour l'exportation" et
	// sauvegarder ces éléments dans le dossier cache
	if (element.hasChildren()){			
		IConfigurationElement[] folders = element.getChildren();
		for (IConfigurationElement folder: folders){
			if (folder.isSetToExport()){
				IConfigurationElement[] children = folder.getChildren();
				for (IConfigurationElement child: children){
					if (child.isSetToExport()){
						// stocker dans le modèle en vue de l'exporation
						...
					}						
				}
			}
		}
		
		// créer un fichier pour stocker les informations exportées
		IFile file = cacheFolder.getFile(new Path("test.properties"));
		...
	}
}

Une fois qu'une configuration a été exportée vers le répertoire cache, la structure push-to-client de base prend en charge le reste de l'opération. Si vous effectuez l'exportation vers un emplacement local, les informations mises en cache seront archivées dans cet emplacement. Si vous effectuez l'exportation vers un serveur commun, les informations modifiées seront archivées et transférées vers ce serveur.

Lors de l'importation de configurations, la structure push-to-client télécharge d'abord l'archive de configuration exportée vers l'espace de travail Eclipse, puis extrait le contenu de l'archive dans le dossier RemoteSystemsTempFiles. Comme pour l'exportation, il y a un dossier cache pour chaque extension de configuration dans le cas d'une importation ; il s'agit du même dossier que celui utilisé pour l'exportation. L'assistant d'importation invitera l'utilisateur à indiquer les éléments à importer. Comme pour populateExportElements(), chaque extension de configuration implémente populateImportElements() en créant des éléments de configuration pour représenter les informations entrantes. Le seul et unique paramètre pour cette méthode est un élément qui renverra le dossier cache pour votre extension de configuration.

Dans l'exemple suivant, la hiérarchie des éléments pour la configuration est générée par l'extraction des informations en dehors du fichier test.properties.
@Override
public void populateImportElements(
		IConfigurationElement parent) {

	// le fichier parent est le dossier cache pour cette configuration
	File parentFile = parent.getFile();
	
	// le fichier test.properties se trouve dans le dossier parent
	File testFile = new File(parentFile, "test.properties");
	
	// lire et analyser le fichier, renseigner les éléments d'importation selon le contenu de testFile
	...

La boîte de dialogue suivante apparaîtra suite à l'importation. En règle générale, tout ce qui est importé est sélectionné par défaut.

Assistant d'importation personnalisé

La méthode finale d'implémentation est importToWorkspace(). Cette méthode est appelée une fois que l'utilisateur a cliqué sur OK dans la boîte de dialogue d'importation. Les éléments sélectionnés pour la configuration sont transmis par cette méthode et c'est à l'implémenteur de récupérer les informations présentes dans le dossier cache d'extension de configuration et de les appliquer à l'espace de travail.
@Override
public void importToWorkspace(IConfigurationElement element,
		IProgressMonitor monitor) {
	// rechercher tous les éléments qui sont configurés pour l'exportation (pareil que pour les éléments qui sont configurés pour l'importation)
	if (element.hasChildren()){			
		IConfigurationElement[] folders = element.getChildren();
		for (IConfigurationElement folder: folders){
			if (folder.isSetToExport()){
				IConfigurationElement[] children = folder.getChildren();
				for (IConfigurationElement child: children){
					if (child.isSetToExport()){
						// transférer les informations correspondantes vers l'espace de travail					...
					}						
				}
			}
		}
	}
}

Commentaires en retour