So bringen Sie die Maven-Projektversion in die Bash-Befehlszeile

Zuvor habe ich eine Frage zum Ändern der Maven-Projektversion über die Befehlszeile gestellt, die mich zu einem neuen Problem führte.

Zuvor konnte ich die Versionsnummer abrufen, da die Version als eine Eigenschaft gespeichert wurde, die einfach über die Befehlszeile (Bash) zu erfassen und zu analysieren war. Nachdem das Element pom.xml dafür verwendet wird, ist es nicht mehr eindeutig, da alle Abhängigkeiten und möglicherweise auch einige andere dies verwenden. Ich denke, es gibt keine Möglichkeit, die aktuelle Versionsnummer mit einem Bash-Skript ohne externe Tools zum Parsen von XML oder einen sehr kontextsensitiven sed-Befehl abzurufen.

Die sauberste Lösung meiner Meinung nach wäre, dass Maven diese Versionsinformationen verteilt. Ich dachte daran, ein benutzerdefiniertes Maven-Plugin zum Abrufen verschiedener Eigenschaften zu schreiben, dachte aber, ich würde hier zuerst nachfragen.

Gibt es eine einfache Möglichkeit, den Wert von ${project.version}auf die Befehlszeile zu übertragen? Danke im Voraus.

Lösung

Danke für die Hilfe. Ich musste cdmanuell in das Verzeichnis, aber das kann leicht gemacht werden. In meinem Bash-Skript habe ich

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

Das gibt mir die aktuelle Version, die ich dann weiterentwickeln kann. Grepping mag einfacher sein, aber ich dachte, ich möchte so robust wie möglich sein, also bin ich mit der ersten Zeile, die mit einer Nummer beginnt, zufrieden und versuche, diese als Versionsnummer zu behandeln.

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

Und ich benutze dies, indem ich einfach anrufe

new_version=$(advance_version $version)

Hoffe das hilft jemandem.

Das Maven Help Plugin schlägt irgendwie schon etwas dafür vor:

• help:evaluate wertet die vom Benutzer angegebenen Maven-Ausdrücke in einem interaktiven Modus aus.

So würden Sie es in der Befehlszeile aufrufen, um Folgendes zu erhalten ${project.version}:

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

Toms Lösung mit dem Exec Maven Plugin ist viel besser, aber immer noch komplizierter als es sein muss. Für mich ist es so einfach wie:

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

Ich habe einige Nachforschungen angestellt und Folgendes festgestellt:

1. Maven wurde beschuldigt, weil die Integration in DevOps-Tools nicht einfach ist, da einige bewährte Methoden für CLI-Tools nicht befolgt werden. (Ref: https://youtu.be/1ILEw6Qca3U?t=372 )

2. Inspiriert von der vorherigen Behauptung, habe ich mich entschlossen, einen Blick auf den Quellcode von maven sowie auf das Maven-Help-Plugin zu werfen. Es scheint, dass sie den -q-Schalter des Maven ein wenig repariert haben (ich verwende Version 3.5.3). Wenn Sie ihn also bestehen, erhalten Sie nicht alle nervigen, unsinnigen Protokollierungsmaterialien, die die Verwendung des Maven verhindern innerhalb automatisierter Skripte. Sie sollten also in der Lage sein, Folgendes zu verwenden:

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

   Das Problem ist, dass dieser Befehl nichts druckt, da das Hilfe-Plugin standardmäßig über den Logger ausgegeben wird, der durch den Schalter -q stummgeschaltet wurde. (Die neueste verfügbare Version des Plugins ist 3.1.0 und wurde am 3. Juni 2018 veröffentlicht.)

3. Karl Heinz Marbaise ( https://github.com/khmarbaise ) hat das Problem behoben, indem er einen optionalen Parameter hinzugefügt hat, mit dem Sie es folgendermaßen aufrufen können:

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

   Die Commit-Beschreibung finden Sie unter: ( 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 '\['

Die beste Antwort ist meiner Meinung nach ziemlich Müll. Sie müssen ein paar grep verwenden, um die Ausgabe der Maven-Konsole zu hacken. Warum nicht das richtige Werkzeug für den Job verwenden? Die Verwendung der xpath-Syntax ist der beste Ansatz zum Abrufen der Versionsnummer, da dies die beabsichtigte Methode für den Zugriff auf eine XML-Datenstruktur ist. Der folgende Ausdruck durchläuft den POM unter Verwendung des "lokalen Namens" der Elemente, dh er ignoriert Namespace-Deklarationen, die in der XML vorhanden sein können oder nicht.

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

Dadurch wird vermieden, dass Protokolleinträge aus der Ausgabe entfernt werden müssen:

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

Dies ist die sauberste Lösung, die ich gefunden habe:

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

Vorteile:

• Dies funktioniert gut auf allen Betriebssystemen und allen Shells.
• Keine externen Werkzeuge erforderlich!

Hinweis:

• maven-help-pluginVersion 3.2.0(und höher) hat forceStdoutOption. Sie können den 3.2.0obigen Befehl durch eine neuere Version aus der Liste der verfügbaren Versionen des mvn-help-Plugins von artifactory ersetzen , falls verfügbar.
• Option -qunterdrückt ausführliche Meldungen ( [INFO], [WARN]etc.)

Wenn Sie holen wollen groupIdund artifactIdauch, überprüfen Sie diese Antwort .

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

Solange Sie Python 2.5 oder höher haben, sollte dies funktionieren. Wenn Sie eine niedrigere Version haben, installieren Sie python-lxmlden Import und ändern Sie ihn in lxml.etree. Diese Methode ist schnell und erfordert kein Herunterladen zusätzlicher Plugins. Es funktioniert auch mit fehlerhaften pom.xml-Dateien, die nicht mit xmllint validiert werden, wie die, die ich analysieren muss. Getestet auf Mac und Linux.

Ich bin immer wieder auf Nebenfälle gestoßen, als ich einige der anderen Antworten hier verwendet habe, also hier noch eine andere Alternative.

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

Wenn es Ihnen nichts ausmacht, die Version in eine temporäre Datei zu schreiben, gibt es eine andere Lösung (ohne grep / sed), die für mich gut funktioniert. ( EDIT : siehe rjrjr Antwort für eine viel einfachere Lösung ohne temporäre Datei Aufwand)

Ich benutze das Exec Maven Plugin zusammen mit der echoBinärdatei. Im Gegensatz zum Maven Help Plugin ermöglicht das Exec Plugin die Umleitung der Ausgabe in eine Datei, mit der grep / sed umgangen werden kann, und ermöglicht es sogar, seltsame Dinge wie mehrzeilige Versionszeichenfolgen (mit CDATA-Block im Versions-Tag) zu analysieren. zumindest bis zu einem gewissen Grad.

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

Nur zur Veranschaulichung: Es ist möglich, die einfache SLF4J-Protokollierung von Maven direkt in der Befehlszeile zu konfigurieren, um nur das auszugeben, was wir benötigen, indem Sie Folgendes konfigurieren:

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

wie unter http://www.slf4j.org/api/org/slf4j/impl/SimpleLogger.html dokumentiert

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

Als Ergebnis kann man einfach laufen tail -1und erhalten:

$ 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

Beachten Sie, dass dies ein Einzeiler ist. MAVEN_OPTSwerden nur für diese bestimmte mvnAusführung umgeschrieben .

Ich bemerkte einige falsche Downloaded:Zeilen in der Ausgabe, die meine ursprüngliche Aufgabe brachen. Hier ist der Filter, auf den ich mich festgelegt habe. ich hoffe es hilft!

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

BEARBEITEN

Nicht 100% sicher warum, aber wenn dies durch ein Post-Build-Skript in Jenkins ausgeführt wird, wird die Ausgabe wie [INFO]versionz[INFO]0.3.2 .

Ich habe die Ausgabe in eine Datei geschrieben und sie direkt von BASH aus durch meinen ersten Filter ausgeführt. Es funktioniert einwandfrei. Also wieder unsicher, was in Jenkins Land los ist.

Um es in Jenkins zu 100% zu erreichen, habe ich einen Nachfolgefilter hinzugefügt sed. Hier ist meine neueste

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

BEARBEITEN

Ein letzter Hinweis hier. Ich fand heraus, dass dies trimmer noch zu Dingen wie /r/n0.3.2(wieder nur beim Laufen über Jenkins) führte. Umgeschaltet auf awkund das Problem ist weg! Mein letztes Arbeitser

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

Eine einfache Lösung nur für Maven

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

Und für Bonuspunkte wurde ein Teil einer Version analysiert

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

Ich habe kürzlich das Release Candidate Maven-Plugin entwickelt, das genau dieses Problem löst, sodass Sie nicht auf hackige Shell-Skripte zurückgreifen und die Ausgabe von analysieren müssen maven-help-plugin.

Führen Sie beispielsweise Folgendes aus, um die Version Ihres Maven-Projekts auf einem Terminal zu drucken:

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

das gibt Ausgabe ähnlich wie maven-help-plugin:

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

Sie können jedoch auch ein beliebiges Ausgabeformat angeben (damit die Version von einem CI-Server wie TeamCity aus dem Protokoll abgerufen werden kann ):

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

Was in ... endet:

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

So speichern Sie die Ausgabe in einer Datei (damit ein CI-Server wie Jenkins sie verwenden kann ):

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

Die resultierende version.propertiesDatei sieht folgendermaßen aus:

PROJECT_VERSION=1.0.0-SNAPSHOT

Darüber hinaus können Sie mit Release Candidate die Version Ihres Projekts (was Sie wahrscheinlich auf Ihrem CI-Server tun würden) basierend auf der API-Version festlegen, die Sie in Ihrem POM definiert haben.

Wenn Sie ein Beispiel für die Verwendung von Release Candidate als Teil des Maven-Lebenszyklus sehen möchten, schauen Sie sich pom.xmlmein anderes Open-Source-Projekt an - Build Monitor for Jenkins .

Es gibt auch eine Option ohne Notwendigkeit Maven:

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

Die leicht verständliche All-in-One-Lösung, die die Maven-Projektversion ausgibt und überflüssige Ausgaben von [INFO]und DownloadNachrichten unterdrückt :

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

Das Gleiche, aber in zwei Zeilen aufgeteilt:

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

Ausgänge: 4.3-SNAPSHOT

Verwenden Sie Ihr project.versionin einem einfachen Bash-Skript:

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

Andere Lösungen auf dieser Seite schienen nicht alle Tricks in einem zu kombinieren.

Sollte einfacher sein, da dieser Fehler im Maven-Help-Plugin 3.0.0 behoben ist: MPH-99 Evaluate hat im leisen Modus keine Ausgabe .

Dies ist bei weitem die einfachste Lösung zum Ausschneiden und Einfügen von Bash:

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

es hallt wider

1.4

Ich habe das richtige Gleichgewicht für mich gefunden. Nach dem mvn packageMaven-Archiver erstellt das Plugin target/maven-archiver/pom.propertiesmit Inhalten wie diesen

version=0.0.1-SNAPSHOT
groupId=somegroup
artifactId=someArtifact

und ich benutze bash nur um es auszuführen

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

dann

echo $version
0.0.1-SNAPSHOT

Natürlich ist die Ausführung dieser Datei überhaupt nicht sicher, aber die Ausführung kann leicht in ein Perl- oder Bash-Skript konvertiert werden, um Umgebungsvariablen aus dieser Datei zu lesen und festzulegen.

Dies funktionierte für mich offline und ohne abhängig von mvn:

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

Das Exec-Plugin funktioniert ohne Analyse der Ausgabe, da die Ausgabe in eine Datei umgeleitet und über das EnvInject-Plugin wieder in die Jobumgebung eingefügt werden kann:

Basierend auf der Frage verwende ich dieses Skript unten, um meine Versionsnummer in allen übergeordneten / Submodulen von Maven automatisch zu erhöhen:

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

Entweder haben mvnSie die Antwort gegeben (wie die meisten Antworten vermuten lassen), oder Sie extrahieren die Antwort aus der pom.xml. Der einzige Nachteil des zweiten Ansatzes besteht darin, dass Sie den Wert des <version/>Tags sehr einfach extrahieren können. Dies ist jedoch nur dann sinnvoll, wenn es sich um ein Literal handelt, dh nicht um eine Maven-Eigenschaft. Ich habe diesen Ansatz trotzdem gewählt, weil:

• mvn ist viel zu ausführlich und ich mag es einfach nicht, seine Ausgabe zu filtern.
• Das Starten mvnist sehr langsam im Vergleich zum Lesen der pom.xml.
• Ich verwende immer wörtliche Werte in <version/>.

mvn-versionist ein zshShell-Skript, mit xmlstarletdem pom.xmldie Version des Projekts (falls vorhanden) oder die Version des übergeordneten Projekts (falls vorhanden) gelesen und gedruckt wird:

$ mvn-version .
1.0.0-SNAPSHOT

Der Vorteil ist, dass es viel schneller ist als das Laufen 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

Der Unterschied auf meiner Maschine ist größer als zwei Größenordnungen.

Ich brauche genau diese Anforderung während meines Travis-Jobs, aber mit mehreren Werten. Ich beginne mit dieser Lösung aber wenn ich mehrmals anrufe, ist dies sehr langsam (ich benötige 5 Ausdrücke).

Ich habe ein einfaches Maven-Plugin geschrieben, um die Werte von pom.xml in die .sh-Datei zu extrahieren.

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

Wird das produzieren:

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

Jetzt können Sie die Datei einfach als Quelle verwenden

source .target/ci-tools-env.sh

Habe Spaß.

Ich benutze einen Einzeiler in meiner Unix-Shell ...

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

Sie können diese Zeile in einem Shell-Skript oder als Alias ​​ausblenden.

Dies ist eine Bearbeitung von oben

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

Ich habe es auf der cmdline getestet und funktioniert gut

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

ist eine andere Version davon. Ich muss die Versionsnummer in Jenkins CI in k8s ohne mvn installieren, daher ist dies am hilfreichsten

Danke an alle.

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'

Ich füge nur eine kleine sedFilterverbesserung hinzu, die ich kürzlich implementiert habe, um project.versionaus der Maven-Ausgabe zu extrahieren .

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

Dies ist, was ich verwendet habe, um die Versionsnummer zu erhalten, dachte, es hätte einen besseren Maven-Weg gegeben, dies zu tun