Accès à un fichier depuis n'importe quel (sous)modules

Version imprimable

Bonjour,

J'ai un projet multi-modules (à plusieurs niveaux), dont la structure est la suivante :
Code:

1 2 3 4 5 6 7 8 9 10 main-project/ module1/ module2/ sous-module1/ sous-module2/ sous-module3/ ... module3/ module4/ ...
J'ai besoin de définir un ensemble de propriétés (qui sont dépendantes de l'environnement destiné à la release) à Maven. Je ne souhaite pas utiliser les <properties> directement, vu que j'ai pas mal de propriétés à définir. De fait, j'utilise le plugin Properties de Codehaus, qui permet de lire un fichier properties...
Ce fichier properties se situe au niveau du répertoire racine, à savoir main-project.
Mon souci, c'est que je n'arrive pas à lui indiquer un chemin d'accès qui soit valable pour chaque module et sous-module.
Mon pom :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>properties-maven-plugin</artifactId> <version>1.0-alpha-1</version> <executions> <execution> <phase>initialize</phase> <goals> <goal>read-project-properties</goal> </goals> <configuration> <files> <file>???/env_${env}.properties</file> </files> </configuration> </execution> </executions> </plugin>
Si je définis <file>env_${env}.properties</file>, alors le plugin Properties va réussir à trouver le fichier quand Maven2 construira le pom parent, mais dès que l'on passe à un module, il ne le trouvera plus !
Pareillement, si je mets <file>../env_${env}.properties</file>, alors si c'est bon pour les modules, ce ne sera pas bon pour le pom parent ou encore les sous-modules...

Donc j'ai 2 options :

Soit j'arrive à définir une propriété pointant toujours sur le répertoire basedir du pom principal
Soit je trouve une autre solution pour charger ces propriétés...

Une idée ?

19/06/2009, 09h26
lordseth0

Je te donne une idée qui me vient comme ça, elle vaut ce qu'elle vaut.
Tu peux peut être définir une propriété dans ton pom parent qui prend comme valeur ${basedir}.

Code:

<main.project.basedir>${basedir}</main.project.basedir >

Tes pom de modules et sous modules auront donc la valeur du répertoire de main_project et devrait trouver tes fichiers de properties.

Code:

<file>${main.project.basedir }/env_${env}...</file>
19/06/2009, 09h35
romaintaz

Merci pour l'idée, j'avais également pensé à utiliser cette "ruse".
Hélas, la propriété main-project-basedir, bien que définie uniquement dans le pom.xml parent, est réactualisée à chaque fois.
Ainsi, main-project-basedir au niveau pom parent vaudra par exemple "C:\toto\projet\", mais dans le module1, il vaudra "C:\toto\projet\module1" !

D'autres pistes ?
19/06/2009, 10h07
lordseth0
Arf je m'en douté un peu. J'ai bien une autre idée, mais nettement moins esthetique : c'est de mettre en 'flat' tout ton projet c'est à dire d'avoir tous les modules au même niveau.
Code:

1 2 3 4 5 6 7 main_project module1 sousmodule1 sousmodule2 sousmodule3 module2 module3
Dans les pom de tes modules parents, tu déclares les modules enfants comme suit:
Code:

1 2 3 <module>../sousmodule1</module> <module>../sousmodule2</module> <module>../sousmodule3</module>
Ainsi tu peux utiliser tout le temps le chemin vers ton main module :

Code:

<file>../main_project/env-${env}...</file>
19/06/2009, 10h45
romaintaz

Alors cette solution ne me plait pas du tout... D'autant que j'ai demandé un CVS move de toute une partie de mon application, donc je ne vais pas m'amuser à refaire ça. En plus, c'est très laid ;)

Je pense que je vais essayer de setter moi même toutes les propriétés en utilisant un plugin qui me permet de faire du groovy dans le pom.xml. Un peu comme Gregory me l'avait proposé pour un autre problème...
Loin d'être une solution ultime, mais à défaut de mieux...

Je testerais ça lundi, je vous dirais si ça marche.
En attendant, si vous avez d'autres pistes...

Bon, comme on est lundi (si si), j'ai testé (bon, en fait j'étais trop curieux pour voir si ça marchait).

J'ai donc fait ainsi :

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
    <plugin>
        <groupId>org.codehaus.groovy.maven</groupId>
        <artifactId>gmaven-plugin</artifactId>
        <version>1.0-rc-5</version>
        <executions>
            <execution>
                <phase>validate</phase>
                <goals>
                    <goal>execute</goal>
                </goals>
                <configuration>
                    <source>
                        import java.io.File;
                        String p = project.properties['env-properties-file'];
                        File f = new File(p); 
                        if (!f.exists()) {
                            f = new File("../" + p);
                            if (!f.exists()) {
                                f = new File("../../" + p);
                            }
                        }
                        project.properties['env-properties-file-by-groovy'] = f.getAbsolutePath();
                </source>
                </configuration>
            </execution>
        </executions>
    </plugin>
    <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>properties-maven-plugin</artifactId>
        <version>1.0-alpha-1</version>
        <executions>
            <execution>
                <phase>initialize</phase>
                <goals>
                    <goal>read-project-properties</goal>
                </goals>
                <configuration>
                    <files>
                        <file>${env-properties-file-by-groovy}</file>
                    </files>
                </configuration>
            </execution>
        </executions>
    </plugin>

et ça marche correctement. C'est pas over-le-top, mais ça marche...
Donc si quelqu'un a une meilleure solution plus propre, je suis prenneur !

Bon, j'ai une autre solution un peu plus propre car elle n'a pas besoin de plugin additionel. Il "suffit" de définir une propriété désignant le répertoire du main-project, et de la redéfinir dans chaque (sous)module :

Pom parent:
Code:

1 2 3 <properties> <root-directory>${basedir}</root-directory> </properties>
et l'utilisation dans le plugin properties:
Code:

1 2 3 4 5 <configuration> <files> <file>${root-directory}/${env-properties-file}</file> </files> </configuration>
Pom d'un module :
Code:

1 2 3 <properties> <root-directory>${project.parent.basedir}</root-directory> </properties>
Pom d'un sous-module:
Code:

1 2 3 <properties> <root-directory>${project.parent.parent.basedir}</root-directory> </properties>