-script {
-    git.setSshKey(GIT_CREDENTIALS_ID)
-    retry(2) {
-        prow.checkoutRefs(REFS, timeout = 5, credentialsId = '', gitBaseUrl = 'https://github.com', withSubmodule=true)
+withCredentials([sshUserPrivateKey(credentialsId: GIT_CREDENTIALS_ID, keyFileVariable: 'SSH_KEY')]) {
+    script {
+        git.setSshKey(SSH_KEY)
+        retry(2) {
+            prow.checkoutRefs(REFS, timeout = 5, credentialsId = '', gitBaseUrl = 'https://github.com', withSubmodule=true)
+        }
     }
 }
 

 stage('TestsGroup1') {
     matrix {
         axes {
             axis {
                 name 'CACHE_ENABLED'
                 values '0', "1"
             }
             axis {
                 name 'TEST_PATH_STRING'
                 values 'index/between/1 index/between/10 index/between/100', 'index/between/100 index/between/1000 index/commute/10',
                     'index/commute/100 index/commute/1000_n1 index/commute/1000_n2',
                     'index/delete/1 index/delete/10 index/delete/100 index/delete/1000 index/delete/10000',
                     'random/aggregates_n1 random/aggregates_n2 random/expr' , 'random/expr random/select_n1 random/select_n2', 
                     'select random/groupby'
             }
         }
         agent{
             kubernetes {
                 namespace K8S_NAMESPACE
                 yamlFile POD_TEMPLATE_FILE
                 defaultContainer 'golang'
             }
         } 
         stages {
             stage("Test") {
                 options { timeout(time: 40, unit: 'MINUTES') }
                 steps {
                     dir('tidb-test') {
                         cache(path: "./sqllogic_test", includes: '**/*', key: "ws/${BUILD_TAG}/tidb-test") {
                             sh label: "print version", script: """
                                 ls -alh sqllogic_test/
                                 ./sqllogic_test/tidb-server -V
                             """
                             container("golang") {
                                 sh label: "test_path: ${TEST_PATH_STRING}, cache_enabled:${CACHE_ENABLED}", script: """#!/usr/bin/env bash
                                     cd sqllogic_test/
                                     env
                                     ulimit -n
                                     sed -i '3i\\set -x' test.sh
 
                                     path_array=(${TEST_PATH_STRING})
                                     for path in \${path_array[@]}; do
                                         echo "test path: \${path}"
                                         export SQLLOGIC_TEST_PATH="/git/sqllogictest/test/\${path}"
                                         export TIDB_PARALLELISM=8
                                         export TIDB_SERVER_PATH="${WORKSPACE}/tidb-test/sqllogic_test/tidb-server"
                                         export CACHE_ENABLED="${CACHE_ENABLED}"
                                         ./test.sh
                                     done
                                 """
                             }
                         }
                     }
                 }
             }
         }
     }
+    post {
+        always {
+            archiveArtifacts artifacts: '**/sqllogic_test/*.log', allowEmptyArchive: true
+        }
+        failure {
+            archiveArtifacts artifacts: '**/sqllogic_test/*.log', allowEmptyArchive: true
+        }
+    }
 }
 

 pipeline {
     agent {
         kubernetes {
             namespace K8S_NAMESPACE
             yamlFile POD_TEMPLATE_FILE
             defaultContainer 'golang'
         }
     }
     environment {
         FILE_SERVER_URL = 'http://fileserver.pingcap.net'
         GITHUB_TOKEN = credentials('github-bot-token')
     }
     options {
         timeout(time: 40, unit: 'MINUTES')
         parallelsAlwaysFailFast()
     }
     stages {
         ...
     }
+    post {
+        always {
+            cleanWs()
+        }
+    }
 }
 

 pipeline {
     agent {
         kubernetes {
             namespace K8S_NAMESPACE
             yamlFile POD_TEMPLATE_FILE
             defaultContainer 'golang'
         }
     }
     environment {
         FILE_SERVER_URL = 'http://fileserver.pingcap.net'
     }
     options {
         timeout(time: 60, unit: 'MINUTES')
     }
     stages {
         ...
     }
+    post {
+        always {
+            echo 'This will always run'
+            // Add any necessary cleanup or notification steps here
+        }
+    }
 }
 

 stage("Test") {
     options { timeout(time: 40, unit: 'MINUTES') }
     steps {
         dir('tidb-test') {
             cache(path: "./", includes: '**/*', key: "ws/${BUILD_TAG}/tidb-test") {
                 sh label: 'print version', script: """
                     ls -alh bin/
                     ./bin/tidb-server -V
                     ./bin/tikv-server -V
                     ./bin/pd-server -V
                 """
                 container("golang") {
                     sh label: "test_store=${TEST_STORE} test_part=${TEST_PART}", script: """#!/usr/bin/env bash
                         if [[ "${TEST_STORE}" == "tikv" ]]; then
                             echo '[storage]\nreserve-space = "0MB"'> tikv_config.toml
                             bash ${WORKSPACE}/scripts/PingCAP-QE/tidb-test/start_tikv.sh
                             export TIDB_SERVER_PATH="${WORKSPACE}/tidb-test/bin/tidb-server"
                             export TIKV_PATH="127.0.0.1:2379"
                             export TIDB_TEST_STORE_NAME="tikv"
                             cd mysql_test/ && ./test.sh -blacklist=1 -part=${TEST_PART}
                         else
                             export TIDB_SERVER_PATH="${WORKSPACE}/tidb-test/bin/tidb-server"
                             export TIDB_TEST_STORE_NAME="unistore"
                             cd mysql_test/ && ./test.sh -blacklist=1 -part=${TEST_PART}
                         fi
                     """
                 }
             }
         }
     }
+    post {
+        always {
+            archiveArtifacts artifacts: '**/test-results/*.xml', allowEmptyArchive: true
+            archiveArtifacts artifacts: '**/logs/*.log', allowEmptyArchive: true
+        }
+    }
 }
 

 stage("Test") {
     options { timeout(time: 40, unit: 'MINUTES') }
     steps {
         dir('tidb-test') {
             cache(path: "./", includes: '**/*', key: "ws/${BUILD_TAG}/tidb-test") {
                 sh label: 'print version', script: """
                     ls -alh bin/
                     ./bin/tidb-server -V
                     ./bin/tikv-server -V
                     ./bin/pd-server -V
                 """
                 sh label: "test_params=${TEST_PARAMS} ", script: """#!/usr/bin/env bash
                     export TIDB_SERVER_PATH="${WORKSPACE}/tidb-test/bin/tidb-server"
                     export TIDB_TEST_STORE_NAME="\$TEST_STORE"
                     set -- \${TEST_PARAMS}
                     TEST_DIR=\$1
                     TEST_SCRIPT=\$2
                     echo "TEST_DIR=\${TEST_DIR}"
                     echo "TEST_SCRIPT=\${TEST_SCRIPT}"
                     cd \${TEST_DIR} && chmod +x *.sh && \${TEST_SCRIPT}
                 """
             }
         }
     }
     post{
         failure {
             script {
                 println "Test failed, archive the log"
             }
         }
+        cleanup {
+            script {
+                println "Cleaning up temporary files and resources"
+                // Add cleanup commands here
+            }
+        }
     }
 }
 

 stage("Test") {
     options { timeout(time: 40, unit: 'MINUTES') }
     steps {
         dir('tidb-test') {
             cache(path: "./", includes: '**/*', key: "ws/${BUILD_TAG}/tidb-test") {
                 sh label: 'print version', script: """
                     ls -alh bin/
                     ./bin/tidb-server -V
                     ./bin/tikv-server -V
                     ./bin/pd-server -V
                 """
                 sh label: "test_params=${TEST_PARAMS} ", script: """#!/usr/bin/env bash
                     export TIDB_SERVER_PATH="${WORKSPACE}/tidb-test/bin/tidb-server"
                     export TIDB_TEST_STORE_NAME="\$TEST_STORE"
                     set -- \${TEST_PARAMS}
                     TEST_DIR=\$1
                     TEST_SCRIPT=\$2
                     echo "TEST_DIR=\${TEST_DIR}"
                     echo "TEST_SCRIPT=\${TEST_SCRIPT}"
                     cd \${TEST_DIR} && chmod +x *.sh && \${TEST_SCRIPT}
                 """
             }
         }
     }
     post{
         failure {
             script {
                 println "Test failed, archive the log"
             }
         }
+        success {
+            script {
+                println "Tests passed successfully, performing post-success actions"
+                // Add success actions here
+            }
+        }
     }
 }
 

 stage('Checkout') {
     options { timeout(time: 10, unit: 'MINUTES') }
     steps {
         dir("tidb") {
             cache(path: "./", includes: '**/*', key: prow.getCacheKey('git', REFS), restoreKeys: prow.getRestoreKeys('git', REFS)) {
                 retry(2) {
                     script {
                         prow.checkoutRefs(REFS)
                     }
                 }
             }
         }
         dir("tidb-test") {
             cache(path: "./", includes: '**/*', key: "git/PingCAP-QE/tidb-test/rev-${REFS.pulls[0].sha}", restoreKeys: ['git/PingCAP-QE/tidb-test/rev-']) {
                 retry(2) {
                     script {
                         component.checkout('[email protected]:PingCAP-QE/tidb-test.git', 'tidb-test', REFS.base_ref, REFS.pulls[0].title, GIT_CREDENTIALS_ID)
                     }
                 }
             }
         }
     }
+    post {
+        always {
+            cleanWs()
+        }
+    }
 }
 

 stage('Prepare') {
     steps {
         dir('tidb') {
             container("golang") {
                 sh label: 'tidb-server', script: '[ -f bin/tidb-server ] || make'
                 sh label: 'ddl-test', script: 'ls bin/ddltest || make ddltest'
                 retry(3) {
                     sh label: 'download binary', script: """
                         chmod +x ${WORKSPACE}/scripts/PingCAP-QE/tidb-test/*.sh
                         ${WORKSPACE}/scripts/PingCAP-QE/tidb-test/download_pingcap_artifact.sh --pd=${REFS.base_ref} --tikv=${REFS.base_ref}
                         mv third_bin/tikv-server bin/
                         mv third_bin/pd-server bin/
                         ls -alh bin/
                     """
                 }
             }
         }
         dir('tidb-test') {
             cache(path: "./", includes: '**/*', key: "ws/${BUILD_TAG}/tidb-test") {
                 sh label: "prepare", script: """
                     touch ws-${BUILD_TAG}
                     mkdir -p bin
                     cp ${WORKSPACE}/tidb/bin/* bin/ && chmod +x bin/*
                     ls -alh bin/
                     ./bin/pd-server -V
                     ./bin/tikv-server -V
                     ./bin/tidb-server -V
                 """
             }
         }
     }
+    post {
+        always {
+            cleanWs()
+        }
+    }
 }
 

 stage("Test") {
     options { timeout(time: 40, unit: 'MINUTES') }
     steps {
         dir('tidb-test') {
             cache(path: "./", includes: '**/*', key: "ws/${BUILD_TAG}/tidb-test") {
                 sh label: 'print version', script: """
                     ls -alh bin/
                     ./bin/tidb-server -V
                     ./bin/tikv-server -V
                     ./bin/pd-server -V
                 """
                 sh label: "test_params=${TEST_PARAMS} ", script: """#!/usr/bin/env bash
                     export TIDB_SERVER_PATH="${WORKSPACE}/tidb-test/bin/tidb-server"
                     export TIDB_TEST_STORE_NAME="\$TEST_STORE"
                     set -- \${TEST_PARAMS}
                     TEST_DIR=\$1
                     TEST_SCRIPT=\$2
                     echo "TEST_DIR=\${TEST_DIR}"
                     echo "TEST_SCRIPT=\${TEST_SCRIPT}"
                     cd \${TEST_DIR} && chmod +x *.sh && \${TEST_SCRIPT}
                 """
             }
         }
     }
     post{
         failure {
             script {
                 println "Test failed, archive the log"
             }
         }
+        unstable {
+            script {
+                println "Tests marked as unstable, performing post-unstable actions"
+                // Add unstable actions here
+            }
+        }
     }
 }
 

 stage("Prepare") {
     steps {
         dir('tidb') {
             cache(path: "./bin", includes: '**/*', key: "binary/pingcap/tidb/tidb-server/rev-${REFS.base_sha}-${REFS.pulls[0].sha}") {
                 sh label: 'tidb-server', script: 'ls bin/tidb-server || make server'
             }
             script {
-                 component.fetchAndExtractArtifact(FILE_SERVER_URL, 'tikv', REFS.base_ref, REFS.pulls[0].title, 'centos7/tikv-server.tar.gz', 'bin', trunkBranch="master", artifactVerify=true)
-                 component.fetchAndExtractArtifact(FILE_SERVER_URL, 'pd', REFS.base_ref, REFS.pulls[0].title, 'centos7/pd-server.tar.gz', 'bin', trunkBranch="master", artifactVerify=true)
+                retry(3) {
+                    component.fetchAndExtractArtifact(FILE_SERVER_URL, 'tikv', REFS.base_ref, REFS.pulls[0].title, 'centos7/tikv-server.tar.gz', 'bin', trunkBranch="master", artifactVerify=true)
+                    component.fetchAndExtractArtifact(FILE_SERVER_URL, 'pd', REFS.base_ref, REFS.pulls[0].title, 'centos7/pd-server.tar.gz', 'bin', trunkBranch="master", artifactVerify=true)
+                }
             }
             // cache it for other pods
             cache(path: "./", includes: '**/*', key: "ws/${BUILD_TAG}") {
                 sh """
                     mv bin/tidb-server bin/integration_test_tidb-server
                     touch rev-${REFS.pulls[0].sha}
                 """
             }
         }
     }
 }
 

 stage('Prepare') {
     steps {
         dir('tidb') {
             container("golang") {
-                sh label: 'tidb-server', script: '[ -f bin/tidb-server ] || make'
+                retry(3) {
+                    sh label: 'tidb-server', script: '[ -f bin/tidb-server ] || make'
+                }
             }
         }
         dir('tidb-test') {
             cache(path: "./sqllogic_test", includes: '**/*', key: "ws/${BUILD_TAG}/tidb-test") {
                 sh label: 'prepare tidb-test', script: """
                     touch ws-${BUILD_TAG}
                     cd sqllogic_test && ./build.sh
                     cp ${WORKSPACE}/tidb/bin/tidb-server ./
                     chmod +x tidb-server && ./tidb-server -V
                 """
             }
         }
     }
 }
 

 sh label: 'Debug info', script: """
     printenv
     echo "-------------------------"
     go env
     echo "-------------------------"
     ls -l /dev/null
     echo "debug command: kubectl -n ${K8S_NAMESPACE} exec -ti ${NODE_NAME} bash"
-"""
+""", timeout: 5
 

 stage('Prepare') {
     steps {
         dir("third_party_download") {
-            retry(2) {
+            retry(3) {
                 sh label: "download third_party", script: """
                     chmod +x ../tidb/lightning/tests/*.sh
                     ${WORKSPACE}/tidb/lightning/tests/download_integration_test_binaries.sh master
                     mkdir -p bin && mv third_bin/* bin/
                     ls -alh bin/
                     ./bin/pd-server -V
                     ./bin/tikv-server -V
                     ./bin/tiflash --version
                 """
             }
         }
         ...
     }
 }
 

 pipeline {
     agent {
         kubernetes {
             namespace K8S_NAMESPACE
             yamlFile POD_TEMPLATE_FILE
             defaultContainer 'golang'
         }
     }
     environment {
         FILE_SERVER_URL = 'http://fileserver.pingcap.net'
     }
     options {
         timeout(time: 60, unit: 'MINUTES')
         // parallelsAlwaysFailFast()
     }
     stages {
         ...
     }
+    post {
+        always {
+            mail to: '[email protected]',
+                 subject: "Build ${currentBuild.fullDisplayName}",
+                 body: "Build ${currentBuild.fullDisplayName} finished with status: ${currentBuild.currentResult}"
+        }
+    }
 }