Comment obtenir une liste des plugins Jenkins installés avec le nom et la paire de versions

Comment puis-je obtenir une liste des plugins Jenkins installés?

J'ai recherché le document de l'API Jenkins Remote Access, mais il n'a pas été trouvé. Dois-je utiliser la CLI de Jenkins? Y a-t-il un document ou un exemple?

Vous pouvez récupérer les informations à l'aide de la console de script Jenkins accessible en visitant http://<jenkins-url>/script. (Étant donné que vous êtes connecté et que vous disposez des autorisations requises).

Entrez le script Groovy suivant pour parcourir les plugins installés et imprimer les informations pertinentes:

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

Il imprimera la liste des résultats comme ceci (découpé):

Cette solution est similaire à l' une des réponses ci-dessus en ce qu'elle utilise Groovy, mais ici, nous utilisons la console de script à la place. La console de script est extrêmement utile lors de l'utilisation de Jenkins.

Mettre à jour

Si vous préférez une liste triée, vous pouvez appeler cette sortméthode :

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

Ajustez la fermeture à votre guise (par exemple, ici, elle est triée par le shortName, dans l'exemple, elle est triée par DisplayName)

Ces jours-ci, j'utilise la même approche que la réponse décrite par @Behe ci-dessous à la place https://stackoverflow.com/a/35292719/1597808

Vous pouvez utiliser l'API en combinaison avec des arguments de profondeur, XPath et wrapper.

Ce qui suit interrogera l'API de pluginManager pour répertorier tous les plugins installés, mais uniquement pour renvoyer leurs attributs shortName et version. Vous pouvez bien sûr récupérer des champs supplémentaires en ajoutant '|' à la fin du paramètre XPath et en spécifiant le modèle pour identifier le nœud.

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

L'argument wrapper est requis dans ce cas, car il renvoie plus d'un nœud dans le cadre du résultat, à la fois en ce qu'il fait correspondre plusieurs champs avec XPath et plusieurs nœuds de plug-in.

Il est probablement utile d'utiliser l'URL suivante dans un navigateur pour voir quelles informations sur les plugins sont disponibles, puis décider de ce que vous souhaitez limiter en utilisant XPath:

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

Jenkins 1,588 (2 ^e de Novembre 2014) et 1.647 (4 ^e de Février 2016)

• Jenkins> Gérer Jenkins

  

• Informations système

  

• Plugins

  

La CLI Jenkins prend en charge la liste de tous les plugins installés:

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

Utilisez Jenkins CLI comme ceci:

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

=dans l'appel signifie «lire à partir de l'entrée standard» . pluginEnumerator.groovy contient le code Groovy suivant:

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 vous souhaitez jouer avec le code, voici la documentation de l'API Java Jenkins .

Si vous travaillez dans un environnement docker et que vous souhaitez afficher la liste des plugins au format plugins.txt afin de la transmettre à install_scripts.sh, utilisez ces scripts dans la http://{jenkins}/scriptconsole:

1. Cette version est utile pour obtenir une version de package spécifique

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

2. Si vous ne voulez que le plugin avec la dernière version, vous pouvez l'utiliser (merci @KymikoLoco pour le conseil)

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

Les réponses ici étaient quelque peu incomplètes. Et j'ai dû compiler des informations provenant d'autres sources pour acquérir la liste des plugins.

1. Obtenez la CLI Jenkins

La CLI Jenkins nous permettra d'interagir avec notre serveur Jenkins à partir de la ligne de commande. Nous pouvons l'obtenir avec un simple appel curl.

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

2. Créez un script Groovy pour l'analyse (grâce à malenkiy_scot)

Enregistrez ce qui suit sous plugins.groovy.

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

3. Appelez l'API Jenkins pour les résultats du plugin

Appelez le serveur Jenkins ( localhost:8080ici) avec votre nom d'utilisateur et votre mot de passe de connexion tout en faisant référence au script Groovy:

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

La sortie vers plugins.txt ressemble à ceci:

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 réponse de Behe avec les plugins de tri ne fonctionnait pas sur ma machine Jenkins. J'ai reçu l'erreur java.lang.UnsupportedOperationExceptionen essayant de trier une collection immuable ie Jenkins.instance.pluginManager.plugins. Solution simple pour le code:

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

Utilisez l' http://<jenkins-url>/scriptURL pour exécuter le code.

Si vous êtes un administrateur Jenkins, vous pouvez utiliser la page d'informations système Jenkins:

http://<jenkinsurl>/systemInfo

Avec curlet jq:

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

Cette commande donne la sortie dans un format utilisé par un plugins.txtfichier Jenkins spécial qui vous permet de pré-installer des dépendances (par exemple dans une image docker):

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

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

Depuis la page d'accueil de Jenkins:

1. Cliquez sur Gérer Jenkins .
2. Cliquez sur Gérer les plugins .
3. Cliquez sur l' onglet Installé .

Ou

1. Accédez directement à l'URL Jenkins: {Votre URL de base Jenkins} / pluginManager / installed

Partager une autre option trouvée ici avec les informations d'identification

JENKINS_HOST=username:password@myhost.com: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/ /:/'

Je voulais une solution qui pourrait fonctionner sur master sans aucune exigence d'authentification et je ne l'ai pas vue ici. J'ai créé un script bash rapide qui extraira toutes les versions du répertoire des plugins.

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

Une autre option pour les utilisateurs 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)

Je pense que ce ne sont pas des réponses suffisantes ... beaucoup impliquent quelques étapes supplémentaires sous le capot. Voici comment je l'ai fait.

sudo apt-get install jq

... car la sortie JSON doit être utilisée après l'appel de l'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

Vous pouvez également être intéressé par les mises à jour disponibles pour les plugins. Pour cela, vous devez fusionner les données sur les plugins installés avec des informations sur les mises à jour disponibles ici https://updates.jenkins.io/current/update-center.json .

Pour analyser le fichier téléchargé en tant que JSON, vous devez lire en ligne la deuxième ligne (ce qui est énorme).

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

Il y a un tableau répertoriant tous les plugins installés et s'ils sont activés ou non sur http: // jenkins / systemInfo

Si Jenkins s'exécute dans un conteneur Jenkins Docker, vous pouvez utiliser cette ligne de commande dans 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`

Pour la version 2.125 de Jenkins, ce qui suit a fonctionné.

REMARQUE: remplacez les sections qui indiquent USERNAME et APIKEY par un UserName et une APIKey valides pour cet utilisateur correspondant. La clé API pour un utilisateur est disponible via l' option Gérer les utilisateurs → Sélectionner un utilisateur → Clé API .

Vous devrez peut-être prolonger la mise en veille si votre installation Jenkins prend plus de temps à démarrer.

L'initiation yum update -ymettra également à niveau la version si vous avez également installé Jenkins en utilisant yum.

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

Il existe de nombreuses façons de récupérer ces informations, mais j'écris de deux manières comme ci-dessous: -

1. Obtenez le cli jenkins.

La CLI jenkins nous permettra d'interagir avec notre serveur jenkins à partir de la ligne de commande. Nous pouvons l'obtenir avec un simple appel curl.

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

2. Créez un script groovy. OU depuis la console de script jenkins

Nous devons créer un script groovy pour analyser les informations que nous recevons de l'API jenkins. Cela affichera chaque plugin avec sa version. Enregistrez ce qui suit sous plugins.groovy.

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