如何访问参数化构建中的参数？

Question

如何访问 "Workflow" Jenkins 作业的 "This build is parameterized" 部分中的 parameters 集？

测试用例

创建一个 WORKFLOW 作业。
启用"This build is parameterized".
使用默认值 bar text 添加字符串参数 foo。

将下面的代码添加到Workflow Script:

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

运行工作。

结果

DEBUG: parameter foo = null

Answer 1

希望以下代码对您有用：

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

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

Answer 2

我认为在使用 Workflow 插件时变量可以直接使用，而不是通过 env。尝试：

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

Answer 3

添加构建参数时，foo，它被转换成类似于 "bare variable" 的东西，所以在你的脚本中你会这样做：

node {
   echo foo
}

如果你查看工作流脚本的实现，你会发现当一个脚本被执行时，一个名为 WorkflowScript 的 class 动态生成的。脚本中的所有语句都在此 class 的上下文中执行。传递给此脚本的所有构建参数都转换为可从此 class.

访问的属性

例如，您可以这样做：

node {
    getProperty("foo")
}

如果你很好奇，这是我写的一个工作流脚本，它试图打印出 WorkflowScript 上的构建参数、环境变量和方法 class。

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}"
   }
}

这是我试过的另一个代码示例，我想测试一下是否设置了构建参数。

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"
   }
}

Answer 4

以下代码段可让您访问所有作业参数

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

Answer 5

使用双引号代替单引号

例如echo "$foo" 相对于 echo '$foo'

如果您使用带有参数的构建选项将管道配置为接受参数，则这些参数可以作为同名的 Groovy 变量访问。参见 Here。

您可以去掉分号 (;)，去掉括号 (( and ))，并使用单引号 (') 而不是双引号 (") 如果您不需要执行变量替换。参见 Here。这让我明白了我的问题，虽然我发现只需要双 (") 就可以让它工作。

Answer 6

根据Pipeline plugin tutorial：

If you have configured your pipeline to accept parameters when it is built — Build with Parameters — they are accessible as Groovy variables of the same name.

所以尝试直接访问变量，例如：

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

Answer 7

请注意，在管道脚本（管道插件）中访问构建参数的方式已更改。这种做法：

getBinding().hasVariable("MY_PARAM")

不再工作了。请试试这个：

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

Answer 8

我尝试了此线程中的一些解决方案。它似乎有效，但我的价值观始终是正确的，我也遇到了以下问题： JENKINS-40235

我设法使用以下语法在 groovy jenkinsfile 中使用参数：params.myVariable

这是一个工作示例：

解决方案

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

一个更详细（和有效）的例子：

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" }
}

输出

[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

我发送了一个 Pull Request to update the misleading pipeline tutorial#build-parameters 引用 "they are accessible as Groovy variables of the same name."。 ;)

编辑： 正如 Jesse Glick 指出的： Release notes 进入更多细节

You should also update the Pipeline Job Plugin to 2.7 or later, so that build parameters are defined as environment variables and thus accessible as if they were global Groovy variables.

Answer 9

给参数变量添加前缀"params." 例如：

params.myParam

不要忘记：如果您使用 myParam 的某些方法，可能您应该在 "Script approval" 中批准它。

Answer 10

您也可以尝试使用 parameters 指令使构建参数化并访问参数：

文档： Pipeline syntax: Parameters

示例：

pipeline{

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

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

    stage('Initialize'){

        steps{

          echo "${params.suiteFile}"

        }
    }
 }

如何访问参数化构建中的参数？

How to access parameters in a Parameterized Build?

groovy

jenkins

jenkins-pipeline

解决方案

一个更详细（和有效）的例子：

输出