origin - Llene dinámicamente el parámetro de elección de Jenkins con las ramas de Git en un Repo especificado

git pull origin master

Question

Tengo un trabajo de Jenkins parametrizado que requiere la entrada de una rama de Git específica en un repositorio de Git específico. Actualmente este parámetro es un parámetro de cadena.

¿Hay alguna manera de hacer de este parámetro un parámetro de elección y llenar dinámicamente la lista desplegable con las ramas de Git? No deseo que alguien mantenga este parámetro de elección configurando manualmente el menú desplegable cada vez que se crea una nueva rama.

Answer 1

Es bastante simple usar el "complemento de parámetros Git" .

Agregar un nombre como "SELECT_BRANCH" ## Asegúrese de que esta variable sea utilizada más adelante. Entonces tipo de parámetro: Rama

Luego, comuníquese con SCM: Seleccione: Git y especificador de sucursal: $ {SELECT_BRANCH}

Para verificar, ejecuta debajo en shell en jenkins:

echo $ {SELECT_BRANCH}

descripción de la imagen env.enter aquí

Answer 2

Intenté un par de respuestas mencionadas en este enlace, pero no pude encontrar la manera de decirle a Jenkins sobre la sucursal seleccionada por el usuario. Como mencioné en mi comentario anterior en el hilo anterior, había dejado el campo selector de ramas vacío.

Pero, durante otras investigaciones, encontré otra forma de hacer lo mismo: https://wiki.jenkins-ci.org/display/JENKINS/Git+Parameter+Plugin Encontré que este método era mucho más simple y tenía menos cosas ¡para configurar!

Esto es lo que configuré -

1. Instalado el plugin de parámetro git
2. Comprueba el ''Esta construcción está parametrizada'' y agrega un ''Parámetro Git''

3. Se agregaron los siguientes valores:

4. Luego, en la sección git SCM del trabajo, agregué el mismo valor mencionado en la sección ''Nombre'', como si fuera una variable de entorno. (Si lees detenidamente la ayuda para este plugin de parámetro git, te darás cuenta de esto)

Después de esto, simplemente ejecuté la compilación, elegí mi rama (Jenkins revisa esta rama antes de construirla) y completó la compilación con éxito, Y al elegir la rama que había especificado.

Answer 3

La siguiente secuencia de comandos groovy sería útil, si su trabajo no utiliza directamente la "Gestión de código fuente" (como también el "Complemento de parámetros de Git"), sino que todavía tiene acceso a un repositorio de git local (clonado):

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()

Vea la explicación completa aquí: https://.com/a/37810768/658497

Answer 4

Para mí, uso el param de etapa de entrada:

1. Comienzo mi tubería revisando el proyecto git.
2. Uso un awk commade para generar un archivo barnch.txt con una lista de todas las ramas
3. En el escenario setps, leo el archivo y lo uso para generar un parámetro de elección de entrada

Cuando un usuario inicia una interconexión, esta le estará esperando para elegir en la lista de opciones.

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

}

Y luego el usuario interactuará con la versión:

enter image description here

enter image description here

Answer 5

Podemos eliminar la lectura / escritura de archivos innecesarios mediante el uso de text . Mi solución completa es la siguiente:

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();

Answer 6

Pude lograr este resultado usando el plugin de parámetros dinámicos de Jenkins . Utilicé la opción Parámetro de elección dinámica y, para el script de opciones, utilicé lo siguiente:

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()

Answer 7

Puede lograr lo mismo utilizando el plugin de parámetros de opción extendida antes mencionado por malenkiy_scot y un script php simple de la siguiente manera (suponiendo que tenga un servidor en algún lugar para implementar scripts de PHP que puede ejecutar desde la máquina Jenkins)

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

o

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

Con la primera opción, necesitaría clonar el repositorio. Con el segundo no lo haces, pero en ambos casos necesitas instalar git en el servidor que aloja tu script php. Si cualquiera de estas opciones se vuelve completamente dinámica, no necesita construir un archivo de lista. Simplemente coloque la URL en su secuencia de comandos en el campo de parámetro de opción extendida "archivo de propiedades".

Answer 8

Sí, escribí un pequeño guión maravilloso que hace el truco. Debe agregar un ''Parámetro de elección dinámica'' a su trabajo y personalizar el siguiente guión maravilloso según sus necesidades:

#!/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()

En mi caso, la cadena de versión estaba en el siguiente formato XXXX y podría tener ramas de usuario en el formato XXX-nombre de usuario, etc. Así que tuve que escribir mi propia función de clasificación. Este fue mi primer guión maravilloso, así que si hay mejores formas de hacer las cosas, me gustaría saberlo.

Answer 9

expandiendo la respuesta de @ malenkiy_scot Creé un nuevo trabajo de jenkins para compilar el archivo que usa Extended Choice Plugin.

puedes hacer lo siguiente (lo hice como ejecutar pasos de shell en jenkins, pero podrías hacerlo en un script):

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

A continuación, utilizo el plugin de despliegue Artifact para enviar ese archivo a una ubicación compartida, que está en una url web, luego simplemente uso ''http: //localhost/branches.txt'' en el complemento Extended Choice como la url. Funciona de maravilla.

Answer 10

El plugin de parámetro de opción extendida le permitirá leer las opciones de un archivo.

Por supuesto, ahora usted tiene otro problema: cómo asegurarse de que el archivo esté actualizado (lo que se puede hacer con un enganche post-commit) y propagado a todos los usuarios (esto se puede hacer colocándolo en un compartimiento compartido). servidor de archivos). Pero puede haber mejores soluciones.