Come ottenere un elenco di plugin Jenkins installati con nome e versione coppia


160

Come posso ottenere un elenco di plugin Jenkins installati?

Ho cercato il documento API di accesso remoto Jenkins, ma non è stato trovato. Dovrei usare la CLI di Jenkins? C'è un documento o un esempio?

Risposte:


161

È possibile recuperare le informazioni utilizzando la Console degli script Jenkins, accessibile visitando http://<jenkins-url>/script. (Dato che hai effettuato l'accesso e hai le autorizzazioni necessarie).

Schermata della Console degli script

Immettere il seguente script Groovy per scorrere i plug-in installati e stampare le informazioni pertinenti:

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

Stampa l'elenco dei risultati in questo modo (troncato):

SScreenshot dell'output dello script

Questa soluzione è simile a una delle risposte sopra in quanto utilizza Groovy, ma qui invece stiamo usando la console di script. La console di script è estremamente utile quando si utilizza Jenkins.

Aggiornare

Se preferisci un elenco ordinato, puoi chiamare questo sortmetodo :

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

Regola la chiusura a tuo piacimento (ad es. Qui è ordinata per shortName, nell'esempio è ordinata per DisplayName)


2
Di tutte le risposte, questa è la più utile per presentare una segnalazione di bug del plugin; può essere fatto utilizzando l'interfaccia utente Web standard e fornisce il risultato in un formato che può essere facilmente incollato nel campo "Ambiente".
Aaron D. Marasco,

8
Ottima risposta per creare rapidamente un plugins.txt per la finestra mobile Jenkins!
Erik Englund,

1
Potrebbe essere utile aggiungere l'ordinamento in modo che l'elenco dei plugin sia coerente: Jenkins.instance.pluginManager.plugins.sort({it.getDisplayName()}).each{ plugin -> println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}") }
wheleph

1
Questa è la risposta a cui siamo passati a livello locale invece del mio suggerimento XPath sopra, racchiuso in una richiesta di arricciatura e una potatura di plug-in di origine creati utilizziamo questo approccio per generare plugins.txt per la nostra immagine docker come menzionato sopra @ErikEnglund echo 'script=Jenkins.instance.pluginManager.plugins.each{ plugin -> println ("${plugin.getShortName()}:${plugin.getVersion()}") } null' \ | no_proxy=localhost curl --netrc --silent --data-binary @- -X POST "http://localhost:8080/jenkins/scriptText" | sort > plugins.txt
Dbailey,

8
L'ordinamento non funziona, è una mappa non modificabile in questi giorni. Usa:jenkins.model.Jenkins.instance.getPluginManager().getPlugins().stream().sorted().each { println "${it.getShortName()} | ${it.getVersion()} | ${it.getDisplayName()}" }
Ed Randall il

96

In questi giorni utilizzo lo stesso approccio della risposta descritta da @Behe di seguito invece https://stackoverflow.com/a/35292719/1597808


È possibile utilizzare l'API in combinazione con argomenti depth, XPath e wrapper.

Di seguito verrà eseguita una query sull'API di pluginManager per elencare tutti i plug-in installati, ma solo per restituire gli attributi shortName e version. Ovviamente puoi recuperare campi aggiuntivi aggiungendo '|' alla fine del parametro XPath e specificando il modello per identificare il nodo.

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

L'argomento wrapper è richiesto in questo caso, perché restituisce più di un nodo come parte del risultato, sia in quanto abbina più campi con XPath sia con più nodi plugin.

È probabilmente utile utilizzare il seguente URL in un browser per vedere quali informazioni sono disponibili sui plug-in e quindi decidere quali limiti limitare utilizzando XPath:

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

Salve, sai come ottenere l'elenco dei plug-in che vengono effettivamente utilizzati dai processi Jenkins e dal sistema Jenkins anziché l'elenco completo dei plug-in installati? Grazie
user1164061

3
Ha funzionato bene per me su Mac OS X. Volevo convertire l'output in un semplice elenco di testo, quindi ho usato un po 'di regex Perl per rimuovere i tag:curl 'http://192.168.197.133:8080/pluginManager/api/xml?depth=1&xpath=/*/*/shortName|/*/*/version&wrapper=plugins' | perl -pe 's/.*?<shortName>([\w-]+).*?<version>([^<]+)()(<\/\w+>)+/\1 \2\n/g'
G. Lombard,

8
Alternativa in formato JSON:curl -s -k "http://jenkins/pluginManager/api/json?depth=1" | jq '.plugins[]|{shortName, version,longName}' -c
MarkHu

1
Credo che ciò richieda i privilegi di amministrazione, ma non ne sono sicuro.
mkobit,

2
Confermato che ciò richiede i privilegi di amministratore per l'avviso di sicurezza 2016-05-11 .
mkobit,

29

Jenkins 1.588 (2 ° di novembre 2014) e 1.647 (4 ° di febbraio 2016)

  • Jenkins> Gestisci Jenkins

    inserisci qui la descrizione dell'immagine

  • Informazioni di sistema

    inserisci qui la descrizione dell'immagine

  • plugin

    inserisci qui la descrizione dell'immagine


1
Questo è molto semplice e sono in grado di ottenere l'elenco dai server DEV e PRD, incollarli in Excel e confrontare le loro versioni fianco a fianco.
Jirong Hu,

24

L'interfaccia della riga di comando di Jenkins supporta l'elenco di tutti i plug-in installati:

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


Questo non elencherà lo stato del plugin.
Akhan

1
E il list-pluginscomando CLI non richiede all'utente di avere l' autorizzazione Overall / RunScripts come groovyfa il comando.
José Andias,

Ciò non sembra funzionare con un token API se l'utente / token non è "Generale / Amministratore".
cgseller

21

Utilizzare l'interfaccia della riga di comando di Jenkins in questo modo:

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

=nella chiamata significa "letto dallo standard input" . pluginEnumerator.groovy contiene il seguente codice 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()}"

Se desideri giocare con il codice, ecco la documentazione dell'API Java Jenkins .


@ user1284795, è stato utile?
malenkiy_scot,

1
Ciao, sai come ottenere i plugin usati dal sistema Jenkins e dal lavoro di Jenkins invece di installare tutti i plugin? Vorrei che questo mi aiutasse a disinstallare tutti i plugin non utilizzati. Qualsiasi aiuto è apprezzato. Grazie!
user1164061

Questa dovrebbe essere la risposta accettata. @utente1164061, non penso che ci sia alcuna differenza tra i plug-in visibili a un lavoro rispetto al server. C'è isActive()un'API che puoi usare nello script groovy in questa risposta per ottenere lo stato del plugin. Vedi javadoc.jenkins-ci.org/hudson/PluginWrapper.html#isActive () .
Akhan

20

Se lavori in un ambiente docker e desideri visualizzare l'elenco dei plug-in in un formato plugins.txt per passarlo a install_scripts.sh usa questi script nella http://{jenkins}/scriptconsole:

  1. Questa versione è utile per ottenere una versione del pacchetto specifica
Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:${plugin.getVersion()}")
}
  1. Se vuoi solo il plugin con l'ultima versione puoi usarlo (grazie a @KymikoLoco per il suggerimento)
Jenkins.instance.pluginManager.plugins.each{
  plugin -> 
    println ("${plugin.getShortName()}:latest")
}

1
Se vuoi ottenere le ultime versioni di tutti i plugin, puoi estenderlo per ottenere solo il nome breve e aggiungere :latestalla fine:println ("${plugin.getShortName()}:latest")
KymikoLoco,

17

Le risposte qui erano in qualche modo incomplete. E ho dovuto compilare informazioni da altre fonti per acquisire effettivamente l'elenco dei plugin.

1. Ottieni l'interfaccia della riga di comando di Jenkins

L'interfaccia della riga di comando di Jenkins ci consentirà di interagire con il nostro server Jenkins dalla riga di comando. Possiamo ottenerlo con una semplice chiamata a ricciolo.

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

2. Crea uno script Groovy per l'analisi (grazie a malenkiy_scot)

Salva quanto segue come plugins.groovy.

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

3. Chiamare l'API Jenkins per i risultati del plug-in

Chiama il server Jenkins ( localhost:8080qui) con il tuo nome utente e password di accesso mentre fai riferimento allo script Groovy:

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

L'output di plugins.txt è simile al seguente:

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

I comandi sopra dovrebbero essere eseguiti sulla workstation e non su un lavoro Jenkins
user3740244

Il comando sembra dare come risultato "ERRORE: mancano i permessi generali / di lettura" nelle ultime versioni .. invece passa l'autorizzazione prima di aver funzionato per me java -jar jenkins-cli.jar -s localhost: 8080 -auth "admin: < password> "groovy = <plugins.groovy
prasanna

12

La risposta di Behe con i plugin di smistamento non ha funzionato sulla mia macchina Jenkins. Ho ricevuto l'errore java.lang.UnsupportedOperationExceptiondovuto al tentativo di ordinare una raccolta immutabile, ad es Jenkins.instance.pluginManager.plugins. Correzione semplice per il codice:

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

Utilizzare l' http://<jenkins-url>/scriptURL per eseguire il codice.


1
Mi sono imbattuto in questo anche usando una versione diversa di Jenkins rispetto al primo sistema su cui l'ho provato. Per v2.81 la risposta migliore ha funzionato, ma per LTS v2.83.xe per tutte le versioni più recenti ha dato l'errore che hai menzionato mentre il tuo codice funzionava ancora.
dragon788,

1
Una cosa che ho appena notato è che stai ordinando in base alla displayNamestampa del shortName, questo è stato molto confuso poiché alcuni plug-in non sono alfabeticamente uguali per entrambi, e risulta in un elenco che non appare ordinato. Cambiare it.displayNameper it.shortNamerisolverlo bene.
dragon788,

8

Se sei un amministratore Jenkins puoi utilizzare la pagina delle informazioni di sistema Jenkins:

http://<jenkinsurl>/systemInfo

/systeminfonon funziona (HTTP 404) su Jenkins 1.594
G. Lombard,

7
Prova: http://localhost:8080/systemInfoalcuni server fanno distinzione tra maiuscole e minuscole. Si noti inoltre che richiede che l'utente attualmente connesso abbia l'autorizzazione Generale / Amministra.
MarkHu

8

Con curle jq:

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

Questo comando fornisce l'output in un formato utilizzato dallo speciale plugins.txtfile Jenkins che consente di preinstallare dipendenze (ad es. In un'immagine docker):

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

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


5

Dalla home page di Jenkins:

  1. Fai clic su Gestisci Jenkins .
  2. Fai clic su Gestisci plug-in .
  3. Fai clic sulla scheda Installato .

O

  1. Vai direttamente all'URL Jenkins: {L'URL di base Jenkins} / pluginManager / installato

1
La pagina "plug-in installati" non riflette necessariamente lo stato del plug-in reale. Ad esempio, è possibile riattivare un plug-in e vederlo verificato mentre il plug-in è ancora disabilitato fino al riavvio di Jenkins. Pertanto, le uniche soluzioni al 100% sono http: // <jenkinsurl> / systeminfo e le risposte alla query API, imho.
t0r0X,

4

Condividere un'altra opzione trovata qui con le credenziali

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/ /:/'

come sopra, ma senza le versioni e ordinati. curl -sSL "http://127.0.0.1:8080/pluginManager/api/xml?depth=1&xpath=/*/*/shortName|/*/*/version&wrapper=plugins" | perl -pe 's/.*?<shortName>([\w-]+).*?<version>([^<]+)()(<\/\w+>)+/\1 \n/g' | sort
ffghfgh,

3

Volevo una soluzione che potesse essere eseguita su master senza requisiti di autenticazione e non la vedevo qui. Ho creato un rapido script bash che estrarrà tutte le versioni dalla directory dei plugin.

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

grep Plugin-Version */META-INF/MANIFEST.MF | sed -e 's!/META-INF/MANIFEST.MF:Plugin-Version: !:!g' > ../plugins2.txt
james dupont il

2

Un'altra opzione per gli utenti 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)

2

Penso che queste non siano risposte abbastanza buone ... molte implicano un paio di passaggi extra sotto il cofano. Ecco come l'ho fatto.

sudo apt-get install jq

... perché l'output JSON deve essere consumato dopo aver chiamato 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


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


0

Se Jenkins viene eseguito in un contenitore Docker Jenkins, è possibile utilizzare questa riga di comando in 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`

0

Per la versione 2.125 di Jenkins ha funzionato.

NOTA: Sostituisci le sezioni che indicano USERNAME e APIKEY con un UserName e APIKey validi per l'utente corrispondente. La chiave API per un utente è disponibile tramite l'opzione Gestisci utentiSeleziona utenteChiave API .

Potrebbe essere necessario prolungare la sospensione se l'installazione di Jenkins impiega più tempo per avviarsi.

L'iniziazione yum update -yaggiornerà anche la versione se hai installato Jenkins usando anche 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
##############

0

Ci sono molti modi per recuperare queste informazioni, ma sto scrivendo due modi come di seguito: -

1. Prendi il jenkins cli.

L'interfaccia della riga di comando di jenkins ci consentirà di interagire con il nostro server jenkins dalla riga di comando. Possiamo ottenerlo con una semplice chiamata a ricciolo.

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

2. Creare uno script groovy. O dalla console di script di jenkins

Dobbiamo creare uno script groovy per analizzare le informazioni che riceviamo dall'API jenkins. Questo produrrà ogni plugin con la sua versione. Salvare quanto segue come plugins.groovy.

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.