Jak uzyskać listę zainstalowanych wtyczek Jenkins z parą nazw i wersji

Jak mogę uzyskać listę zainstalowanych wtyczek Jenkins?

Przeszukałem dokument Jenkins Remote Access API, ale nie został znaleziony. Czy powinienem używać interfejsu wiersza polecenia Jenkinsa? Czy jest dokument lub przykład?

Informacje można pobrać za pomocą konsoli Jenkins Script Console, do której można uzyskać dostęp, odwiedzając witrynę http://<jenkins-url>/script. (Zakładając, że jesteś zalogowany i masz wymagane uprawnienia).

Wprowadź następujący skrypt Groovy, aby iterować po zainstalowanych wtyczkach i wydrukować odpowiednie informacje:

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

Lista wyników zostanie wydrukowana w następujący sposób (obcięta):

To rozwiązanie jest podobne do jednej z powyższych odpowiedzi , ponieważ używa Groovy, ale tutaj używamy zamiast tego konsoli skryptów. Konsola skryptów jest niezwykle pomocna podczas korzystania z Jenkinsa.

Aktualizacja

Jeśli wolisz posortowaną listę, możesz wywołać tę sortmetodę :

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

Dostosuj zamknięcie do swoich upodobań (np. Tutaj jest sortowane według shortName, w przykładzie jest sortowane według DisplayName)

Obecnie używam tego samego podejścia, co odpowiedź opisana przez @Behe poniżej zamiast https://stackoverflow.com/a/35292719/1597808

Możesz używać interfejsu API w połączeniu z argumentami depth, XPath i wrapper.

Następujące polecenie wyśle ​​zapytanie do interfejsu API pluginManager, aby wyświetlić listę wszystkich zainstalowanych wtyczek, ale tylko w celu zwrócenia ich atrybutów shortName i version. Możesz oczywiście pobrać dodatkowe pola, dodając „|” na końcu parametru XPath i określając wzorzec identyfikujący węzeł.

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

Argument opakowujący jest wymagany w tym przypadku, ponieważ zwraca więcej niż jeden węzeł jako część wyniku, zarówno pod względem dopasowania wielu pól do XPath, jak i wielu węzłów wtyczki.

Prawdopodobnie przydatne jest użycie następującego adresu URL w przeglądarce, aby zobaczyć, jakie informacje o wtyczkach są dostępne, a następnie zdecydować, co chcesz ograniczyć za pomocą XPath:

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

Jenkins 1,588 (2 ^nd od listopada 2014) i 1,647 (4 ^th of lutego 2016)

• Jenkins> Zarządzaj Jenkins

  

• Informacje o systemie

  

• Wtyczki

  

Interfejs wiersza polecenia Jenkinsa obsługuje wyświetlanie wszystkich zainstalowanych wtyczek:

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

Użyj Jenkins CLI w następujący sposób:

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

=w wywołaniu oznacza „czytaj ze standardowego wejścia” . pluginEnumerator.groovy zawiera następujący kod 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()}"

Jeśli chcesz bawić się kodem, oto dokumentacja Jenkins Java API .

Jeśli pracujesz w środowisku docker i chcesz wyprowadzić listę wtyczek w formacie plugins.txt, aby przekazać ją do pliku install_scripts.sh, użyj tych skryptów w http://{jenkins}/scriptkonsoli:

1. Ta wersja jest przydatna do pobierania określonej wersji pakietu

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

2. Jeśli chcesz tylko wtyczki z najnowszą wersją, możesz jej użyć (dzięki @KymikoLoco za wskazówkę)

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

Odpowiedzi tutaj były nieco niekompletne. I musiałem skompilować informacje z innych źródeł, aby faktycznie uzyskać listę wtyczek.

1. Pobierz Jenkins CLI

Interfejs wiersza polecenia Jenkins pozwoli nam na interakcję z naszym serwerem Jenkins z wiersza poleceń. Możemy to uzyskać za pomocą prostego zawijania.

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

2. Utwórz skrypt Groovy do parsowania (dzięki malenkiy_scot)

Zapisz poniższe jako plugins.groovy.

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

3. Wywołaj interfejs API Jenkinsa, aby uzyskać wyniki wtyczki

Zadzwoń do serwera Jenkins ( localhost:8080tutaj), podając swoją nazwę użytkownika i hasło podczas odwoływania się do skryptu Groovy:

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

Dane wyjściowe pliku plugins.txt wyglądają następująco:

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

Odpowiedź Behe'ego z sortowaniem wtyczek nie działała na moim komputerze z Jenkinsem. Otrzymałem błąd java.lang.UnsupportedOperationExceptionz powodu próbuje uporządkować niezmiennej zebraniu tzn Jenkins.instance.pluginManager.plugins. Prosta poprawka dla kodu:

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

Użyj http://<jenkins-url>/scriptadresu URL, aby uruchomić kod.

Jeśli jesteś administratorem Jenkins, możesz skorzystać ze strony informacji o systemie Jenkins:

http://<jenkinsurl>/systemInfo

Z curli jq:

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

To polecenie daje dane wyjściowe w formacie używanym przez specjalny plugins.txtplik Jenkins , który umożliwia preinstalację zależności (np. W obrazie dockera):

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

Przykład plugins.txt: https://github.com/hoto/jenkinsfile-examples/blob/master/source/jenkins/usr/share/jenkins/plugins.txt

Ze strony głównej Jenkins:

1. Kliknij Zarządzaj Jenkins .
2. Kliknij Zarządzaj wtyczkami .
3. Kliknij kartę Zainstalowane .

Lub

1. Przejdź bezpośrednio do adresu URL Jenkinsa: {Twój podstawowy adres URL Jenkinsa} / pluginManager / installed

Udostępnianie innej opcji znalezionej tutaj z poświadczeniami

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

Chciałem rozwiązania, które mogłoby działać na serwerze głównym bez żadnych wymagań autoryzacji i nie widziałem go tutaj. Zrobiłem szybki skrypt basha, który wyciągnie wszystkie wersje z wtyczek reż.

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

Myślę, że to nie są wystarczająco dobre odpowiedzi ... wiele z nich wymaga kilku dodatkowych kroków pod maską. Oto jak to zrobiłem.

sudo apt-get install jq

... ponieważ dane wyjściowe JSON muszą zostać wykorzystane po wywołaniu interfejsu 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

Inna opcja dla użytkowników Pythona:

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

Pod adresem http: // jenkins / systemInfo znajduje się tabela z listą wszystkich zainstalowanych wtyczek i informacją, czy są one włączone

Jeśli Jenkins działa w kontenerze Jenkins Docker, możesz użyć tego wiersza poleceń w 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`

W przypadku wersji Jenkins 2.125 działały następujące rozwiązania.

UWAGA: Zastąp sekcje, które mówią USERNAME i APIKEY, prawidłowymi nazwami użytkownika i APIKey dla tego odpowiedniego użytkownika. Klucz API dla użytkownika jest dostępny w opcji Zarządzaj użytkownikami → Wybierz użytkownika → Klucz API .

Może być konieczne przedłużenie uśpienia, jeśli instalacja Jenkinsa trwa dłużej.

Inicjacja yum update -yzaktualizuje również wersję, jeśli zainstalowałeś Jenkins również za pomocą 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
##############

Istnieje wiele sposobów na pobranie tych informacji, ale piszę dwa sposoby, jak poniżej: -

1. Pobierz Cli Jenkinsa.

Interfejs wiersza poleceń jenkins pozwoli nam na interakcję z naszym serwerem jenkins z wiersza poleceń. Możemy to uzyskać za pomocą prostego zawijania.

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

2. Stwórz wspaniały skrypt. LUB z konsoli skryptu Jenkinsa

Musimy stworzyć świetny skrypt, aby przeanalizować informacje otrzymane z API Jenkinsa. Spowoduje to wyświetlenie każdej wtyczki wraz z jej wersją. Zapisz poniższe jako plugins.groovy.

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

Możesz być także zainteresowany, jakie aktualizacje są dostępne dla wtyczek. W tym celu musisz połączyć dane o zainstalowanych wtyczkach z informacjami o aktualizacjach dostępnymi tutaj https://updates.jenkins.io/current/update-center.json .

Aby przeanalizować pobrany plik jako JSON, musisz przeczytać online drugą linię (która jest ogromna).