Scripted Pipeline 语法 #

node {
    stage('Build') {
        echo 'Building...'
    }
}

node {
    // 在任意可用节点执行
}

node('linux') {
    // 在标签为linux的节点执行
}

node('linux && docker') {
    // 在同时具有linux和docker标签的节点执行
}

node {
    stage('Checkout') {
        // 检出代码
    }
    
    stage('Build') {
        // 构建项目
    }
    
    stage('Test') {
        // 运行测试
    }
    
    stage('Deploy') {
        // 部署应用
    }
}

node {
    echo 'Hello, Jenkins!'
    echo "Build number: ${BUILD_NUMBER}"
    echo "Current time: ${new Date()}"
}

node {
    sh 'echo "Hello"'
    
    sh '''
        echo "Multi-line script"
        ls -la
        pwd
    '''
    
    def output = sh(script: 'git rev-parse HEAD', returnStdout: true).trim()
    echo "Git commit: ${output}"
    
    def status = sh(script: 'test -f file.txt', returnStatus: true)
    if (status == 0) {
        echo 'File exists'
    }
}

node('windows') {
    bat 'echo Hello'
    bat '''
        echo Multi-line script
        dir
    '''
}

node {
    stage('Deploy') {
        if (env.BRANCH_NAME == 'main') {
            sh 'deploy-to-prod.sh'
        } else if (env.BRANCH_NAME == 'develop') {
            sh 'deploy-to-dev.sh'
        } else {
            echo 'Skip deployment'
        }
    }
}

node {
    stage('Deploy') {
        switch(env.ENVIRONMENT) {
            case 'prod':
                sh 'deploy-prod.sh'
                break
            case 'staging':
                sh 'deploy-staging.sh'
                break
            case 'dev':
                sh 'deploy-dev.sh'
                break
            default:
                error "Unknown environment: ${env.ENVIRONMENT}"
        }
    }
}

node {
    def environments = ['dev', 'staging', 'prod']
    
    for (env in environments) {
        stage("Deploy to ${env}") {
            sh "deploy.sh ${env}"
        }
    }
}

node {
    def services = [
        'api': 'api-service',
        'web': 'web-service',
        'worker': 'worker-service'
    ]
    
    services.each { name, service ->
        stage("Deploy ${name}") {
            sh "kubectl apply -f ${service}.yaml"
        }
    }
}

node {
    try {
        stage('Build') {
            sh 'mvn clean package'
        }
        
        stage('Test') {
            sh 'mvn test'
        }
        
        stage('Deploy') {
            sh 'deploy.sh'
        }
        
        currentBuild.result = 'SUCCESS'
        
    } catch (Exception e) {
        currentBuild.result = 'FAILURE'
        echo "Build failed: ${e.message}"
        throw e
        
    } finally {
        stage('Cleanup') {
            sh 'cleanup.sh'
        }
    }
}

node {
    stage('Validate') {
        def config = readFile 'config.json'
        if (!config) {
            error 'Configuration file not found'
        }
    }
}

node {
    stage('Test') {
        def result = sh(script: 'npm test', returnStatus: true)
        if (result != 0) {
            currentBuild.result = 'UNSTABLE'
            echo 'Some tests failed'
        }
    }
}

node {
    stage('Test') {
        parallel(
            unitTest: {
                sh 'mvn test'
            },
            integrationTest: {
                sh 'mvn verify -P integration'
            },
            e2eTest: {
                sh 'npm run test:e2e'
            },
            failFast: true
        )
    }
}

node {
    def tests = [:]
    
    def testFiles = findFiles(glob: '**/*Test.java')
    testFiles.each { f ->
        tests["Test ${f.name}"] = {
            sh "mvn test -Dtest=${f.name}"
        }
    }
    
    stage('Run Tests') {
        parallel tests
    }
}

node {
    stage('Test') {
        def result = parallel(
            unitTest: {
                try {
                    sh 'mvn test'
                } catch (e) {
                    echo "Unit tests failed: ${e.message}"
                    throw e
                }
            },
            integrationTest: {
                sh 'mvn verify -P integration'
            },
            failFast: false
        )
    }
}

def buildApp(String appName) {
    echo "Building ${appName}"
    sh "mvn clean package -pl ${appName}"
}

def deployApp(String appName, String env) {
    echo "Deploying ${appName} to ${env}"
    sh "kubectl apply -f ${appName}/${env}.yaml"
}

node {
    stage('Build') {
        buildApp('myapp')
    }
    
    stage('Deploy') {
        deployApp('myapp', 'prod')
    }
}

def deploy(String appName, String env = 'dev') {
    echo "Deploying ${appName} to ${env}"
    sh "deploy.sh ${appName} ${env}"
}

node {
    deploy('myapp')           // 部署到dev
    deploy('myapp', 'prod')   // 部署到prod
}

def getGitCommit() {
    return sh(script: 'git rev-parse HEAD', returnStdout: true).trim()
}

def getVersion() {
    def pom = readFile 'pom.xml'
    def matcher = pom =~ '<version>(.+?)</version>'
    return matcher ? matcher[0][1] : 'unknown'
}

node {
    stage('Info') {
        def commit = getGitCommit()
        def version = getVersion()
        echo "Commit: ${commit}"
        echo "Version: ${version}"
    }
}

def withRetry(int times, Closure body) {
    int count = 0
    while (count < times) {
        try {
            body()
            return
        } catch (e) {
            count++
            if (count >= times) {
                throw e
            }
            echo "Retry ${count}/${times}"
            sleep 5
        }
    }
}

node {
    stage('Deploy') {
        withRetry(3) {
            sh 'deploy.sh'
        }
    }
}

node {
    env.APP_NAME = 'myapp'
    env.VERSION = "${BUILD_NUMBER}"
    
    withEnv(['PATH+MAVEN=/opt/maven/bin', 'JAVA_HOME=/usr/lib/jvm/java-11']) {
        sh 'mvn clean package'
    }
}

node {
    echo "Build number: ${env.BUILD_NUMBER}"
    echo "Job name: ${env.JOB_NAME}"
    echo "Workspace: ${env.WORKSPACE}"
    
    def customVar = env.CUSTOM_VAR ?: 'default'
    echo "Custom var: ${customVar}"
}

node {
    withCredentials([usernamePassword(
        credentialsId: 'docker-registry',
        usernameVariable: 'DOCKER_USER',
        passwordVariable: 'DOCKER_PASS'
    )]) {
        sh "docker login -u ${DOCKER_USER} -p ${DOCKER_PASS}"
    }
}

node {
    withCredentials([sshUserPrivateKey(
        credentialsId: 'ssh-key',
        keyFileVariable: 'SSH_KEY',
        usernameVariable: 'SSH_USER'
    )]) {
        sh "ssh -i ${SSH_KEY} ${SSH_USER}@server 'deploy.sh'"
    }
}

node {
    withCredentials([file(
        credentialsId: 'kube-config',
        variable: 'KUBECONFIG'
    )]) {
        sh 'kubectl apply -f deployment.yaml'
    }
}

node {
    def mvnHome = tool 'Maven 3.8'
    def javaHome = tool 'JDK 11'
    
    env.PATH = "${mvnHome}/bin:${env.PATH}"
    env.JAVA_HOME = javaHome
    
    sh 'mvn clean package'
}

node {
    withMaven(maven: 'Maven 3.8', jdk: 'JDK 11') {
        sh 'mvn clean package'
    }
}

node {
    stage('Trigger') {
        build job: 'downstream-job',
              parameters: [
                  string(name: 'VERSION', value: "${BUILD_NUMBER}")
              ],
              wait: true,
              propagate: true
    }
}

node {
    stage('Wait') {
        def buildInfo = build job: 'upstream-job',
                              wait: true,
                              propagate: false
        
        if (buildInfo.result == 'SUCCESS') {
            echo 'Upstream build succeeded'
        } else {
            error 'Upstream build failed'
        }
    }
}

node {
    stage('Deploy') {
        def input = input message: 'Deploy to production?',
                           ok: 'Deploy',
                           parameters: [
                               choice(name: 'ENVIRONMENT',
                                      choices: ['prod', 'staging'],
                                      description: 'Select environment')
                           ],
                           submitter: 'admin,deploy-team'
        
        echo "Deploying to ${input.ENVIRONMENT}"
        sh "deploy.sh ${input.ENVIRONMENT}"
    }
}

node {
    stage('Deploy') {
        def proceed = input message: 'Continue with deployment?',
                             ok: 'Yes',
                             submitter: 'admin'
        
        sh 'deploy.sh'
    }
}

node {
    def content = readFile 'config.json'
    echo "Content: ${content}"
    
    writeFile file: 'output.txt',
              text: "Build ${BUILD_NUMBER}",
              encoding: 'UTF-8'
}

node {
    def files = findFiles(glob: '**/*.java')
    files.each { f ->
        echo "Found: ${f.name} (${f.length} bytes)"
    }
    
    def exists = fileExists 'config.json'
    if (exists) {
        echo 'Config file exists'
    }
}

node {
    dir('subdirectory') {
        sh 'ls -la'
    }
    
    ws('/tmp/custom-workspace') {
        sh 'pwd'
    }
}

node('linux') {
    stage('Build') {
        sh 'mvn clean package'
        stash includes: 'target/*.jar', name: 'artifacts'
    }
}

node('production') {
    stage('Deploy') {
        unstash 'artifacts'
        sh 'kubectl apply -f k8s/'
    }
}

node {
    stage('Build') {
        sh 'mvn clean package'
        stash includes: 'target/*.jar', name: 'jars'
        stash includes: 'target/site/**', name: 'docs'
    }
}

node {
    stage('Deploy') {
        unstash 'jars'
        sh 'deploy.sh'
    }
}

node {
    stage('Publish Docs') {
        unstash 'docs'
        sh 'publish-docs.sh'
    }
}

node {
    stage('Deploy') {
        lock(resource: 'production-server', inversePrecedence: true) {
            sh 'deploy.sh'
        }
    }
}

node {
    stage('Integration Test') {
        lock(resources: ['db-server', 'cache-server'], quantity: 1) {
            sh 'run-integration-tests.sh'
        }
    }
}

def buildApp(String appName) {
    echo "Building ${appName}"
    sh "mvn clean package -pl ${appName} -am"
}

def runTests(String appName) {
    sh "mvn test -pl ${appName}"
    junit "**/${appName}/target/surefire-reports/*.xml"
}

def deploy(String appName, String env) {
    echo "Deploying ${appName} to ${env}"
    sh "kubectl set image deployment/${appName} ${appName}=myregistry/${appName}:${BUILD_NUMBER} --namespace=${env}"
}

node {
    def apps = ['api', 'web', 'worker']
    
    try {
        stage('Checkout') {
            checkout scm
        }
        
        stage('Build') {
            parallel apps.collectEntries { app ->
                ["Build ${app}": {
                    buildApp(app)
                }]
            }
        }
        
        stage('Test') {
            parallel apps.collectEntries { app ->
                ["Test ${app}": {
                    runTests(app)
                }]
            }
        }
        
        stage('SonarQube') {
            withSonarQubeEnv('SonarQube') {
                sh 'mvn sonar:sonar'
            }
        }
        
        stage('Quality Gate') {
            timeout(time: 5, unit: 'MINUTES') {
                def qg = waitForQualityGate()
                if (qg.status != 'OK') {
                    error "Quality gate failed: ${qg.status}"
                }
            }
        }
        
        stage('Build Images') {
            apps.each { app ->
                sh "docker build -t myregistry/${app}:${BUILD_NUMBER} ${app}/"
            }
            
            withCredentials([usernamePassword(
                credentialsId: 'docker-registry',
                usernameVariable: 'DOCKER_USER',
                passwordVariable: 'DOCKER_PASS'
            )]) {
                sh "docker login -u ${DOCKER_USER} -p ${DOCKER_PASS} myregistry"
                apps.each { app ->
                    sh "docker push myregistry/${app}:${BUILD_NUMBER}"
                }
            }
        }
        
        if (env.BRANCH_NAME == 'main') {
            stage('Deploy to Production') {
                input message: 'Deploy to production?',
                       ok: 'Deploy',
                       submitter: 'admin'
                
                lock(resource: 'production-environment') {
                    apps.each { app ->
                        deploy(app, 'production')
                    }
                }
            }
        }
        
        currentBuild.result = 'SUCCESS'
        
    } catch (Exception e) {
        currentBuild.result = 'FAILURE'
        echo "Build failed: ${e.message}"
        throw e
        
    } finally {
        stage('Cleanup') {
            cleanWs()
        }
        
        mail to: 'team@example.com',
             subject: "${currentBuild.result}: ${JOB_NAME} #${BUILD_NUMBER}",
             body: "Build ${currentBuild.result}\nURL: ${BUILD_URL}"
    }
}

// 推荐
pipeline {
    agent any
    stages { ... }
}

// 仅在需要复杂逻辑时使用Scripted
node {
    // 复杂的Groovy逻辑
}

try {
    // 可能失败的操作
} catch (e) {
    currentBuild.result = 'FAILURE'
    throw e
}

def deploy(String env) {
    // 封装部署逻辑
}

// 保持简单
stage('Build') {
    sh 'mvn clean package'
}