Création D'une variable D'environnement Jenkins en utilisant Groovy
je pense que c'est une autre question simple, mais je n'ai pas pu faire fonctionner les solutions web. Mon projet prend un numéro de version. Chaque numéro peut être séparé par un '.'ou un '_'. Je veux une variable qui n'affiche que les deux premiers nombres.
j'ai essayé d'écrire un script groovy qui crée une variable D'environnement Jenkins.
Je veux prendre les deux premiers chiffres au lieu de la chaîne entière.
//Get the version parameter
def env = System.getenv()
def version = env['currentversion']
def m = version =~/d{1,2}/
env = ['miniVersion':m[0].m[1]]
Est-ce que je fais cela correctement, puis-je même créer une nouvelle variable d'environnement, et il y a une meilleure solution à cela.
8 réponses
Jenkins 1.x
l'extrait de groovy suivant doit passer la version (comme vous l'avez déjà fourni), et la stocker dans les variables du travail comme '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)
La variable sera alors accessible à partir d'autres étapes de génération. par exemple,
echo miniVersion=%miniVersion%
Sorties:
miniVersion=12.34
je crois que vous aurez besoin d'utiliser le "Script de Groovy système" (sur le noeud maître seulement) par opposition au " Plugin de Groovy" - https://wiki.jenkins-ci.org/display/JENKINS/Groovy+plugin#Groovyplugin-GroovyScriptvsSystemGroovyScript
Jenkins 2.x
je crois que la précédente ( Jenkins 1.x) le comportement a cessé de fonctionner à cause de cet avis de Sécurité...
la Solution (reformulation de l'avis de Sécurité)
il est possible de restaurer le comportement précédent en définissant la propriété du système hudson.model.ParametersAction.keepUndefinedParameters
true
. C'est potentiellement très dangereux et n'est destiné qu'à une solution à court terme.
java -Dhudson.model.ParametersAction.keepUndefinedParameters=true -jar jenkins.war
pour permettre à des noms de paramètres de sécurité spécifiques et connus d'être passés à des constructions, définissez la propriété du système hudson.model.ParametersAction.safeParameters
à une liste de noms de paramètres de sécurité séparés par des virgules.
e.g.
java -Dhudson.model.ParametersAction.safeParameters=miniVersion,FOO,BAR -jar jenkins.war
import hudson.model.*
def build = Thread.currentThread().executable
def pa = new ParametersAction([
new StringParameterValue("FOO", "BAR")
])
build.addAction(pa)
alors vous pouvez accéder à cette variable dans la prochaine étape de construction qui (par exemple) est une commande Windows batch:
@echo off
Setlocal EnableDelayedExpansion
echo FOO=!FOO!
cet écho vous montrera "FOO=BAR".
Les Jenkins Plugin EnvInject peut-être être en mesure de vous aider. Il permet d'injecter des variables d'environnement dans l'environnement de compilation.
je sais qu'il a une capacité à faire de script, de sorte qu'il pourrait être en mesure de faire ce que vous voulez. Je ne l'ai utilisé que pour définir des propriétés simples (par exemple "LOG_PATH=${WORKSPACE}\logs").
Comme d'autres réponses paramètre état de new ParametersAction
est la façon d'injecter une ou plusieurs variables d'environnement,mais lorsqu'un travail est déjà paramétré, l'ajout de nouvelles actions n'aura pas d'effet. Au lieu de cela, vous verrez deux liens vers des paramètres de construction pointant vers le même ensemble de paramètres et celui que vous vouliez ajouter sera null
.
voici un extrait mettant à jour la liste des paramètres dans les deux cas (une tâche paramétrée et non paramétrée):
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)
Remplacer
def pa = new ParametersAction([new StringParameterValue("FOO", foo)])
build.addAction(pa)
def pa = new ParametersAction([new StringParameterValue("FOO", foo)], ["FOO"])
build.addAction(pa)
ParametersAction semble avoir un second constructeur qui permet de passer dans "additionalSafeParameters" https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/ParametersAction.java
après quelques recherches, la meilleure solution à mon avis fait usage de hudson.modèle.Environnementcontributionaction.
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;
}
}
}
j'utilise cette classe dans un script de groovy système (en utilisant le plugin de groovy) dans le cadre d'un travail.
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(","));
vous pouvez alors accéder à la variable projectBranchDependencies à tout autre point de votre compilation, dans mon cas, à partir d'un script ANT.
Note: j'ai emprunté / modifié les idées pour certaines parties de cette implémentation à partir d'un billet de blog, mais au moment de cette publication, je n'ai pas été en mesure de localiser la source originale afin d'en donner le crédit.
Juste eu le même problème. Voulu dynamiquement déclencher des travaux paramétrés en aval basés sur le résultat d'un certain groovy scripting.
malheureusement sur notre Jenkins il n'est pas possible d'exécuter des scripts de Groovy système. Par conséquent, j'ai dû faire un petit contournement:
Exécuter groovy script crée un fichier de propriétés où la variable d'environnement est spécifié
def props = new File("properties.text") if (props.text == 'foo=bar') { props.text = 'foo=baz' } else { props.text = 'foo=bar' }
Utilisez env injecter le plugin pour injecter variable écrite dans ce script
Inject environment variable Property file path: properties.text
après cela j'ai pu utiliser la variable 'foo' comme paramètre pour le plugin de déclenchement paramétré. Une sorte de solution de contournement. Mais des travaux!
mon environnement était avant tooling tel que Jenkins et fonctionnait avec des fichiers batch (je sais, je suis vieux). Donc ces fichiers de lots (et leurs fichiers de sous-lots) utilisent des variables d'environnement. C'était mon morceau de script groovy qui injecte des variables d'environnement. Les noms et les paramètres utilisés sont factices.
// 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()
bien sûr, si vous positionnez Jenkins à partir de zéro, vous le feriez probablement différemment et partageriez les variables d'une autre manière, ou passer des paramètres mais ceci pourrait venir à portée de main.