smart - plugin de groovy descargar

Creando una variable de entorno Jenkins usando Groovy

Question

Creo que esta es otra pregunta simple, pero no pude conseguir que ninguna de las soluciones web funcionara. Mi proyecto tiene un número de versión. Cada número puede estar separado por un ''.'' o un ''_''. Quiero una variable que solo muestre los dos primeros números.

Traté de escribir una secuencia de comandos groovy que crea una variable de entorno de Jenkins.
Quiero tomar los primeros dos dígitos en lugar de toda la cadena.

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

¿Estoy haciendo esto correctamente, puedo incluso crear una nueva variable de entorno y hay una mejor solución para esto?

Answer 1

Jenkins 1.x

El siguiente fragmento maravilloso debe pasar la versión (como ya lo ha proporcionado) y almacenarla en las variables del trabajo como ''miniVersión''.

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)

La variable será accesible desde otros pasos de compilación. p.ej

echo miniVersion=%miniVersion%

Productos:

miniVersion=12.34

Creo que necesitarás usar el "Script de Groovy del sistema" (en el nodo Maestro solamente) en lugar del "Complemento Groovy" - https://wiki.jenkins-ci.org/display/JENKINS/Groovy+plugin#Groovyplugin-GroovyScriptvsSystemGroovyScript

Jenkins 2.x

Creo que el comportamiento anterior ( Jenkins 1.x ) dejó de funcionar debido a este Aviso de seguridad ...

Solución (parafraseada del Advisory de seguridad)

Es posible restablecer el comportamiento anterior estableciendo la propiedad del sistema hudson.model.ParametersAction.keepUndefinedParameters en true . Esto es potencialmente muy inseguro y solo como una solución a corto plazo.

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

Para permitir el paso de los nombres de parámetros seguros conocidos y específicos a las construcciones, establezca la propiedad del sistema hudson.model.ParametersAction.safeParameters en una lista de nombres de parámetros seguros separados por comas.

p.ej

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

Answer 2

Como otras respuestas indican el ajuste de nuevos ParametersAction la acción es la forma de inyectar una o más variables de entorno, pero cuando un trabajo ya está parametrizado, agregar nuevas acciones no tendrá efecto. En cambio, verá dos enlaces a los parámetros de compilación que apuntan al mismo conjunto de parámetros y el que desea agregar será null .

Aquí hay un fragmento que actualiza la lista de parámetros en ambos casos (un trabajo parametrizado y no 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<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 3

Después de buscar un poco, la mejor solución en mi opinión utiliza 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;
}
}
}

Utilizo esta clase en una secuencia de comandos groovy del sistema (usando el plugin groovy) dentro de un trabajo.

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

A continuación, puede acceder a la variable projectBranchDependencies en cualquier otro punto de su compilación, en mi caso, desde un script ANT.

Nota: Tomé prestada / modifiqué las ideas para partes de esta implementación de una publicación de blog, pero en el momento de esta publicación no pude encontrar la fuente original para dar el debido crédito.

Answer 4

El plugin EnvInject de Jenkins podría ayudarte. Permite inyectar variables de entorno en el entorno de compilación.

Sé que tiene cierta capacidad para hacer scripts, por lo que podría hacer lo que quiera. Solo lo he usado para establecer propiedades simples (por ejemplo, "LOG_PATH = $ {WORKSPACE} / logs").

Answer 5

Mi entorno era herramientas anteriores como Jenkins y se ejecutaba con archivos por lotes (lo sé, soy viejo). Entonces esos archivos por lotes (y sus archivos sub-batch) están usando variables de entorno. Esta fue mi pieza de script groovy que inyecta variables de entorno. Los nombres y parámetros utilizados son ficticios.

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

Por supuesto, si configuras Jenkins desde cero, probablemente lo harías de manera diferente y compartirías las variables de otra manera, o pasarás parámetros, pero esto podría ser útil.

Answer 6

Para mí, lo siguiente también funcionó en Jenkins 2 (2.73.3)

Reemplazar

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

con

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

ParametersAction parece tener un segundo constructor que permite pasar "additionalSafeParameters" https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/ParametersAction.java

Answer 7

Solo tuve el mismo problema. Quería activar dinámicamente tareas downstream parametrizadas basadas en el resultado de algunas secuencias de comandos groovy.

Desafortunadamente en nuestro Jenkins no es posible ejecutar scripts de System Groovy. Por lo tanto, tuve que hacer una pequeña solución:

1. Ejecute script groovy que crea un archivo de propiedades donde se especifica la variable de entorno que se va a establecer

   def props = new File("properties.text")
   if (props.text == ''foo=bar'') {
   props.text = ''foo=baz''
   } else {
   props.text = ''foo=bar''
   }

2. Use el plugin env injection para inyectar la variable escrita en este script

   Inject environment variable
   Property file path: properties.text

Después de eso, pude usar la variable ''foo'' como parámetro para el plugin de gatillo parametrizado. Algún tipo de solución. ¡Pero funciona!

Answer 8

También puede definir una variable sin el complemento EnvInject dentro de su secuencia de comandos del sistema Groovy:

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

Luego puede acceder a esta variable en el siguiente paso de compilación, que (por ejemplo) es un comando de lote de Windows:

@echo off
Setlocal EnableDelayedExpansion
echo FOO=!FOO!

Este eco te mostrará "FOO = BAR".

Saludos