Jenkinsfile

pipeline {
    agent any
    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timestamps()
    }

    environment {
        // 이 파이프라인의 모든 스테이지에서 사용할 공통 환경 변수
        DOCKER_REGISTRY = "registry.loggle.ideasidus.dev"
    }

    stages {
        stage('Initialize Configuration') {
            steps {
                script {
                    // 멀티브랜치 파이프라인에서는 env.BRANCH_NAME을, 일반 파이프라인에서는 env.GIT_BRANCH를 사용
                    def detectedBranch = env.BRANCH_NAME ?: (env.GIT_BRANCH ?: '').replaceFirst('origin/', '')
                    env.BRANCH_RESOLVED = detectedBranch
                    echo "Resolved branch: ${env.BRANCH_RESOLVED}"

                    // 브랜치별 설정을 중앙에서 관리하는 맵
                    def configMap = [
                        'staging': [
                            ENV_NAME     : 'Staging',
                            TAG          : 'staging',
                            CRED_PREFIX  : 'staging'
                        ],
                        'master': [
                            ENV_NAME     : 'Production',
                            TAG          : 'latest',
                            CRED_PREFIX  : 'production'
                        ]
                    ]

                    def config = configMap[env.BRANCH_RESOLVED]
                    if (config) {
                        // 설정된 값을 이후 스테이지에서 사용할 수 있도록 Jenkins 환경 변수로 저장
                        env.DEPLOY_ENV_NAME = config.ENV_NAME
                        env.IMAGE_TAG       = config.TAG
                        env.CRED_PREFIX     = config.CRED_PREFIX
                    } else {
                        echo "Non-target branch: ${env.BRANCH_RESOLVED}. Skipping main stages."
                        env.DEPLOY_ENV_NAME = '' // 대상 브랜치가 아닐 경우, 이후 when 조건이 false가 되도록 설정
                    }
                }
            }
        }

        stage('Start Pipeline Notification') {
            when { expression { env.DEPLOY_ENV_NAME } }
            steps {
                script {
                    withCredentials([string(credentialsId: 'mattermost-webhook-url', variable: 'MATTERMOST_WEBHOOK_URL')]) {
                        mattermostSend(
                            color: '#00BFFF',
                            message: "🚀 *빌드 시작* (${env.DEPLOY_ENV_NAME})\n프로젝트: `${env.JOB_NAME}`\n빌드 번호: `${env.BUILD_NUMBER}`\n브랜치: `${env.BRANCH_RESOLVED}`\n자세히 보기: `${env.BUILD_URL}`",
                            endpoint: MATTERMOST_WEBHOOK_URL
                        )
                    }
                }
            }
        }

        stage('Build Frontend Image') {
            when { expression { env.DEPLOY_ENV_NAME } }
            steps {
                script {
                    echo "Building Frontend image for ${env.DEPLOY_ENV_NAME}"
                    // CRED_PREFIX에 따라 'staging-...' 또는 'production-...' Credentials를 동적으로 사용
                    withCredentials([
                        string(credentialsId: "${env.CRED_PREFIX}-google-client-id", variable: 'VITE_GOOGLE_CLIENT_ID'),
                        string(credentialsId: "${env.CRED_PREFIX}-google-redirect-uri", variable: 'VITE_GOOGLE_REDIRECT_URI'),
                        string(credentialsId: "${env.CRED_PREFIX}-google-login-url", variable: 'VITE_GOOGLE_LOGIN_URL'),
                        string(credentialsId: "${env.CRED_PREFIX}-api-url", variable: 'VITE_API_URL'),
                        string(credentialsId: "${env.CRED_PREFIX}-use-msw", variable: 'VITE_USE_MSW')
                    ]) {
                        sh """
                            set -eu
                            docker build -t ${DOCKER_REGISTRY}/frontend:${BUILD_NUMBER} \
                            --build-arg VITE_GOOGLE_CLIENT_ID=\"${VITE_GOOGLE_CLIENT_ID}\" \
                            --build-arg VITE_GOOGLE_REDIRECT_URI=\"${VITE_GOOGLE_REDIRECT_URI}\" \
                            --build-arg VITE_GOOGLE_LOGIN_URL=\"${VITE_GOOGLE_LOGIN_URL}\" \
                            --build-arg VITE_API_URL=\"${VITE_API_URL}\" \
                            --build-arg VITE_USE_MSW=\"${VITE_USE_MSW}\" \
                            -f ./front-end/Dockerfile ./front-end
                        """
                    }
                }
            }
        }

        stage('Build Backend Image') {
            when { expression { env.DEPLOY_ENV_NAME } }
            steps {
                echo "Building Backend image for ${env.DEPLOY_ENV_NAME}"
                sh "docker build -t ${DOCKER_REGISTRY}/backend:${BUILD_NUMBER} -f ./back-end/Dockerfile ./back-end"
            }
        }

        stage('Build AI Service Image') {
            when { expression { env.DEPLOY_ENV_NAME } }
            steps {
                echo "Building AI Service image for ${env.DEPLOY_ENV_NAME}"
                sh "docker build -t ${DOCKER_REGISTRY}/ai:${BUILD_NUMBER} -f ./ai/Dockerfile ./ai"
            }
        }

        stage('Push Images') {
            when { expression { env.DEPLOY_ENV_NAME } }
            steps {
                script {
                    // [개선] Jenkins Docker Pipeline 플러그인의 withRegistry 헬퍼를 사용하여 더 안전하고 간결하게 로그인합니다.
                    docker.withRegistry("https://${DOCKER_REGISTRY}", 'docker-registry-auth') {
                        sh "docker push ${DOCKER_REGISTRY}/frontend:${BUILD_NUMBER}"
                        sh "docker push ${DOCKER_REGISTRY}/backend:${BUILD_NUMBER}"
                        sh "docker push ${DOCKER_REGISTRY}/ai:${BUILD_NUMBER}"
                    }
                }
            }
        }

        stage('Tag & Deploy') {
            when { expression { env.DEPLOY_ENV_NAME } }
            steps {
                script {
                    // 1. 이미지 태깅 및 푸시
                    echo "Tagging images with '${env.IMAGE_TAG}' and pushing..."
                    docker.withRegistry("https://${DOCKER_REGISTRY}", 'docker-registry-auth') {
                        sh """
                            docker tag ${DOCKER_REGISTRY}/frontend:${BUILD_NUMBER} ${DOCKER_REGISTRY}/frontend:${IMAGE_TAG}
                            docker push ${DOCKER_REGISTRY}/frontend:${IMAGE_TAG}
                            docker tag ${DOCKER_REGISTRY}/backend:${BUILD_NUMBER} ${DOCKER_REGISTRY}/backend:${IMAGE_TAG}
                            docker push ${DOCKER_REGISTRY}/backend:${IMAGE_TAG}
                            docker tag ${DOCKER_REGISTRY}/ai:${BUILD_NUMBER} ${DOCKER_REGISTRY}/ai:${IMAGE_TAG}
                            docker push ${DOCKER_REGISTRY}/ai:${IMAGE_TAG}
                        """
                    }

                    // 2. 브랜치에 따라 다른 배포 방식 실행
                    if (env.BRANCH_RESOLVED == 'master') {
                        echo "Starting Blue/Green Deployment to Production with environment variables..."
                        // 프로덕션 배포에 필요한 모든 Credentials를 로드합니다.
                        withCredentials([
                            string(credentialsId: 'production-postgres-user', variable: 'PROD_POSTGRES_USER'),
                            string(credentialsId: 'production-postgres-password', variable: 'PROD_POSTGRES_PASSWORD'),
                            string(credentialsId: 'production-postgres-db-name', variable: 'PROD_POSTGRES_DB_NAME'),
                            string(credentialsId: 'production-redis-password', variable: 'PROD_REDIS_PASSWORD'),
                            string(credentialsId: 'production-postgres-full-url', variable: 'PROD_POSTGRES_FULL_URL'),
                            string(credentialsId: 'production-redis-host', variable: 'PROD_REDIS_HOST'),
                            string(credentialsId: 'production-redis-port', variable: 'PROD_REDIS_PORT'),
                            string(credentialsId: 'production-google-client-id', variable: 'PROD_GOOGLE_CLIENT_ID'),
                            string(credentialsId: 'production-google-client-password', variable: 'PROD_GOOGLE_CLIENT_PASSWORD'),
                            string(credentialsId: 'production-jwt-secret-key', variable: 'PROD_JWT_SECRET_KEY'),
                            string(credentialsId: 'production-jwt-access-expiration', variable: 'PROD_JWT_ACCESS_EXPIRATION'),
                            string(credentialsId: 'production-jwt-refresh-expiration', variable: 'PROD_JWT_REFRESH_EXPIRATION'),
                            string(credentialsId: 'production-front-base-url', variable: 'PROD_FRONT_BASE_URL'),
                            string(credentialsId: 'production-front-redirect-uri', variable: 'PROD_FRONT_REDIRECT_URI'),
                            string(credentialsId: 'production-invite-secret-key', variable: 'PROD_INVITE_SECRET_KEY'),
                            string(credentialsId: 'production-invite-expiration', variable: 'PROD_INVITE_EXPIRATION'),
                            string(credentialsId: 'production-openai-api-key', variable: 'PROD_OPENAI_API_KEY'),
                            string(credentialsId: 'production-openai-api-base', variable: 'PROD_OPENAI_API_BASE'),
                            string(credentialsId: 'production-github-api-base', variable: 'PROD_GITHUB_API_BASE'),
                            string(credentialsId: 'production-gitlab-api-base', variable: 'PROD_GITLAB_API_BASE'),
                            string(credentialsId: 'production-gitlab-ssafy-api-base', variable: 'PROD_GITLAB_SSAFY_API_BASE'),
                            string(credentialsId: 'production-allowed-origins', variable: 'PROD_ALLOWED_ORIGINS'),
                            string(credentialsId: 'production-project-name', variable: 'PROD_PROJECT_NAME'),
                            string(credentialsId: 'production-max-concurrent-requests', variable: 'PROD_MAX_CONCURRENT_REQUESTS'),
                            string(credentialsId: 'production-max-commits-per-task', variable: 'PROD_MAX_COMMITS_PER_TASK'),
                            string(credentialsId: 'production-days-to-collect', variable: 'PROD_DAYS_TO_COLLECT'),
                            string(credentialsId: 'production-api-v1-str', variable: 'PROD_API_V1_STR')
                        ]) {
                            // [수정] deploy.sh 스크립트의 정확한 경로로 수정합니다.
                            sh "chmod +x ./infra/ci-cd/apps/production/deploy.sh"
                            sh "./infra/ci-cd/apps/production/deploy.sh"
                        }
                    } else if (env.BRANCH_RESOLVED == 'staging') {
                        echo "Deploying applications to Staging environment..."
                        // Staging 배포에 필요한 모든 Credentials를 로드합니다.
                        withCredentials([
                            string(credentialsId: 'staging-postgres-user', variable: 'STAGING_POSTGRES_USER'),
                            string(credentialsId: 'staging-postgres-password', variable: 'STAGING_POSTGRES_PASSWORD'),
                            string(credentialsId: 'staging-postgres-db-name', variable: 'STAGING_POSTGRES_DB_NAME'),
                            string(credentialsId: 'staging-redis-password', variable: 'STAGING_REDIS_PASSWORD'),
                            string(credentialsId: 'staging-google-client-id', variable: 'STAGING_GOOGLE_CLIENT_ID'),
                            string(credentialsId: 'staging-google-client-password', variable: 'STAGING_GOOGLE_CLIENT_PASSWORD'),
                            string(credentialsId: 'staging-jwt-secret-key', variable: 'STAGING_JWT_SECRET_KEY'),
                            string(credentialsId: 'staging-jwt-access-expiration', variable: 'STAGING_JWT_ACCESS_EXPIRATION'),
                            string(credentialsId: 'staging-jwt-refresh-expiration', variable: 'STAGING_JWT_REFRESH_EXPIRATION'),
                            string(credentialsId: 'staging-front-base-url', variable: 'STAGING_FRONT_BASE_URL'),
                            string(credentialsId: 'staging-front-redirect-uri', variable: 'STAGING_FRONT_REDIRECT_URI'),
                            string(credentialsId: 'staging-invite-secret-key', variable: 'STAGING_INVITE_SECRET_KEY'),
                            string(credentialsId: 'staging-invite-expiration', variable: 'STAGING_INVITE_EXPIRATION'),
                            string(credentialsId: 'staging-openai-api-key', variable: 'STAGING_OPENAI_API_KEY'),
                            string(credentialsId: 'staging-openai-api-base', variable: 'STAGING_OPENAI_API_BASE'),
                            string(credentialsId: 'staging-github-api-base', variable: 'STAGING_GITHUB_API_BASE'),
                            string(credentialsId: 'staging-gitlab-api-base', variable: 'STAGING_GITLAB_API_BASE'),
                            string(credentialsId: 'staging-gitlab-ssafy-api-base', variable: 'STAGING_GITLAB_SSAFY_API_BASE'),
                            string(credentialsId: 'staging-allowed-origins', variable: 'STAGING_ALLOWED_ORIGINS'),
                            string(credentialsId: 'staging-project-name', variable: 'STAGING_PROJECT_NAME'),
                            string(credentialsId: 'staging-max-concurrent-requests', variable: 'STAGING_MAX_CONCURRENT_REQUESTS'),
                            string(credentialsId: 'staging-max-commits-per-task', variable: 'STAGING_MAX_COMMITS_PER_TASK'),
                            string(credentialsId: 'staging-days-to-collect', variable: 'STAGING_DAYS_TO_COLLECT'),
                            string(credentialsId: 'staging-api-v1-str', variable: 'STAGING_API_V1_STR')
                        ]) {
                            // [개선] Staging 배포 시 pull, down, up을 순서대로 실행하여 안정성을 확보합니다.
                            dir('./infra/ci-cd/apps/staging') {
                                sh """
                                    docker compose -f docker-compose.staging.yml pull
                                    docker compose -f docker-compose.staging.yml down --remove-orphans
                                    docker compose -f docker-compose.staging.yml up -d
                                """
                            }
                        }
                    }
                }
            }
        }
    }

    post {
        success {
            script {
                if (env.DEPLOY_ENV_NAME) {
                    withCredentials([string(credentialsId: 'mattermost-webhook-url', variable: 'MATTERMOST_WEBHOOK_URL')]) {
                        mattermostSend(
                            color: '#2A924A', // Green
                            message: "✅ **SUCCESS**: `${env.JOB_NAME}` 빌드 성공! (Branch: `${env.BRANCH_RESOLVED}`, Build: `${env.BUILD_NUMBER}`)",
                            endpoint: MATTERMOST_WEBHOOK_URL
                        )
                    }
                }
            }
        }
        failure {
            script {
                if (env.DEPLOY_ENV_NAME) {
                    withCredentials([string(credentialsId: 'mattermost-webhook-url', variable: 'MATTERMOST_WEBHOOK_URL')]) {
                        mattermostSend(
                            color: '#C91E1E', // Red
                            message: "❌ **FAILURE**: `${env.JOB_NAME}` 빌드 실패. (Branch: `${env.BRANCH_RESOLVED}`, Build: `${env.BUILD_NUMBER}`)\n[빌드 로그 보기](${env.BUILD_URL})",
                            endpoint: MATTERMOST_WEBHOOK_URL
                        )
                    }
                }
            }
        }
        aborted {
            script {
                if (env.DEPLOY_ENV_NAME) {
                    withCredentials([string(credentialsId: 'mattermost-webhook-url', variable: 'MATTERMOST_WEBHOOK_URL')]) {
                        mattermostSend(
                            color: '#808080', // Gray
                            message: "🚫 **ABORTED**: `${env.JOB_NAME}` 빌드 중단. (Branch: `${env.BRANCH_RESOLVED}`, Build: `${env.BUILD_NUMBER}`)\n[빌드 로그 보기](${env.BUILD_URL})",
                            endpoint: MATTERMOST_WEBHOOK_URL
                        )
                    }
                }
            }
        }
    }
}