Cómo obtener una lista de complementos Jenkins instalados con nombre y par de versiones

¿Cómo puedo obtener una lista de complementos instalados de Jenkins?

Busqué el documento de la API de acceso remoto de Jenkins, pero no lo encontré. ¿Debo usar la CLI de Jenkins? ¿Hay un documento o ejemplo?

Puede recuperar la información utilizando la consola de script Jenkins, a la que puede acceder visitando http://<jenkins-url>/script. (Dado que ha iniciado sesión y tiene los permisos necesarios).

Ingrese el siguiente script Groovy para iterar sobre los complementos instalados e imprima la información relevante:

Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}")
}

Imprimirá la lista de resultados de esta manera (recortada):

Esta solución es similar a una de las respuestas anteriores en que usa Groovy, pero aquí estamos usando la consola de script. La consola de script es extremadamente útil cuando se usa Jenkins.

Actualizar

Si prefiere una lista ordenada, puede llamar a este sortmétodo :

def pluginList = new ArrayList(Jenkins.instance.pluginManager.plugins)
pluginList.sort { it.getShortName() }.each{
  plugin -> 
    println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}")
}

Ajuste el cierre a su gusto (por ejemplo, aquí está ordenado por shortName, en el ejemplo está ordenado por DisplayName)

En estos días uso el mismo enfoque que la respuesta descrita por @Behe a continuación en lugar de https://stackoverflow.com/a/35292719/1597808

Puede usar la API en combinación con profundidad, XPath y argumentos de contenedor.

Lo siguiente consultará la API del pluginManager para enumerar todos los complementos instalados, pero solo para devolver sus atributos shortName y version. Por supuesto, puede recuperar campos adicionales agregando '|' hasta el final del parámetro XPath y especificando el patrón para identificar el nodo.

wget http://<jenkins>/pluginManager/api/xml?depth=1&xpath=/*/*/shortName|/*/*/version&wrapper=plugins

El argumento de envoltura es obligatorio en este caso, ya que está devolviendo más de un nodo como parte del resultado, ya que coincide con múltiples campos con XPath y múltiples nodos de complementos.

Probablemente sea útil usar la siguiente URL en un navegador para ver qué información en los complementos está disponible y luego decidir qué desea limitar usando XPath:

http://<jenkins>/pluginManager/api/xml?depth=1

Jenkins 1,588 (2 ^nd de noviembre de 2014) y 1.647 (4 ^º de febrero de 2016)

• Jenkins> Administrar Jenkins

  

• Información del sistema

  

• Complementos

  

La CLI de Jenkins admite la lista de todos los complementos instalados:

java -jar jenkins-cli.jar -s http://localhost:8080/ list-plugins

Utilice Jenkins CLI como este:

java -jar jenkins-cli.jar -s http://[jenkins_server] groovy = < pluginEnumerator.groovy

=en la llamada significa 'leer desde la entrada estándar' . pluginEnumerator.groovy contiene el siguiente código Groovy:

println "Running plugin enumerator"
println ""
def plugins = jenkins.model.Jenkins.instance.getPluginManager().getPlugins()
plugins.each {println "${it.getShortName()} - ${it.getVersion()}"}
println ""
println "Total number of plugins: ${plugins.size()}"

Si desea jugar con el código, aquí está la documentación de Jenkins Java API .

Si está trabajando en un entorno docker y desea generar la lista de complementos en un formato plugins.txt para pasar eso a install_scripts.sh, use estos scripts en la http://{jenkins}/scriptconsola:

1. Esta versión es útil para obtener una versión específica del paquete

Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:${plugin.getVersion()}")
}

2. Si solo desea el complemento con la última versión, puede usarlo (gracias @KymikoLoco por el consejo)

Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:latest")
}

Las respuestas aquí fueron algo incompletas. Y tuve que recopilar información de otras fuentes para adquirir realmente la lista de complementos.

1. Obtenga la CLI de Jenkins

La CLI de Jenkins nos permitirá interactuar con nuestro servidor Jenkins desde la línea de comandos. Podemos obtenerlo con una simple llamada curl.

curl 'localhost:8080/jnlpJars/jenkins-cli.jar' > jenkins-cli.jar

2. Cree un script Groovy para analizar (gracias a malenkiy_scot)

Guarde lo siguiente como plugins.groovy.

def plugins = jenkins.model.Jenkins.instance.getPluginManager().getPlugins()
plugins.each {println "${it.getShortName()}: ${it.getVersion()}"}

3. Llame a la API de Jenkins para obtener resultados de complementos

Llame al servidor Jenkins ( localhost:8080aquí) con su nombre de usuario y contraseña de inicio de sesión mientras hace referencia al script Groovy:

java -jar jenkins-cli.jar -s http://localhost:8080 groovy --username "admin" --password "admin" = < plugins.groovy > plugins.txt

La salida a plugins.txt se ve así:

ace-editor: 1.1
ant: 1.5
antisamy-markup-formatter: 1.5
authentication-tokens: 1.3
blueocean-autofavorite: 1.0.0
blueocean-commons: 1.1.4
blueocean-config: 1.1.4
blueocean-dashboard: 1.1.4
blueocean-display-url: 2.0
blueocean-events: 1.1.4
blueocean-git-pipeline: 1.1.4
blueocean-github-pipeline: 1.1.4
blueocean-i18n: 1.1.4
blueocean-jwt: 1.1.4
blueocean-personalization: 1.1.4
blueocean-pipeline-api-impl: 1.1.4
blueocean-pipeline-editor: 0.2.0
blueocean-pipeline-scm-api: 1.1.4
blueocean-rest-impl: 1.1.4

La respuesta de Behe con los complementos de clasificación no funcionó en mi máquina Jenkins. Recibí el error java.lang.UnsupportedOperationExceptiondebido a intentar ordenar una colección inmutable, es decir Jenkins.instance.pluginManager.plugins. Solución simple para el código:

List<String> jenkinsPlugins = new ArrayList<String>(Jenkins.instance.pluginManager.plugins);
jenkinsPlugins.sort { it.displayName }
              .each { plugin ->
                   println ("${plugin.shortName}:${plugin.version}")
              }

Use la http://<jenkins-url>/scriptURL para ejecutar el código.

Si es administrador de Jenkins, puede usar la página de información del sistema Jenkins:

http://<jenkinsurl>/systemInfo

Con curly jq:

curl -s <jenkins_url>/pluginManager/api/json?depth=1 \
  | jq -r '.plugins[] | "\(.shortName):\(.version)"' \
  | sort

Este comando proporciona la salida en un formato utilizado por un plugins.txtarchivo especial de Jenkins que le permite preinstalar dependencias (por ejemplo, en una imagen acoplable):

ace-editor:1.1
ant:1.8
apache-httpcomponents-client-4-api:4.5.5-3.0

Ejemplo de plugins.txt: https://github.com/hoto/jenkinsfile-examples/blob/master/source/jenkins/usr/share/jenkins/plugins.txt

Desde la página de inicio de Jenkins:

1. Haz clic en Administrar Jenkins .
2. Haz clic en Administrar complementos .
3. Haga clic en la pestaña Instalado .

O

1. Vaya a la URL de Jenkins directamente: {Su URL base de Jenkins} / pluginManager / instalado

Compartir otra opción encontrada aquí con credenciales

JENKINS_HOST=username:[email protected]:port
curl -sSL "http://$JENKINS_HOST/pluginManager/api/xml?depth=1&xpath=/*/*/shortName|/*/*/version&wrapper=plugins" | perl -pe 's/.*?<shortName>([\w-]+).*?<version>([^<]+)()(<\/\w+>)+/\1 \2\n/g'|sed 's/ /:/'

Quería una solución que pudiera ejecutarse en master sin ningún requisito de autenticación y no la vi aquí. Hice un script de bash rápido que extraerá todas las versiones del directorio de complementos.

if [ -f $JENKINS_HOME/plugin_versions.txt ]; then
  rm $JENKINS_HOME/plugin_versions.txt
fi

for dir in $JENKINS_HOME/plugins/*/; do
  dir=${dir%*/}
  dir=${dir##*/}
  version=$(grep Plugin-Version $JENKINS_HOME/plugins/$dir/META-INF/MANIFEST.MF | awk -F': ' '{print $2}')
  echo $dir $version >> $JENKINS_HOME/plugin_versions.txt
done

Otra opción para usuarios de Python:

from jenkinsapi.jenkins import Jenkins

#get the server instance
jenkins_url = 'http://<jenkins-hostname>:<jenkins-port>/jenkins'
server = Jenkins(jenkins_url, username = '<user>', password = '<password>')

#get the installed plugins as list and print the pairs
plugins_dictionary = server.get_plugins().get_plugins_dict()
for key, value in plugins_dictionary.iteritems():
    print "Plugin name: %s, version: %s" %(key, value.version)

Creo que estas no son respuestas suficientemente buenas ... muchas implican un par de pasos extra bajo el capó. Así es como lo hice.

sudo apt-get install jq

... porque la salida JSON debe consumirse después de llamar a la API.

#!/bin/bash
server_addr = 'jenkins'
server_port = '8080'

curl -s -k "http://${server_addr}:${server_port}/pluginManager/api/json?depth=1" \
  | jq '.plugins[]|{shortName, version,longName,url}' -c | sort \
  > plugin-list

echo "dude, here's your list: "
cat plugin-list

También puede interesarle qué actualizaciones están disponibles para los complementos. Para eso, debe fusionar los datos sobre complementos instalados con información sobre actualizaciones disponibles aquí https://updates.jenkins.io/current/update-center.json .

Para analizar el archivo descargado como un JSON, debe leer en línea la segunda línea (que es enorme).

# list of plugins in sorted order
# Copy this into your Jenkins script console
    def plugins = jenkins.model.Jenkins.instance.getPluginManager().getPlugins()

    List<String> list = new ArrayList<String>()

    i = 0
    plugins.each {
      ++i
      //println " ${i}  ${it.getShortName()}: ${it.getVersion()}"
      list.add("${it.getShortName()}: ${it.getVersion()}")
    }

    list.sort{it}
    i = 0
    for (String item : list) {
      i++
      println(" ${i} ${item}")
    }

Hay una tabla que enumera todos los complementos instalados y si están habilitados o no en http: // jenkins / systemInfo

Si Jenkins se ejecuta en un contenedor Jenkins Docker, puede usar esta línea de comando en Bash:

java -jar /var/jenkins_home/war/WEB-INF/jenkins-cli.jar -s http://localhost:8080/ list-plugins --username admin --password `/bin/cat /var/jenkins_home/secrets/initialAdminPassword`

Para Jenkins versión 2.125, funcionó lo siguiente.

NOTA: Reemplace las secciones que dicen USERNAME y APIKEY con un nombre de usuario válido y APIKey para ese usuario correspondiente. La clave API para un usuario está disponible a través de la opción Administrar usuarios → Seleccionar usuario → Clave API .

Es posible que tenga que extender la suspensión si su instalación de Jenkins tarda más en comenzar.

La iniciación yum update -ytambién actualizará la versión si instaló Jenkins usando yum también.

#JENKINS AUTO UPDATE SCRIPT link this script into a cron
##############
!/bin/bash
sudo yum update -y
sleep 120
UPDATE_LIST=$( sudo /usr/bin/java -jar /var/cache/jenkins/war/WEB-INF/jenkins-cli.jar -auth [USERNAME:APIKEY] -s http://localhost:8080/ list-plugins | grep -e ')$' | awk '{ print $1 }' );
if [ ! -z "${UPDATE_LIST}" ]; then
    echo Updating Jenkins Plugins: ${UPDATE_LIST};
    sudo /usr/bin/java -jar /var/cache/jenkins/war/WEB-INF/jenkins-cli.jar -auth [USERNAME:APIKEY] -s http://localhost:8080/ install-plugin ${UPDATE_LIST};
    sudo /usr/bin/java -jar /var/cache/jenkins/war/WEB-INF/jenkins-cli.jar -auth [USERNAME:APIKEY] -s http://localhost:8080/ safe-restart;
fi
##############

Hay muchas maneras de obtener esta información, pero escribo de dos maneras como a continuación:

1. Consigue el cli de jenkins.

La CLI de jenkins nos permitirá interactuar con nuestro servidor jenkins desde la línea de comandos. Podemos obtenerlo con una simple llamada curl.

curl 'localhost:8080/jnlpJars/jenkins-cli.jar' > jenkins-cli.jar

2. Crear un guión maravilloso. O desde la consola de script jenkins

Necesitamos crear un script maravilloso para analizar la información que recibimos de la API de jenkins. Esto generará cada complemento con su versión. Guarde lo siguiente como plugins.groovy.

def plugins = jenkins.model.Jenkins.instance.getPluginManager().getPlugins() plugins.each {println "${it.getShortName()}: ${it.getVersion()}"}