jenkins流水線學習二（工具）

Jenkins特意為了更好使用pipeline，開發了一些工具類，方便我們更好地在step中處理各種需求。

一、Pipeline Utility Steps

https://jenkins.io/doc/pipeline/steps/pipeline-utility-steps/
這是個插件，需要在jenkins插件管理安裝。參考來源：https://blog.csdn.net/u011541946/article/details/83833289

1、findFiles 　　　（需要在項目下要有log文件）

2、readJSON 　　（方法有兩種參數，分別是文件路徑和字符串；示例是文件路徑；　　datas = readJSON text : json_string）

3、writeJSON 　　（file入參是文件路徑，json可以是readJSON的結果，也可以是轉換為json的字符串；示例是writeJSON的方式）

4、readProperties （讀取properties文件，得到是一個map對象）

5、readYaml  　　（讀取yaml文件，得到是一個map對象；有2種參數，同上面的readJson； 　　datas = readYaml text : yaml_string）

6、writeYaml  　　（入參是readYaml的結果，也可以是一個map）

pipeline {
    agent any
    stages {
        stage('env') {
            steps {
                script {
                    println env.JOB_NAME
                    println env.BUILD_NUMBER
                    println env.WORKSPACE
                }
            }
        }
        stage('Utility Steps method---findFiles') {
            steps {
                script {
                    files = findFiles(glob: '**/*.log')
                    println files[0].name
                }
            }
        }
        stage('Utility Steps method---readJSON') {
            steps {
                script {
                    file_path_read = env.WORKSPACE + "/package.json"
                    rd_json = readJSON file : file_path_read
                    println rd_json
                    println rd_json.name
                }
            }
        }
        stage('Utility Steps method---writeJSON') {
            steps {
                script {
                    file_path_write = env.WORKSPACE + "/test_jenkins.json"
                    input_json =  env.WORKSPACE + "/package.json"
                    input = readJSON file : input_json

                    writeJSON file: file_path_write, json: input
                }
            }
        }
        stage('Utility Steps method---readProperties') {
            steps {
                script {
                    properties_file = env.WORKSPACE + "/test_jenkins.properties"
                    props = readProperties interpolate: true, file: properties_file
                    println props
                }
            }
        }
        stage('Utility Steps method---readYaml') {
            steps {
                script {
                    yaml_file = env.WORKSPACE + "/test_jenkins.yaml"
                    y = readYaml file : yaml_file
                    println y
                }
            }
        }
        stage('Utility Steps method---writeYaml') {
            steps {
                script {
                    yaml_path = env.WORKSPACE + "/test_jenkins_write.yaml"
                    input_path = env.WORKSPACE + "/test_jenkins.yaml"
                    input_map = readYaml file : input_path

                    writeYaml file: yaml_path , data: input_map
                }
            }
        }
    }
}

二、pipeline basic steps
這是一個最基礎的pipeline組件，這個也是一個獨立的插件，在安裝pipeline的時候默認會自動安裝
官網：https://jenkins.io/doc/pipeline/steps/workflow-basic-steps/

1、deleteDir()
　　這個是默認遞歸刪除WORKSPACE下的文件和文件夾
　　使用場景：做完了每一個stage里面的事情，我們需要在post{...}里面寫一些clean up操作
2、dir()
　　這個方法是改變當前的工作目錄
3、error()
　　遇到這個方法，該stage和后面的stage都會顯示失敗
4、fileExists
　　判斷一個文件是否存在，返回值是布爾類型
5、isUnix()
　　判斷當前運行的Jenkins node環境是不是linux環境
6、pwd()
　　linux是pwd，windows上是dir。所以這個插件就干脆支持一個方法，統稱為pwd()

pipeline{
    agent any
    stages{
        stage("dir") {
            steps{
                // 如果沒有這個目錄，會自動創建這個目錄
                dir("${env.WORKSPACE}/testdata"){
                    sh "pwd"
                }
            }
        }
        stage("fileExists") {
            steps{
                script {
                    json_file = "${env.WORKSPACE}/test_jenkins.log"
                    if(fileExists(json_file) == true) {
                        echo("log file is exists")
                    }else {
                        error("here haven't find log file")
                    }
                }
            }
        }
        stage("isUnix") {
            steps{
                script {
                    if(isUnix() == true) {
                        echo("this jenkins job running on a linux-like system")
                    }else {
                        error("the jenkins job running on a windows system")
                    }
                }
            }
        }
        stage("pwd()") {
            steps{
                script {
                    sh("pwd")
                    println "==========="
                    println pwd()
                }
            }
        }
    }
    post {
        always {
            script {
                //寫相關清除/恢復環境等操作代碼
                //deleteDir()
                println "結束"
            }
        }
    }
}

三、pipeline basic steps（郵件）

pipeline{
    agent any
    environment {
        to_email = "[e-mail]"
        to_email_address_list = "[e-mail],[e-mail]"
    }
    stages{
        stage("發郵件demo 1") {
            steps{
                script {
                    mail to: to_email,
                    subject: "Running Pipeline: ${currentBuild.fullDisplayName}",
                    body: "Something is wrong with ${env.BUILD_URL}"
                }
            }
        }
        stage("發郵件demo 2") {
            steps{
                script {
                    mail to: to_email,
                    cc: '[e-mail]',            // 抄送
                    charset:'UTF-8',            // or GBK/GB18030
                    mimeType:'text/plain',        // or text/html
                    subject: "Running Pipeline: ${currentBuild.fullDisplayName}",
                    body: "Something is wrong with ${env.BUILD_URL}, just for test send mail via pipeline code"
                }
            }
        }
        stage("發郵件demo 3") {
            steps{
                script {
                    subject = "Jenkins Job : " + env.JOB_NAME + "/" + env.BUILD_ID
                    result_url = env.BUILD_URL + "console"
                    text = """
                    <!DOCTYPE html>
                    <html>
                        <head>
                            <meta charset="utf-8">
                            <title></title>
                        </head>
                        <body>
                            <div>
                                <h1>Summary</h1>
                                <div>
                                    <h2>Jenkins Build</h2>
                                    <ul>
                                        <li>Job URL : <a href='${env.BUILD_URL}'>${env.BUILD_URL}</a></li>
                                        <li>Build Result URL : <a href='${result_url}'>${result_url}</a></li>
                                    </ul>
                                </div>
                                <div>
                                    <h2>GIT Branch</h2>
                                    <ul>
                                        <li>這是一個測試分支</li>
                                    </ul>
                                </div>
                            </div>
                        </body>
                    </html>
                    """
                    mail body: text, subject: subject,  mimeType: 'text/html', to: to_email_address_list
                }
            }
        }
    }
    post{
        always{
            script {
                module_test = load env.WORKSPACE + "/test_groovy.groovy"
            }
        }
        failure {
            script {
                module_test.send_email_results("Failed","Master",to_email_address_list)
            }
        }
        success {
            script {
                module_test.send_email_results("Success","Master",to_email_address_list)
            }
        }
    }
}

上面引用的test_groovy.groovy如下

def send_email_results(status,GITBranch,to_email_address_list) {
    subject = "Jenkins Job : " + env.JOB_NAME + "/" + env.BUILD_ID + " has " +  status
    result_url = env.BUILD_URL + "console"
    
    text = """
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <title></title>
    </head>
    <body>
        <div>
            <h1>Summary</h1>
            <div>
                <h2>Jenkins Build</h2>
                <ul>
                    <li>Job URL : <a href='${env.BUILD_URL}'>${env.BUILD_URL}</a></li>
                    <li>Build Result URL : <a href='${result_url}'>${result_url}</a></li>
                </ul>
            </div>
            <div>
                <h2>GIT Branch</h2>
                <ul>
                    <li>這是測試引用其他groovy文件的郵件${GITBranch}</li>
                </ul>
            </div>
        </div>
    </body>
    </html>
    """
    
    mail body: text, subject: subject,  mimeType: 'text/html', to: to_email_address_list
}

return this

 四、pipeline basic steps（readFile、retry、sleep）

1、readFile，讀取文件內容（兩個參數，第一個是file的path，第二個是encoding，默認是根據你當前平台的編碼）
　　如果不知道文件是什么格式（格式例如txt,log,json,properties,config,yaml），則推薦用readFile
　　如果拿來讀一個圖片或者音頻視頻文件，讀取二進制文件會采用Base64轉碼的字符串輸出。
2、retry和sleep
　　retry只能在出現異常的地方才能使用，否則只跑一遍就結束
　　retry(3)這個3是一個整數，表示嘗試的次數，sleep中的2表示2秒，注意這單位是秒

pipeline{
    agent any
    stages{
        stage("init") {
            steps{
                script {
                    json_file = "${env.WORKSPACE}/package.json"
                    file_contents = readFile json_file
                    println file_contents
                }
            }
        }
        stage("retry and sleep") {
            steps{
                script{
                    try {
                        retry(3) {
                            println "here we are test retry fuction"
                            sleep 5
                            println 10/0
                        }
                    }catch (Exception e) {
                        println e
                    }
                }
            }
        }
    }
}

五、pipeline basic steps（timeout 、waitUntil 、withEnv ）

1、timeout （超時則aborted）
2、waitUntil （直到返回true才跳出，否則一直重試）
3、withEnv （添加環境變量）

pipeline{
    agent any
    stages{
        stage("init") {
            steps{
                script {
                    // 設置超時5s，默認單位是分鍾
                    timeout(time: 50, unit: 'SECONDS') {
                        //initialRecurrencePeriod ：設置重試之間的初始等待時間（以毫秒為單位）。
                        // 默認為 250 毫秒。每次失敗都會將嘗試之間的延遲減慢至最多 15 秒
                        //quiet ：如果為真，則每次檢查條件時該步驟都不會記錄消息。默認為假。類型： boolean
                        println "是unix系統嗎" + isUnix()
                        waitUntil(initialRecurrencePeriod: 1000,quiet: true){
                            script {
                                isUnix()
                            }
                        }
                    }
                }
            }
        }
        stage("env") {
            steps{
                script {
                    withEnv(['java_home=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.181-3.b13.el6_10.i386/jre']) {
                        sh("$java_home/bin/java -version")
                        println "test with withEnv feature"
                    }
                }
            }
        }
    }
}

 六、pipeline basic steps（writeFile）

println env.JOB_NAME
println env.BUILD_NUMBER

pipeline{

    agent any
    stages{
        stage("writeFile demo") {
            steps{
                script {
                    write_file_path = "${env.WORKSPACE}/test_jenkins.txt"
                    file_contents = "Hello Anthony!! 這是一個測試例子"
                    // 寫文件
                    writeFile file: write_file_path, text: file_contents, encoding: "UTF-8"
                    // 讀文件
                    fileContents = readFile file: write_file_path, encoding: "UTF-8"
                    println fileContents
                }
            }
        }
    }
}

七、