Come ottenere la versione del progetto Maven sulla riga di comando bash

In precedenza avevo fatto una domanda su come cambiare la versione del progetto Maven dalla riga di comando che mi ha portato a un nuovo problema.

In precedenza ero in grado di ottenere il numero di versione poiché la versione era memorizzata come una proprietà che era facile da grep e analizzare dalla riga di comando (bash). Ora che l'elemento pom.xml viene utilizzato per questo, non è più unico poiché tutte le dipendenze e forse anche alcuni altri lo usano. Penso che non ci sia modo di ottenere l'attuale numero di versione con uno script bash senza strumenti esterni per l'analisi di XML o qualche comando sed molto sensibile al contesto.

La soluzione più pulita secondo me sarebbe che Maven distribuisse queste informazioni sulla versione. Stavo pensando di scrivere un plug-in personalizzato maven per recuperare proprietà diverse, ma ho pensato di chiedere prima qui.

Quindi, c'è un modo semplice per ottenere il valore della ${project.version}riga di comando? Grazie in anticipo.

Soluzione

Grazie per l'aiuto. Ho dovuto cdaccedere manualmente alla directory, ma ciò può essere fatto facilmente. Nel mio script bash che ho

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 } }'`

Il che mi dà la versione attuale che posso quindi avanzare. Grepping potrebbe essere più semplice, ma ho pensato che mi sarebbe piaciuto il più robusto possibile, quindi sono soddisfatto della prima riga che inizia con un numero e provo a gestirlo come un numero di versione.

# 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 lo uso semplicemente chiamando

new_version=$(advance_version $version)

Spero che questo aiuti qualcuno.

Il plugin Help di Maven sta già proponendo qualcosa per questo:

• help:evaluate valuta le espressioni Maven fornite dall'utente in modalità interattiva.

Ecco come lo invocheresti dalla riga di comando per ottenere il ${project.version}:

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

La soluzione di Tom con il plug-in Exav Maven è molto migliore, ma ancora più complicata di quanto debba essere. Per me è semplice come:

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

Ho fatto alcune ricerche e ho trovato quanto segue:

1. Maven è stato accusato perché l'integrazione con gli strumenti DevOps non è facile a causa del fatto che non segue alcune buone pratiche relative agli strumenti CLI. (rif: https://youtu.be/1ILEw6Qca3U?t=372 )

2. Ispirato alla precedente affermazione, ho deciso di dare un'occhiata al codice sorgente di Maven e anche a Maven-Help-Plugin. Sembra che abbiano risolto un po 'l'interruttore -q di Maven (sto usando la versione 3.5.3), quindi ora se lo passi, non otterrai tutte le fastidiose cose di registrazione senza senso che impediscono l'utilizzo di Maven all'interno di script automatici. Quindi dovresti essere in grado di usare qualcosa del genere:

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

   Il problema è che questo comando non stampa nulla perché per impostazione predefinita il plug-in della guida viene emesso attraverso il logger che è stato messo a tacere dall'opzione -q. (l'ultima versione disponibile del plugin è la 3.1.0 rilasciata il 3 giugno 2018)

3. Karl Heinz Marbaise ( https://github.com/khmarbaise ) lo ha corretto aggiungendo un parametro facoltativo che consente di chiamarlo nel modo seguente:

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

   La descrizione del commit è disponibile su: ( 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 '\['

La risposta migliore è piuttosto spazzatura secondo me, devi usare un sacco di grep per hackerare l'output della console di Maven. Perché non usare lo strumento giusto per il lavoro? L'uso della sintassi xpath è l'approccio migliore per recuperare il numero di versione, poiché è il metodo previsto per accedere a una struttura di dati XML. L'espressione sotto sta attraversando il pom usando il "nome locale" degli elementi, in altre parole ignorando le dichiarazioni dello spazio dei nomi che possono o meno essere presenti nell'xml.

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

Ciò eviterà la necessità di disattivare le voci di registro dall'output:

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

Questa è la soluzione più pulita che ho trovato:

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

vantaggi:

• Funziona bene su tutti i sistemi operativi e su tutte le shell.
• Non sono necessari strumenti esterni!
• [importante] Funziona anche se la versione del progetto è ereditata dal genitore pom.xml

Nota:

• maven-help-pluginversione 3.2.0(e successive) ha forceStdoutun'opzione. È possibile sostituire il 3.2.0comando precedente con una versione più recente dall'elenco delle versioni disponibili di mvn-help-plugin da artefactory , se disponibile.
• L'opzione -qsopprime i messaggi dettagliati ( [INFO], [WARN]ecc.)

Se si vuole andare a prendere groupIde artifactIdcosì, controllare questa risposta .

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

Finché hai Python 2.5 o superiore, questo dovrebbe funzionare. Se si dispone di una versione precedente, installare python-lxmle modificare l'importazione in lxml.etree. Questo metodo è rapido e non richiede il download di alcun plug-in aggiuntivo. Funziona anche su file pom.xml non validi che non convalidano con xmllint, come quelli che devo analizzare. Testato su Mac e Linux.

Ho continuato a imbattermi in casi secondari quando ho usato alcune delle altre risposte qui, quindi ecco l'ennesima alternativa.

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

Se non ti dispiace scrivere la versione in un file temporaneo, c'è un'altra soluzione (senza grep / sed) che funziona bene per me. ( EDIT : vedi la risposta di rjrjr per una soluzione molto più semplice senza alcun problema temporaneo con i file)

Uso il plug-in Exav Maven insieme al file echobinario. A differenza del plug-in di aiuto Maven, il plug-in Exec consente il reindirizzamento dell'output in un file, che può essere utilizzato per bypassare grep / sed e rende persino possibile analizzare cose strane come le stringhe di versione multilinea (con blocco CDATA nel tag versione), almeno in una certa misura.

#!/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"

Solo per la cronaca, è possibile configurare la registrazione Simple SLF4J di Maven direttamente nella riga di comando per produrre solo ciò di cui abbiamo bisogno configurando:

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

come documentato su 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

Di conseguenza, si può eseguire semplicemente tail -1e ottenere:

$ 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

Si noti che questa è una linea. MAVEN_OPTSvengono riscritti solo per questa particolare mvnesecuzione.

Ho notato alcune Downloaded:linee spurie in arrivo che stavano interrompendo il mio incarico originale. Ecco il filtro su cui ho optato; spero che sia d'aiuto!

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

MODIFICARE

Non sono sicuro del perché al 100%, ma quando si esegue questo tramite uno script post-build in Jenkins, l'output stava uscendo come [INFO]version, ad es [INFO]0.3.2.

Ho scaricato l'output in un file e l'ho eseguito attraverso il mio primo filtro direttamente da BASH, funziona bene .., quindi, ancora una volta, non sono sicuro di cosa stia succedendo nella terra di Jenkins.

Per ottenerlo al 100% in Jenkins, ho aggiunto un sedfiltro di follow-up ; ecco la mia ultima

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

MODIFICARE

Un'ultima nota qui ... Ho scoperto che trstava ancora producendo cose come /r/n0.3.2(di nuovo solo quando correvo via Jenkins). Passato a awke il problema è scomparso! Il mio risultato di lavoro finale

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

Una soluzione unica maven semplice

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

E per i punti bonus analizzati parte di una versione

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

Di recente ho sviluppato il plugin Release Candidate Maven che risolve questo esatto problema in modo da non dover ricorrere a script di shell hacky e analizzare l'output di maven-help-plugin.

Ad esempio, per stampare la versione del progetto Maven su un terminale, eseguire:

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

che fornisce un output simile a maven-help-plugin:

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

Tuttavia, è anche possibile specificare un formato di output arbitrario (in modo che la versione possa essere prelevata dal registro da un server CI come TeamCity ):

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

Che si traduce in:

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

Per salvare l'output in un file (in modo che un server CI come Jenkins possa usarlo ):

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

Il version.propertiesfile risultante apparirà come segue:

PROJECT_VERSION=1.0.0-SNAPSHOT

Oltre a tutto quanto sopra, Release Candidate consente anche di impostare la versione del tuo progetto (che è qualcosa che probabilmente faresti sul tuo server CI) in base alla versione dell'API che hai definito nel tuo POM.

Se desideri vedere un esempio di Release Candidate utilizzato come parte del ciclo di vita di Maven, dai un'occhiata al pom.xmlmio altro progetto open source: Build Monitor for Jenkins .

C'è anche un'opzione senza bisogno di Maven:

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

La soluzione all-in-one di facile comprensione che genera la versione del progetto maven e elimina l'output [INFO]e i Downloadmessaggi estranei :

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

Stessa cosa, ma divisa in due righe:

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

Uscite: 4.3-SNAPSHOT

Quindi, usando il tuo project.versionin un semplice script bash:

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

Altre soluzioni in questa pagina non sembrano combinare tutti i trucchi in uno.

Dovrebbe essere più semplice poiché questo errore è stato corretto in maven-help-plugin 3.0.0: MPH-99 Evaluate non ha output in modalità silenziosa .

Questa è di gran lunga la soluzione più semplice per tagliare e incollare bash:

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

echeggia

1.4

Ho trovato il giusto equilibrio per me. Dopo mvn packagemaven-archiver il plugin crea target/maven-archiver/pom.propertiescon contenuti come questo

version=0.0.1-SNAPSHOT
groupId=somegroup
artifactId=someArtifact

e sto usando bash solo per eseguirlo

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

poi

echo $version
0.0.1-SNAPSHOT

Naturalmente questo non è affatto sicuro per eseguire questo file, ma l'esecuzione può essere facilmente convertita in script perl o bash per leggere e impostare la variabile di ambiente da quel file.

Questo ha funzionato per me, offline e senza dipendere da mvn:

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

Il plug-in Exec funziona senza analisi dell'output poiché l'output può essere reindirizzato nel file e reimmesso nell'ambiente di lavoro tramite il plug-in EnvInject:

Sulla base della domanda, utilizzo questo script qui sotto per aumentare automaticamente il mio numero di versione in tutti i genitori / sottomoduli 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

O ti hai mvndato la risposta (come la maggior parte delle risposte suggerisce) oppure estrai la risposta da pom.xml. L'unico inconveniente del secondo approccio è che puoi estrarre molto facilmente il valore del <version/>tag, ma sarà significativo solo se è letterale , cioè non una proprietà Maven. Ho scelto questo approccio comunque perché:

• mvn è un modo dettagliato e semplicemente non mi piace filtrarne l'output.
• L'avvio mvnè molto lento rispetto alla lettura del pom.xml.
• Uso sempre valori letterali in <version/>.

mvn-versionè uno zshscript di shell che utilizza xmlstarletper leggere pom.xmle stampare la versione del progetto (se esiste) o la versione del progetto principale (se esiste):

$ mvn-version .
1.0.0-SNAPSHOT

Il vantaggio è che è molto più veloce della corsa 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

La differenza sulla mia macchina è maggiore di due ordini di grandezza.

Ho bisogno esattamente di questo requisito durante il mio lavoro Travis ma con più valori. Comincio con questa soluzione ma quando chiamo più volte questo è molto lento (ho bisogno di 5 espressioni).

Ho scritto un semplice plugin maven per estrarre i valori di pom.xml nel file .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

Produrrà che:

#!/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';

ora puoi semplicemente trovare il file

source .target/ci-tools-env.sh

Divertiti.

Sto usando un one-liner nella mia shell unix ...

gatto pom.xml | grep "" | head -n 1 | sed -e "s / version // g" | sed -e "s / \ s * [<> /] * // g"

Puoi nascondere questa riga in uno script di shell o come alias.

questa è una modifica dall'alto

gatto pom.xml | grep "" | head -n 1 | sed -e "s / version // g" | sed -e "s / \ s * [<> /] * // g"

L'ho provato su sulla cmdline funziona bene

grep "" pom.xml | head -n 1 | sed -e "s / version // g" | sed -e "s / \ s * [<> /] * // g"

è un'altra versione della stessa. Ho bisogno di ottenere il numero di versione in Jenkins CI in k8s senza mvn installato, quindi questo è molto utile

ringrazia tutti.

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'

Sto solo aggiungendo un piccolo sedmiglioramento del filtro che ho implementato di recente per estrarre project.versiondall'output di Maven.

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

Questo è quello che ho usato per ottenere il numero di versione, ho pensato che ci sarebbe stato un modo migliore per farlo