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

Sie können die Informationen mit der Jenkins Script Console abrufen , auf die Sie über http://<jenkins-url>/script zugreifen können. (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 ist ähnlich zu einer der obigen Antworten , dass Groovy verwendet wird, aber hier verwenden wir stattdessen die Skriptkonsole. Die Skriptkonsole ist äußerst hilfreich bei der Verwendung von Jenkins.

Update

Wenn Sie eine sortierte Liste bevorzugen, können Sie diese sort-Methode aufrufen:

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

Passen Sie den Verschluss Ihren Wünschen an.

In diesen Tagen verwende ich stattdessen dieselbe Vorgehensweise wie die von @Behe beschriebene Antwort https://stackoverflow.com/a/35292719/1597808

Sie können die API in Kombination mit den Argumenten für die Tiefe, XPath und Wrapper verwenden.

Im Folgenden wird die API des PluginManagers abgefragt, um alle installierten Plugins aufzulisten, jedoch nur 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 Festlegen 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 mehr als einen Knoten als Teil des Ergebnisses zurückgibt, da es mehrere Felder mit den XPath- und mehreren Plug-In-Knoten abgleichen soll.

Es ist wahrscheinlich nützlich, die folgende URL in einem Browser zu verwenden, um zu sehen, welche Informationen in 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 vom November 2014) & 1.647 (4^th vom Februar 2016)

• Jenkins> Jenkins verwalten

   

• System Information

   

• Plugins

   

Verwenden Sie Jenkins CLI wie folgt:

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

= im Aufruf bedeutet 'von Standardeingabe gelesen'. 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, ist hier die Jenkins Java API-Dokumentation .

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

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

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

Die Jenkins-CLI ermöglicht uns die Interaktion mit unserem Jenkins-Server über die Befehlszeile. Wir können es mit einem einfachen Curl-Aufruf bekommen.

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

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

Speichern Sie das Folgende als plugins.groovy.

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

3. Rufen Sie die Jenkins-API für Plugin-Ergebnisse auf

Rufen Sie den Jenkins-Server (hier localhost:8080) mit Ihrem Login-Benutzernamen und Kennwort auf, 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 Sortierplugins funktionierte auf meiner Jenkins-Maschine nicht. Ich habe den Fehler Java.lang.UnsupportedOperationException erhalten, weil ich versuche, eine unveränderliche Sammlung zu sortieren, d. H. Jenkins.instance.pluginManager.plugins. Einfacher Fix 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>/script-URL, um den Code auszuführen.

Von der Jenkins-Homepage:

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

Oder

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

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

http://<jenkinsurl>/systemInfo

Freigabe einer anderen Option, die here mit Anmeldeinformationen gefunden wurde

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

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

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

Ich denke, dass diese Antworten nicht gut genug sind ... 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

Mit curl und jq:

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

Dieser Befehl gibt die Ausgabe in einem Format aus, das von der speziellen Jenkins plugins.txt-Datei 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 einen plugins.txt: https://github.com/hoto/jenkinsfile-examples/blob/master/source/jenkins/usr/share/jenkins/plugins.txt

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)

Es gibt eine Tabelle, in der alle installierten Plugins aufgelistet sind und ob sie unter http: // jenkins/systemInfo aktiviert sind.

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

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

Für Jenkins Version 2.125 funktionierte Folgendes.

HINWEIS: Ersetzen Sie Abschnitte mit den Bezeichnungen 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 die Option Benutzer verwalten → Benutzer auswählen → API-Schlüssel verfügbar.

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

Die Initiation yum update -y aktualisiert auch die Version, 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
##############

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

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`

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

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

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

1. Holen Sie sich die Jenkins cli.

Die Jenkins-CLI ermöglicht uns die Interaktion mit unserem Jenkins-Server über die Befehlszeile. Wir können es mit einem einfachen Curl-Aufruf bekommen.

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

2. Erstellen Sie ein grooviges Skript. OR von der 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 das Folgende als plugins.groovy.

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