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?
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:
È 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).
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):
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 sort
metodo :
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)
Jenkins.instance.pluginManager.plugins.sort({it.getDisplayName()}).each{ plugin -> println ("${plugin.getDisplayName()} (${plugin.getShortName()}): ${plugin.getVersion()}") }
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
jenkins.model.Jenkins.instance.getPluginManager().getPlugins().stream().sorted().each { println "${it.getShortName()} | ${it.getVersion()} | ${it.getDisplayName()}" }
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
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'
curl -s -k "http://jenkins/pluginManager/api/json?depth=1" | jq '.plugins[]|{shortName, version,longName}' -c
Jenkins 1.588 (2 ° di novembre 2014) e 1.647 (4 ° di febbraio 2016)
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
list-plugins
comando CLI non richiede all'utente di avere l' autorizzazione Overall / RunScripts come groovy
fa il comando.
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 .
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 () .
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}/script
console:
Jenkins.instance.pluginManager.plugins.each{
plugin ->
println ("${plugin.getShortName()}:${plugin.getVersion()}")
}
Jenkins.instance.pluginManager.plugins.each{
plugin ->
println ("${plugin.getShortName()}:latest")
}
:latest
alla fine:println ("${plugin.getShortName()}:latest")
Le risposte qui erano in qualche modo incomplete. E ho dovuto compilare informazioni da altre fonti per acquisire effettivamente l'elenco dei plugin.
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
Salva quanto segue come plugins.groovy
.
def plugins = jenkins.model.Jenkins.instance.getPluginManager().getPlugins()
plugins.each {println "${it.getShortName()}: ${it.getVersion()}"}
Chiama il server Jenkins ( localhost:8080
qui) 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
La risposta di Behe con i plugin di smistamento non ha funzionato sulla mia macchina Jenkins. Ho ricevuto l'errore java.lang.UnsupportedOperationException
dovuto 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>/script
URL per eseguire il codice.
displayName
stampa 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.displayName
per it.shortName
risolverlo bene.
Se sei un amministratore Jenkins puoi utilizzare la pagina delle informazioni di sistema Jenkins:
http://<jenkinsurl>/systemInfo
/systeminfo
non funziona (HTTP 404) su Jenkins 1.594
http://localhost:8080/systemInfo
alcuni server fanno distinzione tra maiuscole e minuscole. Si noti inoltre che richiede che l'utente attualmente connesso abbia l'autorizzazione Generale / Amministra.
Con curl
e 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.txt
file 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
Dalla home page di Jenkins:
O
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/ /:/'
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
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
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)
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
Puoi anche essere interessato agli aggiornamenti disponibili per i plug-in. Per questo, devi unire i dati sui plugin installati con informazioni sugli aggiornamenti disponibili qui https://updates.jenkins.io/current/update-center.json .
Per analizzare il file scaricato come JSON devi leggere online la seconda riga (che è 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}")
}
C'è una tabella che elenca tutti i plugin installati e se sono abilitati o meno su http: // jenkins / systemInfo
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`
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 utenti → Seleziona utente → Chiave API .
Potrebbe essere necessario prolungare la sospensione se l'installazione di Jenkins impiega più tempo per avviarsi.
L'iniziazione yum update -y
aggiornerà 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
##############
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()}"}