Git branch sélectionnez dans Jenkins avec groovy script

Je suis en train de faire un Parameterized build dans Jenkins. De cette façon, l'utilisateur peut choisir la branche git il/elle veut déployer à partir d'une cascade de menu.

Il y a deux façons possibles:

L'écriture de la branche dans les noms de fichier et de configurer Jenkins pour lire ce fichier (project configuration > extend choice parameter and selecting Property file).
Problème : Vous devez faire un dépôt local comme un miroir de la distance de pensions et de garder ce local de pensions de la synchronisation à distance avec des pensions de titres. En d'autres termes, vous devez mettre à jour le fichier contenant le disponible nom de la branche mise à jour. Cela nécessite un travail planifié par cron et je ne suis pas autorisé l'utilisation de cette approche.
À l'aide de 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 ça ne fonctionne pas. J'ai installé groovy sur ma machine.

Quelqu'un peut-il m'aider? Pour faire bref: j'ai besoin d'un script groovy qui renvoie à la disposition des noms de branche d'un dépôt distant.

OriginalL'auteur Danial | 2014-08-26

12

Le script ci-dessous doit être utile. Il est basé sur les scripts de lié à la question. Il filtre commande git de sortie avec une expression régulière simple et crée une liste de noms de branche pour le dépôt git. Testé sur graal-core dépôt github:
```
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
```
Être conscient de la System.exit() si en cours d'exécution dans le Jenkins (par exemple, "extensible" choix de plugin).
est droit. à l'aide de cette instruction permet de redémarrer l'ensemble jenkins, si quelque chose va mal. BTW, la dernière déclaration doit être return branches

OriginalL'auteur Paweł Piecyk
3

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

seulement si c'est un public de pensions ou vous êtes en utilisant ssh. Il ne fonctionne pas avec les informations d'identification lors de la moment
Aussi ne fonctionne pas si vous avez plusieurs référentiels, il sera toujours seulement de montrer les branches de l'un des repos seulement.
Aussi Git Paramètre Plugin ne fonctionne pas bien avec Jenkins Pipelines (vous ne pouvez pas le programme d'installation SCM config dans le Pipeline de vue).

OriginalL'auteur Wilfred Hughes
2

Vous pouvez utiliser Extensible Paramètre de Choix de plugin pour récupérer les branches Git d'un clone de votre référentiel. Pour ce faire, ajoutez de Maître-Nœud de propriété d'une variable d'environnement .git chemin d'accès au répertoire, par exemple:

Puis ajouter un Extensible paramètre de Choix à la suite de groovy script (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_') }
```
Qui devrait liste de vos branches (j'ai éliminé tous "Branch_*" dans la liste):

Notes:
Dans le cas où vous ne voyez rien, lors de la validation du script (avec "Exécuter le script"), c'est probablement dû aux requis de l'utilisateur/mot de passe invite donc, au départ, exécuter "git ls-à distance -t --les chefs origine".répertoire git.
Pour enregistrer des informations d'identification sur Windows, essayez d'exécuter "git config --global d'identification.helper wincred".

OriginalL'auteur Noam Manos
2

Essayez D'Utiliser
- Choix Actif plugin et Extensible choix paramètre plugin pour les dynamiques des pensions et de la direction générale des sélections
- Extensible choix paramètre plugin pour le choix de la branche pour un défaut repo.
Utilisez les étapes suivantes:
1. Ajouter un extensible paramètre de choix pour votre travail
2. sélectionnez Système Groovy paramètre de Choix dans le Choix du champ de paramètre
3. Placez le script suivant dans Groovy script zone de texte et remplacez la place des titulaires "< >" avec 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 choix actif réactif paramètre de votre travail
5. Place Paramètre de Référence comme référentiel et le script suivant dans le Script Groovy zone de texte
```
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 de référentiel paramètre.
  - ignorer pour le dépôt public.
6. Maintenant, essayez de construire de travail avec le paramètre
caisse github api docs pour plus d'informations. Espérons que ce yould être utile..!! 😉

OriginalL'auteur Aananth K

Ce fut la seule technique que j'ai trouvé qui ne vous obligent pas à creuser repo git de l'information de l'espace de travail. Il utilise Groovy code pour inspecter les paramètres de travail pour le Git URI, puis shells pour git pour faire le reste du travail.

Il devrait être possible d'utiliser JGit pour accéder au référentiel en natif Groovy façon, mais je ne peux pas la 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()