Transférer des assemblies par FTP avec Maven 2

Je sais que Maven 2 n'est pas un outil super adapté au déploiement, mais bon...

Mon problème est le suivant :

J'ai un projet multi-modules du genre :

Code:

1
2
3
4
5
 
app
  + commons
  + client
  + server

J'ai paramétrer mon pom.xml de façon à ce qu'à la fin d'un mvn clean package, je me retrouve avec 3 assemblies dans app/target : client.zip, server.tar.gz et oracle.tar.gz.

Maintenant, je veux transférer les 2 derniers assemblies sur un serveur, en utilisant le FTP.

Tout d'abord, pouvez-vous me confirmer que cargo n'est pas utile ici, car c'est mon assembly et non mon livrable (i.e. les JAR et pom) que je souhaite transférer ? Il me semble avoir vu que c'était possible, mais de façon un peu douloureuse...

Je décide donc d'opter, à défaut de mieux, de faire ça par Ant (via le plugin antrun). Techniquement, je n'ai pas trop de soucis.
Là où je ne trouve pas de solution idéale, c'est comment faire pour stocker et utiliser les bons paramètres de connexion.
Il est juste hors de question que je stocke un mot de passe en clair dans le pom.xml.

Du coup, j'ai pour l'instant opté pour la solution suivante :

Dans mon settings.xml, j'ai stocké les mots de passe :

Code:

1
2
3
4
5
 
<properties>
    <ftp-pass-dev>toto</ftp-pass-dev>
    <ftp-pass-hom>tutu</ftp-pass-hom>
</properties>

Dans mon pom.xml, j'ai définit plusieurs profils, un par environnement (activable selon la valeur de la propriété env). Par exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
    <profiles>
        <!-- DEVELOPMENT profile -->
        <profile>
            <id>development</id>
            <activation>
                <activeByDefault>false</activeByDefault>
                <property>
                    <name>env</name>
                    <value>dev</value>
                </property>
            </activation>
            <properties>
                <ftp-url>serveur</ftp-url>
                <ftp-username>userdev</ftp-username>
            </properties>
        </profile>

Bon, je pourrais décider aussi d'externaliser l'url du serveur, ainsi que le nom de l'utilisateur dans le settings.xml, comme je l'ai fait pour le password.

Enfin, dans mon pom.xml du server (c'est lui qui crée les assemblies que je souhaite transférer), je définis ceci :

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
 
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-antrun-plugin</artifactId>
                <version>1.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>run</goal>
                        </goals>
                        <configuration>
                            <tasks>
                                <ftp server="${ftp-url}" userid="${ftp-username}" password="${ftp-pass-${env}}" passive="yes">
                                    <fileset dir="../target/">
                                        <include name="*.tar.gz"/>
                                    </fileset>
                                </ftp>
                            </tasks>
                        </configuration>
                    </execution>
                </executions>
                <dependencies>
                    <dependency>
                        <groupId>ant</groupId>
                        <artifactId>ant-commons-net</artifactId>
                        <version>1.6.5</version>
                    </dependency>
                    <dependency>
                        <groupId>commons-net</groupId>
                        <artifactId>commons-net</artifactId>
                        <version>1.4.1</version>
                    </dependency>
                </dependencies>
            </plugin>

Ca marche, c'est cool, mais je ne trouve pas ça vraiment optimal. Avez-vous des idées ou des commentaires quant à cette façon de faire ?

Merci.

Je ne vois pas d’autres méthodes de faire ceci en Maven.
Selon moi, on entre ici dans les limites de Maven.

Le problème est avant tout que chaque module Maven n’a vocation a ne produire que un seul artefact par défaut. Ainsi tu ne peux pas utiliser la phase de déploiement (deploy) de Maven avec comme url ton adresse FTP.

Il est temps d’envisager des solutions alternatives comme Ivy qui va te permettre de gérer cela proprement. Et pour garder l’aspect conventions, multi projet, ne pas hésiter a le coupler à Gradle

La solution qui resterait plus dans l'esprit Maven à mon sens serait d'utiliser le site-plugin pour déployer par FTP le contenu "site", dans lequel tu aurais placé tes assemblies générées.

Tu peux regarder le plugin wagon : http://mojo.codehaus.org/wagon-maven-plugin/

Bon, je parlais de cargo dans mon message initial, mais c'était bien wagon.

J'avoue ne pas avoir réussi à configurer simplement ce plugin pour qu'il me transfère l'assembly, et non le livrable final.
L'une des idées sinon serait de faire autant de modules qu'il n'y a d'assemblies, et de bidouiller de façon à ce le livrable soit en réalité l'assembly... Mais je ne trouve pas ça très propre. A moins qu'il n'y ait une meilleure méthode ?