Como excluir um módulo de uma construção de reator Maven?

Temos um projeto Maven 2 com vários módulos. Exemplo:

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

Digamos que o módulo de "dados" consuma muito tempo para construir e queremos excluí-lo quando o projeto é construído por um servidor CI. Atualmente, usamos dois arquivos pom.xml para fazer isso. Um tem todos os módulos e o outro tem todos os módulos, exceto aqueles que podem ser deixados de fora para o CI. Mas isso é muito chato porque às vezes esquecemos de colocar um novo módulo em ambos os arquivos.

Existe uma solução que não precisa de duas listas de módulos separadas?

O mais fácil pode ser usar profilesassim:

<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>

Você deve, então, verificar as maneiras de ativar perfis

Com o Maven 3.2.1, agora você pode usar -pl !<module_name>,!<module_name>para excluir certos módulos da construção do reator.

Veja esta solicitação de recurso: https://issues.apache.org/jira/browse/MNG-5230

Os projetos a serem construídos também podem ser especificados na linha de comando mvn. Isso eliminaria a necessidade de um pom separado, mas, em vez disso, você teria que alterar a configuração do CI sempre que houver um novo módulo.

-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.

Talvez uma combinação deste sinalizador e / --also-make-dependentsou --also-makereduzisse novamente a carga de manutenção.

-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

Presumo que você queira que a construção padrão sempre crie tudo, independentemente da velocidade, para que novos desenvolvedores possam começar rapidamente sem ter que entender muito sobre o POM. Você pode usar perfis como este:

<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>

O problema com isso é que, se um desenvolvedor especificar outro perfil na linha de comando, o expensive-modules-to-buildnão será incluído (a menos que o desenvolvedor também o especifique). Isso torna complicado lembrar quais perfis devem ser incluídos.

Aqui está uma maneira hacky de contornar isso. Ambos os perfis estão sempre incluídos, porque o arquivo pom.xml sempre existe. Então, para excluir os módulos caros, você pode usar -P!full-buildna linha de comando.

<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>

Outra ideia: os módulos do Reactor podem ser aninhados, portanto, deve ser possível agrupar seus módulos de construção rápida e lenta em poms separados e, em seguida, adicionar outro pom agregador contendo esses dois como módulos. Seu servidor CI só poderia fazer referência ao pom que contém os módulos de construção rápida.

<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>

Você poderia usar perfis maven . Em nosso ambiente de construção, criamos um perfil quickque desabilita muitos plug-ins e execução de teste.

Isso é feito por

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

E então invocamos o maven da seguinte maneira

mvn groupId:artifactId:goal -P quick

Você pode desabilitar a compilação e outros plug-ins padrão no pom do seu módulo para acelerá-lo.

Não era exatamente a resposta que essas pessoas estavam pedindo. Minha situação era que eu queria implantar apenas o pom pai. Estou usando o spring-boot-thin-layoutmódulo em um filho. Isso requer que o módulo pai seja implantado no artifactory. Eu adicionei o seguinte em meu projeto. Ele permite o salto installe / ou deployfase.

No meu pai pom:

<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>

E no meu pom (s) filho (s) ou qualquer módulo que você não deseja implantado com o pai:

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

Então, efetivamente, quando eu executar mvn deployno pom pai, ele compilará todos os módulos, não executará a instalação em nada e, no final, implementará qualquer módulo que não tenha <maven.deploy.skip>${disable.deploy}</maven.deploy.skip>em suas propriedades. Portanto, no meu caso, apenas implantar o pai.