Comment obtenir la version du projet Maven sur la ligne de commande bash

Auparavant, j'ai publié une question sur la façon de changer la version du projet Maven de la ligne de commande, ce qui m'a amené à un nouveau problème.

Auparavant, je pouvais obtenir le numéro de version car la version était stockée en tant que propriété facile à grep et à analyser à partir de la ligne de commande (bash). Maintenant que l'élément pom.xml est utilisé pour cela, il n'est plus unique car toutes les dépendances et peut-être d'autres aussi l'utilisent. Je pense qu'il n'y a aucun moyen d'obtenir le numéro de version actuel avec un script bash sans outils externes pour analyser xml ou une commande sed très sensible au contexte.

La solution la plus propre à mon avis serait que Maven distribue ces informations de version. Je pensais à écrire un plugin maven personnalisé pour récupérer différentes propriétés mais j'ai pensé que je demanderais d'abord ici.

Alors, existe-t-il un moyen simple d'obtenir la valeur de ${project.version}sur la ligne de commande? Merci d'avance.

Solution

Merci pour l'aide. J'ai dû cdmanuellement le répertoire mais cela peut être fait facilement. Dans mon script bash, j'ai

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

Ce qui me donne la version actuelle que je peux ensuite avancer. Grepping pourrait être plus simple mais je pensais que je voudrais aussi robuste que possible, donc je suis satisfait de la première ligne qui commence par un nombre et essayez de gérer cela comme un numéro de version.

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

Et je l'utilise en appelant simplement

new_version=$(advance_version $version)

J'espère que cela aide quelqu'un.

Le plugin d'aide Maven propose déjà quelque chose pour cela:

• help:evaluate évalue les expressions Maven données par l'utilisateur en mode interactif.

Voici comment vous pouvez l'invoquer sur la ligne de commande pour obtenir ${project.version}:

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

La solution de Tom avec le plugin Exec Maven est bien meilleure, mais toujours plus compliquée qu'elle ne devrait l'être. Pour moi, c'est aussi simple que:

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

J'ai fait quelques recherches et j'ai trouvé ce qui suit:

1. Maven a été blâmé parce que l'intégration avec les outils DevOps n'est pas facile car il ne respecte pas certaines bonnes pratiques concernant les outils CLI. (réf: https://youtu.be/1ILEw6Qca3U?t=372 )

2. Inspiré de l'assertion précédente, j'ai décidé de jeter un œil au code source de maven ainsi qu'au maven-help-plugin. Il semble qu'ils aient corrigé un peu le commutateur -q du maven (j'utilise la version 3.5.3), donc maintenant si vous le réussissez, vous n'obtiendrez pas tous les trucs de journalisation ennuyeux qui empêchent l'utilisation de maven dans des scripts automatisés. Vous devriez donc pouvoir utiliser quelque chose comme ceci:

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

   Le problème est que cette commande n'imprime rien car par défaut le plugin d'aide sort par le logger qui a été désactivé par le commutateur -q. (la dernière version disponible du plugin est 3.1.0 publiée le 3 juin 2018)

3. Karl Heinz Marbaise ( https://github.com/khmarbaise ) l'a corrigé en ajoutant un paramètre facultatif qui vous permet de l'appeler de la manière suivante:

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

   La description de la validation est disponible sur: ( 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 '\['

À mon avis, la meilleure réponse est assez poubelle, vous devez utiliser un tas de grep pour pirater la sortie de la console Maven. Pourquoi ne pas utiliser le bon outil pour le travail? L'utilisation de la syntaxe xpath est la meilleure approche pour récupérer le numéro de version, car c'est la méthode prévue pour accéder à une structure de données XML. L'expression ci-dessous traverse le pom en utilisant le "nom local" des éléments, en d'autres termes en ignorant les déclarations d'espace de noms qui peuvent ou non être présentes dans le xml.

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

Cela évitera d'avoir à récupérer les entrées de journal de la sortie:

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

Voici la solution la plus propre que j'ai trouvée:

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

Avantages:

• Cela fonctionne bien sur tous les systèmes d'exploitation et tous shells.
• Pas besoin d'outils externes!
• [important] Cela fonctionne même si la version du projet est héritée du parent pom.xml

Remarque:

• maven-help-pluginla version 3.2.0(et supérieure) a une forceStdoutoption. Vous pouvez remplacer la 3.2.0commande ci-dessus par une version plus récente de la liste des versions disponibles de mvn-help-plugin de artifactory, si disponible.
• L'option -qsupprime les messages verbeux ( [INFO], [WARN]etc.)

Si vous voulez chercher groupIdet artifactIdainsi, vérifier cette réponse .

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

Tant que vous avez python 2.5 ou supérieur, cela devrait fonctionner. Si vous disposez d'une version inférieure à celle-ci, installez python-lxmlet modifiez l'importation en lxml.etree. Cette méthode est rapide et ne nécessite aucun téléchargement de plugins supplémentaires. Il fonctionne également sur les fichiers pom.xml malformés qui ne sont pas validés avec xmllint, comme ceux que j'ai besoin d'analyser. Testé sur Mac et Linux.

J'ai continué à rencontrer des cas secondaires lorsque j'utilisais certaines des autres réponses ici, alors voici encore une autre alternative.

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

Si cela ne vous dérange pas d'écrire la version dans un fichier temporaire, il existe une autre solution (sans grep / sed) qui fonctionne bien pour moi. ( EDIT : voir la réponse de rjrjr pour une solution beaucoup plus simple sans aucun problème de fichier temporaire)

J'utilise le plugin Exec Maven avec le echobinaire. Contrairement au plug-in d'aide Maven, le plug-in Exec permet la redirection de sortie vers un fichier, qui peut être utilisé pour contourner grep / sed, et permet même d'analyser des choses étranges comme les chaînes de version multiligne (avec le bloc CDATA dans la balise de version), au moins dans une certaine mesure.

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

Pour mémoire, il est possible de configurer la journalisation Simple SLF4J de Maven directement dans la ligne de commande pour afficher uniquement ce dont nous avons besoin en configurant:

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

tel que documenté à 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

En conséquence, on peut exécuter simplement tail -1et obtenir:

$ 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

Notez qu'il s'agit d'une doublure. MAVEN_OPTSsont en cours de réécriture uniquement pour cette mvnexécution particulière .

J'ai remarqué des Downloaded:lignes parasites entrant dans la sortie qui rompaient mon affectation d'origine. Voici le filtre sur lequel je me suis installé; J'espère que ça aide!

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

ÉDITER

Je ne sais pas à 100% pourquoi, mais lors de l'exécution de cela via un script post-build dans Jenkins, la sortie sortait par [INFO]versionexemple[INFO]0.3.2 .

J'ai vidé la sortie dans un fichier et l'ai exécuté via mon premier filtre directement à partir de BASH, cela fonctionne bien .., encore une fois, je ne sais pas ce qui se passe dans le pays Jenkins.

Pour l'obtenir à 100% dans Jenkins, j'ai ajouté un sedfiltre de suivi ; voici mon dernier

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

ÉDITER

Une dernière remarque ici .. J'ai découvert trétait encore entraînant des choses comme /r/n0.3.2(encore une fois que lors de l' exécution par Jenkins). Passé à awket le problème a disparu! Mon résultat de travail final

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

Une solution simple Maven

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

Et pour les points bonus, une partie analysée d'une version

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

J'ai récemment développé le plugin Release Candidate Maven qui résout ce problème exact afin que vous n'ayez pas à recourir à des scripts shell hacky et à analyser la sortie du maven-help-plugin.

Par exemple, pour imprimer la version de votre projet Maven sur un terminal, exécutez:

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

ce qui donne une sortie similaire à maven-help-plugin:

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

Cependant, vous pouvez également spécifier un format de sortie arbitraire (afin que la version puisse être récupérée dans le journal par un serveur CI tel que TeamCity ):

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

Ce qui se traduit par:

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

Pour enregistrer la sortie dans un fichier (afin qu'un serveur CI tel que Jenkins puisse l' utiliser ):

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

Le version.propertiesfichier résultant se présente comme suit:

PROJECT_VERSION=1.0.0-SNAPSHOT

En plus de tout ce qui précède, Release Candidate vous permet également de définir la version de votre projet (ce que vous feriez probablement sur votre serveur CI) en fonction de la version d'API que vous avez définie dans votre POM.

Si vous souhaitez voir un exemple d'utilisation de Release Candidate dans le cadre du cycle de vie Maven, jetez un œil à pom.xmlmon autre projet open-source - Build Monitor for Jenkins .

Il y a aussi une option sans avoir besoin de Maven:

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

La solution tout-en-un facile à comprendre qui génère la version du projet maven et supprime la sortie [INFO]et les Downloadmessages étrangers :

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

Même chose, mais divisé en deux lignes:

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

Les sorties: 4.3-SNAPSHOT

Donc, en utilisant votre project.versiondans un simple 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"

Les autres solutions de cette page ne semblent pas combiner toutes les astuces en une seule.

Cela devrait être plus facile car ce bogue est corrigé dans maven-help-plugin 3.0.0: MPH-99 Evaluate n'a pas de sortie en mode silencieux .

C'est de loin la solution de couper-coller la plus simple:

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

ça fait écho

1.4

J'ai trouvé le bon équilibre pour moi. Après que le mvn packageplugin maven-archiver crée target/maven-archiver/pom.propertiesavec des contenus comme celui-ci

version=0.0.1-SNAPSHOT
groupId=somegroup
artifactId=someArtifact

et j'utilise bash juste pour l'exécuter

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

puis

echo $version
0.0.1-SNAPSHOT

Bien sûr, il n'est pas du tout sûr d'exécuter ce fichier, mais l'exécution peut facilement être convertie en script perl ou bash pour lire et définir la variable d'environnement à partir de ce fichier.

Cela a fonctionné pour moi, hors ligne et sans dépendre de mvn:

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

Le plugin Exec fonctionne sans analyse de sortie car la sortie peut être redirigée dans un fichier et réinjectée dans l'environnement de travail via le plugin EnvInject:

Sur la base de la question, j'utilise ce script ci-dessous pour augmenter automatiquement mon numéro de version dans tous les parents / sous-modules 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

Soit vous avez mvndonné la réponse (comme le suggèrent la plupart des réponses), soit vous extrayez la réponse du pom.xml. Le seul inconvénient de la deuxième approche est que vous pouvez extraire très facilement la valeur de la <version/>balise, mais elle n'aura de sens que si elle est littérale , c'est-à-dire pas une propriété Maven. J'ai quand même choisi cette approche car:

• mvn est un moyen de verbaliser et je n'aime tout simplement pas filtrer sa sortie.
• Le démarrage mvnest très lent par rapport à la lecture dupom.xml .
• J'utilise toujours des valeurs littérales dans <version/>.

mvn-versionest un zshscript shell qui utilise xmlstarletpour lire pom.xmlet imprimer la version du projet (si elle existe) ou la version du projet parent (si elle existe):

$ mvn-version .
1.0.0-SNAPSHOT

L'avantage est que c'est beaucoup plus rapide que de courir 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 différence sur ma machine est supérieure à deux ordres de grandeur.

J'ai besoin exactement de cette exigence pendant mon travail Travis mais avec plusieurs valeurs. Je commence par cette solution mais lors de plusieurs appels, c'est très lent (j'ai besoin de 5 expressions).

J'ai écrit un simple plugin maven pour extraire les valeurs de pom.xml dans un fichier .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

Produira cela:

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

vous pouvez maintenant simplement source le fichier

source .target/ci-tools-env.sh

S'amuser.

J'utilise un one-liner dans ma coque unix ...

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

Vous pouvez masquer cette ligne dans un script shell ou en tant qu'alias.

c'est un montage d'en haut

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

Je l'ai testé sur la cmdline qui fonctionne bien

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

est une autre version du même. J'ai besoin d'obtenir le numéro de version dans Jenkins CI dans k8s sans mvn installé donc c'est très utile

Merci a tous.

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'

J'ajoute juste une petite sedamélioration de filtre que j'ai récemment implémentée pour extraire project.versionde la sortie maven.

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

C'est ce que j'ai utilisé pour obtenir le numéro de version, je pensais qu'il y aurait eu un meilleur moyen maven de le faire