web-dev-qa-db-fra.com

Comment implémenter l'étape de post-construction à l'aide du plug-in Jenkins Pipeline?

Après avoir lu Jenkins tutorial explaining Pipeline plug-in, il semble que le plug-in devrait permettre de mettre en œuvre les étapes Post-Build. Cependant, la documentation est plutôt limitée en ce qui concerne les instructions spécifiques.

Par exemple, je me demande comment implémenter:

  • Exécuter que si la construction réussit 
  • Exécuter uniquement si la construction réussit ou est instable 
  • Exécuter indépendamment du résultat de la construction

  • _ {Exécuter uniquement si la construction réussit

    stage 'build'
... build
... tests
stage 'post-build'
...

    (Ou ajoutez -Dmaven.test.failure.ignore=false au MAVEN_OPTS)

  • _ {Exécuter uniquement si la construction réussit ou est instable} _

    stage 'build'
... build
try {
    ... tests
} catch {
    ...
}
stage 'post-build'
...

    (Ou ajoutez -Dmaven.test.failure.ignore=true au MAVEN_OPTS)

  • Exécuté indépendamment du résultat de la construction} - pourrait-il être utilisé avec try / catch / finally? 

    try {
    stage 'build'
    ...
} catch {
    ...
} finally {
    stage 'post-build'
    ...
}

(J'ai remarqué que le statut de construction final est défini sur SUCCESS même si certaines étapes, par exemple, «build», ont échoué car elles étaient définies en fonction de la dernière étape. Cela signifie-t-il que le statut de construction final doit être explicitement défini? , ie .currentBuild.result = 'UNSTABLE'?)

jenkinsjenkins-workflowjenkins-pipeline
40
luka5z

Le meilleur moyen consiste à utiliser une action post-génération dans le script de pipeline.

Traitement des échecs
Le pipeline déclaratif prend en charge les défaillances robustes traitement par défaut via sa section post qui permet de déclarer un nombre de "conditions de poste" différentes, telles que: always, unstable, succès, échec et changement. La section Syntaxe du pipeline fournit plus de détails sur l'utilisation des différentes conditions de poste.

Jenkinsfile (pipeline déclaratif)

pipeline {
    agent any
    stages {
        stage('Test') {
            steps {
                sh 'make check'
            }
        }
    }
    post {
        always {
            junit '**/target/*.xml'
        }
        failure {
            mail to: [email protected], subject: 'The Pipeline failed :('
        }
    }
}

La documentation est ci-dessous https://jenkins.io/doc/book/pipeline/syntax/#post

31
Mohamed Thoufeeque

Si vous utilisez try/catch et que vous voulez qu'une version soit marquée comme étant instable ou en échec, vous devez utiliser currentBuild.result = 'UNSTABLE' etc. tests dans les résultats junit. Mais dans la plupart des cas, vous devez le définir vous-même si vous détectez des erreurs.

La deuxième option si vous ne voulez pas continuer est de rétablir l'erreur. 

stage 'build'
... build
try {
    ... tests
} catch(err) {
    //do something then re-throw error if needed.
    throw(err)
}
stage 'post-build'
...
4
DanielD

FWIW, si vous utilisez des pipelines scriptés et non déclaratifs, vous devez utiliser un bloc try/catch/finally comme suggéré dans les autres réponses. Dans le bloc finally, si vous voulez imiter ce que fait le pipeline déclaratif, vous pouvez insérer les éléments suivants directement dans le bloc ou en faire une fonction et appeler cette fonction depuis votre bloc finally:

def currResult = currentBuild.result ?: 'SUCCESS'
def prevResult = currentBuild.previousBuild?.result ?: 'NOT_BUILT'

// Identify current result
boolean isAborted = (currResult == 'ABORTED')
boolean isFailure = (currResult == 'FAILURE')
boolean isSuccess = (currResult == 'SUCCESS')
boolean isUnstable = (currResult == 'UNSTABLE')

boolean isChanged = (currResult != prevResult)
boolean isFixed = isChanged && isSuccess && (prevResult != 'ABORTED') && (prevResult != 'NOT_BUILT')
boolean isRegression = isChanged && currentBuild.resultIsWorseOrEqualTo(prevResult)

onAlways()
if (isChanged) {
    onChanged()
    if (isFixed) {
        onFixed()
    } else if (isRegression) {
        onRegression()
    }
}
if (isSuccess) {
    onSuccess()
} else {
    if (isAborted) {
        onAborted()
    }
    onUnsuccessful()
    if (isFailure) {
        onFailure()
    }
    if (isUnstable) {
        onUnstable()
    }
}
onCleanup()

Les différents appels onXYZ() sont des fonctions que vous définiriez pour gérer cette condition particulière au lieu d'utiliser la syntaxe plus agréable des blocs déclaratifs post.

1
Will

Des blocs try-catch peuvent être configurés pour gérer les erreurs, comme dans le code d'une application réelle.

Par exemple:

try {
    node {
        sh 'sleep 20' // <<- can abort here
    }
} catch (Exception e) {
    println 'catch'
} finally {
    println 'finally'
}

node {
    println 'second'
}

try {
    node {
        sh 'sleep 20' // <<- can abort here again
    }
} catch (Exception e) {
    println 'catch'
} finally {
    println 'finally'
}

Et voici un exemple de sortie avec deux abandons.

Started by user me
Replayed #3
[Pipeline] node
Running on my-node in /var/lib/jenkins-slave/workspace/my-job
[Pipeline] {
[Pipeline] sh
[my-job] Running Shell script
+ sleep 20

Aborted by me

Sending interrupt signal to process

/var/lib/jenkins-slave/workspace/my-job@tmp/durable-9e1a15e6/script.sh: line 2: 10411 Terminated              sleep 20
[Pipeline] }
[Pipeline] // node
[Pipeline] echo
catch
[Pipeline] echo
finally
[Pipeline] node
Running on my-node in /var/lib/jenkins-slave/workspace/my-job
[Pipeline] {
[Pipeline] echo
second
[Pipeline] }
[Pipeline] // node
[Pipeline] node
Running on my-node in /var/lib/jenkins-slave/workspace/my-job
[Pipeline] {
[Pipeline] sh
[my-job] Running Shell script
+ sleep 20

Aborted by me

Sending interrupt signal to process
/var/lib/jenkins-slave/workspace/my-job@tmp/durable-d711100c/script.sh: line 2: 10416 Terminated              sleep 20
[Pipeline] }
[Pipeline] // node
[Pipeline] echo
catch
[Pipeline] echo
finally
[Pipeline] End of Pipeline
Finished: ABORTED

Bien sûr, cela fonctionne pour toutes les exceptions se produisant pendant l'exécution.

1
allprog