So erhalten Sie eine Liste der installierten Jenkins-Plugins mit Name und Versionspaar

Wie kann ich eine Liste der installierten Jenkins-Plugins erhalten?

Ich habe das Jenkins Remote Access API-Dokument durchsucht, aber es wurde nicht gefunden. Soll ich Jenkins 'CLI verwenden? Gibt es ein Dokument oder ein Beispiel?

Sie können die Informationen über die Jenkins Script Console abrufen, auf die Sie unter zugreifen können http://<jenkins-url>/script. (Vorausgesetzt, Sie sind angemeldet und verfügen über die erforderlichen Berechtigungen).

Geben Sie das folgende Groovy-Skript ein , um die installierten Plugins zu durchlaufen und die relevanten Informationen auszudrucken:

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

Die Ergebnisliste wird wie folgt gedruckt (abgeschnitten):

Diese Lösung ähnelt einer der obigen Antworten , da sie Groovy verwendet, aber hier verwenden wir stattdessen die Skriptkonsole. Die Skriptkonsole ist äußerst hilfreich bei der Verwendung von Jenkins.

Aktualisieren

Wenn Sie eine sortierte Liste bevorzugen, können Sie diese sortMethode aufrufen :

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

Passen Sie den Abschluss nach Ihren Wünschen an (z. B. wird er hier nach dem Kurznamen sortiert, im Beispiel nach dem Anzeigenamen).

Heutzutage verwende ich den gleichen Ansatz wie die von @Behe unten beschriebene Antwort anstelle von https://stackoverflow.com/a/35292719/1597808

Sie können die API in Kombination mit Tiefen-, XPath- und Wrapper-Argumenten verwenden.

Im Folgenden wird die API des pluginManager abgefragt, um alle installierten Plugins aufzulisten, jedoch nur, um deren Kurznamen- und Versionsattribute zurückzugeben. Sie können natürlich zusätzliche Felder abrufen, indem Sie '|' hinzufügen. bis zum Ende des XPath-Parameters und Angabe des Musters zur Identifizierung des Knotens.

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

Das Wrapper-Argument ist in diesem Fall erforderlich, da es als Teil des Ergebnisses mehr als einen Knoten zurückgibt, da mehrere Felder mit dem XPath- und mehreren Plugin-Knoten abgeglichen werden.

Es ist wahrscheinlich nützlich, die folgende URL in einem Browser zu verwenden, um zu sehen, welche Informationen zu den Plugins verfügbar sind, und dann zu entscheiden, was Sie mit XPath einschränken möchten:

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

Jenkins 1,588 (2 ^nd November 2014) und 1.647 (4 ^th Februar 2016)

• Jenkins> Jenkins verwalten

  

• System Information

  

• Plugins

  

Die Jenkins-CLI unterstützt das Auflisten aller installierten Plugins:

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

Verwenden Sie Jenkins CLI wie folgt:

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

=im Aufruf bedeutet "von Standardeingabe lesen" .pluginEnumerator.groovy enthält den folgenden Groovy-Code:

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

Wenn Sie mit dem Code spielen möchten, finden Sie hier die Dokumentation zur Jenkins Java-API .

Wenn Sie in einer Docker-Umgebung arbeiten und die Plugin-Liste in einem plugins.txt-Format ausgeben möchten, um diese an install_scripts.sh zu übergeben, verwenden Sie diese Skripte in der http://{jenkins}/scriptKonsole:

1. Diese Version ist nützlich, um eine bestimmte Paketversion zu erhalten

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

2. Wenn Sie nur das Plugin mit der neuesten Version möchten, können Sie dies verwenden (danke @KymikoLoco für den Tipp)

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

Die Antworten hier waren etwas unvollständig. Und ich musste Informationen aus anderen Quellen zusammenstellen, um die Plugin-Liste tatsächlich zu erhalten.

1. Holen Sie sich die Jenkins CLI

Über die Jenkins-CLI können wir über die Befehlszeile mit unserem Jenkins-Server interagieren. Wir können es mit einem einfachen Curl Call bekommen.

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

2. Erstellen Sie ein Groovy-Skript zum Parsen (dank malenkiy_scot).

Speichern Sie Folgendes als plugins.groovy.

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

3. Rufen Sie die Jenkins-API auf, um Plugin-Ergebnisse zu erhalten

Rufen Sie den Jenkins-Server an (localhost:8080 hier) mit Ihrem Login-Benutzernamen und Passwort an, während Sie auf das Groovy-Skript verweisen:

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

Die Ausgabe in plugins.txt sieht folgendermaßen aus:

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

Behes Antwort mit Sortier-Plugins funktionierte auf meinem Jenkins-Computer nicht. Ich habe den Fehler erhalten, java.lang.UnsupportedOperationExceptionweil ich versucht habe, eine unveränderliche Sammlung zu sortieren, d Jenkins.instance.pluginManager.plugins. H. Einfache Korrektur für den Code:

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

Verwenden Sie die http://<jenkins-url>/scriptURL, um den Code auszuführen.

Wenn Sie ein Jenkins-Administrator sind, können Sie die Jenkins-Systeminformationsseite verwenden:

http://<jenkinsurl>/systemInfo

Mit curlund jq:

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

Dieser Befehl gibt eine Ausgabe in einem Format aus, das von einer speziellen Jenkins- plugins.txtDatei verwendet wird, mit der Sie Abhängigkeiten vorinstallieren können (z. B. in einem Docker-Image):

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

Beispiel für plugins.txt: https://github.com/hoto/jenkinsfile-examples/blob/master/source/jenkins/usr/share/jenkins/plugins.txt

Von der Jenkins-Homepage:

1. Klicken Sie auf Jenkins verwalten .
2. Klicken Sie auf Plugins verwalten .
3. Klicken Sie auf die Registerkarte Installiert .

Oder

1. Gehen Sie direkt zur Jenkins-URL: {Ihre Jenkins-Basis-URL} / pluginManager / installiert

Teilen Sie eine andere hier gefundene Option mit Anmeldeinformationen

JENKINS_HOST=username:[email protected]: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/ /:/'

Ich wollte eine Lösung, die auf dem Master ohne Authentifizierungsanforderungen ausgeführt werden kann, und habe sie hier nicht gesehen. Ich habe ein schnelles Bash-Skript erstellt, das alle Versionen aus dem Plugins-Verzeichnis herausholt.

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

Ich denke, diese Antworten sind nicht gut genug ... viele beinhalten ein paar zusätzliche Schritte unter der Haube. So habe ich es gemacht.

sudo apt-get install jq

... weil die JSON-Ausgabe nach dem Aufruf der API verbraucht werden muss.

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

Eine weitere Option für Python-Benutzer:

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)

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

Unter http: // jenkins / systemInfo gibt es eine Tabelle, in der alle installierten Plugins aufgelistet sind und ob sie aktiviert sind oder nicht

Wenn Jenkins in einem Jenkins Docker-Container ausgeführt wird, können Sie diese Befehlszeile in Bash verwenden:

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`

Für Jenkins Version 2.125 funktionierte Folgendes.

HINWEIS: Ersetzen Sie Abschnitte mit den Angaben USERNAME und APIKEY durch einen gültigen Benutzernamen und APIKey für den entsprechenden Benutzer. Der API-Schlüssel für einen Benutzer ist über Benutzer verwalten → Benutzer auswählen → API-Schlüssel verfügbar Option .

Möglicherweise müssen Sie den Ruhezustand verlängern, wenn der Start Ihrer Jenkins-Installation länger dauert.

Durch die Initiierung yum update -ywird auch die Version aktualisiert, wenn Sie Jenkins ebenfalls mit yum installiert haben.

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

Es gibt viele Möglichkeiten, diese Informationen abzurufen, aber ich schreibe zwei Möglichkeiten wie folgt: -

1. Holen Sie sich die Jenkins Cli.

Über die Jenkins-CLI können wir über die Befehlszeile mit unserem Jenkins-Server interagieren. Wir können es mit einem einfachen Curl Call bekommen.

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

2. Erstellen Sie ein grooviges Skript. ODER von Jenkins Skriptkonsole

Wir müssen ein grooviges Skript erstellen, um die Informationen zu analysieren, die wir von der Jenkins-API erhalten. Dadurch wird jedes Plugin mit seiner Version ausgegeben. Speichern Sie Folgendes als plugins.groovy.

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

Sie können auch interessiert sein, welche Updates für Plugins verfügbar sind. Dazu müssen Sie die Daten zu installierten Plugins mit Informationen zu Updates zusammenführen, die hier verfügbar sind: https://updates.jenkins.io/current/update-center.json .

Um die heruntergeladene Datei als JSON zu analysieren, müssen Sie die zweite Zeile (die riesig ist) online lesen.