branchJobs = Hudson.instance.items.findAll { item -> item.scm.class != NullSCM }

def job = Hudson.instance.getItem("JobName");   
def envVars= job.lastBuild.properties.get("envVars");  // this is actually the currently running build, if the script is executed in "JobName"
println envVars["MyParameterName"];

#!/bin/bash
exec /path/to/groovy /path/to/script.groovy

#!/bin/bash
exec ${GROOVY_BIN_5} /path/to/script.groovy

/**
 * Fails the current build if any of the specified builds are failing
 * 
 * Required a Variable Bindings
 * projectNames     - A comma delimited list of projects to check
 * 
 * Optional Variable Bindings
 * requireOnlyMostRecent    - If true only the most recent build among the list of projects must be successful
 */

try {
  requireOnlyMostRecent;
}
catch (MissingPropertyException e) {
  requireOnlyMostRecent = false;
}

def mostRecentSuccess = null;
def mostRecentFailure = null;

for (projectName in projectNames.split(",")) {
    def proj = hudson.model.Hudson.instance.getItem(projectName);

    if (proj == null) {
        println projectName + " DOES NOT EXIST, failing build";
        return false;
    }
    else if (proj.lastBuild == null) {
        if (!requireOnlyMostRecent) {
            println projectName + ": has no builds, failing build";
            return false;
        }
    }
    else if (proj.lastBuild.result != hudson.model.Result.SUCCESS) {
        if (!requireOnlyMostRecent) {
            println projectName + ": the last build was not successful, failing build";
            return false;
        }
        
        if (mostRecentFailure == null || mostRecentFailure < proj.lastBuild.time) {
            println projectName + ": the last build was not successful, recording mostRecentFailure";
            mostRecentFailure = proj.lastBuild.time;
        }
        else {
            println projectName + ": the last build was not successful, but is not mostRecentFailure";
        }
    }
    else {
        println projectName + ": the last build was successful";
        
        if (mostRecentSuccess == null || mostRecentSuccess < proj.lastBuild.time) {
            mostRecentSuccess = proj.lastBuild.time;
        }
    }
}

if (!requireOnlyMostRecent) {
    //All builds must be successful, continue with build
    return true;
}

println "mostRecentSuccess: " + mostRecentSuccess;
println "mostRecentFailure: " + mostRecentFailure;
return mostRecentSuccess != null && (mostRecentFailure == null || mostRecentSuccess > mostRecentFailure);

// basic classes
import hudson.*
import hudson.model.*
import hudson.util.*

def thr = Thread.currentThread();
def currentBuild = thr?.executable;
def workspace = currentBuild.getModuleRoot().absolutize().toString();


//////START///// DETERMINE MAX SVN REVISION ///////////
def SVN_REVISION = currentBuild.getEnvironment()["SVN_REVISION"]
def SVN_REVISION_1 = currentBuild.getEnvironment()["SVN_REVISION_1"]
def SVN_REVISION_2 = currentBuild.getEnvironment()["SVN_REVISION_2"]
if ( SVN_REVISION < SVN_REVISION_1 ) { SVN_REVISION = SVN_REVISION_1; }
if ( SVN_REVISION < SVN_REVISION_2 ) { SVN_REVISION = SVN_REVISION_2; }
println "[TSS] MAX_SVN_REVISION="+SVN_REVISION
//currentBuild.getEnvironments().add(Environment.create(new EnvVars(["MAX_SVN_REVISION":SVN_REVISION])))
currentBuild.addAction(new ParametersAction(new StringParameterValue("MAX_SVN_REVISION", SVN_REVISION)));
//////END///// DETERMINE MAX SVN REVISION ///////////

//////START///// PARSE XML OR GET MAVENVER ///////////
if ( currentBuild.getEnvironment().containsKey("POM_XML") ) {
 POM_XML = currentBuild.getEnvironment()["POM_XML"]
 println "[TSS] POM_XML=${POM_XML} (hard coded -> XML needs to be parsed)"
 def project = new XmlSlurper().parse(new File("$workspace/$POM_XML"));
 mavenVer = project.version.toString();
} else {
 println '[TSS] Automatically retrieve component version from Maven build.'
 println '[TSS] If it is wrong (usually it is ok, and this message just info), you can parse pom file with XML.'
 println '[TSS] For this please specify environment variable POM_XML=relative_path_to/pom.xml (usually the same as specified for in maven "Root POM" section)'
 mavenVer = currentBuild.getParent().getModules().toArray()[0].getVersion();
}
//////END///// PARSE XML OR GET MAVENVER ///////////

println '[TSS] COMPONENT_VERSION='+mavenVer

def newParamAction = new hudson.model.ParametersAction(new hudson.model.StringParameterValue("COMPONENT_VERSION", mavenVer));
currentBuild.addAction(newParamAction);

// Determine if RELEASE=true => Sonar will skip code checks, otherwise it fails
if ( mavenVer.matches(".*SNAPSHOT") ) {
    currentBuild.addAction(new hudson.model.ParametersAction(new hudson.model.BooleanParameterValue("RELEASE", false)));
    println '[TSS] RELEASE=false';
} else {
    currentBuild.addAction(new hudson.model.ParametersAction(new hudson.model.BooleanParameterValue("RELEASE", true)));
    println '[TSS] RELEASE=true';
}

// base classes
import hudson.*
import hudson.model.*
import hudson.util.*
// classes for triggering another job
import hudson.AbortException
import hudson.console.HyperlinkNote
import java.util.concurrent.CancellationException

// GET INFO ABOUT CI JOB (which is current job)
def thr = Thread.currentThread();
def currentBuild = thr?.executable;
def CI_JOB_NAME = currentBuild.getEnvironment()["JOB_NAME"]

//////START///// DETERMINE BUILD JOB NAME ///////////
if ( currentBuild.getEnvironment().containsKey("BUILD_JOB_NAME") ) {
 BUILD_JOB_NAME = currentBuild.getEnvironment()["BUILD_JOB_NAME"]
 println "[TSS] BUILD_JOB_NAME=${BUILD_JOB_NAME} (hard coded)"
} else {
 BUILD_JOB_NAME = (CI_JOB_NAME =~ /-CI/).replaceFirst("-build")
 println "[TSS] BUILD_JOB_NAME=${BUILD_JOB_NAME} (auto suggestion)"
 println '[TSS] If it is wrong (usually it is ok, and this message just info), you can setup it manually.'
 println '[TSS] For this please specify environment variable "BUILD_JOB_NAME=Build-Job-Name"'
}
//////END///// DETERMINE BUILD JOB NAME ///////////


def BUILD_JOB = Hudson.instance.getJob(BUILD_JOB_NAME)


//////START///// DETERMINE CI MAX SVN REVISION ///////////
def CI_SVN_REVISION = currentBuild.getEnvironment()["SVN_REVISION"]
def CI_SVN_REVISION_1 = currentBuild.getEnvironment()["SVN_REVISION_1"]
def CI_SVN_REVISION_2 = currentBuild.getEnvironment()["SVN_REVISION_2"]
if ( CI_SVN_REVISION < CI_SVN_REVISION_1 ) { CI_SVN_REVISION = CI_SVN_REVISION_1; }
if ( CI_SVN_REVISION < CI_SVN_REVISION_2 ) { CI_SVN_REVISION = CI_SVN_REVISION_2; }
println '[TSS] '+CI_SVN_REVISION+' = SVN REVISION OF JOB '+CI_JOB_NAME
//////END///// DETERMINE CI MAX SVN REVISION ///////////


//////START///// DETERMINE BUILD MAX SVN REVISION ///////////
def BUILD_SVN_REVISION =  BUILD_JOB.getLastBuild().getEnvironment()["MAX_SVN_REVISION"]
//def BUILD_SVN_REVISION_1 =  BUILD_JOB.getLastBuild().getEnvironment()["SVN_REVISION_1"]
//def BUILD_SVN_REVISION_2 =  BUILD_JOB.getLastBuild().getEnvironment()["SVN_REVISION_2"]
//if ( BUILD_SVN_REVISION < BUILD_SVN_REVISION_1 ) { BUILD_SVN_REVISION = BUILD_SVN_REVISION_1; }
//if ( BUILD_SVN_REVISION < BUILD_SVN_REVISION_2 ) { BUILD_SVN_REVISION = BUILD_SVN_REVISION_2; }
println '[TSS] '+BUILD_SVN_REVISION+' = SVN REVISION OF JOB '+BUILD_JOB_NAME
//////END///// DETERMINE BUILD MAX SVN REVISION ///////////


//////START///// COMPARING REVISIONS AND TRIGGER BUILD JOB IF NEED
if ( BUILD_SVN_REVISION != CI_SVN_REVISION ) {
  println "[TSS] Versions are not the same -> need to trigger build job"
  // don't need this var, but leave it as example of setup up env (not sys) var
  currentBuild.getEnvironments().add(Environment.create(new EnvVars(["BUILD_TRIGGER":"true"])))
  //////START///// TRIGGER BUILD JOB BLOCK /////////// (see examples on https://wiki.jenkins-ci.org/display/JENKINS/Groovy+plugin )
  def job = Hudson.instance.getJob(BUILD_JOB_NAME)
  def anotherBuild
  try {
    def params = [
    // UNCOMMENT/ and MODIFY THIS IF NEED TO PASS ANY ARGS TO BUILD JOB
    //  new StringParameterValue('FOO', foo),
    ]
    def future = job.scheduleBuild2(0, new Cause.UpstreamCause(currentBuild), new ParametersAction(params))
    println "Waiting for the completion of " + HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName)
    anotherBuild = future.get()
  } catch (CancellationException x) {
    throw new AbortException("${job.fullDisplayName} aborted.")
  }
  println HyperlinkNote.encodeTo('/' + anotherBuild.url, anotherBuild.fullDisplayName) + " completed. Result was " + anotherBuild.result

  // Check that it succeeded
  currentBuild.result = anotherBuild.result
  def anotherBuildResult = anotherBuild.result.toString()

  if (anotherBuildResult != 'SUCCESS' && anotherBuildResult != 'UNSTABLE') {
      // We abort this build right here and now.
      throw new AbortException("${anotherBuild.fullDisplayName} failed.")
  }
  ////// END ///// TRIGGER BUILD JOB BLOCK ///////////
} else {
  println '[TSS] Build job SVN revision is current which means that current code already build -> NOT TRIGGERING BUILD JOB'
  currentBuild.getEnvironments().add(Environment.create(new EnvVars(["BUILD_TRIGGER":"false"])))
}
//////END///// COMPARING REVISIONS AND TRIGGER BUILD JOB IF NEED


/////START//// RETRIEVE LATEST COMPONENT_VERSION AND SVN REVISION
// THIS WORKS ONLY IF MAVEN BUILD SUCCESFULL
//def BUILD_JOB_COMPONENT_VERSION = BUILD_JOB.getLastBuild().getParent().getModules().toArray()[0].getVersion();
// THIS WORKS ONLY WHEN WE CREATE THIS VARIABLE ON BUILD JOB SIDE
def BUILD_JOB_COMPONENT_VERSION =  BUILD_JOB.getLastBuild().getEnvironment()["COMPONENT_VERSION"]
// NOT IMPORTANT AND WORKS ONLY IF PROPER GROOVY SCRIPT EXIST ON BUILD JOB SIDE, OTHERWISE JOB WILL RETURN NONE
// SET UP AS ENV VAR (not system) -> otherwise will break nolio
def LATEST_BUILD_SVN_REVISION =  BUILD_JOB.getLastBuild().getEnvironment()["MAX_SVN_REVISION"]
if ( LATEST_BUILD_SVN_REVISION ) {
  currentBuild.getEnvironments().add(Environment.create(new EnvVars(["MAX_SVN_REVISION":LATEST_BUILD_SVN_REVISION])))
  println '[TSS] Last Build job svn_revision = '+LATEST_BUILD_SVN_REVISION
} else {
  currentBuild.getEnvironments().add(Environment.create(new EnvVars(["MAX_SVN_REVISION":"NONE"])))
}
// Nolio can use only System variables
currentBuild.addAction(new ParametersAction(new StringParameterValue("COMPONENT_VERSION", BUILD_JOB_COMPONENT_VERSION)));
/////END//// RETRIEVE LATEST COMPONENT_VERSION AND SVN REVISION

import hudson.model.*

// get the original parameters as they were submitted
current_param_actions = build.getAction(ParametersAction.class)
def current_params = current_param_actions.getParameters()

// create a new empty set of parameters that will eventually contain our substituting value
Collection<? extends ParameterValue> new_params = new ArrayList<>();

// copy all the submitted parameters, except the one that we are altering
current_params.each() {
	if ( ! it.getName().equals("NAME_OF_PARAM_TO_ALTER") ) {
		new_params.add( it )
	}
}

// determine new value of the parameter we wish to override and add it to our set of parameters
new_value = func_to_find_value()
new_params.add( new StringParameterValue("NAME_OF_PARAM_TO_ALTER", new_value ) )

// replace the submitted set of values with our altered set of values
build.actions.remove(current_param_actions)
new_param_actions = current_param_actions.createUpdated(new_params)
build.actions.add(new_param_actions)

// some debugging output for sanity checking when examining console output
build.getAction(ParametersAction.class).getParameters().each {
	println "[info] parameter ${it.name}:"
	println "[info] " + it.dump()
	println "-" * 80
}

CompilerConfiguration compilerConfig = new CompilerConfiguration();        
if (classpath != null) {            
	compilerConfig.setClasspath(classpath);        
}

build.addAction(new ParametersAction(new StringParameterValue('BAR', '3')))

May 19, 2016 11:10:24 AM hudson.model.ParametersAction filter
WARNING: Skipped parameter `BAR` as it is undefined on `test`. Set `-Dhudson.model.ParametersAction.keepUndefinedParameters`=true to allow undefined parameters to be injected as environment variables or `-Dhudson.model.ParametersAction.safeParameters=[comma-separated list]` to whitelist specific parameter names, even though it represents a security breach

def newEnv = new EnvVars ( "BAR", "3" )
def paramAction = new ParametersAction()
paramAction.buildEnvVars( build, newEnv )