How do I pass variables between stages in a declarative Jenkins pipeline?

Question

How do I pass variables between stages in a declarative pipeline?

In a scripted pipeline, I gather the procedure is to write to a temporary file, then read the file into a variable.

How do I do this in a declarative pipeline?

E.g. I want to trigger a build of a different job, based on a variable created by a shell action.

stage("stage 1") {
    steps {
        sh "do_something > var.txt"
        // I want to get var.txt into VAR
    }
}
stage("stage 2") {
    steps {
        build job: "job2", parameters[string(name: "var", value: "${VAR})]
    }
}

Answer 1

If you want to use a file (since a script is the thing generating the value you need), you could use readFile as seen below. If not, use sh with the script option as seen below:

// Define a groovy local variable, myVar.
// A global variable without the def, like myVar = 'initial_value',
// was required for me in older versions of jenkins. Your mileage
// may vary. Defining the variable here maybe adds a bit of clarity,
// showing that it is intended to be used across multiple stages.
def myVar = 'initial_value'

pipeline {
  agent { label 'docker' }
  stages {
    stage('one') {
      steps {
        echo "1.1. ${myVar}" // prints '1.1. initial_value'
        sh 'echo hotness > myfile.txt'
        script {
          // OPTION 1: set variable by reading from file.
          // FYI, trim removes leading and trailing whitespace from the string
          myVar = readFile('myfile.txt').trim()
        }
        echo "1.2. ${myVar}" // prints '1.2. hotness'
      }
    }
    stage('two') {
      steps {
        echo "2.1 ${myVar}" // prints '2.1. hotness'
        sh "echo 2.2. sh ${myVar}, Sergio" // prints '2.2. sh hotness, Sergio'
      }
    }
    // this stage is skipped due to the when expression, so nothing is printed
    stage('three') {
      when {
        expression { myVar != 'hotness' }
      }
      steps {
        echo "three: ${myVar}"
      }
    }
  }
}

Answer 2

Simply:

  pipeline {
        parameters {
            string(name: 'custom_var', defaultValue: '')
        }

        stage("make param global") {
             steps {
               tmp_param =  sh (script: 'most amazing shell command', returnStdout: true).trim()
               env.custom_var = tmp_param
              }
        }
        stage("test if param was saved") {
            steps {
              echo "${env.custom_var}"
            }
        }
  }

Answer 3

I had a similar problem as I wanted one specific pipeline to provide variables and many other ones using it to get this variables.

I created a my-set-env-variables pipeline

script
{
    env.my_dev_version = "0.0.4-SNAPSHOT"
    env.my_qa_version  = "0.0.4-SNAPSHOT"
    env.my_pp_version  = "0.0.2"
    env.my_prd_version = "0.0.2"
    echo " My versions  [DEV:${env.my_dev_version}] [QA:${env.my_qa_version}] [PP:${env.my_pp_version}] [PRD:${env.my_prd_version}]"
}

I can reuse these variables in a another pipeline my-set-env-variables-test

script 
{
    env.dev_version = "NOT DEFINED DEV"
    env.qa_version  = "NOT DEFINED QA"
    env.pp_version  = "NOT DEFINED PP"
    env.prd_version = "NOT DEFINED PRD"
}

stage('inject variables') {

    echo "PRE DEV version = ${env.dev_version}"
    script 
    {
       def variables = build job: 'my-set-env-variables'
       def vars = variables.getBuildVariables()
      //println "found variables" + vars
      env.dev_version = vars.my_dev_version
      env.qa_version  = vars.my_qa_version
      env.pp_version  = vars.my_pp_version
      env.prd_version = vars.my_prd_version
    }
}

stage('next job') {
    echo "NEXT JOB DEV version = ${env.dev_version}"
    echo "NEXT JOB QA version = ${env.qa_version}"
    echo "NEXT JOB PP version = ${env.pp_version}"
    echo "NEXT JOB PRD version = ${env.prd_version}"

}

Answer 4

there is no need for (hidden plugin) parameter definitions or temp-file access. Sharing varibles across stages can be acomplished by using global Groovy variables in a Jenkinsfile like so:

#!/usr/bin/env groovy 
def MYVAR

def outputOf(cmd) { return sh(returnStdout:true,script:cmd).trim(); }

pipeline {
    agent any    
    stage("stage 1") {
        steps {
            MYVAR = outputOf('echo do_something')
            sh "echo MYVAR has been set to: '${MYVAR}'"
        }
    }
    stage("stage 2") {
        steps {
            sh '''echo "...in multiline quotes: "''' + MYVAR + '''" ... '''
            build job: "job2", parameters[string(name: "var", value: MYVAR)]
        }
    }
}

Answer 5

I have enhanced the existing solution by correcting syntax .Also used hidden parameter plugin so that it does not show up as an extra parameter in Jenkins UI. Works well :)

properties([parameters([[$class: 'WHideParameterDefinition', defaultValue: 'yoyo', name: 'hidden_var']])]) 
  pipeline {
        agent any

stages{
        stage("make param global") {
             steps {
                 script{
               env.hidden_var = "Hello"
                 }
              }
        }
        stage("test if param was saved") {
            steps {
              echo"About to check result"
              echo "${env.hidden_var}"
            }
        }
    }
  }

Answer 6

pipeline {

agent any
stages {
    stage('stage 1') {
        steps {
           script {           
            def INSTANCE_ID = sh(returnStdout: true , script: 'aws ec2 run-instances --image-id ami-12345678 --count 1 --instance-type t2.micro --key-name MyKeyPair --security-group-ids sg-12345678 --subnet-id subnet-12345678')
            env.INSTANCE_ID = INSTANCE_ID
                    }
                } 
            }
    stage('stage 2') {
        steps {
           script {
            echo "This is your INSTANCE_ID, $INSTANCE_ID"    
            } 
        }
    }
}

}

Answer 7

We have several variable levels, stage, script and sh and this is where majority answers do not stress enough differences so people end up using files or scripts to capture outputs... Here's what works for me.

def buildNameGlobal
pipeline {
    stages {
        stage("Initialize") {
            steps {
                script {
                    buildNameGlobal = "123"
                    echo "buildNameGlobal: ${buildNameGlobal}"
                    // will show 123
                }
            }
        }

        stage("Task 1") {
            steps {
                script {
                    echo "buildNameGlobal: ${buildNameGlobal}"
                    // will show 123 as expected but we must set env to use it from sh script
                    env.buildNameGlobalEnv = buildNameGlobal
                    sh label: '', script: '''
                    echo "buildNameGlobalEnv :$buildNameGlobalEnv "'''
                    // and now we also have 123 here
                }
            }
        }
    }
}

Answer 8

I use a shared lib method in the background, that handles a global environment variable with a JSON map as data. This way, it's persistent over Jenkins controller restarts and it can store all kinds of objects:

pipelineStore.groovy

def getAll() {
    return jsonUtils.fromJson(env.PIPELINE_STORE)
}

def put(key, value) {
    def tmpMap = jsonUtils.fromJson(env.PIPELINE_STORE)
    if (!tmpMap) {
        tmpMap = [:]
    }
    def result = tmpMap.put(key, value)
    env.PIPELINE_STORE = jsonUtils.toJson(tmpMap)
    return result
}

def get(key) {
    return jsonUtils.fromJson(env.PIPELINE_STORE)[key]
}

def remove(key) {
    tmpMap = jsonUtils.fromJson(env.PIPELINE_STORE)
    def result = tmpMap.remove(key)
    env.PIPELINE_STORE = jsonUtils.toJson(tmpMap)
    return result
}

jsonUtils.groovy

import groovy.json.JsonSlurper
import groovy.json.JsonBuilder
import groovy.json.JsonSlurperClassic 

def toJson(object) {
    return new JsonBuilder(object).toPrettyString()
}

def fromJson(text) {
    if (!text) {
        return ''
    }
    try {
        return new JsonSlurper().parseText(text)
    } catch (Exception e) {
        return new JsonSlurperClassic().parseText(text)
    }
}

And in my pipelines I can use it across stages like

stages {
    stage ('1') {
        steps {
            script {
                pipelineStore.put("key_1", [name: "value_1", version: 23])
            }
        }
    }
    
    stage ('2') {
        steps {
            script {
                def value = pipelineStore.get("key_1")
            }
        }
    }
}

post {
    unsuccessful {
        node ('master') {
            script {
                pipelineStore.getAll().each { key, value ->
                    // e.g. cleanup operations
                }
            }
        }
    }
}

for more information on shared libraries on Jenkins see https://www.jenkins.io/doc/book/pipeline/shared-libraries/