使用Groovy创建Jenkins环境变量

时间:2012-05-02 12:38:10

标签: groovy jenkins

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

我尝试编写一个创建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]]

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

10 个答案:

答案 0 :(得分:48)

Jenkins 1.x

以下groovy代码段应该通过版本(正如您已经提供的那样),并将其存储在作业的变量中作为' miniVersion'。

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

我相信您需要使用" System Groovy Script" (仅在主节点上)而不是" Groovy插件" - 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

答案 1 :(得分:19)

您还可以在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”。

此致

答案 2 :(得分:9)

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

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

答案 3 :(得分:9)

作为其他答案状态设置新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)

答案 4 :(得分:9)

对我来说,以下内容也适用于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

答案 5 :(得分:7)

在搜索了一下之后,我认为最好的解决方案是使用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变量。

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

答案 6 :(得分:4)

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

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

  1. 运行groovy脚本,创建一个属性文件,指定要设置的环境变量

    Inject environment variable
    Property file path: properties.text
    
  2. 使用env inject插件注入写入此脚本的变量

    validates :some_checkbox, :acceptance => true
    
  3. 之后我就可以使用变量&#39; foo&#39;作为参数化触发器插件的参数。某种解决方法。但是有效!

答案 7 :(得分:1)

我的环境是先前的工具,如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,你可能会采用不同的方式,以另一种方式共享变量,或传递参数,但这可能会派上用场。

答案 8 :(得分:0)

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

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

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

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

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

答案 9 :(得分:0)

对我来说,以下内容适用于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没有任何其他更改。