Déploiement avec plugins

Version imprimable

Bonjour {^_^}, (desole pour les accents et autres, je suis sur un clavier QWERTY)

Tout d'abord le contexte. Je cree un framework qui execute des algorithmes ayant un objectif commun (trier des besoins selon differents criteres). Les algorithmes sont charges dynamiquement a l'execution, l'utilisateur pouvant alors choisir lequel il veut utiliser. Pour cela, chaque algorithme est developpe dans un projet a part, qui depend donc d'un projet decrivant les interfaces a utiliser (et differents outils communs). De maniere plus shematisee :

- Projet "algorithm" : regroupe les interfaces generiques et les outils communs aux differents algorithmes.

- Projet algo1 : implemente un algorithme particulier, qui etend les interfaces du projet "algorithm" (et donc en depend). Un JAR est cree une fois l'algo implemente.

- Projets algo2, algo3, ... : idem, chacun implemente un algorithme particulier.

- Projet "framework" : implemente le framework qui execute les algorithmes. Les JAR des algos disponibles sont places dans un dossier specifique, scanne par le framework. Il charge alors les algorithmes qui implementent les interfaces definies dans le projet "algorithm" (et donc il en depend aussi). Il convient de noter que ce projet ne depend pas des projets algo1, algo2, ... Il n'a aucune connaissance de ces projets, seuls les JARs dispo dans son dossier sont charges dynamiquement (et s'ils implementent les interfaces de "algorithms", alors ils sont reconnus et listes).

Voila en gros comment ca se passe. Pour gerer tout ca, j'utilise Maven via Eclipse. J'ai donc un pom parent qui regroupe tous mes projets (interfaces + algos + framework) et un pom pour chaque projet. Le pom parent definit chaque projet comme un de ses modules (j'ai retire les infos sensibles et change les noms, mais la structure est strictement la meme) :
Code:

1 2 3 4 5 6 <modules> <module>framework</module> <module>algorithm</module> <module>algo1</module> <module>algo2</module> </modules>
Bien entendu, chaque projet voit son pom lie au parent :
Code:

1 2 3 4 5 <parent> <artifactId>parent</artifactId> <groupId>...</groupId> <version>...</version> </parent>
Les projets framework et algoX definissent bien entendu leurs dependances aux interfaces :
Code:

1 2 3 4 5 6 <dependency> <groupId>...</groupId> <artifactId>algorithm</artifactId> <version>...</version> <scope>compile</scope> </dependency>
Notez qu'ils definissent aussi tous une dependance pour JUnit :
Code:

1 2 3 4 5 6 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.8.2</version> <scope>test</scope> </dependency>
A part ca je n'ai rien de special qui me vient en tete. Voila pour illustrer le pom d'un algo :
Code:

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 <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> <parent> <artifactId>parent</artifactId> <groupId>...</groupId> <version>...</version> </parent> <artifactId>algo1</artifactId> <name>...</name> <description>...</description> <inceptionYear>...</inceptionYear> <developers> <developer> <name>...</name> <email>...</email> </developer> </developers> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.8.2</version> <scope>test</scope> </dependency> <dependency> <groupId>...</groupId> <artifactId>algorithm</artifactId> <version>...</version> <scope>compile</scope> </dependency> </dependencies> </project>
Et le pom du parent :
Code:

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 <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>...</groupId> <artifactId>parent</artifactId> <version>...</version> <packaging>pom</packaging> <name>...</name> <description>...</description> <inceptionYear>...</inceptionYear> <developers> <developer> <name>...</name> <email>...</email> </developer> </developers> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>2.3.2</version> <configuration> <source>1.6</source> <target>1.6</target> </configuration> </plugin> </plugins> </build> <modules> <module>framework</module> <module>algorithm</module> <module>algo1</module> <module>algo2</module> </modules> </project>
Maintenant mon niveau. Je suis un debutant sous Maven : je m'y suis mis parce qu'un camarade a mavenise un de mes projets, et depuis je me contente de copier-coller les poms en changeant juste ce que j'ai besoin. Aussi je pense avoir bien compris le role de chaque element present dans ces poms, mais je n'ai aucune idee de ce que je peux mettre d'autre. J'apprends sur le tas.

Mon soucis est le suivant : j'aimerais que lorsque j'ai fini une release de mon projet, je puisse le deployer en compilant tout et en m'assurant qu'au final j'ai un framework complet, c'est a dire :
- un JAR executable du framework (qui contient les interfaces et outils du projet algorithm)
- un dossier contenant tous les JARs des algorithmes implementes (algo1.jar, algo2.jar, ...)

Je suis capable de le faire a la main sous Eclipse (exporter le projet du framework dans un JAR executable, exporter chaque projet algo dans un JAR que je place dans le dossier du framework) et ca marche. Ce que j'essaye de faire est d'automatiser ce processus via Maven.

Ma question est donc la suivante : comment automatiser ce processus de la maniere la plus propre que possible ? J'ai deja vu un sujet similaire mais je ne suis pas sur que ce soit le meme probleme : http://www.developpez.net/forums/d11...dances-projet/

Une question subsidiaire serait : auriez-vous un tutoriel pas-a-pas ET complet sur Maven ? J'ai vu plein de tutos sur le net, mais a chaque fois c'etait soit super simple mais on fait juste un projet sous Maven, on va pas beaucoup plus loin, soit bien detaille mais il faut deja maitriser maven pour savoir de quoi on parle, ce qui n'est pas mon cas (et c'est le feeling que m'a donne le sujet cite ci-dessus).

Tu peux jouer avec la configuration du plugin maven-jar-plugin
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <version>2.3.2</version> <configuration> <outputDirectory>myPath</outputDirectory> </configuration> </plugin> </plugins> </build>
Tu peux biensur parametrer ta sortie via une variable <outputDirectory>${dir}</outputDirectory> ; et, lui affecter une valeur depuis la ligne de commande mvn -Ddir=myPath ou dans ton settings.xml

17/11/2011, 14h53
Matthieu Vergne

J'ai regarde vite fait ton lien et, si j'ai bien compris, cette description permet de dire ou tu veux generer le JAR du projet concerne, c'est ca ?

Si non alors j'ai pas compris son utilisation.

Si oui alors ce n'est peut-etre pas exactement ce qu'il me faut, dans le sens ou cela m'oblige a definir une partie de la logique globale dans chaque projet (pour chaque algo je dois lui dire de faire un JAR a mettre dans un dossier qu'il n'est pas sense manager). Je serai plus partant pour une solution qui me fait generer mes JAR normalement, mais qui me permette de dire dans la config du parent "tu recuperes le JAR du framework que tu met la, et le JAR de algo1 et algo2 que tu met la". De cette maniere la logique est centralisee et ca m'evite de devoir retoucher tous les poms des que je veux changer un truc.
18/11/2011, 10h23
Philippe Bastiani

maven-assembly-plugin

Ok donc tu souhaites faire un délivrabre: dans ce cas, tu auras, sans doute, à déposer tes dépendances externes, ta javadoc, ...

Donc ce plugin maven-assembly-plugin. Tu pourras noter que ton assembly pourra prendre plusieurs formes (zip, dir, etc).

Tu trouveras sur le site d'Apache des exemples; où dans ce livre de référence sur Maven

a+
18/11/2011, 12h37
Matthieu Vergne

Effectivement ca a l'air pas mal du tout. Je vois ca et je viens faire un retour {^_^}.

Ça marche pas mal du tout. J'ai fait un nouveau projet "all" qui récupère le framework et les algos. J'ai préféré faire ça car je n'ai pas envie de mettre des dépendances entre le framework et les algos, sinon ça perd son sens. Du coup j'ai mon projet "all" qui ne fait que fusionner l'ensemble des éléments en un tout cohérent. Il dépend donc de tous les projets et définit un assembly.xml qui récupère ce dont il a besoin.

Le pom du projet all :

Code:

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
<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>
	<parent>
		<groupId>groupId</groupId>
		<artifactId>irp-parent</artifactId>
		<version>1.0.0</version>
	</parent>
 
	<artifactId>all</artifactId>
	<name>...</name>
	<description>...</description>
	<inceptionYear>...</inceptionYear>
 
	<developers>
		<developer>
			<name>...</name>
			<email>...</email>
		</developer>
	</developers>
 
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-assembly-plugin</artifactId>
				<version>2.2.1</version>
				<configuration>
					<descriptors>
						<descriptor>assembly.xml</descriptor> <!-- assembly fait main -->
					</descriptors>
				</configuration>
				<executions>
					<execution>
						<id>make-assembly</id> <!-- this is used for inheritance merges -->
						<phase>package</phase> <!-- bind to the packaging phase -->
						<goals>
							<goal>single</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>
 
	<properties>
		<deps.scope>runtime</deps.scope>
	</properties>
 
	<dependencies>
		<dependency>
			<groupId>${project.parent.groupId}</groupId>
			<artifactId>framework</artifactId>
			<version>LATEST</version>
			<scope>${deps.scope}</scope>
		</dependency>
		<dependency>
			<groupId>${project.parent.groupId}</groupId>
			<artifactId>algo1</artifactId>
			<version>LATEST</version>
			<scope>${deps.scope}</scope>
		</dependency>
		<dependency>
			<groupId>${project.parent.groupId}</groupId>
			<artifactId>algo2</artifactId>
			<version>LATEST</version>
			<scope>${deps.scope}</scope>
		</dependency>
	</dependencies>
</project>

Et l'assembly qui définit ce que je veux mettre ensemble :

Code:

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
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
  <id>bin</id>
 
  <formats>
    <format>tar.gz</format>
    <format>tar.bz2</format>
    <format>zip</format>
  </formats>
 
  <fileSets>
    <!-- recopié depuis un modèle de base -->
    <!-- on recopie la doc, les licences, ... -->
    <fileSet>
      <directory>${project.basedir}</directory>
      <outputDirectory>/</outputDirectory>
      <includes>
        <include>README*</include>
        <include>LICENSE*</include>
        <include>NOTICE*</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>${project.build.directory}/site</directory>
      <outputDirectory>docs</outputDirectory>
    </fileSet>
  </fileSets>
 
  <dependencySets>
    <!-- on récupère le framework -->
    <dependencySet>
      <outputDirectory>/</outputDirectory>
      <includes>
        <include>${project.parent.groupId}:framework</include>
      </includes>
    </dependencySet>
    <!-- on récupère les algos (algo* = algo1, algo2, ...)-->
    <dependencySet>
      <outputDirectory>/algorithms/</outputDirectory>
      <includes>
        <include>${project.parent.groupId}:algo*</include>
      </includes>
    </dependencySet>
  </dependencySets>
</assembly>

Maintenant, ce que j'aimerais, c'est que les resources que je définis dans chacun des algos soit aussi récupérés, pas juste les JAR. J'ai pas trouvé de moyen propre de le faire (obligé de donner le chemin complet vers le dossier via un fileSet). J'espère pouvoir dire "récupère les ressources des projets algo1, algo2, ... pour les mettre dans un dossier resources dans l'archive".

Une idée pour ce dernier point ?

24/11/2011, 01h31
Matthieu Vergne

Pas d'idée ?
24/11/2011, 10h38
Philippe Bastiani

Une composition de moduleSets avec des fileSets :idea:
24/11/2011, 12h52
Matthieu Vergne

Je crois saisir l'idée, mais si tu as un exemple pour illustrer ?

Regardes la structure complète du descripteur

Tu remarqueras que la section moduleSets permet
- de selectionner les modules <include> <exclude> (en positionnant useAllReactorProjects à true). Ces balises sont de la forme <include>groupid:artifactid</include>
- de sélectionner les sources <sources> à l'aide d'un <filesets>

Tu peux définir un ou plusieurs modulesets (par exemple, un pour chaque type de ressources).

Ici pour les .txt :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 <moduleSet> <useAllReactorProjects>true</useAllReactorProjects> <includes> <include>projet:moduleA</include> </includes> <sources> <includeModuleDirectory>false</includeModuleDirectory> <fileSets> <fileSet> <directory>res</directory> <includes> <include>*.txt</include> </includes> </fileSet> </fileSets> </sources> </moduleSet>
Pas évident ce plugin...

Tu noteras aussi que tu as des conf spécifiques pour la javadoc

24/11/2011, 16h58
Matthieu Vergne

Aïe, ça marche pas :
- apparemment il voit pas mes modules, ce qui me semble normal normal vu que je définit dans mon POM les projets comme dépendances, et non module (c'est le projet parent, un niveau au dessus, qui englobe tout les modules, le projet all compris)
- du coup je rajoute les modules (les algos) dans mon POM du projet all, mais ça me dit que les modules n'existent pas... Je me dis normal vu qu'ils sont au même niveau que le projet all (mais est-ce que ça a vraiment une influence ?)... mais si je devais mettre mes projets dans le projet all, ça reviendrait au même que d'utiliser le projet parent directement pour mon assembly, et là je me mord la queue : si je définis l'assembly pour le projet parent il l'applique à tous les modules, et donc tous les projets me font des zip et autres tar à la queue-leu-leu et plantent en chantant.

Pour rappel :

parent
- algorithm
- framework (dépend de algorithm)
- algo1 (dépend de algorithm)
- algo2 (dépend de algorithm)
- all (zip de framework + algo1 + algo2)

Du coup je me suis dit "ben si je peux pas utiliser les modules, vu que j'ai définis les dépendances y'a qu'à passer par là", mais apparemment pas de fileset (faut dire que j'avais déjà regarder et que c'est pour ça que je posais la question).

{'@_@} non c'est pas simple.
24/11/2011, 17h39
Matthieu Vergne
Pour être plus clair, voilà le genre d'erreur qu'il me fait quand je rajoute le moduleSet (et tout ce qui va bien pour que ça passe) :
Code:

1 2 [WARNING] The following patterns were never triggered in this artifact inclusion filter: o 'grouId:algo*'
Et même si je stipule un algo spécifique ça fait pareil.
24/11/2011, 18h24
Philippe Bastiani
Il est clair que l'approche dependencySet avec un module dédié est largement plus simple que l'approche moduleSet (tu n’as pas les problèmes liés aux relations parent/fils; et, tu contrôles peut-être mieux ton build)... mais tu devras passer par les filesets pour tes ressources !
Citation:
Envoyé par sazaju

Pour être plus clair, voilà le genre d'erreur qu'il me fait quand je rajoute le moduleSet (et tout ce qui va bien pour que ça passe) :

Code:

1 2 [WARNING] The following patterns were never triggered in this artifact inclusion filter: o 'grouId:algo*'

Et même si je stipule un algo spécifique ça fait pareil.
grouId est-ce bien le libélé de ton projet :? plus haut tu parles de groupId (imho, dans tous les cas depuis all celà ne peut passer) ! Sinon... Es-tu allé regarder du côté de la bas Jira du projet ! Peut-être est-ce une bogue référencée !
24/11/2011, 18h57
Matthieu Vergne

En ce qui concerne le nommage, ne t'en soucie pas, je remplace les noms par des trucs plus simple (le group ID est un truc du style eu.company.project par exemple). J'ai juste oublié le 'p' en réécrivant le nom c'est tout. J'utilise des propriétés comme ${parent.project.groupId} pour être sûr de pas faire d'erreur de frappe.

Pour réorienter le problème, est-ce qu'il y a moyen de demander l'exécution d'un plugin (mon assembly en l'occurrence), uniquement pour le parent, sans avoir besoin de retoucher les POM de ses modules (pas de transitivité) ? De cette manière je pourrais utiliser le projet parent directement plutôt qu'un projet all supplémentaire.
25/11/2011, 00h19
Philippe Bastiani

Regardes ce projet1 et cet autre projet2

-Projet1-
Dans le pom parent tu touves la liste des modules ainsi que la declaration du plugin assembly

Dans le pom.xml du dist tu y trouves (outre le plugin assembly) une liste de dependances (ici dans ce projet, les modues de bases api, etc n'ont pas besoin d'y apparaître puisqu'ils sont dans les autres dépendances).

Dans le dist.xml
- une partie s'apppliquent à tous les modules (sources et binaires) - sans filtre
- une partie spécifique aux fichiers
26/11/2011, 02h08
Matthieu Vergne

Le projet 1 semble faire pareil que moi : même si c'est le pom parent qui définit le plugin assembly et le descripteur à utiliser, c'est le modules dist qui dispose de ce descripteur et donc exécute ledit plugin. La seule différence avec moi me semble être que plutôt que de stipuler le plugin au niveau du module lui-même il le fait au niveau du parent (et donc il utilise la transitivité). Dans ce cas ce n'est pas le parent qui fait le packaging mais bien un module à part, comme mon projet all. Cela dit il ne semble pas utiliser de resources (ou quoi que ce soit d'autre de lié aux projets), donc ça ne semble résoudre aucun de mes deux problèmes.

Le projet 2 je vois pas le lien.
26/11/2011, 02h10
Matthieu Vergne

Je vais essayer quelques trucs et je ferai un feedback.

N'ayant pas pris beaucoup de temps pour le faire, je me suis finalement retourne sur un simple fileset pour chaque dossier resource de chaque projet :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 <fileSets> ... <fileSet> <directory>../framework/resources</directory> <outputDirectory>/resources/</outputDirectory> </fileSet> <fileSet> <directory>../algo1/resources</directory> <outputDirectory>/resources/</outputDirectory> </fileSet> ... </fileSets>
Du coup, ce n'est pas le plus propre, mais ca marche. Si quelqu'un trouve une meilleure solution, qu'il ne la garde pas pour lui svp {'^_^}.

Le probleme principal etant resolu, je marque donc le sujet comme tel.