Comment exclure un module d'une construction de réacteur Maven?

Nous avons un projet Maven 2 avec de nombreux modules. Exemple:

<modules>
  <module>common</module>
  <module>foo</module>
  <module>data</module>
  <module>bar</module>
  ... more ...
</module>

Disons que le module "data" prend du temps à construire et que nous voulons l'exclure lorsque le projet est construit par un serveur CI. Actuellement, nous utilisons deux fichiers pom.xml pour y parvenir. L'un contient tous les modules et l'autre contient tous les modules sauf ceux qui peuvent être laissés de côté pour CI. Mais c'est assez ennuyeux car parfois on oublie de mettre un nouveau module dans les deux fichiers.

Existe-t-il une solution qui ne nécessite pas deux listes de modules distinctes?

Le plus simple pourrait être d'utiliser profilescomme ceci:

<project>
  ...
  <modules>
    <module>common</module>
    <module>foo</module>
    <module>bar</module>
  <modules>
  ...
  <profiles>
    <profile>
      <id>expensive-modules-to-build</id>
      <modules>
        <module>data</module>
      </modules>
    </profile>
  </profiles>
</project>

Vous devriez ensuite vérifier les moyens d'activer les profils

Avec Maven 3.2.1, vous pouvez désormais utiliser -pl !<module_name>,!<module_name>pour exclure certains modules de la construction du réacteur.

Voir cette demande de fonctionnalité: https://issues.apache.org/jira/browse/MNG-5230

Les projets à construire peuvent également être spécifiés sur la ligne de commande mvn. Cela éliminerait le besoin d'un pom séparé, mais à la place, vous devrez changer la configuration du CI à chaque fois qu'il y a un nouveau module.

-pl,--projects <arg>                Comma-delimited list of specified
                                    reactor projects to build instead
                                    of all projects. A project can be
                                    specified by [groupId]:artifactId
                                    or by its relative path.

Peut-être qu'une combinaison de cet indicateur et / --also-make-dependentsou --also-makeréduirait à nouveau ce fardeau de maintenance.

-am,--also-make                     If project list is specified, also
                                    build projects required by the
                                    list
-amd,--also-make-dependents         If project list is specified, also
                                    build projects that depend on
                                    projects on the list

Je suppose que vous voulez que la version par défaut construise toujours tout, quelle que soit la vitesse, afin que les nouveaux développeurs puissent démarrer rapidement sans avoir à en comprendre beaucoup sur le POM. Vous pouvez utiliser des profils comme celui-ci:

<modules>
    <module>common</module>
    <module>foo</module>
    <module>bar</module>
  </modules>
  ...
  <profiles>
    <profile>
      <id>expensive-modules-to-build</id>
      <activation>
         <activeByDefault>true</activeByDefault>
      </activation>
      <modules>
        <module>data</module>
      </modules>
    </profile>
  </profiles>
</project>

Le problème avec ceci est que si un développeur spécifie un autre profil sur la ligne de commande, alors le expensive-modules-to-buildn'est pas inclus (sauf si le développeur le spécifie également). Cela complique la mémorisation des profils à inclure.

Voici un moyen de contourner cela. Les deux profils sont toujours inclus, car le fichier pom.xml existe toujours. Donc, pour exclure les modules coûteux, vous pouvez utiliser -P!full-buildsur la ligne de commande.

<profiles>
    <profile>
        <id>full-build</id>
        <activation>
            <file>
                <exists>pom.xml</exists>
            </file>
        </activation>
        <modules>
            <module>data</module>
        </modules>
    </profile>
    <profile>
        <id>short-build</id>
        <activation>
            <file>
                <exists>pom.xml</exists>
            </file>
        </activation>
        <modules>
           <module>common</module>
           <module>foo</module>
           <module>bar</module>
        </modules>
    </profile>
</profiles>

Une autre idée: les modules Reactor peuvent être imbriqués, il devrait donc être possible de regrouper vos modules à construction rapide et lente dans des poms séparés, puis d'ajouter un autre pom d'agrégateur contenant ces deux sous forme de modules. Votre serveur CI pourrait alors uniquement référencer le pom contenant les modules de construction rapide.

<artifactId>fast</artifactId>
<modules>
    <module>fast-a</module>
    <module>fast-b</module>
    <module>fast-c</module>
</module>

<artifactId>all</artifactId>
<modules>
    <module>fast</module>
    <module>slow</module>
</module>

Vous pourriez utiliser des profils maven . Dans notre environnement de construction, nous avons créé un profilquick qui désactive de nombreux plugins et l'exécution de tests.

Ceci est fait par

    <profile>
        <id>quick</id>
        <properties>
            <skipTests>true</skipTests>
            <!-- others... -->
        </properties>   
        <build>
            <plugins>
                 <!-- configuration... -->
            </plugins>
        </build>
    </profile>

Et puis nous invoquons maven de la manière suivante

mvn groupId:artifactId:goal -P quick

Vous pourriez peut-être désactiver la compilation et d'autres plugins standard dans le pom de votre module pour l'accélérer.

Pas exactement la réponse que ces gens demandaient. Ma situation était que je voulais déployer uniquement le pom parent. J'utilise le spring-boot-thin-layoutdans un module enfant. Cela nécessite que le module parent soit déployé dans un artificiel. J'ai ajouté ce qui suit dans mon projet. Il permet de sauter installet / ou de deployphase.

Dans mon pom parent:

<properties>
    <disable.install>true</disable.install>
    <disable.deploy>true</disable.deploy>
    <enable.deployAtEnd>true</enable.deployAtEnd>
</properties>

<profiles>
    <profile>
        <id>deploy-parent</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <disable.install>true</disable.install>
            <disable.deploy>true</disable.deploy>
            <deployAtEnd>${enable.deployAtEnd}</deployAtEnd>
        </properties>
        <build>
            <finalName>${project.version}</finalName>
        </build>
    </profile>
</profiles>

Et le (s) pom (s) de mon enfant ou tout module que vous ne voulez pas déployer avec le parent:

<properties>
    <maven.install.skip>${disable.install}</maven.install.skip>
    <maven.deploy.skip>${disable.deploy}</maven.deploy.skip>
    <deployAtEnd>${enable.deployAtEnd}</deployAtEnd>
</properties>

Donc, effectivement, lorsque je lance mvn deploysur le pom parent, il compilera tous les modules, ne lancera l'installation sur rien, puis à la fin, déploiera tout module n'ayant pas <maven.deploy.skip>${disable.deploy}</maven.deploy.skip>dans ses propriétés. Donc, dans mon cas, ne déployer que le parent.