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

comment accéder parameters dans la section "Cette construction est paramétrée" d'un travail Jenkins "flux de travail"?

TEST CASE

  1. créer un travail de flux de travail.
  2. activer "cette construction est paramétrée".
  3. Ajouter un paramètre STRING foo avec la valeur par défaut bar text.
  4. ajouter le code ci-dessous à Workflow Script:

    node()
    {
         print "DEBUG: parameter foo = ${env.foo}"
    }
    
  5. courir emploi.

RESULT

DEBUG: parameter foo = null

45
demandé sur Jesse Glick 2015-02-18 01:10:58

9 réponses

je pense que la variable est disponible directement, plutôt que par le biais d'env, lors de L'utilisation du plugin Workflow. À essayer:

node()
{
    print "DEBUG: parameter foo = ${foo}"
}
62
répondu Nick 2015-03-27 12:19:44

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

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

Voici un exemple:

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

je envoyé un Pull Request mettre à jour le trompeur tutorial pipeline#build-parameters citation qui dit "ils sont accessibles comme des variables Groovy du même nom.". ;)

Edit: comme L'a souligné Jesse Glick: notes de mise à jour aller dans plus de détails

vous devriez également mettre à jour le Plugin de travail de Pipeline à 2.7 ou plus tard, de sorte que les paramètres de construction soient définis comme des variables d'environnement et donc accessibles comme s'il s'agissait de variables globales Groovy.

43
répondu GabLeRoux 2017-02-10 13:25:45

lorsque vous ajoutez un paramètre de construction, foo, il est converti en quelque chose qui agit comme un "nu variable", donc 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és dynamiquement. Toutes les déclarations contenues dans le 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 qui sont accessible à 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 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 a été 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"
   }
}
9
répondu Craig Rodrigues 2015-12-29 23:34:39

au paramètre variable ajouter le préfixe " params." Par exemple:

params.myParam

N'oubliez pas: si vous utilisez une méthode de myParam, vous devriez peut-être l'approuver dans "Script approval".

5
répondu burtsevyg 2017-04-04 07:52:34

utilisez des guillemets doubles au lieu de guillemets simples

e.g. echo "$foo" plutôt pour echo '$foo'

si vous avez configuré votre pipeline pour accepter des paramètres en utilisant L'option Build with Parameters, ces paramètres sont accessibles en tant que variables Groovy du même nom. Voir Ici.

vous pouvez laisser tomber le point-virgule (;), supprimer les parenthèses (( and )), et utilisez des guillemets simples (') au lieu de double (") si vous n'avez pas besoin de effectuer des substitutions variables. Voir Ici. Cela m'a impliqué dans mon problème, bien que j'ai trouvé que seulement le double (") est nécessaire pour le faire fonctionner.

4
répondu Ken Goodridge 2018-01-02 11:06:29

veuillez noter que la façon d'accéder aux paramètres de construction dans les scripts de pipeline (pipeline plugin) a changé. Cette approche:

getBinding().hasVariable("MY_PARAM")

ne fonctionne plus. Veuillez essayer ceci à la place:

def myBool = env.getEnvironment().containsKey("MY_BOOL") ? Boolean.parseBoolean("$env.MY_BOOL") : false
2
répondu Maksim 2018-01-02 11:05:15

j'Espère que le morceau de code suivant fonctionne pour vous:

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

def value = item.lastBuild.getEnvironment(null).get('foo')
1
répondu DevD 2015-02-18 07:37:01

L'extrait suivant vous donne accès à toutes les params de travail

    def myparams = currentBuild.rawBuild.getAction(ParametersAction)
    for( p in myparams ) {
        pMap[p.name.toString()] = p.value.toString()
    }
1
répondu ScaryGhast 2016-02-28 18:04:44

par plugin de Pipeline tutorial:

Si vous avez configuré votre pipeline pour accepter les paramètres quand il est construit - Construire avec les Paramètres qu'ils sont accessibles 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
répondu kenorb 2016-10-19 21:56:22