Git branch select in Jenkins avec un script groovy

Question

J'essaie de créer un Parameterized build à Jenkins. De cette manière, l'utilisateur peut choisir la branche git qu'il/elle souhaite déployer à partir d'un menu en cascade.

Il y a deux manières possibles:

1. Écrire des noms de branche dans un fichier et configurer Jenkins pour lire ce fichier (project configuration > extend choice parameter and selecting Property file).

   Problème: Vous devez créer un référentiel local en tant que miroir du référentiel distant et maintenir ce référentiel local synchronisé avec le référentiel distant. En d'autres termes, vous devez mettre à jour le fichier contenant le nom de la branche disponible updated . Cela nécessite un travail planifié par cron et je ne suis pas autorisé à utiliser cette approche.
   

2. Utilisation du script Groovy (project configuration > extend choice parameter and selecting "Groovy script"). Ensuite, vous avez besoin d'un script groovy pour récupérer le nom de la branche comme suit: branches=master,feature/Feature-1,feature/Feature-2,hotfix/Hotfix-1,release/Release-1.

J'ai trouvé un script groovy dans ici mais cela ne fonctionne pas. J'ai installé groovy sur ma machine.

Quelqu'un peut-il m'aider? Pour que l'histoire soit courte: j'ai besoin d'un script groovy qui renvoie les noms de branche disponibles d'un référentiel distant.

Answer 1

Le script ci-dessous devrait être utile. Il est basé sur les scripts de question liée . Il filtre le résultat de la commande git avec une expression régulière simple et crée une liste de noms de branches pour le référentiel git spécifié. Testé sur grails-core github repo :

def gitURL = "https://github.com/grails/grails-core.git"
def command = "git ls-remote -h $gitURL"

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

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

def branches = proc.in.text.readLines().collect { 
    it.replaceAll(/[a-z0-9]*\trefs\/heads\//, '') 
}

println branches

Answer 2

Vous n'avez pas besoin d'un script Groovy pour cela. Le Git Parameter Plugin vous permet d’ajouter des branches git en tant que paramètre.

Answer 3

Essayez d'utiliser 

• Active Choice plugin et Choix extensible plug-in de paramètres pour les sélections de référents dynamiques et de branches
• Choix extensible paramètre plugin pour la sélection de branche pour un référentiel par défaut.

Utilisez les étapes suivantes:

1. Ajouter un paramètre de choix extensible à votre travail

    

2. select Paramètre System Groovy Choice in Champ du paramètre Choice

    

3. Placez le script suivant dans Groovy script zone de texte et remplacez les espaces réservés "<>" par les valeurs requises.

   import groovy.json.JsonSlurper;
   try{
      List<String>params = new ArrayList<String>()
      URL apiUrl = "https://api.github.com/users/<repo-owner>/repos?access_token=<github-access-token>".toURL()
      List branches = new JsonSlurper().parse(apiUrl.newReader())
      for (branch in branches ) { 
        params.add(branch.name) 
      }
      return params
   }
   catch(IOException ex){
      print ex
   }
   

4. Ajouter un paramètre réactif à choix actif à votre travail

    

5. Place Paramètre de référence as repository et script suivant dans la zone de texte Groovy Script

   import groovy.json.JsonSlurper;
   try{
      List<String>params = new ArrayList<String>()
      URL apiUrl = "https://api.github.com/repos/<repo-owner>/$repository/branches?access_token=<github-access-token>".toURL()
      List json = new JsonSlurper().parse(apiUrl.newReader())
      for (repo in json ) { 
      params.add(repo.name) 
     }
   return params
   }
   catch(IOException ex){
      print ex
   }
   

    

   Remarque: 

   • $repository prend la valeur dynamique du paramètre repository.
   • ignorer pour le référentiel public. 

6. Maintenant, essayez de construire le travail avec le paramètre

      

checkout github api docs pour plus d'informations. J'espère que cela vous sera utile .. !! ;-)

Answer 4

Vous pouvez utiliser le plugin Extensible Choice Parameter pour récupérer les branches Git de votre référentiel cloné. Pour ce faire, ajoutez à la propriété Master-Node une variable d'environnement de chemin de répertoire .git, par exemple:

 

Ajoutez ensuite un paramètre Extensible Choice avec le script groovy suivant (et cochez la case "Utiliser des variables prédéfinies"):

def envVars = jenkins.getNodeProperties()[0].getEnvVars() 
def NODE_PROJECT_PATH = envVars.get('NODE_PROJECT_PATH') 
def gettags = "git ls-remote -t --heads Origin".execute(null, new File(NODE_PROJECT_PATH))

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

Cela devrait lister vos branches (j'ai filtré tous les "Branch_ *" de la liste):

 

Notes: Si vous ne voyez rien lors de la validation du script (avec le bouton "Exécuter le script maintenant"), cela est probablement dû à l'invite utilisateur/mot de passe requise - lancez donc initialement "git ls- remote -t ​​--heads Origin "dans le répertoire .git. Pour enregistrer les informations d'identification sous Windows, essayez d'exécuter "git config --global credential.helper wincred".

Answer 5

C’est la seule technique que je propose qui ne vous oblige pas à extraire des informations de dépôt git hors de l’espace de travail. Ceci utilise le code Groovy pour inspecter les paramètres de travail pour l'URI Git, puis passe à git pour effectuer le reste du travail.

Il devrait être possible d'utiliser JGit pour accéder au référentiel de manière native dans Groovy, mais je n'arrive pas à le comprendre.

import jenkins.*
import jenkins.model.*
import hudson.*
import hudson.model.*
import org.Eclipse.jgit.transport.RemoteConfig;
import org.Eclipse.jgit.transport.URIish;

def build = Thread.currentThread().toString()
def regexp= ".+?/job/([^/]+)/.*"
def match = build  =~ regexp
def jobName = match[0][1]
def job = Jenkins.instance.getJob(jobName)
def workspace = job.lastBuild.workspace

for(project in Hudson.instance.items) {
  scm = job.scm;
  if (scm instanceof hudson.plugins.git.GitSCM) {
    for (RemoteConfig cfg : scm.getRepositories()) {
      for (URIish uri : cfg.getURIs()) {
        gitUri = uri
      }
    }
  }
}

def branchlist = ["/bin/bash", "-c", "git ls-remote --heads ${gitUri}"].execute() | ["/bin/bash", "-c", "cut -f2"].execute()
branchlist.waitFor()

return branchlist.in.text.readLines()

Définissez-le comme Groovy Script _ pour votre Source de la valeur sur un paramètre de choix étendu comme ceci:

 

Et vous pourrez ensuite sélectionner une liste de branches en tant que paramètres de construction: