Jenkins Controller
├── Manages configuration
├── Schedules builds
└── Dispatches to agents
        ↓
Agent 1 (Linux - Java builds)
Agent 2 (Windows - .NET builds)
Agent 3 (Docker agent)
Agent 4 (macOS - iOS builds)

Single machine (no agents):
Build A (20 minutes) → Build B (waits) → Build C (waits)
Total time: 60 minutes

With 3 agents:
Agent 1: Build A (20 minutes)
Agent 2: Build B (20 minutes) ← Parallel
Agent 3: Build C (20 minutes) ← Parallel
Total time: 20 minutes (3× faster)

Jenkins UI → Manage Jenkins → Nodes → New Node
Name: linux-agent-01
Labels: linux docker nodejs
Launch method: SSH
Host: 192.168.1.100
Credentials: jenkins-ssh-key

# Build step — Execute shell
npm install
npm run lint
npm run test
npm run build

# Post-build: Archive artifacts
Files to archive: dist/**/*

Poll SCM: H/5 * * * *    # Check for changes every 5 minutes
Cron schedule: 0 2 * * * # Run at 2 AM daily
GitHub webhook: trigger on push immediately
Manual: only when triggered by a user
Upstream job: run when another job completes

Traditional (GUI configured jobs):
❌ Configuration lives in Jenkins — not in source control
❌ Hard to review configuration changes
❌ Difficult to reproduce if Jenkins server is lost
❌ Cannot evolve with your code

Pipeline as Code (Jenkinsfile):
✅ Stored in your repository — versioned alongside code
✅ Code review for pipeline changes
✅ Reproducible from scratch
✅ Evolves with the project

// Jenkinsfile (Declarative Pipeline)
pipeline {
    agent any    // Run on any available agent

    environment {
        NODE_VERSION = "20"
        DOCKER_IMAGE = "futuretechzone/app"
        REGISTRY = "ghcr.io"
    }

    stages {
        stage("Checkout") {
            steps {
                checkout scm
            }
        }

        stage("Setup") {
            steps {
                sh """
                    node --version
                    npm --version
                    npm ci
                """
            }
        }

        stage("Lint and Test") {
            parallel {
                stage("Lint") {
                    steps {
                        sh "npm run lint"
                    }
                }
                stage("Unit Tests") {
                    steps {
                        sh "npm test -- --coverage"
                    }
                    post {
                        always {
                            junit "coverage/junit.xml"
                            publishHTML([
                                allowMissing: false,
                                reportDir: "coverage",
                                reportFiles: "index.html",
                                reportName: "Coverage Report"
                            ])
                        }
                    }
                }
            }
        }

        stage("Build") {
            steps {
                sh "npm run build"
                archiveArtifacts artifacts: "dist/**/*", fingerprint: true
            }
        }

        stage("Build Docker Image") {
            when {
                branch "main"    // Only on main branch
            }
            steps {
                script {
                    def image = docker.build("${DOCKER_IMAGE}:${BUILD_NUMBER}")
                    docker.withRegistry("https://${REGISTRY}", "ghcr-credentials") {
                        image.push()
                        image.push("latest")
                    }
                }
            }
        }

        stage("Deploy to Staging") {
            when { branch "main" }
            steps {
                sshPublisher(publishers: [
                    sshPublisherDesc(
                        configName: "staging-server",
                        transfers: [
                            sshTransfer(execCommand: """
                                docker pull ${REGISTRY}/${DOCKER_IMAGE}:${BUILD_NUMBER}
                                docker stop app || true
                                docker rm app || true
                                docker run -d --name app -p 3000:3000 \
                                    ${REGISTRY}/${DOCKER_IMAGE}:${BUILD_NUMBER}
                            """)
                        ]
                    )
                ])
            }
        }

        stage("Deploy to Production") {
            when { branch "main" }
            input {
                message "Deploy to production?"
                ok "Yes, deploy!"
            }
            steps {
                echo "Deploying to production..."
                sh "./deploy-production.sh ${BUILD_NUMBER}"
            }
        }
    }

    post {
        success {
            slackSend(channel: "#deployments", color: "good",
                message: "✅ Build ${BUILD_NUMBER} succeeded and deployed!")
        }
        failure {
            slackSend(channel: "#deployments", color: "danger",
                message: "❌ Build ${BUILD_NUMBER} failed! Check: ${BUILD_URL}")
            emailext(
                subject: "Jenkins Build FAILED: ${JOB_NAME} #${BUILD_NUMBER}",
                body: "Build failed. Check: ${BUILD_URL}",
                to: "${GIT_AUTHOR_EMAIL}"
            )
        }
        always {
            cleanWs()   // Clean workspace after every build
        }
    }
}

// Jenkinsfile (Scripted Pipeline)
node("linux && docker") {
    def dockerImage
    def BUILD_TAG = "${env.BUILD_NUMBER}-${env.GIT_COMMIT.take(7)}"

    try {
        stage("Checkout") {
            checkout scm
        }

        stage("Install") {
            sh "npm ci"
        }

        stage("Test") {
            try {
                sh "npm test -- --reporters=jest-junit"
            } finally {
                junit "test-results/*.xml"
            }
        }

        stage("Build") {
            sh "npm run build"
        }

        if (env.BRANCH_NAME == "main") {
            stage("Docker Build") {
                dockerImage = docker.build("myapp:${BUILD_TAG}")
            }

            stage("Push to Registry") {
                docker.withRegistry("https://registry.example.com", "registry-creds") {
                    dockerImage.push()
                    dockerImage.push("latest")
                }
            }

            def environments = ["staging", "production"]
            environments.each { env ->
                if (env == "production") {
                    timeout(time: 1, unit: "HOURS") {
                        input message: "Deploy to production?", ok: "Deploy"
                    }
                }

                stage("Deploy to ${env.capitalize()}") {
                    sh "./deploy.sh ${env} ${BUILD_TAG}"
                }
            }
        }

        currentBuild.result = "SUCCESS"

    } catch (Exception e) {
        currentBuild.result = "FAILURE"
        throw e
    } finally {
        notifyBuild(currentBuild.result)
    }
}

def notifyBuild(String buildStatus) {
    def color = buildStatus == "SUCCESS" ? "good" : "danger"
    slackSend(color: color, message: "${buildStatus}: ${env.JOB_NAME} #${env.BUILD_NUMBER}")
}