Dynamiczne wypełnianie parametru wyboru Jenkins gałęziami Git w określonym Repo

Próbowałem kilku odpowiedzi wymienionych w tym linku, ale nie mogłem rozgryźć, jak powiedzieć Jenkinsowi o wybranej przez użytkownika gałęzi. Jak wspomniałem w poprzednim komentarzu w powyższym wątku, pozostawiłem pole wyboru gałęzi puste.

Ale podczas dalszych dochodzeń znalazłem inny sposób na zrobienie tego samego - https://wiki.jenkins-ci.org/display/JENKINS/Git + parametr + Wtyczka Okazało się, że ta metoda była o wiele prostsza i miała mniej rzeczy do skonfigurowania!

Oto co ja konfiguracja -

1. zainstalowano wtyczkę parametru git
2. sprawdzono 'parametryzacja tej kompilacji' i dodano parametr ' Git '

3. Dodano następujące wartości:

4. Następnie w sekcji GIT SCM zadania dodałem tę samą wartość, o której mowa w sekcji 'Name', tak jakby była to zmienna środowiskowa. (Jeśli uważnie przeczytasz help for this Git parameter plugin, zdasz sobie z tego sprawę)

Po tym właśnie uruchomiłem build, wybrał moją gałąź (Jenkins sprawdza tę gałąź przed zbudowaniem) i zakończył kompilację pomyślnie i wybierając gałąź, którą podałem.

Udało mi się osiągnąć ten wynik za pomocą wtyczki dynamicznego parametru Jenkins . Użyłem opcji Dynamic Choice Parameter i, dla skryptu choices, użyłem następującego:

proc1 = ['/bin/bash', '-c', "/usr/bin/git ls-remote -h ssh://[email protected]/path/to/repo.git"].execute()
proc2 = ['/bin/bash', '-c', "awk '{print \$2}'"].execute()
proc3 = ['/bin/bash', '-c', "sed s%^refs/heads%origin%"].execute()

all = proc1 | proc2 | proc3
String result = all.text

String filename = "/tmp/branches.txt"
boolean success = new File(filename).write(result) 

def multiline = "cat /tmp/branches.txt".execute().text
def list = multiline.readLines()

To dość proste użycie "wtyczki parametru Git" .

Dodaj nazwę w stylu "SELECT_BRANCH" # # upewnij się, że ta zmienna zostanie użyta później. Następnie Typ Parametru: Branch

Następnie skontaktuj się z SCM : Wybierz: Git and branch specifier: ${SELECT_BRANCH}

Aby zweryfikować, wykonaj poniżej w powłoce w jenkins:

Echo ${SELECT_BRANCH}

Env.Tutaj wpisz opis obrazka

Rozszerzenie na odpowiedź @ malenkiy_scot. Stworzyłem nowe zadanie jenkins, aby zbudować plik, który jest używany przez wtyczkę Extended Choice.

Możesz wykonać następujące czynności (zrobiłem to jako wykonanie kroków powłoki w jenkins, ale można to zrobić w skrypcie):

git ls-remote [email protected]:my/repo.git |grep refs/heads/* >tmp.txt
sed -e 's/.*refs\/heads\///' tmp.txt > tmp2.txt
tr '\n' ',' < tmp2.txt > tmp3.txt
sed '1i\branches=' tmp3.txt > tmp4.txt
tr -d '\n'  < tmp4.txt > branches.txt

Następnie używam wtyczki Artifact deployer, aby wypchnąć ten plik do współdzielonej lokalizacji, która znajduje się w adresie URL, a następnie po prostu użyj " http://localhost/branches.txt ' w rozszerzonej wtyczki wyboru jako url. działa jak urok.

Możesz osiągnąć to samo za pomocą rozszerzonego parametru wyboru plugin wcześniej wspomniany przez malenkiy_scot i prostego skryptu php w następujący sposób (zakładając, że masz gdzieś serwer do wdrożenia skryptów php, które możesz uderzyć z maszyny Jenkins)

<?php
chdir('/path/to/repo');
exec('git branch -r', $output);
print('branches='.str_replace('  origin/','',implode(',', $output)));
?>

Lub

<?php
exec('git ls-remote -h http://user:[email protected]', $output);
print('branches='.preg_replace('/[a-z0-9]*\trefs\/heads\//','',implode(',', $output)));
?>

Przy pierwszej opcji trzeba by sklonować repo. Z drugim nie, ale w obu przypadkach musisz zainstalować git na serwerze hostującym Twój skrypt php. Odrobina każdej z tych opcji dostaje w pełni dynamiczny, nie trzeba budować pliku listy. Po prostu umieść adres URL skryptu w polu parametr rozszerzonego wyboru "Plik Właściwości".

Tak, Napisałem świetny scenariusz, który załatwia sprawę. Należy dodać "Dynamic Choice Parameter" do swojej pracy i dostosować następujący skrypt groovy do swoich potrzeb:

#!/usr/bin/groovy

def gitURL = "git repo url"
def command = "git ls-remote --heads --tags ${gitURL}"

def proc = command.execute()
proc.waitFor()              

if ( proc.exitValue() != 0 ) {
   println "Error, ${proc.err.text}"
   System.exit(-1)
}

def text = proc.in.text
# put your version string match
def match = /<REGEX>/
def tags = []

text.eachMatch(match) { tags.push(it[1]) }
tags.unique()
tags.sort( { a, b ->
         def a1 = a.tokenize('._-')
         def b1 = b.tokenize('._-')
         try {
            for (i in 1..<[a1.size(), b1.size()].min()) { 
                 if (a1[i].toInteger() != b1[i].toInteger()) return a1[i].toInteger() <=> b1[i].toInteger()
            }
            return 1
         } catch (e) {
            return -1;
         }
} )
tags.reverse()

W moim przypadku ciąg wersji był w następującym formacie X. X. X. X i mógł mieć gałęzie użytkownika w formacie X. X. X-username, itp... Więc musiałem napisać własną funkcję sortowania. To był mój pierwszy groovy scenariusz, więc jeśli są lepsze sposoby robienia rzeczy chciałbym wiedzieć.

Poniższy skrypt groovy byłby przydatny, Jeśli Twoje zadanie nie używa bezpośrednio "zarządzania kodem źródłowym" (podobnie "Wtyczka parametru Git"), ale nadal ma dostęp do lokalnego (sklonowanego) repozytorium git:

import jenkins.model.Jenkins

def envVars = Jenkins.instance.getNodeProperties()[0].getEnvVars() 
def GIT_PROJECT_PATH = envVars.get('GIT_PROJECT_PATH') 
def gettags = "git ls-remote -t --heads origin".execute(null, new File(GIT_PROJECT_PATH))

return gettags.text.readLines()
         .collect { it.split()[1].replaceAll('\\^\\{\\}', '').replaceAll('refs/\\w+/', '')  }
         .unique()

Zobacz pełne wyjaśnienie tutaj: https://stackoverflow.com/a/37810768/658497

Możemy wyeliminować niepotrzebne pliki do odczytu/zapisu za pomocą text. Moje kompletne rozwiązanie jest następujące:

proc1 = ['/bin/bash', '-c', 
  "/usr/bin/git ls-remote --heads ssh://repo_url.git"].execute()
proc2 = ['/bin/bash', '-c', 
  "/usr/bin/awk ' { gsub(/refs\\/heads\\//, \"\"); print \$2 }' "].execute()
all = proc1 | proc2

choices = all.text
return choices.split().toList();

Dla mnie używam input stage param:

1. uruchamiam swój pipeline od sprawdzenia projektu git.
2. używam komendy awk do generowania barncha.plik txt z listą wszystkich gałęzi
3. w stage setps, czytam plik i używam go do generowania input choice params

Gdy użytkownik uruchomi rurociąg, ten będzie czekał na wybór z listy.

pipeline{
agent any

stages{

    stage('checkout scm') {
        steps {
            script{
                git credentialsId: '8bd8-419d-8af0-30960441fcd7', url: 'ssh://[email protected]:/usr/company/repositories/repo.git'
                sh 'git branch -r | awk \'{print $1}\' ORS=\'\\n\' >>branch.txt'
            }

        }
    }
     stage('get build Params User Input') {
        steps{
            script{

                liste = readFile 'branch.txt'
                echo "please click on the link here to chose the branch to build"
                env.BRANCH_SCOPE = input message: 'Please choose the branch to build ', ok: 'Validate!',
                        parameters: [choice(name: 'BRANCH_NAME', choices: "${liste}", description: 'Branch to build?')]


            }
        }
    } 
    stage("checkout the branch"){
        steps{
            echo "${env.BRANCH_SCOPE}"
            git  credentialsId: 'ea346a50-8bd8-419d-8af0-30960441fcd7', url: 'ssh://[email protected]/usr/company/repositories/repo.git'
            sh "git checkout -b build ${env.BRANCH_NAME}"
        }
    }
    stage(" exec maven build"){
        steps{
            withMaven(maven: 'M3', mavenSettingsConfig: 'mvn-setting-xml') {
               sh "mvn clean install "
            }
        }
    }
    stage("clean workwpace"){
        steps{
            cleanWs()
        }
    }
}

}

I wtedy użytkownik będzie współdziałał z kompilatorem:

Enter opis obrazka tutaj

Tutaj wpisz opis obrazka