// Jenkinsfile (Declarative)
pipeline {
    agent any // Run on any available agent node
    
    options {
        timeout(time: 1, unit: 'HOURS') // Cancel if execution hangs
        timestamps() // Print console line execution timestamps
        disableConcurrentBuilds() // Prevent concurrent runs of same job
    }
    
    environment {
        APP_ENV = 'production'
        DB_SECRET = credentials('db-password-credential-id') // Safe credential binding
    }
    
    parameters {
        string(name: 'DEPLOY_BRANCH', defaultValue: 'main', description: 'Target branch')
        booleanParam(name: 'RUN_TESTS', defaultValue: true, description: 'Verify test suite')
    }
    
    stages {
        stage('Preparation') {
            steps {
                echo "Checking out code from branch: ${params.DEPLOY_BRANCH}"
                checkout scm
            }
        }
        
        stage('Build & Test') {
            when {
                expression { return params.RUN_TESTS }
            }
            steps {
                echo "Building in Environment: ${env.APP_ENV}"
                // Execution commands inside shell execution blocks
                sh 'npm install'
                sh 'npm test'
            }
        }
        
        stage('Parallel Deploy') {
            parallel {
                stage('Deploy Asia') {
                    steps {
                        sh 'echo "Deploying to Asia clusters..."'
                    }
                }
                stage('Deploy Europe') {
                    steps {
                        sh 'echo "Deploying to Europe clusters..."'
                    }
                }
            }
        }
    }
    
    post {
        always {
            echo "Cleaning up workspace workspace files..."
            cleanWs()
        }
        success {
            echo "Pipeline completed successfully!"
        }
        failure {
            // Execute Slack/Email notification helper actions
            echo "Pipeline failed! Sending notification alerts..."
        }
    }
}

// Jenkinsfile (Scripted)
node('linux-agent') { // Allocates an executor on nodes matching label 'linux-agent'
    try {
        stage('Checkout') {
            checkout scm
        }
        
        stage('Conditional Build') {
            def files = sh(script: 'ls -la', returnStdout: true).trim()
            echo "Workspace listing:\n${files}"
            
            if (files.contains('package.json')) {
                sh 'npm install'
                sh 'npm run build'
            } else {
                error "Missing package.json in workspace repository."
            }
        }
    } catch (err) {
        currentBuild.result = 'FAILURE'
        echo "Execution failed with error: ${err.message}"
        throw err
    } finally {
        stage('Cleanup') {
            cleanWs()
        }
    }
}

pipeline {
    agent {
        docker {
            image 'node:18-alpine'
            args '-v /tmp:/data --entrypoint=' // Map volumes and override entries
        }
    }
    
    stages {
        stage('Verify Environment') {
            steps {
                // Executes inside the node:18-alpine container environment
                sh 'node --version'
                sh 'npm --version'
            }
        }
    }
}

shared-library-repo/
├── src/                     # Standard Object-Oriented Groovy classes
│   └── org/company/Helper.groovy
├── vars/                    # Global custom steps (accessible as functions)
│   ├── buildApp.groovy
│   └── notifySlack.groovy
└── resources/               # Static assets (JSON templates, SQL templates)

// vars/buildApp.groovy
def call(Map config = [:]) {
    def appName = config.name ?: 'Unlabeled App'
    
    echo "Running shared custom build steps for ${appName}"
    sh "npm install"
    sh "npm run build"
}

@Library('my-shared-library') _ // Import library (must be configured in Jenkins settings)
 
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                // Call vars script custom step directly like a native function
                buildApp(name: 'Customer Service API')
            }
        }
    }
}

pipeline {
    agent any
    
    triggers {
        // Trigger build every 3 hours on weekdays
        cron('0 */3 * * 1-5')
        
        // Poll SCM source control for changes every 15 minutes
        pollSCM('*/15 * * * *')
        
        // Triggers build automatically when dependencies complete
        upstream(upstreamProjects: 'parent-job-name', threshold: hudson.model.Result.SUCCESS)
    }
    
    stages {
        stage('Execute') {
            steps {
                echo "Running automated schedule build"
            }
        }
    }
}