Eclipse


Eclipse RCP : exécuter une LaunchConfiguration

Dans une application RCP, il peut être utile de créer une action pour exécuter une launchConfiguration présente dans le workspace.

Pour ce faire, il va falloir utiliser des classes présentes dans le plugin org.eclipse.debug et re-créer manuellement la configuration telle que l'IDE l'exécute lorsque l'on lance l'action "Run...".

Commençons par exporter la configuration dans un fichier afin de voir de quoi elle est constituée. Dans le menu "Run configurations", ouvrir l'onglet Common pour définir l'endroit où sauvegarder le fichier (option "Shared file") :

A la fermeture de cette fenêtre, un fichier *.launch a été créé. Voici un exemple de contenu :

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<launchConfiguration type="org.eclipse.ant.AntLaunchConfigurationType">
<booleanAttribute key="org.eclipse.ant.ui.DEFAULT_VM_INSTALL" value="false"/>
<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
<listEntry value="/my.project/buildProduct.xml"/>
</listAttribute>
<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
<listEntry value="1"/>
</listAttribute>
<stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="my.project"/>
<stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
<stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="${workspace_loc:/my.project/buildProduct.xml}"/>
<stringAttribute key="process_factory_id" value="org.eclipse.ant.ui.remoteAntProcessFactory"/>
</launchConfiguration>

Le fichier est finalement assez simple, on trouve le type de configuration (ici une tâche Ant) et tous les paramètres requis.

Et voici en quelques lignes comment créer les objets nécessaires pour le lancement manuel :

import java.util.Arrays;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.ui.DebugUITools;

public class RunAntBuild {

 public static void main(String... args) {
  ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager();
  ILaunchConfigurationType type =
        manager.getLaunchConfigurationType("org.eclipse.ant.AntLaunchConfigurationType");
  try {
   ILaunchConfigurationWorkingCopy workingCopy =
           type.newInstance(null, "Run ant task");
   workingCopy.setAttribute("org.eclipse.ant.ui.DEFAULT_VM_INSTALL","false");
   workingCopy.setAttribute("org.eclipse.debug.core.MAPPED_RESOURCE_PATHS",Arrays.asList("/my.project/buildProduct.xml"));
   workingCopy.setAttribute("org.eclipse.debug.core.MAPPED_RESOURCE_TYPES",Arrays.asList("1"));
   workingCopy.setAttribute("org.eclipse.jdt.launching.CLASSPATH_PROVIDER","org.eclipse.ant.ui.AntClasspathProvider");
   workingCopy.setAttribute("org.eclipse.jdt.launching.PROJECT_ATTR","my.project");
   workingCopy.setAttribute("org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER","org.eclipse.ant.ui.AntClasspathProvider");
   workingCopy.setAttribute("org.eclipse.ui.externaltools.ATTR_LOCATION",antXmlPath);
   workingCopy.setAttribute("process_factory_id","org.eclipse.ant.ui.remoteAntProcessFactory");
   DebugUITools.launch(workingCopy, ILaunchManager.RUN_MODE);
  } catch (CoreException e) {
   e.printStackTrace();
  }
 }

}

Fichier(s) joint(s) :

Eclipse RCP : fenêtre de sélection de ressource

Petit mémo pour ne pas ré-inventer la roue : voici un lien très utile qui recense les fenêtres de dialogue facilement implémentables disponibles dans la plateforme RCP : EclipseTips - Selection Dialogs in Eclipse

Et un petit exemple, avec un bonus. Ici on crée une fenêtre permettant de sélectionner uniquement un fichier XML présent dans le workspace :

final ElementTreeSelectionDialog selectDialog = new ElementTreeSelectionDialog(Display.getDefault().getActiveShell(), 
  new WorkbenchLabelProvider(), new BaseWorkbenchContentProvider());
selectDialog.setTitle("Sélection de ressource");
selectDialog.setMessage("Sélectionner le fichier XML :");
selectDialog.setInput(ResourcesPlugin.getWorkspace().getRoot());
selectDialog.setAllowMultiple(false);
selectDialog.setHelpAvailable(false);
selectDialog.setValidator(new ISelectionStatusValidator() {
 @Override
 public IStatus validate(final Object[] arg0) {
  boolean isFileOK = arg0.length>0 && (arg0[0] instanceof IFile) && ((IFile)arg0[0]).getName().endsWith(".xml");
  selectDialog.getOkButton().setVisible(isFileOK);
  return isFileOK ? Status.OK_STATUS : Status.CANCEL_STATUS;
 }
});
selectDialog.open();

String xmlPath = ((IFile)selectDialog.getFirstResult()).getRawLocationURI().getPath().substring(1);

On notera l'utilisation du ISelectionStatusValidator pour valider l'objet sélectionné.

Hope this helps!


Fichier(s) joint(s) :

Eclipse RCP : intéragir avec une tache ANT

Dans cet article je vais décrire comment lancer, dans une application RCP, une tâche Ant et surtout comment intéragir avec : input, console...

Tout d'abord, voici le script Ant à manipuler :

<project default="main">
    <target name="deploy.checks">
        <input message="Etes vous sûrs de vouloir lancer ce script?"
         validargs="o,n" addproperty="do.answer.runtime" />
        <condition property="do.abort.runtime">
            <equals arg1="n" arg2="${do.answer.runtime}"/>
        </condition>
        <fail if="do.abort.runtime">Abandon.</fail>
 </target>
    <target name="main" depends="deploy.checks">
     <echo message="Run from Eclipse!"/>
    </target>
</project>

Comme on le voit, celui-ci est assez simple, avec une tâche de demande de saisie et une tâche principale affichant des informations. Pour continuer, notre outil va avoir besoin des librairies suivantes :

  • ant.jar
  • ant-launcher.jar

Et voici le code :

import java.io.File;
import java.io.PrintStream;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.DefaultLogger;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.ProjectHelper;
import org.apache.tools.ant.input.DefaultInputHandler;
import org.apache.tools.ant.input.InputRequest;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.console.ConsolePlugin;
import org.eclipse.ui.console.IConsole;
import org.eclipse.ui.console.MessageConsole;

public class RunAntBuild {

 public static void build() {
  // Fichier ant
  File buildFile = new File("...");
  
  // projet ant
  Project p = new Project();
  
  // gestion des inputs ant
  p.setInputHandler(new PluginInputHandler());
  
  // definition du logger...
  DefaultLogger consoleLogger = new DefaultLogger();
  
  // ... qui sera une console
  MessageConsole capiBuildConsole = new MessageConsole("AntConsole", null);
  
  // on ajoute notre console ant aux consoles de l'IDE Eclipse
  ConsolePlugin.getDefault().getConsoleManager().addConsoles(new IConsole[] {
   capiBuildConsole
  });
  
  // le stream de sortie pour ant
  PrintStream printStream = new PrintStream(capiBuildConsole.newOutputStream());
  consoleLogger.setErrorPrintStream(printStream);
  consoleLogger.setOutputPrintStream(printStream);
  consoleLogger.setMessageOutputLevel(Project.MSG_INFO);
  p.addBuildListener(consoleLogger);
  
  // definition des propriétés
  p.setUserProperty("ant.file", buildFile.getAbsolutePath());
  
  p.init();
  ProjectHelper helper = ProjectHelper.getProjectHelper();
  p.addReference("ant.projectHelper", helper);
  helper.parse(p, buildFile);
  p.executeTarget(p.getDefaultTarget());

 }

 static class PluginInputHandler extends DefaultInputHandler {
  @Override
  public void handleInput(InputRequest arg0) throws BuildException {
   InputDialog dlg = new InputDialog(Display.getCurrent().getActiveShell(), "Vérification", arg0.getPrompt() + " (o/n)", "",
     null);
   if (dlg.open() == Window.OK) {
    arg0.setInput(dlg.getValue());
   }
  }
 }

}

Le code et les commentaires parlent d'eux-mêmes, mais il est intéressant de noter l'utilisation de la console via le ConsolePlugin et de l'InputDialog comme utilitaire pour permettre la saisie de paramètres d'entrée.

Voici donc le résultat en images :

Ouverture de la fenêtre d'input au début du script

Affichage dans la console des sorties texte du script

Et voilà! En espérant vous avoir fait gagner du temps...


Fichier(s) joint(s) :



Continuous Performance

Les test unitaires c'est bien, mais peut mieux faire!

J'ai déjà abordé le sujet de l'intégration continue avec un article sur Jenkins. Il est indéniable que ce genre d'outil apporte une sécurité et une assurance de stabilité dans la conception d'une application, même si cela ne fait pas tout!

Il est pourtant possible d'ajouter un nouvel élément dédié au respect des performances du code : les deux librairies JUnitPerf et ContiPerf sont des extensions JUnit qui permettent de mesurer notamment les temps d'exécution des différents tests.

JUnitPerf utilise essentiellement le design pattern Decorator pour ajouter des fonctionnalités aux tests existants. Assez simple d'utilisation, elle permet même de simuler des tests de monter en charge (Load test).

ContiPerf se base plutôt sur des annotations pour configurer les métriques désirées. Un peu plus souple et plus précis (par le calcul de moyennes sur des déciles), elle permet de générer des rapports graphiques sur les exécutions :

A vous de jouer!

Sources

  • http://blog.javabenchmark.org/2013/03/continuous-performance-and-junit-with.html

Fichier(s) joint(s) :