Jenkinsfile

pipeline {
    agent any

    options {
        timestamps()
        timeout(time: 45, unit: 'MINUTES')
        disableConcurrentBuilds()
    }

    environment {
        COMPOSE_FILE = 'docker-compose.yml'
        ENV_FILE = '.env'
        APP_SERVICES = 'redis backend frontend edge-nginx loki alloy grafana'
    }

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

        stage('Prepare Runtime Config') {
            steps {
                script {
                    withCredentials([file(credentialsId: 'MY_ENV_FILE', variable: 'ENV_SOURCE_FILE')]) {
                        sh '''
                            set -eu
                            install -m 600 "${ENV_SOURCE_FILE}" "${ENV_FILE}"
                        '''
                    }

                    echo "Refreshed ${env.ENV_FILE} from Jenkins credential: MY_ENV_FILE"
                }
            }
        }

        stage('Validate Runtime Config') {
            steps {
                sh '''
                    set -eu
                    set +x

                    test -f "${ENV_FILE}" || {
                      echo "Missing ${ENV_FILE}. Provide required runtime env values (RDS/Redis/JWT, etc.)."
                      exit 1
                    }

                    get_env_value() {
                      key="$1"
                      awk -F= -v target="$key" '
                        /^[[:space:]]*#/ { next }
                        /^[[:space:]]*$/ { next }
                        {
                          line=$0
                          sub(/\r$/, "", line)
                          pos=index(line, "=")
                          if (pos == 0) next

                          current=substr(line, 1, pos - 1)
                          gsub(/^[[:space:]]+|[[:space:]]+$/, "", current)
                          if (current == target) {
                            print substr(line, pos + 1)
                            found=1
                            exit
                          }
                        }
                        END {
                          if (!found) exit 1
                        }
                      ' "${ENV_FILE}"
                    }

                    strip_outer_quotes() {
                      value="$1"
                      printf '%s' "$value" | sed -e 's/^"//' -e 's/"$//' -e "s/^'//" -e "s/'$//"
                    }

                    REQUIRED_VARS="DB_URL DB_USERNAME DB_PASSWORD AUTH_JWT_SECRET API_PATH VITE_API_BASE_URL REDIS_HOST REDIS_PORT"
                    for var in ${REQUIRED_VARS}; do
                      value="$(get_env_value "${var}" || true)"
                      value="$(strip_outer_quotes "${value}")"
                      if [ -z "${value}" ]; then
                        echo "Missing required env var: ${var}"
                        exit 1
                      fi
                    done

                    ssl_enabled="$(get_env_value "SSL_ENABLED" || true)"
                    ssl_enabled="$(strip_outer_quotes "${ssl_enabled}")"
                    ssl_enabled="$(printf '%s' "${ssl_enabled}" | tr '[:upper:]' '[:lower:]')"

                    if [ "${ssl_enabled:-false}" = "true" ]; then
                      ssl_cert_path="$(get_env_value "SSL_CERT_PATH" || true)"
                      ssl_key_path="$(get_env_value "SSL_KEY_PATH" || true)"
                      ssl_cert_path="$(strip_outer_quotes "${ssl_cert_path}")"
                      ssl_key_path="$(strip_outer_quotes "${ssl_key_path}")"

                      if [ -z "${ssl_cert_path}" ] || [ -z "${ssl_key_path}" ]; then
                        echo "SSL_ENABLED=true but SSL_CERT_PATH/SSL_KEY_PATH are missing."
                        exit 1
                      fi
                      echo "SSL cert path precheck is skipped. edge-nginx runtime will validate mounted cert files."
                    fi
                '''
            }
        }

        stage('Docker Build') {
            steps {
                sh '''
                    docker version
                    docker compose -f "${COMPOSE_FILE}" --env-file "${ENV_FILE}" build --pull
                '''
            }
        }

        stage('Deploy') {
            steps {
                sh '''
                    docker compose -f "${COMPOSE_FILE}" --env-file "${ENV_FILE}" up -d ${APP_SERVICES}
                '''
            }
        }

        stage('Smoke Test') {
            steps {
                sh '''
                    api_path="$(docker compose -f "${COMPOSE_FILE}" --env-file "${ENV_FILE}" exec -T backend printenv API_PATH 2>/dev/null || true)"
                    api_path="$(printf '%s' "${api_path}" | tr -d '\r')"

                    if [ -n "${api_path}" ] && [ "${api_path#'/'}" = "${api_path}" ]; then
                      api_path="/${api_path}"
                    fi

                    if [ "${api_path}" != "/" ]; then
                      api_path="${api_path%/}"
                    fi

                    for i in $(seq 1 20); do
                      if docker compose -f "${COMPOSE_FILE}" --env-file "${ENV_FILE}" exec -T frontend \
                           wget -q --spider http://127.0.0.1/ >/dev/null 2>&1; then
                        readiness_ok=0

                        if [ -n "${api_path}" ]; then
                          readiness_body="$(docker compose -f "${COMPOSE_FILE}" --env-file "${ENV_FILE}" exec -T frontend \
                            wget -q -O - "http://backend:8080${api_path}/actuator/health/readiness" || true)"

                          if printf '%s' "${readiness_body}" | grep -Eq '"status"[[:space:]]*:[[:space:]]*"UP"'; then
                            readiness_ok=1
                          fi
                        fi

                        if [ "${readiness_ok}" -ne 1 ]; then
                          readiness_body="$(docker compose -f "${COMPOSE_FILE}" --env-file "${ENV_FILE}" exec -T frontend \
                            wget -q -O - "http://backend:8080/actuator/health/readiness" || true)"

                          if printf '%s' "${readiness_body}" | grep -Eq '"status"[[:space:]]*:[[:space:]]*"UP"'; then
                            readiness_ok=1
                          fi
                        fi

                        if [ "${readiness_ok}" -eq 1 ]; then
                          echo "Smoke test passed"
                          exit 0
                        fi
                      fi

                      sleep 5
                    done

                    echo "Smoke test failed"
                    docker compose -f "${COMPOSE_FILE}" --env-file "${ENV_FILE}" ps
                    exit 1
                '''
            }
        }

        stage('Notification') {
            steps {
                success {
                    script {
                        def Author_ID = sh(script: "git show -s --pretty=%an", returnStdout: true).trim()
                        def Author_Name = sh(script: "git show -s --pretty=%ae", returnStdout: true).trim()
                        mattermostSend(color: 'good',
                            message: "빌드 성공: ${env.JOB_NAME} #${env.BUILD_NUMBER} by ${Author_ID}(${Author_Name})\n(<${env.BUILD_URL}|Details>)",
                            endpoint: 'https://meeting.ssafy.com/hooks/kip759cnntfw8nr3mpaqqqacgcL',
                            channel: 'a605_noti_channel'
                                )
                        }
                    }
                failure {
                    script {
                        def Author_ID = sh(script: "git show -s --pretty=%an", returnStdout: true).trim()
                        def Author_Name = sh(script: "git show -s --pretty=%ae", returnStdout: true).trim()
                        mattermostSend(color: 'danger',
                            message: "빌드 실패: ${env.JOB_NAME} #${env.BUILD_NUMBER} by ${Author_ID}(${Author_Name})\n(<${env.BUILD_URL}|Details>)",
                            endpoint: 'https://meeting.ssafy.com/hooks/kip759cnntfw8nr3mpaqqqacgc',
                            channel: 'a605_noti_channel'
                                )
                    }
                }
            }
        }
    }

    post {
        always {
            script {
                if (fileExists(env.ENV_FILE)) {
                    sh 'docker compose -f "${COMPOSE_FILE}" --env-file "${ENV_FILE}" ps || true'
                } else {
                    echo "Skipping compose ps in post: ${env.ENV_FILE} not found"
                }
            }
        }
        failure {
            script {
                if (fileExists(env.ENV_FILE)) {
                    sh 'docker compose -f "${COMPOSE_FILE}" --env-file "${ENV_FILE}" logs --tail=100 || true'
                } else {
                    echo "Skipping compose logs in post failure: ${env.ENV_FILE} not found"
                }
            }
        }
    }
}