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

201

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.

mkko
fonte
1
A solução parece não ter terminado a expressão sed.
Nahroth # 14/11
Qual sed exp? Eu não consigo perceber.
Mkko #
1
que uma mvn -o fazer para execução mais rápida
Nathan Bubna
2
Você pode substituir essa expressão sed complexo com um simplesgrep -e '^[[:digit:]]'
bpedman
2
Se você usar -o como recomendado por @NathanBubna, isso colocará o maven no modo 'offline'. Se você ainda não possui o plug-in de ajuda maven e os jars dependentes baixados, a compilação falhará. Fiquei um pouco queimado com isso, espero que ajude outra pessoa.
Phillipuniverse

Respostas:

217

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
Pascal Thivent
fonte
8
Ok obrigado. Acho que é o mais próximo que chegarei a uma solução limpa. Alguma idéia de como eu poderia suprimir a saída do maven e filtrar essas [INFO]mensagens? Não encontrei um interruptor para o maven. Caso contrário, adicionarei alguns scripts de linha de comando para analisar o número da versão.
Mkko
80
Estou removendo todas as mensagens de log (INFO, WARNING, etc) e 'Download' commvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version|grep -Ev '(^\[|Download\w+:)'
Chadwick
13
não esperaria nada menos detalhada do Maven
Andy
24
Aqui está uma abordagem que eu sou a favor:printf 'VERSION=${project.version}\n0\n' | mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate | grep '^VERSION'
ash
40
@montoyaed postou a melhor resposta que simplesmente é mvn help:evaluate -Dexpression=project.version -q -DforceStdout. Para capturá-lo em uma variável em uso Bashversion=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)
Sebastian Thomschke
200

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)
rjrjr
fonte
30
Eu acho que esta é a maneira mais fácil, pois não implica o uso de grep ou coisas semelhantes. Nota rápida: você pode torná-lo um pouco mais curto:mvn -q -Dexec.executable="echo" -Dexec.args='${project.version}' --non-recursive exec:exec
scrutari
1
Esta solução funcionou bem para mim como eu queria imprimir groupId, artifactId e versão .. -Dexec.args='${project.groupId}:${project.artifactId}:${project.version}'.
James H.
1
[ERROR] Failed to execute goal org.codehaus.mojo:exec-maven-plugin:1.3.2:exec (default-cli) on project audit-events-processor-parent: Command execution failed. Cannot run program "maven" (in directory "/tmp"): error=2, No such file or directory encolher ainda outra resposta que não funciona para mim, oh bem
cbmanica
Obrigado esta é a melhor solução que tenho visto até agora, uma vez que não necessitam de aplicar grep / sed comandos frágeis ou similares
Mike76
O que é #set -o errexit
theonlygusti
80

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 )

Eduardo Montoya
fonte
2
Essa seria minha solução preferida e também é mencionada nas páginas de ajuda oficiais . No entanto, isso não funciona para mim. Estou no MacOS com o Maven v3.5.3. Quando não uso a -qopção, ela imprime a versão corretamente (entre as linhas de log). Alguma ideia?
gucce
3
Essa deve ser a resposta aceita. Funciona no Windows e Linux (não experimentei o Max OSX) e é simples. Obrigado.
Trash80
1
@montoyaedu Desculpe por não responder. Enquanto isso, atualizei para o maven 3.5.4, que funciona bem com o -qswitch.
gucce
1
@gucce Posso confirmar que a versão maven usada afeta isso: com 3.5.2 (versão do pacote no debian 9) a saída -q -DforceStdoutestava vazia, garantindo que a versão 3.1.0 do plugin fosse usada com pluginManagement); i configurado invólucro maven com a versão 3.5.4 do perito, e ele funcionou corretamente
Gorkk
3
Finalmente, uma solução prática sem grep para 2019 - (essa deve se tornar a resposta aceita). Também funciona com versões compatíveis com CI - testado em 3.3.9, 3.5.3, 3.5.4, 3.6.0
Ed Randall
47
mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | grep -v '\['
user1712021
fonte
2
fazer essa mvn -o para execução mais rápida
Nathan Bubna
1
Veja minha resposta (quickshiftin) abaixo da qual filtra as linhas 'Downloaded:' também.
quickshiftin
10
Se você usar -o como recomendado por @NathanBubna, isso colocará o maven no modo 'offline'. Se você ainda não possui o plug-in de ajuda do maven e os jars dependentes baixados, a compilação falhará. Fiquei um pouco queimado com isso, espero que ajude outra pessoa.
Phillipuniverse
Você pode querer adicionar também 2> /dev/nullcomo você pode obter #Picked up _JAVA_OPTIONS:
Jakub Bochenski
2
No Windows, substitua o final do comando por | findstr /v "[".
Tunaki
39

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
lukeforehand
fonte
@bobmarksie Eu segundo isso; usar maven e esfregar a saída com regexp's é doloroso.
Mhvelplund 13/06/19
3
Que tal um projeto que herda de um pom pai.
Wes
2
"Por que não usar a ferramenta certa para o trabalho?" IE! Maven?
jeremyjjbrown
Eu entendo que usar mvné a abordagem correta e o execplug - in realmente funciona bem, mas todas as soluções mvn precisam ser resolvidas e estou tentando inicializar um pipeline de construção em que a resolução de dependência não funcione, por isso vou substituir a execabordagem por esta solução. Felizmente, não preciso me preocupar com versões herdadas dos pais.
haridsv
Isso não funcionará com o controle de versão compatível com ci, onde a versão é uma propriedade como, ${revision}por exemplo. Ref. maven.apache.org/maven-ci-friendly.html
Ed Randall
30

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
Jose Alban
fonte
Embora esse código possa responder à pergunta, fornecer um contexto adicional a respeito de por que e / ou como responde à pergunta melhoraria significativamente seu valor a longo prazo. Por favor edite sua resposta para adicionar alguma explicação.
Toby Speight
1
Eu acho que, para essa abordagem, é necessário colocar o "-q" após o mvn.
Rudge
Isso é melhor que a solução aceita; não é necessário filtrar a saída barulhenta.
Willian Mitsuda
20

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 .

Manu Manjunath
fonte
13
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.

pdr
fonte
12

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)
lento
fonte
1
printf 'VER\t${project.version}' | mvn help:evaluate 2> /dev/null | grep '^VER' | cut -f2
yegeniy
7

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"
Tom
fonte
6
Essa é uma solução muito melhor que o plug-in auxiliar, e você não precisa de toda essa E / S. Basta adicionar um sinalizador -q e a única saída será a versão. Então: mvn -q -Dexec.executable = "echo" -Dexec.args = '$ {project.version}' - não-recursivo org.codehaus.mojo: exec-maven-plugin: 1.3.1: exec
rjrjr
rjrjr: Ótimo! A única coisa que preciso mencionar aqui é o tratamento de erros: Se o mvn falhar, você receberá uma string de versão inválida. Portanto, é necessária alguma validação, como verificar o código de retorno mvn ou a própria string.
Tom
6

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 .

Stepan Vavra
fonte
5

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=''
troca rápida
fonte
5

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}'
Jakob O.
fonte
5

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 .

Jan Molak
fonte
5

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

grep -oPm1 "(?<=<version>)[^<]+" "pom.xml"
Michal Šípek
fonte
Este mostra apenas a primeira ocorrência em pom. No meu caso, a primeira ocorrência fornece a versão pom dos pais. Mas, para ser sincero, esta é a resposta que eu estava procurando. É muito mais rápido que as soluções mencionadas anteriormente e é fácil modificá-lo para obter a ocorrência adequada. Para obter a segunda ocorrência, use: grep -oPm2 "(?<=<version>)[^<]+" pom.xml | sed -n 2pPara obter a terceira ocorrência, use: grep -oPm3 "(?<=<version>)[^<]+" pom.xml | sed -n 3pe assim por diante
Krzysztof Cieśliński
Você está assumindo que o elemento version é a primeira ocorrência e não funciona quando a suposição é inválida.
devildelta
3

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.

Peter Dietz
fonte
3

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
freedev
fonte
2

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.

Vladimir I
fonte
1

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
George
fonte
1

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:

insira a descrição da imagem aqui

Ondřej Kmoch
fonte
1

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
Yu Jiaao
fonte
0

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.

Enrico M. Crisostomo
fonte
0

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.

Florent Amaridon
fonte
-1

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.

MichaOnline
fonte
-1

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.

Philip Ruff
fonte
-2
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.

websigni
fonte
-2
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

Tristik
fonte