Quiero pasar una variable que leí en Una etapa hacia la fase B de alguna manera. Veo en algunos de los ejemplos de que la gente escribe en un archivo, pero supongo que no es realmente una buena solución. He tratado de escribir a una variable de entorno, pero no estoy muy acertado en eso. ¿Cómo puedo configurarlo correctamente?

Para que funcione he intentado un montón de cosas y leer que debo usar el «»» en lugar de «» para iniciar una shell y escapar de esas variables para \${foo} por ejemplo.

A continuación es lo que yo tengo como una tubería:

#!/usr/bin/env groovy

pipeline {

    agent { node { label 'php71' } }

    environment {
        packageName='my-package'
        packageVersion=''
        groupId='vznl'
        nexus_endpoint='http://nexus.devtools.io'
        nexus_username='jenkins'
        nexus_password='J3nkins'
    }

    stages{

        //Package dependencies
        stage('Install dependencies') {
            steps {
                sh '''
                    echo Skip composer installation
                    #composer install  --prefer-dist --optimize-autoloader --no-interaction
                '''
            }
        }

        //Unit tests
        stage('Unit Tests') {
            steps {
                sh '''
                    echo Running PHP code coverage tests...
                    #composer test
                '''
            }
        }

        //Create artifact
        stage('Package') {
            steps {
                echo 'Create package refs'
                sh """
                    mkdir -p ./build/zpk
                    VERSIONTAG=$(grep 'version' composer.json)
                    REGEX='"version": "([0-9]+.[0-9]+.[0-9]+)"'
                    if [[ ${VERSIONTAG} =~ ${REGEX} ]]
                    then
                        env.packageVersion=${BASH_REMATCH[1]}
                        /usr/bin/zs-client packZpk --folder=. --destination=./build/zpk --name=${env.packageName}-${env.packageVersion}.zpk --version=${env.packageVersion}
                    else
                        echo "No version found!"
                        exit 1
                    fi
                """
            }
        }

        //Publish ZPK package to Nexus
        stage('Publish packages') {
            steps {
                echo "Publish ZPK Package"
                sh "curl -u ${env.nexus_username}:${env.nexus_password} --upload-file ./build/zpk/${env.packageName}-${env.packageVersion}.zpk ${env.nexus_endpoint}/repository/zpk-packages/${groupId}/${env.packageName}-${env.packageVersion}.zpk"
                archive includes: './build/**/*.{zpk,rpm,deb}'
            }
        }
    }
}

Como se puede ver el packageVersion que he leído de la etapa Paquete debe ser utilizado en la etapa Publicar así.

General de los consejos en contra de la tubería siempre es bienvenido también.

  • Tratar de «env variable» plugin que podría ser de ayuda que
  • consulte stackoverflow.com/a/44101004/6090676 (que pasa a ser la lectura de un archivo para establecer la variable, pero usted puede ponerlo en cualquier forma que usted desee).
  • intente reutilizar nodo con reuseNode true cuando la definición de agente
  • el problema no es la reutilización del nodo, pero la asignación de variables ya que sólo hay 1 nodo. El problema es cuando ejecuto el comando de arriba me recibe esta como salida: + env.packageVersion=1.71.0 /var/lib/jenkins-slave/workspace/l_omnius-vf-nl-co[email protected]tmp/durable-acda6886/script.sh: line 9: env.packageVersion=1.71.0: command not found La solución de escribir en el archivo es muy mal de la omi?
  • responde a continuación, solución poco mejor que escribir en el archivo, todavía hace que el espacio de memoria de bit sucio y no es capaz de parellize. Usted puede escribir el archivo y stash / unstash – de este modo, sería seguro para subprocesos.
InformationsquelleAutor Dirkos | 2017-11-23

2 Comentarios

  1. 15

    Un problema en el código es que usted está asignando versión de la variable de entorno dentro de la sh paso. Este paso se ejecuta en su propio proceso aislado, heredando de padres de proceso las variables de entorno.

    Sin embargo, la única manera de pasar los datos de vuelta al padre es a través de STDOUT/STDERR o código de salida. Como quiera una cadena de valor, lo mejor es hacerse eco de la versión de la sh paso y asignarlo a una variable dentro de la script contexto.

    Si volver a utilizar el nodo, la secuencia de comandos de contexto persistirá, y variables que van a estar disponibles en la etapa posterior. Un ejemplo de trabajo está por debajo de. Tenga en cuenta que cualquier intento poner esto dentro de un parallel bloque puede ser de fracaso, como la información de versión de la variable puede ser escrito por varios procesos.

    #!/usr/bin/env groovy
    
    pipeline {
    
        environment {
            AGENT_INFO = ''
        }
    
        agent {
            docker {
                image 'alpine'
                reuseNode true
            }
        }
    
        stages {
    
            stage('Collect agent info'){
                steps {
                    echo "Current agent  info: ${env.AGENT_INFO}"
                    script {
                        def agentInfo = sh script:'uname -a', returnStdout: true
                        println "Agent info within script: ${agentInfo}"
                        AGENT_INFO = agentInfo.replace("/n", "")
                        env.AGENT_INFO = AGENT_INFO
                    }
                }
            }
    
            stage("Print agent info"){
                steps {
                    script {
                        echo "Collected agent info: ${AGENT_INFO}"
                        echo "Environment agent info: ${env.AGENT_INFO}"
                    }
                }
            }
        }
    }
    
    • Si las fases se realizaran con los diferentes agentes ? Voy a intentar
    • Yo no esperaría a trabajar en los diferentes agentes
    • hizo usted trate de usar en los diferentes agentes?
    • Sí, lo hice, pero no pongo la variable como una variable de Entorno en el bloque de Entorno, sino como una variable: def myVar = … antes de que la tubería de bloque, y luego, cuando lo uso en diferentes etapas, funciona bien.
    • Me gusta bastante esta solución, pero también puede utilizar los archivos para pasar variables. Usted podría <<sh ‘echo hola > hello.txt’ >> y, a continuación, «readFile(‘hello.txt’)
  2. 4

    Otra opción que no implican el uso de script, pero es sólo declarativa, es para guardar las cosas en un pequeño entorno temporal de archivo.

    Usted puede utilizar este tipo de imágenes (como una caché temporal que sólo vive para la carrera) si la carga de trabajo se rocía a cabo a través de paralelo o nodos distribuidos según sea necesario.

    Algo como:

    pipeline {
        agent any
    
        stages {
            stage('first stage') {
                steps {
                    //Write out any environment variables you like to a temporary file
                    sh 'echo export FOO=baz > myenv'
    
                    //Stash away for later use
                    stash 'myenv'
                }
            }
    
            stage ("later stage") {
                steps {
    
                    //Unstash the temporary file and apply it
                    unstash 'myenv'
                    sh 'source ./myenv'
    
                    //Now continue on with variables set
                    sh 'echo $FOO'
                }
            }
        }
    }
    
    • Ya que cada «sh» bloque se ejecuta en una consola diferente proceso, usted puede fuente primera y, a continuación, utilizar una variable en un diferente «sh» de comandos. Se puede hacer en el mismo, aunque. sh ‘fuente myenv ; echo $FOO’
    • La observación de que no es necesario el prefijo «./» en orden a la FUENTE de un archivo en el shell actual. Usted necesidad de que para la ejecución de comandos cuando «.» no está en la ruta de acceso actual, pero «el origen», simplemente lee el archivo dado.

Dejar respuesta

Please enter your comment!
Please enter your name here