hgzero/Jenkinsfile

pipeline {
    agent any

    parameters {
        choice(
            name: 'ENVIRONMENT',
            choices: ['dev', 'staging', 'prod'],
            description: 'Target environment'
        )
    }

    environment {
        // Container Registry
        REGISTRY = 'acrdigitalgarage02.azurecr.io'
        IMAGE_ORG = 'hgzero'

        // Azure
        RESOURCE_GROUP = 'rg-digitalgarage-02'
        AKS_CLUSTER = 'aks-digitalgarage-02'
        NAMESPACE = 'hgzero'

        // Image Tag
        IMAGE_TAG = "${new Date().format('yyyyMMddHHmmss')}"

        // Services
        SERVICES = 'user meeting stt ai notification'

        // Credentials
        ACR_CREDENTIALS = credentials('acr-credentials')
        DOCKERHUB_CREDENTIALS = credentials('dockerhub-credentials')
        GIT_CREDENTIALS = credentials('github-credentials-dg0506')
    }

    stages {
        stage('Checkout') {
            steps {
                script {
                    echo "🔄 Checking out code..."
                    checkout scm
                }
            }
        }

        stage('Setup Java') {
            steps {
                script {
                    echo "☕ Setting up Java 21..."
                    // JDK 21 설치 및 대기
                    def jdkHome = tool name: 'JDK21', type: 'jdk'
                    def jdkPath = "${jdkHome}/jdk-21"
                    env.JAVA_HOME = jdkPath
                    env.PATH = "${jdkPath}/bin:${env.PATH}"

                    // JDK 설치 완료 대기 및 확인
                    sh """
                        echo "Waiting for JDK installation..."
                        while [ ! -f ${jdkPath}/bin/java ]; do
                            echo "Waiting for JDK to be extracted..."
                            sleep 2
                        done
                        echo "JDK installation completed"
                        ${jdkPath}/bin/java -version
                    """
                }
            }
        }

        stage('Load Environment Variables') {
            steps {
                script {
                    echo "📋 Loading environment variables for ${params.ENVIRONMENT}..."

                    def configFile = ".github/config/deploy_env_vars_${params.ENVIRONMENT}"
                    if (fileExists(configFile)) {
                        def config = readFile(configFile)
                        config.split('\n').each { line ->
                            if (line && !line.startsWith('#')) {
                                def parts = line.split('=', 2)
                                if (parts.size() == 2) {
                                    def key = parts[0].trim()
                                    def value = parts[1].trim()

                                    if (key == 'resource_group') {
                                        env.RESOURCE_GROUP = value
                                    } else if (key == 'cluster_name') {
                                        env.AKS_CLUSTER = value
                                    }
                                }
                            }
                        }
                    }

                    echo "Registry: ${env.REGISTRY}"
                    echo "Image Org: ${env.IMAGE_ORG}"
                    echo "Resource Group: ${env.RESOURCE_GROUP}"
                    echo "AKS Cluster: ${env.AKS_CLUSTER}"
                }
            }
        }

        stage('Build with Gradle') {
            steps {
                script {
                    echo "🔨 Building with Gradle..."
                    sh 'chmod +x gradlew'
                    sh """
                        export JAVA_HOME=${env.JAVA_HOME}
                        export PATH=\${JAVA_HOME}/bin:\${PATH}
                        java -version
                        ./gradlew build -x test
                    """
                }
            }
        }

        stage('Archive Artifacts') {
            steps {
                script {
                    echo "📦 Archiving build artifacts..."
                    archiveArtifacts artifacts: '**/build/libs/*.jar', fingerprint: true
                }
            }
        }

        stage('Docker Build & Push') {
            steps {
                script {
                    echo "🐳 Building and pushing Docker images..."

                    // Login to Docker Hub (prevent rate limit)
                    sh """
                        echo ${DOCKERHUB_CREDENTIALS_PSW} | docker login -u ${DOCKERHUB_CREDENTIALS_USR} --password-stdin
                    """

                    // Login to Azure Container Registry
                    sh """
                        echo ${ACR_CREDENTIALS_PSW} | docker login ${REGISTRY} -u ${ACR_CREDENTIALS_USR} --password-stdin
                    """

                    // Build and push each service
                    env.SERVICES.split().each { service ->
                        echo "Building ${service}..."

                        def imageTag = "${env.REGISTRY}/${env.IMAGE_ORG}/${service}:${params.ENVIRONMENT}-${env.IMAGE_TAG}"

                        sh """
                            docker build \
                              --build-arg BUILD_LIB_DIR="${service}/build/libs" \
                              --build-arg ARTIFACTORY_FILE="${service}.jar" \
                              -f deployment/container/Dockerfile-backend \
                              -t ${imageTag} .
                        """

                        echo "Pushing ${service}..."
                        sh "docker push ${imageTag}"

                        echo "✅ ${service} image pushed: ${imageTag}"
                    }
                }
            }
        }

        stage('Update Manifest Repository') {
            steps {
                script {
                    echo "📝 Updating manifest repository..."

                    // Clone manifest repository
                    sh """
                        rm -rf manifest-repo
                        git clone https://${GIT_CREDENTIALS_USR}:${GIT_CREDENTIALS_PSW}@github.com/hjmoons/hgzero-manifest.git manifest-repo
                    """

                    dir('manifest-repo') {
                        // Install Kustomize
                        sh """
                            curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash
                            chmod +x kustomize
                        """

                        // Update manifest
                        dir("hgzero-back/kustomize/overlays/${params.ENVIRONMENT}") {
                            env.SERVICES.split().each { service ->
                                sh """
                                    ../../../kustomize edit set image ${env.REGISTRY}/${env.IMAGE_ORG}/${service}:${params.ENVIRONMENT}-${env.IMAGE_TAG}
                                """
                            }
                        }

                        // Git commit and push
                        sh """
                            git config user.name "Jenkins"
                            git config user.email "jenkins@hgzero.com"
                            git add .
                            git commit -m "🚀 Update hgzero ${params.ENVIRONMENT} images to ${params.ENVIRONMENT}-${env.IMAGE_TAG}"
                            git push origin main
                        """
                    }

                    echo "✅ Manifest repository updated. ArgoCD will auto-deploy."
                }
            }
        }
    }

    post {
        success {
            echo "✅ Pipeline completed successfully!"
            echo "Environment: ${params.ENVIRONMENT}"
            echo "Image Tag: ${env.IMAGE_TAG}"
        }
        failure {
            echo "❌ Pipeline failed!"
        }
    }
}