Jenkins 1.x

Question

我认为这是另一个简单的问题，但我无法使用任何网络解决方案。我的项目采用版本号。每个数字可以用'。'分隔。或'_'。我想要一个只显示前两个数字的变量。

我尝试编写一个创建Jenkins环境变量的groovy脚本我想取前两位而不是整个字符串。

//Get the version parameter
def env = System.getenv()
def version = env['currentversion']
def m = version =~/\d{1,2}/
env = ['miniVersion':m[0].m[1]]

我是否正确地执行此操作，我是否可以创建新的环境变量，并且有更好的解决方案。

Answer 1

Jenkins 1.x

以下groovy代码段应该通过版本（正如您已经提供的那样），并将其存储在作业的变量中作为＆＃39; miniVersion＆＃39;。

import hudson.model.*

def env = System.getenv()
def version = env['currentversion']
def m = version =~/\d{1,2}/
def minVerVal = m[0]+"."+m[1]

def pa = new ParametersAction([
  new StringParameterValue("miniVersion", minVerVal)
])

// add variable to current job
Thread.currentThread().executable.addAction(pa)

然后可以从其他构建步骤访问该变量。 e.g。

echo miniVersion=%miniVersion%

输出：

miniVersion=12.34

我相信您需要使用＆＃34; System Groovy Script＆＃34; （仅在主节点上）而不是＆＃34; Groovy插件＆＃34; - https://wiki.jenkins-ci.org/display/JENKINS/Groovy+plugin#Groovyplugin-GroovyScriptvsSystemGroovyScript

Jenkins 2.x

我认为之前的（ Jenkins 1.x ）行为因this Security Advisory而停止工作...

解决方案（从安全通报中解释）

通过将系统属性hudson.model.ParametersAction.keepUndefinedParameters设置为true，可以恢复以前的行为。 这可能非常不安全，仅作为短期解决方法。

java -Dhudson.model.ParametersAction.keepUndefinedParameters=true -jar jenkins.war

要允许将特定的已知安全参数名称传递给构建，请将系统属性hudson.model.ParametersAction.safeParameters设置为以逗号分隔的安全参数名称列表。

<强> e.g。

java -Dhudson.model.ParametersAction.safeParameters=miniVersion,FOO,BAR -jar jenkins.war

Answer 2

您还可以在Groovy系统脚本中定义不带EnvInject插件的变量：

import hudson.model.*
def build = Thread.currentThread().executable
def pa = new ParametersAction([
  new StringParameterValue("FOO", "BAR")
])
build.addAction(pa)

然后，您可以在下一个构建步骤中访问此变量，其中（例如）是一个Windows批处理命令：

@echo off
Setlocal EnableDelayedExpansion
echo FOO=!FOO!

此回音将显示“FOO = BAR”。

此致

Answer 3

詹金斯EnvInject Plugin也许可以帮助你。它允许将环境变量注入构建环境。

我知道它有一些编写脚本的能力，所以它可能能够做你想要的。我只用它来设置简单的属性（例如“LOG_PATH = $ {WORKSPACE} \ logs”）。

Answer 4

作为其他答案状态设置新ParametersAction是注入一个或多个环境变量的方式，但当作业已经参数化时添加新操作不会生效。相反，您会看到指向同一组参数的构建参数的两个链接，而您要添加的参数将是null。

以下是在两种情况下更新参数列表的片段（参数化和非参数化作业）：

import hudson.model.*

def build = Thread.currentThread().executable

def env = System.getenv()
def version = env['currentversion']
def m = version =~/\d{1,2}/
def minVerVal = m[0]+"."+m[1]

def newParams = null

def pl = new ArrayList<StringParameterValue>()
pl.add(new StringParameterValue('miniVersion', miniVerVal))

def oldParams = build.getAction(ParametersAction.class)

if(oldParams != null) {
  newParams = oldParams.createUpdated(pl)
  build.actions.remove(oldParams)
} else {
  newParams = new ParametersAction(pl)
}

build.addAction(newParams)

Answer 5

对我来说，以下内容也适用于Jenkins 2（2.73.3）

替换

def pa = new ParametersAction([new StringParameterValue("FOO", foo)])
build.addAction(pa)

与

def pa = new ParametersAction([new StringParameterValue("FOO", foo)], ["FOO"])
build.addAction(pa)

ParametersAction似乎有第二个构造函数允许传入“additionalSafeParameters”https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/ParametersAction.java

Answer 6

在搜索了一下之后，我认为最好的解决方案是使用hudson.model.EnvironmentContributingAction。

import hudson.model.EnvironmentContributingAction
import hudson.model.AbstractBuild 
import hudson.EnvVars

class BuildVariableInjector {

    def build
    def out

    def BuildVariableInjector(build, out) {
        this.build = build
        this.out = out
    }

    def addBuildEnvironmentVariable(key, value) {
        def action = new VariableInjectionAction(key, value)
        build.addAction(action)
        //Must call this for action to be added
        build.getEnvironment()
    }

    class VariableInjectionAction implements EnvironmentContributingAction {

        private String key
        private String value

        public VariableInjectionAction(String key, String value) {
            this.key = key
            this.value = value
        }

        public void buildEnvVars(AbstractBuild build, EnvVars envVars) {

            if (envVars != null && key != null && value != null) {
                envVars.put(key, value);
            }
        }

        public String getDisplayName() {
            return "VariableInjectionAction";
        }

        public String getIconFileName() {
            return null;
        }

        public String getUrlName() {
            return null;
        }
    }    
}

我在作业中的系统groovy脚本（使用groovy插件）中使用此类。

import hudson.model.*
import java.io.File;
import jenkins.model.Jenkins;    

def jenkinsRootDir = build.getEnvVars()["JENKINS_HOME"];
def parent = getClass().getClassLoader()
def loader = new GroovyClassLoader(parent)

def buildVariableInjector = loader.parseClass(new File(jenkinsRootDir + "/userContent/GroovyScripts/BuildVariableInjector.groovy")).newInstance(build, getBinding().out)

def projectBranchDependencies = [] 
//Some logic to set projectBranchDependencies variable

buildVariableInjector.addBuildEnvironmentVariable("projectBranchDependencies", projectBranchDependencies.join(","));

然后，您可以在我的案例中从ANT脚本访问构建中任何其他位置的projectBranchDependencies变量。

注意：我从博客文章中借用/修改了部分实现的想法，但在发布时我无法找到原始来源以便给予应有的信任。

Answer 7

刚刚遇到同样的问题。希望根据一些groovy脚本的结果动态触发参数化的下游作业。

不幸的是，在我们的Jenkins上，它无法运行System Groovy脚本。因此，我必须做一个小的解决方法：

运行groovy脚本，创建一个属性文件，指定要设置的环境变量
```
Inject environment variable
Property file path: properties.text
```
使用env inject插件注入写入此脚本的变量
```
validates :some_checkbox, :acceptance => true
```

之后我就可以使用变量＆＃39; foo＆＃39;作为参数化触发器插件的参数。某种解决方法。但是有效！

Answer 8

我的环境是先前的工具，如Jenkins，并且正在运行批处理文件（我知道，我已经老了）。所以那些批处理文件（及其子批处理文件）正在使用环境变量。这是我的一个groovy脚本，它注入了环境变量。使用的名称和参数是虚拟的。

// The process/batch which uses environment variables
def buildLabel = "SomeVersionNr"
def script = "startBuild.bat"
def processBuilder = new ProcessBuilder(script, buildLabel)

//Inject our environment variables
Map<String, String> env = processBuilder.environment()
env.put("ProjectRoot", "someLocation")
env.put("SomeVar", "Some")

Process p = processBuilder.start()
p.waitFor()

当然，如果你从头开始设置Jenkins，你可能会采用不同的方式，以另一种方式共享变量，或传递参数，但这可能会派上用场。

Answer 9

在我这方面，它只能通过替换现有参数来工作。

def artifactNameParam = new StringParameterValue('CopyProjectArtifactName', 'bla bla bla')
build.replaceAction(new ParametersAction(artifactNameParam))

此外，此脚本必须以系统常规运行。

必须在该系统上手动安装groovy，并且groovy的 bin 目录必须添加到 path 。另外，在 lib 文件夹中，我还必须添加 jenkins-core.jar 。

然后可以在groovy脚本中修改参数并在继续工作后在批处理脚本中获取修改后的值。

Answer 10

对我来说，以下内容适用于Jenkins 2.190.1，并且比其他一些解决方法简单得多：

matcher = manager.getLogMatcher('^.*Text we want comes next: (.*)$');

if (matcher.matches()) {
    def myVar = matcher.group(1);
    def envVar = new EnvVars([MY_ENV_VAR: myVar]);
    def newEnv = Environment.create(envVar);
    manager.build.environments.add(0, newEnv);
    // now the matched text from the LogMatcher is passed to an
    // env var we can access at $MY_ENV_VAR in post build steps
}

这使用了Groovy Script插件，而对Jenkins没有任何其他更改。

使用Groovy创建Jenkins环境变量

10 个答案:

Jenkins 1.x

Jenkins 2.x

解决方案（从安全通报中解释）