Comment obtenir une liste des plugins Jenkins installés avec une paire de noms et de versions

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

vous pouvez utiliser L'API en combinaison avec les arguments depth, XPath et wrapper.

ce qui suit interrogera l'API du pluginManager pour lister tous les plugins installés, mais seulement pour retourner leurs attributs shortName et version. Vous peut bien sûr récupérer des champs supplémentaires en ajoutant ' | ' à la fin du paramètre XPath et en spécifiant le motif pour identifier le noeud.

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

l'argument wrapper est requis dans ce cas, parce qu'il renvoie plus d'un noeud dans le cadre du résultat, à la fois en ce qu'il associe plusieurs champs avec le XPath et plusieurs noeuds de plugin.

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

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

vous pouvez récupérer l'information en utilisant le Jenkins Script Console qui est accessible en visitant http://<jenkins-url>/script . (Étant donné que vous êtes connecté et que vous disposez des autorisations nécessaires).

entrer le Groovy script pour itérer sur les plugins installés et imprimer les informations pertinentes:

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

il va imprimer la liste des résultats comme ceci (découpée):

Cette solution est similaire à 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 lorsque vous utilisez Jenkins.

mise à Jour

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

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

ajustez la fermeture à vos goûts.

Jenkins 1.588 (2 ^nd de novembre, 2014) & 1.647 (4 ^th de février, 2016)

• Jenkins > Manage Jenkins

  

• Système D'Information

  

• Plugins

  

utilisez Jenkins CLI comme ceci:

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

= dans l'appel signifie "lecture 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 voulez jouer avec le code, Voici la documentation de L'API Java de Jenkins .

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

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

les réponses ici étaient quelque peu incomplètes. Et j'ai dû compiler des informations à partir d'autres sources pour réellement acquérir la liste du plugin.

1. Obtenir le CLI de Jenkins 151990920"

le CLI Jenkins nous permettra d'interagir avec notre serveur Jenkins à partir de la ligne de commande. On peut l'avoir avec un simple appel Bouclé.

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

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

Enregistrer l' suivi de 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:8080 ici) avec votre nom d'utilisateur et votre mot de passe en se référant au script Groovy:

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

la sortie vers les 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

De l'Jenkins page d'accueil:

1. , Cliquez Sur Gérer Jenkins .
2. Cliquez Sur Gérer Les Plugins .
3. cliquez sur l'onglet installé .

ou

1. allez directement à L'URL Jenkins: {Your Jenkins base URL} / pluginManager / installed

réponse de Behe avec des plugins de tri ne fonctionnait pas sur ma machine Jenkins. J'ai reçu l'erreur java.lang.UnsupportedOperationException en raison d'essayer de trier une collection immuable i.e. Jenkins.instance.pluginManager.plugins . Correction 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'URL http://<jenkins-url>/script pour exécuter le code.

si vous êtes un administrateur de Jenkins, vous pouvez utiliser la page D'information du système de Jenkins:

http://<jenkinsurl>/systemInfo

partager une autre option trouvée ici avec justificatifs d'identité

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+>)+/ \n/g'|sed 's/ /:/'

je pense qu'ils ne sont pas assez bonnes réponse(s)... plusieurs comportent quelques marches supplémentaires sous le capot. Voici comment je l'ai fait.

sudo apt-get install jq

...parce que la sortie JSON doit être consommée après que vous ayez appelé 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

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)

il y a un tableau qui liste tous les plugins installés et s'ils sont activés ou non à http://jenkins/systemInfo

si Jenkins fonctionne dans un conteneur Jenkins Docker, vous pouvez utiliser cette ligne de commande à 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`

Jenkins Pour la version 2.125 la suite travaillé.

NOTE: remplacer les sections qui disent nom D'utilisateur et APIKEY par un nom d'Utilisateur et APIKey valides pour l'utilisateur correspondant. La clé API pour un utilisateur est disponible via Gérer les utilisateurs → sélectionner L'utilisateur → touche API option.

vous devrez peut-être prolonger le sommeil si votre installation de Jenkins prend plus de temps à démarrer.

l'initiation yum update -y mettra également à jour la version si vous avez 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  }' );
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 y a beaucoup de façons de récupérer cette information mais j'écris deux façons comme ci-dessous: -

1. Va chercher le CLI de jenkins.

le CLI jenkins nous permettra d'interagir avec notre serveur jenkins à partir de la ligne de commande. On peut l'avoir avec un simple appel Bouclé.

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

2. Créer un script groovy. Ou de la console de script jenkins

nous avons besoin de 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 comme plugins.groovy.

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

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 les informations sur les mises à jour disponibles ici https://updates.jenkins.io/current/update-center.json .

pour analyser le fichier téléchargé comme un JSON, vous devez lire en ligne la deuxième ligne (qui est énorme).