web-dev-qa-db-fra.com

Comment accéder aux paramètres dans une construction paramétrée?

Comment accéder à parameters défini dans la section "Cette construction est paramétrée" d'un travail Jenkins "Workflow"?

CAS DE TEST  

  1. Créez un travail WORKFLOW.
  2. Activer "Cette construction est paramétrée".
  3. Ajoutez une STRING PARAMETER foo avec la valeur par défaut bar text.

  4. Ajoutez le code ci-dessous à Workflow Script:

    node()
{
     print "DEBUG: parameter foo = ${env.foo}"
}
  5. Exécuter le travail.

RÉSULTAT

DEBUG: parameter foo = null

jenkinsgroovyjenkins-pipeline
47
Vizionz

Je pense que la variable est disponible directement, plutôt que via env, lorsque vous utilisez le plugin Workflow . Essayez:

node()
{
    print "DEBUG: parameter foo = ${foo}"
}
65
Nick

J'ai essayé quelques-unes des solutions de ce fil. Cela semblait fonctionner, mais mes valeurs étaient toujours vraies et j'ai également rencontré le problème suivant: JENKINS-40235

J'ai réussi à utiliser des paramètres dans groovy jenkinsfile en utilisant la syntaxe suivante: params.myVariable

Voici un exemple de travail:

Solution

print 'DEBUG: parameter isFoo = ' + params.isFoo
print "DEBUG: parameter isFoo = ${params.isFoo}"

Un exemple plus détaillé (et fonctionnel):

node() {
   // adds job parameters within jenkinsfile
   properties([
     parameters([
       booleanParam(
         defaultValue: false,
         description: 'isFoo should be false',
         name: 'isFoo'
       ),
       booleanParam(
         defaultValue: true,
         description: 'isBar should be true',
         name: 'isBar'
       ),
     ])
   ])

   // test the false value
   print 'DEBUG: parameter isFoo = ' + params.isFoo
   print "DEBUG: parameter isFoo = ${params.isFoo}"
   sh "echo sh isFoo is ${params.isFoo}"
   if (params.isFoo) { print "THIS SHOULD NOT DISPLAY" }

   // test the true value
   print 'DEBUG: parameter isBar = ' + params.isBar
   print "DEBUG: parameter isBar = ${params.isBar}"
   sh "echo sh isBar is ${params.isBar}"
   if (params.isBar) { print "this should display" }
}

Sortie

[Pipeline] {
[Pipeline] properties
WARNING: The properties step will remove all JobPropertys currently configured in this job, either from the UI or from an earlier properties step.
This includes configuration for discarding old builds, parameters, concurrent builds and build triggers.
WARNING: Removing existing job property 'This project is parameterized'
WARNING: Removing existing job property 'Build triggers'
[Pipeline] echo
DEBUG: parameter isFoo = false
[Pipeline] echo
DEBUG: parameter isFoo = false
[Pipeline] sh
[wegotrade-test-job] Running Shell script
+ echo sh isFoo is false
sh isFoo is false
[Pipeline] echo
DEBUG: parameter isBar = true
[Pipeline] echo
DEBUG: parameter isBar = true
[Pipeline] sh
[wegotrade-test-job] Running Shell script
+ echo sh isBar is true
sh isBar is true
[Pipeline] echo
this should display
[Pipeline] }
[Pipeline] // node
[Pipeline] End of Pipeline
Finished: SUCCESS

J'ai envoyé un Requête Pull pour mettre à jour le trompeur tutoriel de pipeline # build-parameters quote qui indique "ils sont accessibles en tant que variables Groovy du même nom". ;)

Edit: Comme Jesse Glick l’a souligné: Notes de mise à jour aller dans plus de détails

Vous devez également mettre à jour le plug-in Pipeline Job Plugin vers la version 2.7 ou une version ultérieure, de sorte que les paramètres de construction soient définis en tant que variables d'environnement et donc accessibles comme s'il s'agissait de variables globales Groovy.

47
GabLeRoux

Lorsque vous ajoutez un paramètre de construction, foo, , Il est converti en quelque chose qui agit comme une "variable nue", Ainsi, dans votre script, vous feriez:

node {
   echo foo
}

Si vous regardez l'implémentation du script de flux de travail, vous verrez que lorsqu'un script est exécuté, une classe appelée WorkflowScript est générée dynamiquement Toutes les instructions du script sont exécutées dans le contexte de cette classe. Tous les paramètres de construction transmis à ce script sont convertis en propriétés accessibles à partir de cette classe.

Par exemple, vous pouvez faire:

node {
    getProperty("foo")
}

Si vous êtes curieux, voici un script de flux de travail que j'ai écrit et qui tente d’imprimer les paramètres de construction, les variables d’environnement et les méthodes de la classe WorkflowScript.

node {
   echo "I am a "+getClass().getName()

   echo "PARAMETERS"
   echo "=========="
   echo getBinding().getVariables().getClass().getName()
   def myvariables = getBinding().getVariables()
   for (v in myvariables) {
       echo "${v} " + myvariables.get(v)
   }
   echo STRING_PARAM1.getClass().getName()

   echo "METHODS"
   echo "======="
   def methods = getMetaClass().getMethods()

   for (method in methods) {
       echo method.getName()    
   } 

   echo "PROPERTIES"
   echo "=========="
   properties.each{ k, v -> 
       println "${k} ${v}" 
   }
   echo properties
   echo properties["class"].getName()

   echo "ENVIRONMENT VARIABLES"
   echo "======================"
   echo "env is " + env.getClass().getName()
   def envvars = env.getEnvironment()
   envvars.each{ k, v ->
        println "${k} ${v}"
   }
}

Voici un autre exemple de code que j'ai essayé, où je voulais tester pour voir Si un paramètre de construction était défini ou non.

node {
   groovy.lang.Binding myBinding = getBinding()
   boolean mybool = myBinding.hasVariable("STRING_PARAM1")
   echo mybool.toString()
   if (mybool) {
       echo STRING_PARAM1
       echo getProperty("STRING_PARAM1")
   } else {
       echo "STRING_PARAM1 is not defined"
   }

   mybool = myBinding.hasVariable("DID_NOT_DEFINE_THIS")
   if (mybool) {
       echo DID_NOT_DEFINE_THIS
       echo getProperty("DID_NOT_DEFINE_THIS")
   } else {
       echo "DID_NOT_DEFINE_THIS is not defined"
   }
}
11
Craig Rodrigues

Pour paramétrer la variable, ajoutez le préfixe "params" Par exemple:

params.myParam

N'oubliez pas: si vous utilisez une méthode de myParam, vous devez peut-être l'approuver dans "Approbation du script".

6
burtsevyg

Utilisez des guillemets doubles au lieu de guillemets simples

par exemple. echo "$foo" par opposition à echo '$foo'

Si vous avez configuré votre pipeline pour accepter les paramètres à l'aide de l'option Construire avec les paramètres, ces paramètres sont accessibles en tant que variables Groovy du même nom. Voir Ici .

Vous pouvez supprimer le point-virgule (;), les parenthèses (( and )) et utiliser des guillemets simples (') au lieu de doubles (") si vous n'avez pas besoin de remplacer les variables. Voir Ici . Cela m’a fait comprendre mon problème, bien que j’ai constaté que seul le double (") est nécessaire pour que cela fonctionne.

5
Ken Goodridge

L'extrait suivant vous donne accès à tous les paramètres du travail

    def myparams = currentBuild.rawBuild.getAction(ParametersAction)
    for( p in myparams ) {
        pMap[p.name.toString()] = p.value.toString()
    }
2
ScaryGhast

Veuillez noter que la manière dont les paramètres de construction sont utilisés dans les scripts de pipeline (plug-in de pipeline) a changé. Cette approche:

getBinding().hasVariable("MY_PARAM")

Ne fonctionne plus. S'il vous plaît essayez ceci à la place:

def myBool = env.getEnvironment().containsKey("MY_BOOL") ? Boolean.parseBoolean("$env.MY_BOOL") : false
2
Maksim

J'espère que le code suivant fonctionnera pour vous:

def item = hudson.model.Hudson.instance.getItem('MyJob')

def value = item.lastBuild.getEnvironment(null).get('foo')
1
DevD

Vous pouvez également essayer d’utiliser parameters directive pour paramétrer votre construction et accéder aux paramètres:

Doc: Syntaxe du pipeline: Paramètres

Exemple:

pipeline{

agent { node { label 'test' } }
options { skipDefaultCheckout() }

parameters {
    string(name: 'suiteFile', defaultValue: '', description: 'Suite File')
}
stages{

    stage('Initialize'){

        steps{

          echo "${params.suiteFile}"

        }
    }
 }
0
Shivankur Pal

Selon Tutoriel du plug-in Pipeline :

Si vous avez configuré votre pipeline pour accepter les paramètres lors de sa construction - Construire avec les paramètres - ils sont accessibles en tant que Groovy variables du même nom.

Essayez donc d’accéder directement à la variable, par exemple:

node()
{
     print "DEBUG: parameter foo = " + foo
     print "DEBUG: parameter bar = ${bar}"
}
0
kenorb