Frage Erstellen einer Jenkins-Umgebungsvariablen mit Groovy


Ich denke, das ist eine andere einfache Frage, aber ich konnte keine der Web-Lösungen zum Funktionieren bringen. Mein Projekt nimmt eine Versionsnummer an. Jede Nummer kann durch ein '.' Getrennt werden. oder ein '_'. Ich möchte eine Variable, die nur die ersten zwei Zahlen anzeigt.

Ich habe versucht, ein grooviges Skript zu schreiben, das eine Jenkins-Umgebungsvariable erzeugt.
Ich möchte die ersten zwei Ziffern anstelle der gesamten Zeichenfolge nehmen.

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

Mache ich das richtig, kann ich sogar eine neue Umgebungsvariable erstellen, und gibt es dafür eine bessere Lösung?


28
2018-05-02 12:38


Ursprung


Antworten:


Jenkins 1.x

Das folgende groovige Snippet sollte die Version (wie Sie bereits angegeben haben) bestehen und in den Variablen des Jobs als 'miniVersion' speichern.

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)

Auf die Variable kann dann von anderen Build-Schritten zugegriffen werden. z.B.

echo miniVersion=%miniVersion%

Ausgänge:

miniVersion=12.34

Ich glaube, dass Sie das "System Groovy Script" (nur auf dem Master-Knoten) anstelle des "Groovy Plugins" verwenden müssen - https://wiki.jenkins-ci.org/display/JENKINS/Groovy+plugin#Groovyplugin-GroovyScriptvsSystemGroovyScript

Jenkins 2.x

Ich glaube das vorherige (Jenkins 1.x) Verhalten funktioniert nicht mehr wegen diese Sicherheitsempfehlung...

Lösung (aus der Sicherheitsempfehlung umschrieben)

Es ist möglich, das vorherige Verhalten wiederherzustellen, indem Sie die Systemeigenschaft festlegen hudson.model.ParametersAction.keepUndefinedParameters zu true. Dies ist möglicherweise sehr unsicher und nur als kurzfristige Abhilfe gedacht.

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

Um zuzulassen, dass bestimmte bekannte sichere Parameternamen an Builds übergeben werden, legen Sie die Systemeigenschaft fest hudson.model.ParametersAction.safeParameters zu einer durch Kommas getrennten Liste von sicheren Parameternamen.

z.B.

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

48
2017-10-04 06:31



Sie können auch eine Variable ohne das EnvInject Plugin in Ihrem Groovy System Script definieren:

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

Dann können Sie im nächsten Build-Schritt auf diese Variable zugreifen, die (zum Beispiel) ein Windows-Batch-Befehl ist:

@echo off
Setlocal EnableDelayedExpansion
echo FOO=!FOO!

Dieses Echo zeigt Ihnen "FOO = BAR".

Grüße


18
2018-02-21 13:59



Die Jenkins EnvInject-Plugin könnte Ihnen vielleicht helfen. Es ermöglicht das Injizieren von Umgebungsvariablen in die Build-Umgebung.

Ich weiß, dass es einige Fähigkeiten zum Scripting hat, also könnte es tun, was Sie wollen. Ich habe es nur benutzt, um einfache Eigenschaften zu setzen (z.B. "LOG_PATH = $ {ARBEITSBEREICH} \ logs").


9
2018-05-02 14:00



Wie andere Antworten die Einstellung neu festlegen ParametersAction ist die Möglichkeit, eine oder mehrere Umgebungsvariablen zu injizieren, aber Wenn ein Job bereits parametrisiert ist, wird das Hinzufügen neuer Aktionen nicht wirksam. Stattdessen sehen Sie zwei Links zu einem Build-Parameter, der auf den gleichen Parameter-Satz zeigt und der, den Sie hinzufügen wollten null.

Hier ist ein Ausschnitt, der die Parameterliste in beiden Fällen aktualisiert (ein parametrisierter und nicht parametrisierter Job):

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
2017-09-11 20:37



Für mich funktionierte das Folgende auch in Jenkins 2 (2.73.3)

Ersetzen

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

mit

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

ParametersAction scheint einen zweiten Konstruktor zu haben, der es erlaubt "additionalSafeParameters" zu übergeben https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/ParametersAction.java


6
2018-01-22 09:01



Nach einigem Suchen nutzt die beste Lösung meiner Meinung nach 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;
        }
    }    
}

Ich verwende diese Klasse in einem System-Groovy-Skript (mit dem Groovy-Plugin) innerhalb eines Jobs.

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

Sie können dann auf die Variable projectBranchDependencies an jedem anderen Punkt in Ihrem Build zugreifen, in meinem Fall von einem ANT-Skript.

Hinweis: Ich habe die Ideen für Teile dieser Implementierung von einem Blog-Beitrag ausgeliehen / modifiziert, aber zum Zeitpunkt dieses Beitrags war ich nicht in der Lage, die ursprüngliche Quelle zu finden, um einen fälligen Kredit zu erhalten.


4
2018-04-07 13:18



Hatte nur das gleiche Problem. Wollte dynamisch parametrisierte Downstream-Jobs basierend auf dem Ergebnis einiger grooviger Scripts auslösen.

Leider ist es auf unseren Jenkins nicht möglich, System Groovy-Skripte auszuführen. Daher musste ich einen kleinen Workaround machen:

  1. Führen Sie groovy script aus, das eine Eigenschaftendatei erstellt, in der die festzulegende Umgebungsvariable angegeben wird

    def props = new File("properties.text")
    if (props.text == 'foo=bar') {
        props.text = 'foo=baz'
    } else {
        props.text = 'foo=bar'
    }
    
  2. Verwenden Sie das env inject-Plugin, um die in dieses Skript geschriebene Variable zu injizieren

    Inject environment variable
    Property file path: properties.text
    

Danach konnte ich die Variable 'foo' als Parameter für das parametrierte Trigger-Plugin verwenden. Eine Art Workaround. Aber funktioniert!


3
2017-09-09 16:48