Como obter a versão do projeto Maven na linha de comando do bash

Anterior Emiti uma pergunta sobre como alterar a versão do projeto Maven da linha de comando que me levou a um novo problema.

Anteriormente, eu era capaz de obter o número da versão, pois a versão era armazenada como uma propriedade que era fácil de grep e analisar na linha de comando (bash). Agora que o elemento pom.xml é usado para isso, ele não é mais exclusivo, pois todas as dependências e talvez alguns outros também o usam. Eu acho que não há como obter o número da versão atual com um script bash sem ferramentas externas para analisar xml ou algum comando sed muito sensível ao contexto.

A solução mais limpa na minha opinião seria que o Maven distribuísse as informações dessa versão. Eu estava pensando em escrever um plug-in personalizado para recuperar propriedades diferentes, mas pensei em perguntar aqui primeiro.

Então, existe alguma maneira fácil de obter o valor da ${project.version}linha de comando? Desde já, obrigado.

Solução

Obrigado pela ajuda. Eu tive que ir cdpara o diretório manualmente, mas isso pode ser feito facilmente. No meu script bash eu tenho

version=`cd $project_loc && mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | sed -n -e '/^\[.*\]/ !{ /^[0-9]/ { p; q } }'`

O que me dá a versão atual que eu posso avançar. O Grepping pode ser mais simples, mas achei que fosse o mais robusto possível, por isso estou satisfeito com a primeira linha que começa com um número e tento lidar com isso como um número de versão.

# Advances the last number of the given version string by one.
function advance_version () {
    local v=$1
    # Get the last number. First remove any suffixes (such as '-SNAPSHOT').
    local cleaned=`echo $v | sed -e 's/[^0-9][^0-9]*$//'`
    local last_num=`echo $cleaned | sed -e 's/[0-9]*\.//g'`
    local next_num=$(($last_num+1))
    # Finally replace the last number in version string with the new one.
    echo $v | sed -e "s/[0-9][0-9]*\([^0-9]*\)$/$next_num/"
}

E eu uso isso simplesmente chamando

new_version=$(advance_version $version)

Espero que isso ajude alguém.

O Maven Help Plugin já está de alguma forma propondo algo para isso:

• help:evaluate avalia expressões Maven fornecidas pelo usuário em um modo interativo.

Aqui está como você o chamaria na linha de comando para obter ${project.version}:

mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate \
    -Dexpression=project.version

A solução de Tom com o Exec Maven Plugin é muito melhor, mas ainda mais complicada do que precisa. Para mim, é tão simples quanto:

MVN_VERSION=$(mvn -q \
    -Dexec.executable=echo \
    -Dexec.args='${project.version}' \
    --non-recursive \
    exec:exec)

Tenho pesquisado e descobri o seguinte:

1. O Maven foi responsabilizado porque a integração com as ferramentas do DevOps não é fácil devido ao fato de não seguir algumas boas práticas em relação às ferramentas da CLI. (ref: https://youtu.be/1ILEw6Qca3U?t=372 )

2. Inspirado na afirmação anterior, decidi dar uma olhada no código fonte do maven, bem como no maven-help-plugin. Parece que eles corrigiram um pouco a opção -q do maven (eu estou usando a versão 3.5.3), então agora, se você a aprovar, não obterá todo o material irritante de log sem sentido que impede a utilização do maven dentro de scripts automatizados. Portanto, você deve poder usar algo como isto:

   mvn help:evaluate -Dexpression=project.version -q

   O problema é que esse comando não imprime nada porque, por padrão, o plug-in de ajuda é enviado pelo criador de logs que foi silenciado pela opção -q. (a versão mais recente disponível do plugin é 3.1.0 lançada em 3 de junho de 2018)

3. Karl Heinz Marbaise ( https://github.com/khmarbaise ) o corrigiu adicionando um parâmetro opcional que permite chamá-lo da seguinte maneira:

   mvn help:evaluate -Dexpression=project.version -q -DforceStdout

   A descrição da confirmação está disponível em: ( https://github.com/apache/maven-help-plugin/commit/316656983d780c04031bbadd97d4ab245c84d014 )

mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | grep -v '\['

A resposta principal é bastante lixo, na minha opinião, você precisa usar um monte de grep para hackear a saída do console maven. Por que não usar a ferramenta certa para o trabalho? O uso da sintaxe xpath é a melhor abordagem para recuperar o número da versão, pois é o método pretendido para acessar uma estrutura de dados XML. A expressão abaixo está percorrendo o pom usando o "nome local" dos elementos, ou seja, ignorando as declarações de namespace que podem ou não estar presentes no xml.

xmllint --xpath "//*[local-name()='project']/*[local-name()='version']/text()" pom.xml

Isso evitará a necessidade de receber as entradas de log da saída:

mvn -Dexec.executable='echo' -Dexec.args='${project.version}' --non-recursive exec:exec -q

Esta é a solução mais limpa que encontrei:

mvn org.apache.maven.plugins:maven-help-plugin:3.2.0:evaluate -Dexpression=project.version -q -DforceStdout

Vantagens:

• Isso funciona bem em todos os sistemas operacionais e todos os shells.
• Não há necessidade de ferramentas externas!
• [importante] Isso funciona mesmo se a versão do projeto for herdada do pai pom.xml

Nota:

• maven-help-pluginversão 3.2.0(e acima) tem forceStdoutopção. Você pode substituir o 3.2.0comando acima por uma versão mais recente da lista de versões disponíveis do mvn-help-plugin do artifactory, se disponível.
• A opção -qsuprime mensagens detalhadas ( [INFO], [WARN]etc.)

Se você deseja buscar groupIde artifactIdtambém, marque esta resposta .

python -c "import xml.etree.ElementTree as ET; \
  print(ET.parse(open('pom.xml')).getroot().find( \
  '{http://maven.apache.org/POM/4.0.0}version').text)"

Contanto que você tenha python 2.5 ou superior, isso deve funcionar. Se você tiver uma versão inferior a essa, instale python-lxmle altere a importação para lxml.etree. Este método é rápido e não requer o download de plug-ins extras. Também funciona em arquivos pom.xml malformados que não são validados com xmllint, como os que eu preciso analisar. Testado em Mac e Linux.

Eu continuei correndo para casos secundários ao usar algumas das outras respostas aqui, então aqui está mais uma alternativa.

version=$(printf 'VER\t${project.version}' | mvn help:evaluate | grep '^VER' | cut -f2)

Se você não se importa em escrever a versão em um arquivo temporário, existe outra solução (sem grep / sed) que funciona bem para mim. ( EDIT : veja a resposta de rjrjr para uma solução muito mais simples, sem qualquer aborrecimento de arquivo temporário)

Eu uso o Exec Maven Plugin junto com o echobinário. Ao contrário do Maven Help Plugin, o Exec Plugin permite o redirecionamento de saída para um arquivo, que pode ser usado para ignorar o grep / sed, e torna ainda possível analisar coisas estranhas, como seqüências de caracteres de versão com várias linhas (com bloco CDATA na tag de versão), pelo menos até certo ponto.

#!/usr/bin/env sh

MVN_VERSION=""
VERSION_FILE=$( mktemp mvn_project_version_XXXXX )
trap "rm -f -- \"$VERSION_FILE\"" INT EXIT

mvn -Dexec.executable="echo" \
    -Dexec.args='${project.version}' \
    -Dexec.outputFile="$VERSION_FILE" \
    --non-recursive \
    --batch-mode \
    org.codehaus.mojo:exec-maven-plugin:1.3.1:exec > /dev/null 2>&1 ||
    { echo "Maven invocation failed!" 1>&2; exit 1; }

# if you just care about the first line of the version, which will be
# sufficent for pretty much every use case I can imagine, you can use
# the read builtin
[ -s "$VERSION_FILE" ] && read -r MVN_VERSION < "$VERSION_FILE"

# Otherwise, you could use cat.
# Note that this still has issues when there are leading whitespaces
# in the multiline version string
#MVN_VERSION=$( cat "$VERSION_FILE" )

printf "Maven project version: %s\n" "$MVN_VERSION"

Apenas para o registro, é possível configurar o log SLF4J simples do Maven diretamente na linha de comando para gerar apenas o que precisamos, configurando:

• org.slf4j.simpleLogger.defaultLogLevel=WARN e
• org.slf4j.simpleLogger.log.org.apache.maven.plugins.help=INFO

conforme documentado em http://www.slf4j.org/api/org/slf4j/impl/SimpleLogger.html

MAVEN_OPTS="\
-Dorg.slf4j.simpleLogger.defaultLogLevel=WARN \
-Dorg.slf4j.simpleLogger.log.org.apache.maven.plugins.help=INFO" \
mvn help:evaluate -o -Dexpression=project.version

Como resultado, pode-se executar simplesmente tail -1e obter:

$ MAVEN_OPTS="\
-Dorg.slf4j.simpleLogger.defaultLogLevel=WARN \
-Dorg.slf4j.simpleLogger.log.org.apache.maven.plugins.help=INFO" \
mvn help:evaluate -o -Dexpression=project.version | tail -1

1.0.0-SNAPSHOT

Observe que este é um item único. MAVEN_OPTSestão sendo reescritos apenas para esta mvnexecução específica .

Notei algumas Downloaded:linhas espúrias na saída que estavam quebrando minha tarefa original. Aqui está o filtro em que eu decidi; espero que ajude!

version=$(mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | egrep -v '^\[|Downloading:' | tr -d ' \n')

EDITAR

Não tenho 100% de certeza do motivo, mas ao executar isso por meio de um script pós-compilação no Jenkins, a saída estava saindo como [INFO]version, por exemplo,[INFO]0.3.2 .

Coloquei a saída em um arquivo e executei-a no meu primeiro filtro diretamente do BASH, funciona bem ... então, novamente, sem saber o que está acontecendo na terra de Jenkins.

Para obtê-lo 100% no Jenkins, adicionei um sedfiltro de acompanhamento ; aqui está o meu mais recente

version=$(mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | egrep -v '^\[|Downloading:' | tr -d ' \n' | sed -E 's/\[.*\]//g')

EDITAR

Uma última nota aqui .. Eu descobri que aindatr estava resultando em coisas como (novamente apenas quando executado via Jenkins). Mudou para e o problema desapareceu! Meu resultado final de trabalho/r/n0.3.2awk

mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version \
| egrep -v '^\[|Downloading:' | sed 's/[^0-9\.]//g' | awk 1 ORS=''

Uma solução simples e única

mvn -q -N org.codehaus.mojo:exec-maven-plugin:1.3.1:exec \
    -Dexec.executable='echo' \
    -Dexec.args='${project.version}'

E para pontos de bônus analisados ​​parte de uma versão

mvn -q -N org.codehaus.mojo:build-helper-maven-plugin:3.0.0:parse-version \
    org.codehaus.mojo:exec-maven-plugin:1.3.1:exec \
    -Dexec.executable='echo' \
    -Dexec.args='${parsedVersion.majorVersion}.${parsedVersion.minorVersion}.${parsedVersion.incrementalVersion}'

Desenvolvi recentemente o plug-in Release Candidate Maven que resolve esse problema exato, para que você não precise recorrer a nenhum script de shell hacky e analisar a saída do maven-help-plugin.

Por exemplo, para imprimir a versão do seu projeto Maven em um terminal, execute:

mvn com.smartcodeltd:release-candidate-maven-plugin:LATEST:version

que fornece uma saída semelhante a maven-help-plugin:

[INFO] Detected version: '1.0.0-SNAPSHOT'
1.0.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

No entanto, você também pode especificar um formato de saída arbitrário (para que a versão possa ser selecionada no log por um servidor de IC, como o TeamCity ):

mvn com.smartcodeltd:release-candidate-maven-plugin:LATEST:version \
   -DoutputTemplate="##teamcity[setParameter name='env.PROJECT_VERSION' value='{{ version }}']"

O que resulta em:

[INFO] Detected version: '1.0.0-SNAPSHOT'
##teamcity[setParameter name='env.PROJECT_VERSION' value='1.0.0-SNAPSHOT']
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

Para salvar a saída em um arquivo (para que um servidor de IC como o Jenkins possa usá-lo ):

mvn com.smartcodeltd:release-candidate-maven-plugin:LATEST:version \
   -DoutputTemplate="PROJECT_VERSION={{ version }}" \
   -DoutputUri="file://\${project.basedir}/version.properties"

O version.propertiesarquivo resultante terá a seguinte aparência:

PROJECT_VERSION=1.0.0-SNAPSHOT

Além disso, o Release Candidate também permite definir a versão do seu projeto (algo que você provavelmente faria no servidor de CI) com base na versão da API que você definiu no seu POM.

Se você quiser ver um exemplo de Release Candidate sendo usado como parte do ciclo de vida do Maven, dê uma olhada no pom.xmlmeu outro projeto de código aberto - Build Monitor for Jenkins .

Há também uma opção sem a necessidade do Maven:

grep -oPm1 "(?<=<version>)[^<]+" "pom.xml"

A solução tudo-em-um fácil de entender que gera a versão do projeto maven e suprime a saída estranha de [INFO]e Downloadmensagens:

mvn -o org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | grep -v '\['

A mesma coisa, mas dividida em duas linhas:

mvn -o org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate \
      -Dexpression=project.version | grep -v '\['

Saídas: 4.3-SNAPSHOT

Então, usando o seu project.versionem um script simples do bash:

projectVersion=`mvn -o org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | grep -v '\['`
cd "target/"$projectVersion"-build"

Outras soluções nesta página não pareciam combinar todos os truques em um.

Deveria ser mais fácil, pois esse bug foi corrigido no maven-help-plugin 3.0.0: MPH-99 Evaluate não possui saída no modo silencioso .

Essa é de longe a solução mais fácil de cortar e colar no bash:

VERSION=$(mvn -Dexec.executable='echo' -Dexec.args='${project.version}' --non-recursive exec:exec -q)
echo $VERSION

ecoa

1.4

Encontrei o equilíbrio certo para mim. Após o mvn packagemaven-archiver, o plugin cria target/maven-archiver/pom.propertiescom conteúdo como este

version=0.0.1-SNAPSHOT
groupId=somegroup
artifactId=someArtifact

e eu estou usando o bash apenas para executá-lo

. ./target/maven-archiver/pom.properties

então

echo $version
0.0.1-SNAPSHOT

É claro que isso não é seguro para executar este arquivo, mas a execução pode ser facilmente convertida em script perl ou bash para ler e definir variáveis ​​de ambiente a partir desse arquivo.

Isso funcionou para mim, offline e sem depender do mvn:

VERSION=$(grep --max-count=1 '<version>' <your_path>/pom.xml | awk -F '>' '{ print $2 }' | awk -F '<' '{ print $1 }')
echo $VERSION

O plug-in Exec funciona sem nenhuma análise de saída, porque a saída pode ser redirecionada para o arquivo e injetada novamente no ambiente de trabalho através do plug-in EnvInject:

Com base na pergunta, eu uso este script abaixo para aumentar automaticamente meu número de versão em todos os pais / submódulos maven:

#!/usr/bin/env bash  

# Advances the last number of the given version string by one.  
function advance\_version () {  
    local v=$1  
    \# Get the last number. First remove any suffixes (such as '-SNAPSHOT').  
  local cleaned=\`echo $v | sed \-e 's/\[^0-9\]\[^0-9\]\*$//'\`  
 local last\_num=\`echo $cleaned | sed \-e 's/\[0-9\]\*\\.//g'\`  
 local next\_num=$(($last\_num+1))  
  \# Finally replace the last number in version string with the new one.  
  echo $v | sed \-e "s/\[0-9\]\[0-9\]\*\\(\[^0-9\]\*\\)$/$next\_num/"  
}  

version=$(mvn org.apache.maven.plugins:maven-help-plugin:3.2.0:evaluate -Dexpression=project.version -q -DforceStdout)  

new\_version=$(advance\_version $version)  

mvn versions:set -DnewVersion=${new\_version} -DprocessAllModules -DgenerateBackupPoms=false

Você mvndeu a resposta (como a maioria das respostas sugere) ou extrai a resposta da pom.xml. A única desvantagem da segunda abordagem é que você pode extrair facilmente o valor da <version/>tag, mas isso só será significativo se for literal , ou seja, não for uma propriedade Maven. Eu escolhi essa abordagem de qualquer maneira porque:

• mvn é uma maneira detalhada e eu simplesmente não gosto de filtrar sua saída.
• O início mvné muito lento em comparação com a leitura do pom.xml.
• Eu sempre uso valores literais em <version/>.

mvn-versioné um zshscript de shell usado xmlstarletpara ler pom.xmle imprimir a versão do projeto (se existir) ou a versão do projeto pai (se existir):

$ mvn-version .
1.0.0-SNAPSHOT

A vantagem é que é muito mais rápido que a execução mvn:

$ time mvn-version .
1.1.0-SNAPSHOT
mvn-version .  0.01s user 0.01s system 75% cpu 0.019 total

$ time mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate \
> -Dexpression=project.version
mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate   4.17s user 0.21s system 240% cpu 1.823 total

A diferença na minha máquina é maior que duas ordens de magnitude.

Preciso exatamente desse requisito durante meu trabalho no Travis, mas com vários valores. Começo com esta solução, mas ao chamar várias vezes isso é muito lento (preciso de 5 expressões).

Eu escrevi um plugin simples do maven para extrair os valores do pom.xml no arquivo .sh.

https://github.com/famaridon/ci-tools-maven-plugin

mvn com.famaridon:ci-tools-maven-plugin:0.0.1-SNAPSHOT:environment -Dexpressions=project.artifactId,project.version,project.groupId,project.build.sourceEncoding

Produzirá isso:

#!/usr/bin/env bash
CI_TOOLS_PROJECT_ARTIFACTID='ci-tools-maven-plugin';
CI_TOOLS_PROJECT_VERSION='0.0.1-SNAPSHOT';
CI_TOOLS_PROJECT_GROUPID='com.famaridon';
CI_TOOLS_PROJECT_BUILD_SOURCEENCODING='UTF-8';

agora você pode simplesmente obter o arquivo

source .target/ci-tools-env.sh

Diverta-se.

Estou usando um one-liner no meu shell unix ...

cat pom.xml | grep "" | cabeça -n 1 | sed -e "s / versão // g" | sed -e "s / \ s * [<> /] * // g"

Você pode ocultar essa linha em um script de shell ou como um alias.

esta é uma edição de cima

cat pom.xml | grep "" | cabeça -n 1 | sed -e "s / versão // g" | sed -e "s / \ s * [<> /] * // g"

Eu testei no cmdline funciona bem

grep "" pom.xml | cabeça -n 1 | sed -e "s / versão // g" | sed -e "s / \ s * [<> /] * // g"

é outra versão do mesmo. Preciso obter o número da versão no Jenkins CI no k8s sem o mvn instalado, portanto, isso é muito útil

obrigado a todos.

mvn help:evaluate -Dexpression=project.version | sed -e 1h -e '2,3{H;g}' -e '/\[INFO\] BUILD SUCCESS/ q' -e '1,2d' -e '{N;D}' | sed -e '1q'

Estou apenas adicionando um pequeno sedaprimoramento de filtro que recentemente implementei para extrair project.versionda saída maven.

VERSION=$(head -50 pom.xml | awk -F'>' '/SNAPSHOT/ {print $2}' | awk -F'<' '{print $1}')

Isto é o que eu costumava obter o número da versão, pensei que haveria uma maneira melhor de fazê-lo