如何创建带有阶段和步骤的groovy函数

Question

我有一个 Jenkinsfile，其管道调用变得越来越长，我想从中创建函数以具有更好的可读性。

参见 Jenkinsfile ：

def utils

def setupEnvironment() {
    def localUtils

     SVN Export for cm/jenkins
    pwsh """
        svn export --username=\"\$env:ARTIFACTORY_CREDS_USR\" --password=\"\$env:ARTIFACTORY_CREDS_PSW\" -q ${UTILS_SVN_PATH} cm/jenkins
    """    

     Load utils.groovy
    echo "Loading utils.groovy from ${WORKSPACE}/cm/jenkins/utils.groovy"
    localUtils = load("${WORKSPACE}/cm/jenkins/utils.groovy")
    
     Check if utils is loaded successfully
    if (localUtils == null) {
        error "Failed to load utils.groovy"
    } else {
        echo "utils.groovy loaded successfully."
    }

    return localUtils
}


pipeline {
    agent { label 'master' }
    environment {
        List of env variables to set from jenkins server
    }

    stages {   
        stage('Setup') {
            agent { label 'linux-docker' }
            steps {
                script {
                    utils = setupEnvironment()
                }
            }
        }

        stage('main') {
            parallel {
                stage('Windows') {
                     agent {label 'windows-docker'}
                     environment {
                         WINDOWS_EXPORT_DIR = "voice_windows-${env.CURRENT_DATE_TIME}"   New environment variable
                     }                    
                     stages {
                         stage('Windows svn'){
                             steps{
                                 script{
                                     echo "The Windows svn export Node Name is: ${NODE_NAME}"
                                     utils.svnExport(FX_SVN_PATH, WINDOWS_EXPORT_DIR)
                                 }
                             }
                         }
                         stage('Windows docker') {
                             steps {
                                 pwsh """
                                     docker image prune -f
                                 """
                                 script {
                                     echo "The Windows docker image Node Name is: ${NODE_NAME}"
                                     env.DOCKER_IMAGE_TAG_FOR_VOICE = utils.processDockerImage(WINDOWS_EXPORT_DIR,
                                                                                         WINDOWS_VOICE_DOCKERFILE, 
                                                                                         WINDOWS_IMAGE_NAME, 
                                                                                         FX_SVN_PATH, 
                                                                                         FX_DOCKERFILES_SVN_PATH)
                                 }
                             }
                         }
                         stage('Windows Build') {
                             steps {
                                  Your build steps go here.
                                 script {
                                     utils.buildWindowsVoice(WINDOWS_EXPORT_DIR, WINDOWS_IMAGE_NAME, env.DOCKER_IMAGE_TAG_FOR_VOICE)
                                 }
                             }
                         }
                     }
                     post {
                         always {
                             cleanWs()
                         }
                     }
                }
            }
        }
    }
}

从上面的文件中，我想从舞台创建一个函数

stage('Windows')

。所以，我会有这样的东西：

        stage('main') {
            parallel {
                buildWindows()
            }
         }

我尝试将代码移动到 groovy 函数中，但出现错误，提示

steps

无法识别。我认为这是因为我混合了脚本语法和声明语法。

谢谢你

Answer 1

为了更好的可读性，您应该在 Jenkins 共享库中定义函数，并使用注释 @Library('my-shared-library') _

将它们包含在 Jenkinsfile 中

https://www.jenkins.io/doc/book/pipeline/shared-libraries/