Cómo obtener la versión del proyecto Maven en la línea de comando bash

Anteriormente emití una pregunta sobre cómo cambiar la versión del proyecto Maven desde la línea de comandos que me llevó a un nuevo problema.

Anteriormente pude obtener el número de versión ya que la versión se almacenaba como una propiedad que era fácil de seleccionar y analizar desde la línea de comandos (bash). Ahora que el elemento pom.xml se usa para esto, ya no es único ya que todas las dependencias y tal vez otros también lo usan. Creo que no hay forma de obtener el número de versión actual con un script bash sin herramientas externas para analizar xml o algún comando sed muy sensible al contexto.

La solución más limpia en mi opinión sería que Maven entregue la información de esta versión. Estaba pensando en escribir un complemento Maven personalizado para recuperar diferentes propiedades, pero pensé en preguntar aquí primero.

Entonces, ¿hay alguna manera fácil de obtener el valor de ${project.version}la línea de comando? Gracias por adelantado.

Solución

Gracias por la ayuda. Tuve que cdir al directorio manualmente, pero eso se puede hacer fácilmente. En mi script bash tengo

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

Lo que me da la versión actual que luego puedo avanzar. El grepping podría ser más simple, pero pensé que me gustaría lo más robusto posible, así que estoy satisfecho con la primera línea que comienza con un número y trato de manejarlo como un número de versión.

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

Y uso esto simplemente llamando

new_version=$(advance_version $version)

Espero que esto ayude a alguien.

El complemento de ayuda de Maven de alguna manera ya está proponiendo algo para esto:

• help:evaluate evalúa las expresiones de Maven proporcionadas por el usuario en un modo interactivo.

Así es como lo invocarías en la línea de comando para obtener ${project.version}:

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

La solución de Tom con Exec Maven Plugin es mucho mejor, pero aún más complicada de lo necesario. Para mí es tan simple como:

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

He estado investigando y encontré lo siguiente:

1. Se ha culpado a Maven porque la integración con las herramientas DevOps no es fácil debido al hecho de que no sigue algunas buenas prácticas con respecto a las herramientas CLI. (ref: https://youtu.be/1ILEw6Qca3U?t=372 )

2. Inspirado en la afirmación anterior, decidí echar un vistazo al código fuente de maven, así como a maven-help-plugin. Parece que han solucionado un poco el modificador -q de maven (estoy usando la versión 3.5.3), por lo que ahora si lo pasa, no obtendrá todas las cosas molestas de registro sin sentido que evitan que se use maven dentro de guiones automatizados. Entonces deberías poder usar algo como esto:

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

   El problema es que este comando no imprime nada porque, de forma predeterminada, el complemento de ayuda sale a través del registrador que ha sido silenciado por el modificador -q. (la última versión disponible del complemento es la 3.1.0 lanzada el 3 de junio de 2018)

3. Karl Heinz Marbaise https://github.com/khmarbaise ) lo arregló agregando un parámetro opcional que le permite llamarlo de la siguiente manera:

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

   La descripción de confirmación está disponible en: ( 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 respuesta principal es bastante basura en mi opinión, tienes que usar un montón de grep para hackear la salida de la consola maven. ¿Por qué no usar la herramienta adecuada para el trabajo? El uso de la sintaxis xpath es el mejor enfoque para recuperar el número de versión, ya que es el método previsto para acceder a una estructura de datos XML. La siguiente expresión está atravesando el pom utilizando el "nombre local" de los elementos, en otras palabras, ignorando las declaraciones de espacios de nombres que pueden o no estar presentes en el xml.

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

Esto evitará la necesidad de extraer entradas de registro de la salida:

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

Esta es la solución más limpia que encontré:

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

Ventajas:

• Esto funciona bien en todos los sistemas operativos y todos los shells.
• ¡No se necesitan herramientas externas!
• [importante] Esto funciona incluso si la versión del proyecto se hereda del padre pom.xml

Nota:

• maven-help-pluginLa versión 3.2.0(y superior) tiene forceStdoutopción. Puede reemplazar el 3.2.0comando anterior con una versión más nueva de la lista de versiones disponibles de mvn-help-plugin de artifactory, si está disponible.
• La opción -qsuprime los mensajes detallados ( [INFO], [WARN]etc.)

Si desea buscar groupIdy artifactIdtambién, verifique esta respuesta .

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

Mientras tenga Python 2.5 o superior, esto debería funcionar. Si tiene una versión inferior, instale python-lxmly cambie la importación a lxml.etree. Este método es rápido y no requiere descargar ningún complemento adicional. También funciona en archivos pom.xml mal formados que no se validan con xmllint, como los que necesito analizar. Probado en Mac y Linux.

Seguí encontrando casos secundarios al usar algunas de las otras respuestas aquí, así que aquí hay otra alternativa.

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

Si no le importa escribir la versión en un archivo temporal, hay otra solución (sin grep / sed) que me funciona bien. ( EDITAR : ver la respuesta de rjrjr para obtener una solución mucho más simple sin problemas de archivos temporales)

Yo uso el complemento Exec Maven junto con el echobinario. A diferencia del complemento de ayuda de Maven, el complemento de Exec permite la redirección de salida a un archivo, que se puede utilizar para omitir grep / sed, y hace posible incluso analizar cosas extrañas como cadenas de versión multilínea (con bloque CDATA en la etiqueta de versión), al menos hasta cierto punto.

#!/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 para el registro, es posible configurar el registro Simple SLF4J de Maven directamente en la línea de comando para generar solo lo que necesitamos configurando:

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

como se documenta en 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, uno puede correr simplemente tail -1y obtener:

$ 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

Tenga en cuenta que esta es una línea. MAVEN_OPTSse reescriben solo para esta mvnejecución particular .

Noté algunas Downloaded:líneas espurias entrando en la salida que estaban rompiendo mi asignación original. Aquí está el filtro en el que me he decidido; ¡Espero eso ayude!

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

EDITAR

No estoy 100% seguro de por qué, pero al ejecutar esto a través de un script posterior a la compilación en Jenkins, el resultado salía como [INFO]version, por ejemplo [INFO]0.3.2.

Volqué la salida a un archivo y lo ejecuté a través de mi primer filtro directamente desde BASH, funciona bien ..., así que de nuevo, no estoy seguro de lo que está sucediendo en la tierra de Jenkins.

Para obtener el 100% en Jenkins, he agregado un sedfiltro de seguimiento ; Aquí está mi último

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

Una última nota aquí .. descubrí trfue aún resultando en cosas como /r/n0.3.2(de nuevo sólo cuando se ejecuta a través de Jenkins). ¡Cambié awky el problema desapareció! Mi resultado de trabajo 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=''

Una solución simple solo para expertos

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

Y para puntos de bonificación analizados parte de una versión

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

Recientemente desarrollé el complemento Release Candidate Maven que resuelve este problema exacto para que no tenga que recurrir a ningún script de shell hacky y analizar la salida delmaven-help-plugin .

Por ejemplo, para imprimir la versión de su proyecto Maven en una terminal, ejecute:

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

que da una salida similar a maven-help-plugin:

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

Sin embargo, también puede especificar un formato de salida arbitrario (para que un servidor de CI como TeamCity pueda recoger la versión del registro ):

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

Lo que resulta en:

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

Para guardar la salida en un archivo (para que un servidor CI como Jenkins pueda usarlo ):

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

El version.propertiesarchivo resultante tendrá el siguiente aspecto:

PROJECT_VERSION=1.0.0-SNAPSHOT

Además de todo lo anterior, Release Candidate también le permite configurar la versión de su proyecto (que es algo que probablemente haría en su servidor CI) en función de la versión de API que ha definido en su POM.

Si desea ver un ejemplo de Release Candidate que se usa como parte del ciclo de vida de Maven, eche un vistazo a pom.xmlmi otro proyecto de código abierto: Build Monitor for Jenkins .

También hay una opción sin necesidad de Maven:

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

La solución todo en uno fácil de entender que genera la versión del proyecto maven y suprime los resultados [INFO]y Downloadmensajes extraños :

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

Lo mismo, pero dividido en dos líneas:

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

Salidas: 4.3-SNAPSHOT

Entonces, usando su project.versionen un script bash simple:

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

Otras soluciones en esta página no parecen combinar todos los trucos en uno.

Debería ser más fácil ya que este error se solucionó en maven-help-plugin 3.0.0: MPH-99 Evaluate no tiene salida en modo silencioso .

Esta es, con mucho, la solución más fácil para cortar y pegar bash:

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

hace eco

1.4

Encontré el equilibrio adecuado para mí. Después mvn packagede que el complemento maven-archiver cree target/maven-archiver/pom.propertiescon contenidos como este

version=0.0.1-SNAPSHOT
groupId=somegroup
artifactId=someArtifact

y estoy usando bash solo para ejecutarlo

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

luego

echo $version
0.0.1-SNAPSHOT

Por supuesto, esto no es seguro en absoluto para ejecutar este archivo, pero la ejecución se puede convertir fácilmente en script perl o bash para leer y establecer la variable de entorno desde ese archivo.

Esto funcionó para mí, sin conexión y sin depender de mvn:

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

El complemento Exec funciona sin ningún análisis de salida porque la salida se puede redirigir al archivo e inyectar nuevamente en el entorno de trabajo a través del complemento EnvInject:

Basándome en la pregunta, uso este script a continuación para aumentar automáticamente mi número de versión en todos los submódulos / padres principales de 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 le ha mvndado la respuesta (como sugiere la mayoría de las respuestas), o extrae la respuesta del pom.xml. El único inconveniente del segundo enfoque es que puede extraer fácilmente el valor de la <version/>etiqueta, pero será significativo solo si es literal , es decir, no es una propiedad de Maven. Elegí este enfoque de todos modos porque:

• mvn es una manera detallada y simplemente no me gusta filtrar su salida.
• El inicio mvnes muy lento en comparación con la lectura depom.xml .
• Siempre uso valores literales en <version/>.

mvn-versiones un zshscript de shell que se utiliza xmlstarletpara leer pom.xmle imprimir la versión del proyecto (si existe) o la versión del proyecto principal (si existe):

$ mvn-version .
1.0.0-SNAPSHOT

La ventaja es que es mucho más rápido que correr 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 diferencia en mi máquina es mayor que dos órdenes de magnitud.

Necesito exactamente este requisito durante mi trabajo en Travis pero con múltiples valores. Empiezo con esta solución pero cuando llamo varias veces, esto es muy lento (necesito 5 expresiones).

Escribí un complemento Maven simple para extraer los valores de pom.xml en el archivo .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

Producirá eso:

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

ahora puedes simplemente obtener el archivo

source .target/ci-tools-env.sh

Que te diviertas.

Estoy usando una línea en mi shell de Unix ...

gato pom.xml | grep "" | cabeza -n 1 | sed -e "s / versión // g" | sed -e "s / \ s * [<> /] * // g"

Puede ocultar esta línea en un script de shell o como un alias.

esta es una edición desde arriba

gato pom.xml | grep "" | cabeza -n 1 | sed -e "s / versión // g" | sed -e "s / \ s * [<> /] * // g"

Lo probé en cmdline funciona bien

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

Es otra versión de la misma. Tengo la necesidad de obtener el número de versión en Jenkins CI en k8s sin mvn instalado, así que esto es de gran ayuda

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

Solo estoy agregando una pequeña sedmejora de filtro que he implementado recientemente para extraer project.versionde la salida de Maven.

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

Esto es lo que solía obtener el número de versión, pensé que habría sido una mejor manera de hacerlo