Criando uma Variável de Ambiente Jenkins Usando o Groovy

Acho que essa é outra pergunta simples, mas não consegui que nenhuma das soluções da Web funcionasse. Meu projeto leva em um número de versão. Cada número pode ser separado por um ‘.’ ou um ‘_’. Eu quero uma variável que exibe apenas os dois primeiros números.

Eu tentei escrever um script groovy que cria uma variável de ambiente Jenkins.
Eu quero pegar os dois primeiros dígitos ao invés da string inteira.

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

Estou fazendo isso corretamente, posso criar uma nova variável de ambiente e há uma solução melhor para isso?

Jenkins 1.x

O seguinte trecho groovy deve passar a versão (como você já forneceu) e armazená-lo nas variables ​​do trabalho como ‘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) 

A variável será então acessível a partir de outras etapas de compilation. por exemplo

 echo miniVersion=%miniVersion% 

Saídas:

 miniVersion=12.34 

Eu acredito que você precisará usar o “System Groovy Script” (no nó mestre apenas) em oposição ao “Groovy Plugin” – https://wiki.jenkins-ci.org/display/JENKINS/Groovy+plugin# Groovyplugin-GroovyScriptvsSystemGroovyScript

Jenkins 2.x

Eu acredito que o comportamento anterior ( Jenkins 1.x ) parou de funcionar por causa deste aviso de segurança …

Solução (parafraseada do Security Advisory)

É possível restaurar o comportamento anterior definindo a propriedade do sistema hudson.model.ParametersAction.keepUndefinedParameters como true . Isso é potencialmente inseguro e destina-se apenas a uma solução alternativa de curto prazo.

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

Para permitir que nomes de parâmetros seguros conhecidos e específicos sejam passados ​​para compilações, defina a propriedade do sistema hudson.model.ParametersAction.safeParameters como uma lista separada por vírgulas de nomes de parâmetros seguros.

por exemplo

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

Você também pode definir uma variável sem o Plugin EnvInject dentro do seu Script do Sistema Groovy:

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

Então você pode acessar essa variável na próxima etapa de construção que (por exemplo) é um comando em lote do Windows:

 @echo off Setlocal EnableDelayedExpansion echo FOO=!FOO! 

Esse eco mostrará a você “FOO = BAR”.

Saudações

O plugin Jenkins EnvInject pode ajudá-lo. Permite injetar variables ​​de ambiente no ambiente de construção.

Eu sei que tem alguma capacidade de fazer scripts, por isso pode ser capaz de fazer o que quiser. Eu usei apenas para definir propriedades simples (por exemplo, “LOG_PATH = $ {WORKSPACE} \ logs”).

À medida que outras respostas definem, a nova ParametersAction é a maneira de injetar uma ou mais variables ​​de ambiente, mas quando uma tarefa já está parametrizada, a adição de uma nova ação não será efetivada. Em vez disso, você verá dois links para os parâmetros de construção que apontam para o mesmo conjunto de parâmetros e o que você deseja adicionar será null .

Aqui está um trecho atualizando a lista de parâmetros em ambos os casos (um trabalho parametrizado e não parametrizado):

 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() 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) 

Para mim, o seguinte também trabalhou em Jenkins 2 (2.73.3)

Substituir

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

com

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

ParametersAction parece ter um segundo construtor que permite passar em “additionalSafeParameters” https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/ParametersAction.java

Depois de pesquisar um pouco, a melhor solução na minha opinião faz uso do 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; } } } 

Eu uso essa class em um script groovy do sistema (usando o plugin groovy) dentro de um trabalho.

 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(",")); 

Você pode acessar a variável projectBranchDependencies em qualquer outro ponto da sua compilation, no meu caso, a partir de um script ANT.

Nota: Eu pedi emprestado / modifiquei as idéias para partes desta implementação a partir de um post de blog, mas no momento desta postagem eu não consegui localizar a fonte original para dar o devido crédito.

Apenas tive o mesmo problema. Desejava triggersr dinamicamente tarefas de downstream parametrizadas com base no resultado de alguns scripts interessantes.

Infelizmente no nosso Jenkins não é possível executar scripts do System Groovy. Portanto, tive que fazer uma pequena solução alternativa:

  1. Execute um script groovy que cria um arquivo de propriedades onde a variável de ambiente a ser definida é especificada

     def props = new File("properties.text") if (props.text == 'foo=bar') { props.text = 'foo=baz' } else { props.text = 'foo=bar' } 
  2. Use env plugin injet para injetar a variável escrita neste script

     Inject environment variable Property file path: properties.text 

Depois disso, pude usar a variável ‘foo’ como parâmetro para o plugin de trigger parametrizado. Algum tipo de solução alternativa. Mas funciona!

Meu ambiente era de ferramentas anteriores, como Jenkins e estava executando com arquivos em lote (eu sei, eu sou velho). Então, esses arquivos em lote (e seus arquivos sub-batch) estão usando variables ​​de ambiente. Este foi o meu pedaço de groovy script que injeta variables ​​de ambiente. Os nomes e parâmetros usados ​​são falsos.

 // 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 env = processBuilder.environment() env.put("ProjectRoot", "someLocation") env.put("SomeVar", "Some") Process p = processBuilder.start() p.waitFor() 

É claro que se você definir Jenkins a partir do zero, provavelmente fará de forma diferente e compartilhará as variables ​​de outra maneira, ou passará parâmetros, mas isso pode ser útil.