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

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?

È 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 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)

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

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

• Jenkins> Gestisci Jenkins

  

• Informazioni di sistema

  

• plugin

  

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

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 .

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

2. 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")
}

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

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.

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

http://<jenkinsurl>/systemInfo

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

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

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

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

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

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