A grande maioria das pessoas irá trabalhar com esteiras relativamente lineares do Jenkins - ainda que estas esteiras chamem outras esteiras, que chamem outras esteiras, e outras, e assim por diante, criando verdadeiros monstros dos espaguetis voadores.

Jenkins는 실행이 빌드되는 동안 설계 또는 설명할 수 없는 동기를 부여하는 설계를 시작했습니다. Uma das consequências disso é o fato de que o comportamento padrão do Jenkins é falhar uma esteira quando qualquer um dos seus stage falha. E cabe a você, a pessoa que está desenvolvendo a esteira, cuidar disso.

Durante este post, irei abordar alguns cenários comuns e algumas soluções possíveis para os mesmos.

Primeiro cenário: continuar um build mesmo quando um stage falha

Esta é uma pergunta muito comum na stack mais famosa do mundo. 상상해보십시오 que você possui um stage que pode falhar, mas que não necessariamente impedirá a execução da esteira como um todo. Se você ama Java, você simplesmente irá adorar o quê vem a seguir.

모든 시나리오에서 trabalhar는 다음 파이프라인과 연결됩니다.

pipeline {
    agent any

    stages {
        stage('Primeiro stage') {
            steps {
                script {
                    git credentialsId: 'Bitbucket', url: 'https://bitbucket.org/stefano/bla.git' 
                }
            }
        }

        stage('Segundo stage') {
            steps {
                script {
                    print('Ooopsie, nunca vou rodar! :(')
                }
            }
        }
    }
}

Esta 파이프라인은 8년에 한 번도 존재하지 않는 특정 리포지토리를 보유하고 있습니다. Na a presentação visual da pipeline, teremos algo parecido com isto:

해결 방법: utilizar um bloco try {} catch() {}

Podemos utilizar um bloco try {} catch() {} ao redor do trecho passível de erro.

pipeline {
    agent any

    stages {
        stage('Primeiro stage') {
            steps {
                script {
                    try {
                        git credentialsId: 'Bitbucket', url: 'https://bitbucket.org/stefano/bla.git' 
                    }
                    catch(Exception e) {
                        print("${e}")
                    }
                }
            }
        }

        stage('Segundo stage') {
            steps {
                script {
                    print('Ooopsie, nunca vou rodar! :(')
                    print('Opa pera! :)')
                }
            }
        }
    }
}

파이프라인에 대한 설명:



Como pode-se observar, ambos os stage são executados, contudo o primeiro é apresentado com sucesso, ainda que o comando tenha apresentado falha. Isso é uma questão de semântica: houve um erro em tempo de execução da pipeline e houve uma tratativa quanto a ele, logo, há o entendimento de que está tudo bem e que o stage deve ser marcado como SUCCESS.

해결 방법: Quando queremos marcar o stage como FAILED

Caso desejemos marcar aquele stage como FAILED, devemos utilizar um bloco catchError() , podendo utilizá-lo juntamente com um bloco try {} catch() {} ou sozinho. catchError() faz é pegar o resultado de um step(ou steps) que estão dentro do bloco e caso algum destes termine em erro, ele setará os status do stage ou o build conforme o seu desejo, normalmente sendo como SUCCESS ou FAILURE. Abaixo dois exemplos, um não aninhado e o outro com um bloco try {} catch() {}, assim como suas 각각의 실행:

pipeline {
    agent any

    stages {
        stage('Primeiro stage') {
            steps {
                script {
                    catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                        git credentialsId: 'Bitbucket', url: 'https://bitbucket.org/stefano/bla.git' 
                    }
                }
            }
        }

        stage('Segundo stage') {
            steps {
                script {
                    print('Ooopsie, nunca vou rodar! :(')
                    print('Opa, vou sim! :)')
                }
            }
        }
    }
}

pipeline {
    agent any

    stages {
        stage('Primeiro stage') {
            steps {
                script {
                    try {
                        sh 'cat /tmp'
                    }
                    catch(Exception e) {
                        print("${e}")
                        catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                            sh 'exit 1'
                        }
                    }
                }
            }
        }

        stage('Segundo stage') {
            steps {
                script {
                    print('Ooopsie, nunca vou rodar! :(')
                    print('Opa, vou sim!')
                }
            }
        }
    }
}

세군도 시나리오: Execução de um stage de forma condicional

Imagine que você deseja que um stage seja executado condicionalmente, dependency do status do anterior. A primeira solução que nos vêm à mente é trabalhar com blocos when {} . 프로세스가 진행 중일 때 파이프라인 실행 시 분석 결과가 나오지 않을 수 있습니다.

A segunda solução é criar algumas variáveis ​​de ambiente em bloco environment {} e analisá-las de um bloco para o outro, o quê também não daria certo, pois não conseguimos trocar seus valores.

Chegamos então à uma solução possível que é: Arquivos texto. Abaixo 음 예:

pipeline {
    agent any

    stages {
        stage("stage1") {
            steps {
                script {
                    try {
                        sh 'cat /tmp'
                        writeFile encoding: 'utf-8', file: 'stageStatus', text: 'SUCCESS'
                    }
                    catch(Exception e) {
                        writeFile encoding: 'utf-8', file: 'stageStatus', text: 'FAILED'
                        print("Ooopsie!")
                        catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                            sh 'exit 1'
                        }
                    }
                }
            }
        }

        stage("stage2") {
            steps {
                script {
                    def previousStageStatus = readFile encoding: 'utf-8', file: 'stageStatus'
                    if (previousStageStatus == 'FAILED') {
                        print('The previous stage failed')
                    }
                }
            }
        }
    }
}

Nele는 writeFile() 및 readFile() 함수를 funções로 사용하여 다른 문서의 텍스트와 관련하여 이전 단계의 상태를 확인하고 실패할 경우가 발생합니다.

O único problema desta solução - que não é grande, pelo menos da minha perspectiva - é que não importa o quê aconteça, o segundo stage semper será executado, ainda que ele não faça nada.


Pipeline quando o stage é disparado


Pipeline quando o stage não é disparado

Bom pessoal, por hoje é só. Espero que tenham gostado!

아브라소!