jeudi 21 avril 2011

Automatiser l'installation d'applications - Squelette

Dans un précédent article, nous expliquions comment automatiser l'installation de serveur et d'application en un seul processus via l'outil IzPack. Dans cet article, nous décrypterons le squelette minimal à mettre en place pour utiliser IzPack à l'intérieur d'un projet Maven.


Objectif

A la fin de ce tutorial, nous disposerons d'un code répondant aux critères suivants :

  • Le code sera compilé avec Maven
  • Il embarquera un installeur fait avec IzPack
  • L'installeur aura deux écrans (un écran d'accueil et un écran de fin)
  • L'installeur n'effectuera aucune opération

Mise en place du projet Maven

Commençons par créer le projet Maven que nous utiliserons. Pour cela, nous utiliserons la commande mvn archetype:generate en spécifiant le modèle maven-archetype-quickstart, c'est à dire le modèle par défaut.

$ mvn archetype:generate
[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO]    task-segment: [archetype:generate] (aggregator-style)
[INFO] ------------------------------------------------------------------------
[...]
Choose a number:  (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34/35/36/37/38/39/40/41/42/43/44/45/46) 20: :
[INFO] artifact org.apache.maven.archetypes:maven-archetype-quickstart: checking for updates from central
Define value for groupId: : fr.pingtimeout
Define value for artifactId: : izpack-environment-installer
Define value for version:  1.0-SNAPSHOT: :
Define value for package:  fr.pingtimeout: :
Confirm properties configuration:
groupId: fr.pingtimeout
artifactId: izpack-environment-installer
version: 1.0-SNAPSHOT
package: fr.pingtimeout
 Y: :
[...]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1 minute 59 seconds
[INFO] Finished at: Tue Apr 19 17:20:49 CEST 2011
[INFO] Final Memory: 8M/14M
[INFO] ------------------------------------------------------------------------

Modification du projet Maven

Le modèle maven-archetype-quickstart a ceci d'intéressant qu'il nous crée rapidement la structure Maven classique de tout projet.

Commençons par supprimer les fichiers src/main/java/App.java et src/test/java/AppTest.java. Il nous faut ensuite créer le dossier src/main/resources/ qui contiendra la configuration de IzPack.

Modifions maintenant le pom.xml de manière à ne plus avoir de dépendance vers une ancienne version de JUnit et à packager notre installeur en même temps que le projet. Nous introduisons les éléments suivants :

  • Une propriété définit la version d'IzPack que nous utiliserons
  • Une autre propriété pointe vers le répertoire de travail que Maven utilisera pour construire l'installeur
  • L'appel du plugin maven-izpack-plugin est réalisé pendant la phase "package" avec les propriétés ci-dessus
  • Nous utilisons le plugin maven-resources-plugin pour copier les ressources de notre projet dans le dossier de travail utilisé par Maven
Le nouveau pom.xml est le suivant :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>fr.pingtimeout</groupId>

 <artifactId>izpack-maven-empty-model</artifactId>
 <version>1.0-SNAPSHOT</version>
 <packaging>pom</packaging>

 <name>izpack-maven-empty-model</name>

 <url>http://www.pingtimeout.fr/</url>

 <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <izpack.staging.dir>${project.build.directory}/izpack-staging</izpack.staging.dir>

  <izpack.standalone.compiler.version>4.3.2</izpack.standalone.compiler.version>
 </properties>

 <build>
  <plugins>
   <!-- IzPack Installer -->

   <plugin>
    <groupId>org.codehaus.izpack</groupId>
    <artifactId>izpack-maven-plugin</artifactId>
    <version>1.0-alpha-5</version>

    <executions>
     <execution>
      <phase>package</phase>
      <goals>
       <goal>izpack</goal>

      </goals>
      <configuration>
       <izpackBasedir>${izpack.staging.dir}</izpackBasedir>
      </configuration>
     </execution>

    </executions>
    <dependencies>
     <dependency>
      <groupId>org.codehaus.izpack</groupId>
      <artifactId>izpack-standalone-compiler</artifactId>

      <version>${izpack.standalone.compiler.version}</version>
     </dependency>
    </dependencies>
   </plugin>

   <plugin>

    <artifactId>maven-resources-plugin</artifactId>
    <version>2.4.2</version>
    <executions>
     <execution>
      <id>copy-resources</id>

      <phase>validate</phase>
      <goals>
       <goal>copy-resources</goal>
      </goals>
      <configuration>

       <encoding>UTF-8</encoding>
       <outputDirectory>${izpack.staging.dir}</outputDirectory>
       <resources>
        <resource>
         <directory>src/main/resources</directory>

        </resource>
       </resources>
      </configuration>
     </execution>
    </executions>
   </plugin>

  </plugins>
 </build>
</project>

Configuration d'IzPack

Il ne reste plus qu'à configurer IzPack pour que ce dernier nous construire l'installeur tant attendu. Pour cela, nous créons le fichier install.xml dans le dossier src/main/resources/.

Dans la section info, nous définissons que :

  • L'application s'appelle "IzPack empty Model"
  • Elle est en version 1.0
  • Nous ne voulons pas de désinstalleur
  • La version 1.6 du JRE est requise
  • Nous utilisons la méthode de compression Pack200

Nous indiquons ensuite que l'installeur est en français et qu'il s'exécute dans une fenêtre redimensionnable de 640x480 pixels

Ensuite, nous créons deux écrans dans la section panels. Le premier est un écran d'accueil générique. Le second est un écran de fin d'installation, également générique.

Enfin, nous définissons la liste des fichiers que IzPack doit traiter. Dans notre cas, il n'y en a aucun. La documentation d'IzPack nous dit cependant que la section packs est requise et qu'au moins un pack doit y être présent. Nous créons donc un pack vide.


Génération de l'installeur

La configuration du projet Maven est maintenant terminée. Il ne nous reste plus qu'à générer notre installeur en compilant simplement le projet maven.

$ mvn clean package
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building izpack-maven-empty-model
[INFO]    task-segment: [clean, package]
[INFO] ------------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] [resources:copy-resources {execution: copy-resources}]
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO] [site:attach-descriptor {execution: default-attach-descriptor}]
[INFO] [izpack:izpack {execution: default}]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 11 seconds
[INFO] Finished at: Thu Apr 21 11:54:40 CEST 2011
[INFO] Final Memory: 11M/21M
[INFO] ------------------------------------------------------------------------

Voici des captures d'écrans d'un installeur généré sur le même modèle.

Ecran 1 - Accueil

Ecran 2 - Fin de l'installation


Conclusion

Ce tutoriel nous permet rapidement de mettre en place, ou d'inclure, Izpack dans un projet Maven. Idéalement, il pourrait d'ailleurs être automatisé à l'aide d'un artefact Maven.

Pour parfaire notre installeur, il nous faut maintenant nous plonger dans la documentation très complète d'IzPack.


Ressources

Les ressources utilisées dans ce tutoriel sont les suivantes :

Pas encore convaincu de la facilité d'intégration d'un installeur pour un projet Java ? Discutons-en dans les commentaires !

2 commentaires:

  1. Salut,
    d'abord je vous remercie pour ce tutoriel. Mon problème j'ai un projet qui comporte 3 module et chaqu'un à 1 fichier pom. Pour compiler, j'ai crée un pom parent qui permet de compiler chaque module. Comment je pourrai intégrer cette solution avec un tel projet ?

    Merci pour votre aide

    RépondreSupprimer
  2. Bonjour,

    Vous pouvez facilement créer un quatrième module qui dépendra des trois autres et qui sera donc construit en dernier par Maven.

    Votre nouveau module serait dédié à l'installeur (descriptif des écrans, gestion de la licence, inputs utilisateur) et pourrait récupérer les fichiers jar produits par vos modules actuels pour en effectuer l'installation.

    RépondreSupprimer