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.

28
demandé sur themaniac27 2012-05-02 16:38:09

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.keepUndefinedParameterstrue. 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
48
répondu Nick Grealy 2016-08-14 00:27:11
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".

18
répondu stede 2014-02-21 13:59:42

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").

9
répondu jwernerny 2012-05-02 14:00:35

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)
9
répondu Rajish 2014-09-11 20:37:35

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

6
répondu jammann 2018-01-22 09:01:45

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.

5
répondu TheEllis 2016-04-07 13:18:38

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:

  1. 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'
    }
    
  2. 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!

3
répondu Joerg S 2015-09-09 16:48:14

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.

1
répondu Erwin 2017-08-06 07:41:44