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.
com.ibm.etools.systems.pushtoclient.core
org.eclipse.core.resources
org.eclipse.core.runtime
org.eclipse.ui
<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.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);
}
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.@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 :

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.
@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.
@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.

@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 ...
}
}
}
}
}
}