Jenkins Pipeline 基础语法整合

以下代码直接放在pipeline任务里就可以直接运行哦

pipeline {
    // agent指示Jenkins为整个Pipeline分配一个执行器(在Jenkins环境中任何可用的代理/节点上)和工作区。
    agent {
        node {
            // 运行管道或单个阶段的标签或标签条件。
            label 'built-in'
            
            // 在这个自定义工作空间内运行管道或应用此代理的各个阶段，而不是默认阶段。它可以是相对路径(在这种情况下，自定义工作区将位于节点上的工作区根下)，也可以是绝对路径。
            customWorkspace "WS/${JOB_NAME}"
        }
    }
    
    // 触发器指令定义了应该重新触发流水线的自动方法。
    triggers {
        
        // 接受cron样式的字符串，以定义应在其中重新触发管道的常规间隔，
        cron('H */4 * * 1-5')
        
        // 接受以逗号分隔的作业字符串和一个阈值。当字符串中的任何作业以最小阈值结束时，管道将被重新触发。
        upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS)
    }
    
    parameters {
        string(name: 'PERSON', defaultValue: 'TOBEALISTENER', description: 'Who should I say hello to?')
        text(name: 'BIOGRAPHY', defaultValue: '', description: 'Enter some information about the person')
        booleanParam(name: 'TOGGLE', defaultValue: true, description: 'Toggle this value')
        choice(name: 'CHOICE', choices: ['One', 'Two', 'Three'], description: 'Pick something')
        password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'Enter a password')
        choice(name: 'PLATFORM_FILTER', choices: ['all', 'linux', 'windows', 'mac'], description: 'Run on specific platform')
    }
    
    environment {
        // 直接赋值给环境变量
        Var01="Hello"
        
        // 通过变量赋值给环境变量
        Var02="${PERSON}_$COMPUTERNAME"
        
        // 通过脚本返回值字符串赋值给环境变量
        CC="""${sh(
            returnStdout: true,
            script: 'echo "Hello World!"'
        )}"""
        
        // 通过脚本返回值状态码赋值给环境变量
        EXIT_STATUS="""${sh(
            returnStatus: true,
            script: 'echo "Hello World!"'
        )}"""
    }
    
    options {
        // 为最近的管道运行的特定数量持久化工件和控制台输出。
        buildDiscarder(logRotator(numToKeepStr: '1'))
        
        // 在工作空间的子目录中执行自动源代码控制签出。
        checkoutToSubdirectory('foo')
        
        // 禁止流水线的并发执行。可用于防止对共享资源的同步访问。
        disableConcurrentBuilds()
        
        // 如果控制器重新启动，不允许管道恢复。
        disableResume()
        
        // 允许重写分支索引触发器的默认处理。
        // 如果分支索引触发器在multibranch或organization标签下被禁用，选项{overrideIndexTriggers(true)}将只在该任务中启用它们。
        // 否则，选项{overrideIndexTriggers(false)}将仅为该任务禁用分支索引触发器。
        overrideIndexTriggers(true)
        
        // 保留已完成构建的存储，以用于阶段重新启动。
        // 例如:options {preserveStashes()}保存最近完成的构建的存储，
        // 或者options {preserveStashes(buildCount: 5)}保存最近5个完成的构建的存储。
        preserveStashes()
        
        // 为管道设置以秒为单位的静默周期，覆盖全局默认值。
        quietPeriod(30)
        
        // 如果失败，请按指定次数重试整个管道。
        retry(3)
        
        // 默认情况下，在代理指令中跳过从源代码控制检出代码。
        skipDefaultCheckout()
        
        // 一旦构建状态变为不稳定，就跳过各个阶段。
        skipStagesAfterUnstable() 
        
        // 设置管道运行的超时时间，在此之后Jenkins应该中止管道。
        timeout(time: 1, unit: 'HOURS')
        
        // 在由Pipeline运行生成的所有控制台输出前加上发出该行的时间。
        timestamps () 
        
        // 将管线中所有后续并行阶段的failfast设置为true。
        parallelsAlwaysFailFast()
    }
    
    stages {
        stage('Example') {
            
            // when指令允许Pipeline根据给定条件决定是否执行该阶段。
            when {
                // 执行正在构建的分支与给定的分支模式是否匹配,可选参数comparator可以添加在属性之后，以指定如何对匹配的模式进行评估:
                // "EQUALS"表示一个简单的字符串比较，
                // "GLOB"(默认)用于ANT样式的路径GLOB(与changeset示例相同)，
                // "REGEXP"，用于正则表达式匹配。
                branch pattern: "release-\\d+", comparator: "REGEXP"
                
                // 执行构建构建标记时的阶段。
                buildingTag()
                
                // 如果构建的SCM变更日志包含给定的正则表达式模式，则执行该阶段，
                changelog '.*^\\[DEPENDENCY\\] .+$'
                
                // 如果构建的SCM变更集包含一个或多个匹配给定模式的文件，则执行该阶段。
                changeset "**/*.js"
                changeset pattern: ".TEST\\.java", comparator: "REGEXP"
                
                // 如果当前的构建是为了一个"变更请求"(也就是在GitHub和Bitbucket上的Pull request，在giitlab上的Merge request，在Gerrit上的change，等等)，则执行该阶段。
                // 当没有传递参数时，该阶段将对每个变更请求运行，
                changeRequest()
                
                // 通过向变更请求添加带有参数的过滤器属性，可以使该阶段仅在匹配的变更请求上运行。
                // 可能的属性有id、target、branch、fork、url、title、author、authorDisplayName和authorEmail。
                changeRequest target: 'master'
                changeRequest authorEmail: "[\\w_-.]+@example.com", comparator: 'REGEXP'
                
                // 当指定的环境变量设置为给定值时，执行该阶段
                environment name: 'DEPLOY_TO', value: 'production'
                
                // 执行期望值等于实际值的阶段，
                equals expected: 2, actual: currentBuild.number
                
                // 当指定的Groovy表达式的计算结果为true时，执行这个阶段，
                expression { return params.DEBUG_BUILD }
                
                // 如果TAG_NAME变量与给定的模式匹配，则执行该阶段。
                // 例如:when {tag "release-*"}。
                // 如果提供了一个空模式，如果TAG_NAME变量存在，则该阶段将执行(与buildingTag()相同)。
                tag "release-*"
                tag pattern: "release-\\d+", comparator: "REGEXP"
                
                // 当嵌套条件为false时，执行阶段。必须包含一个条件。
                not { branch 'master' }
                
                // 当所有嵌套条件都为真时，执行阶段。必须包含至少一个条件。
                allOf { 
                    branch 'master'
                    environment name: 'DEPLOY_TO', value: 'production' 
                }
                
                // 当至少有一个嵌套条件为真时，执行阶段。必须包含至少一个条件。
                anyOf { 
                    branch 'master'
                    branch 'staging' 
                }
                
                // 当给定参数触发当前构建时，执行该阶段。
                triggeredBy 'SCMTrigger'
                triggeredBy 'TimerTrigger'
                triggeredBy 'BuildUpstreamCause'
                triggeredBy cause: "UserIdCause", detail: "vlinde"
                
                // 默认 "when" 阶段的执行要晚于agent、input和options阶段，但可以强行更改
                beforeAgent true
                beforeInput true
                beforeOptions true
            }
            
            options {
                skipDefaultCheckout()
                timeout(time: 1, unit: 'HOURS')
                retry(3)
                timestamps()
            }
            
            // "stage"上的"input"指令允许你使用"input step"来提示输入。
            // "stage"将在任何"options"被应用后，以及在进入该"stage"的"agent"块或评估"stage"的"when"条件之前暂停。
            // 如果"input"得到批准，则"stage"将继续。作为"input"提交的一部分提供的任何参数都将在"stage"的其余环境中可用。
            input {
                // 必需的。这将在用户提交输入时呈现给用户。
                message "Should we continue?"
                
                // id: 此输入的可选标识符。默认为 stage 名。
                
                // 输入表单上"ok"按钮的可选文本。
                ok "Yes, we should."
                
                // submitter "alice,bob" 允许提交此输入的用户或外部组名的可选列表，以逗号分隔。默认允许任何用户使用。
                // submitterParameter 环境变量的可选名称，如果存在，则使用提交者名称设置。
                
                // 提示提交者提供的可选参数列表。
                parameters {
                    string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')
                }
            }
            
            steps {
                echo "Hello ${params.PERSON}"
                echo "Biography: ${params.BIOGRAPHY}"
                echo "Toggle: ${params.TOGGLE}"
                echo "Choice: ${params.CHOICE}"
                echo "Password: ${params.PASSWORD}"
                
                
                script {
                    def browsers = ['chrome', 'firefox']
                    for (int i = 0; i < browsers.size(); ++i) {
                        echo "Testing the ${browsers[i]} browser"
                    }
                }
            }
        }
        
        // 声明性管道中的阶段可以有一个Stages部分，其中包含要按顺序运行的嵌套阶段列表。
        stage('Sequential') {
            environment {
                FOR_SEQUENTIAL = "some-value"
            }
            stages {
                stage('In Sequential 1') {
                    steps {
                        echo "In Sequential 1"
                    }
                }
                stage('In Sequential 2') {
                    steps {
                        echo "In Sequential 2"
                    }
                }
                stage('Parallel In Sequential') {
                    parallel {
                        stage('In Parallel 1') {
                            steps {
                                echo "In Parallel 1"
                            }
                        }
                        stage('In Parallel 2') {
                            steps {
                                echo "In Parallel 2"
                            }
                        }
                    }
                }
            }
        }
        
        // 声明性管道中的阶段可以有一个并行部分，其中包含要并行运行的嵌套阶段列表。
        stage('Parallel Stage') {
            failFast true
            parallel {
                stage('Branch C') {
                    stages {
                        stage('Nested 1') {
                            steps {
                                echo "In stage Nested 1 within Branch C"
                            }
                        }
                        stage('Nested 2') {
                            steps {
                                echo "In stage Nested 2 within Branch C"
                            }
                        }
                    }
                }
            }
        }
        
        // 声明性管道中的阶段可以有一个矩阵部分，定义要并行运行的名称-值组合的多维矩阵。我们将这些组合称为矩阵中的"单元格"。
        // 你可以通过在包含矩阵的阶段中添加 failFast true 来强制你的矩阵单元格在其中任何一个失败时全部被终止。
        stage('BuildAndTest') {
            
            // "matrix"部分必须包括"axes"部分和"stages"部分。
            matrix {
                // "stage"上的许多指令，包括"agent"、"tools"、"when"等，也可以添加到"matrix"中来控制每个单元格的行为。
                // "axes"部分定义了"matrix"中每个"axis"的值。
                axes {
                    axis {
                        name 'PLATFORM'
                        values 'linux', 'windows', 'mac'
                    }
                    axis {
                        name 'BROWSER'
                        values 'firefox', 'chrome', 'safari', 'edge'
                    }
                }
                
                // "matrix"可以有一个"excludes"部分，以从"matrix"中删除无效的单元格。
                excludes {
                    exclude {
                        axis {
                            name 'PLATFORM'
                            values 'linux'
                        }
                        axis {
                            name 'BROWSER'
                            values 'safari'
                        }
                    }
                    exclude {
                        axis {
                            name 'PLATFORM'
                            notValues 'windows'
                        }
                        axis {
                            name 'BROWSER'
                            values 'edge'
                        }
                    }
                }
                
                // "stages"部分定义了要在每个单元中顺序运行的"stages"列表。
                stages {
                    stage('Build') {
                        steps {
                            echo "Do Build for ${PLATFORM} - ${BROWSER}"
                        }
                    }
                    stage('Test') {
                        steps {
                            echo "Do Test for ${PLATFORM} - ${BROWSER}"
                        }
                    }
                }
            }
        }
    }
    
    post {
        failure { echo 'failure -- 构建失败' }
        success { echo 'success -- 构建成功' }
        always { echo 'always -- 总是输出' }
        changed { echo 'changed -- 我与上次的构建结果不同' }
        fixed { echo 'fixed -- 上一次构建失败，这一次构建成功了我才输出' }
        regression { echo 'regression -- 上一次构建失败，这一次构建成功了我才输出' }
        aborted { echo 'aborted -- 有人中止了当前构建，我才会被输出~' }
        unstable { echo 'unstable -- 只有当前构建不稳定时，我才会输出' }
        unsuccessful { echo 'unsuccessful -- 只要构建不成功，我都会输出！' }
        cleanup { echo 'cleanup -- 无论状态如何，全部阶段结束时输出' }
    }
}