Administrator / spring-boot-microservices-onlineshooping-fullstack · Files

pipeline {
    agent {
        label 'jenkins-agent'
    }

    environment {
        // AWS Configuration
        AWS_ACCOUNT_ID = '319998871902'
        AWS_REGION = 'us-east-1'
        EKS_CLUSTER_NAME = 'comic-website-prod'
        DOCKER_REGISTRY = "${AWS_ACCOUNT_ID}.dkr.ecr.${AWS_REGION}.amazonaws.com"
        
        // Project Configuration
        PROJECT_NAME = 'ecommerce'
        NAMESPACE = 'ecommerce'
        
        // Docker Images
        FRONTEND_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-frontend"
        USER_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-user-service"
        PRODUCT_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-product-service"
        ORDER_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-order-service"
        PAYMENT_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-payment-service"
        INVENTORY_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-inventory-service"
        NOTIFICATION_SERVICE_IMAGE = "${DOCKER_REGISTRY}/${PROJECT_NAME}-notification-service"
        
        // Versioning - 现在从versions.yaml读取
        BUILD_VERSION = "${env.BUILD_NUMBER}"
        GIT_COMMIT_SHORT = "${env.GIT_COMMIT?.substring(0, 7) ?: 'unknown'}"
        
        // Java Configuration
        JAVA_HOME = "/opt/java/openjdk"
        
        // Version Control Configuration
        VERSION_FILE = 'versions.yaml'
        VERSION_CONFIGMAP_FILE = 'version-configmap.yaml'
    }

    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timeout(time: 60, unit: 'MINUTES')
        disableConcurrentBuilds()
    }

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

        stage('Setup Environment') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "=== Environment Setup ==="
                            echo "Build Version: ${BUILD_VERSION}"
                            echo "Git Commit: ${env.GIT_COMMIT}"
                            echo "Java Home: \$JAVA_HOME"
                            echo "Java Version:"
                            java -version
                            echo "Gradle Version:"
                            gradle --version
                            echo "Node Version:"
                            node --version || echo "Node.js not installed"
                            
                            # Configure AWS and EKS
                            aws configure set region ${AWS_REGION}
                            aws configure set output json
                            aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}
                            
                            echo "Kubernetes cluster info:"
                            kubectl cluster-info
                            
                            echo "Available disk space:"
                            df -h
                            
                            echo "=== Environment setup completed ==="
                        """
                    }
                }
            }
        }

        stage('Version Control') {
            steps {
                script {
                    try {
                        loadVersionConfig()
                        generateVersionConfigMap()
                        
                        // 设置构建显示名称和描述
                        currentBuild.displayName = "#${BUILD_VERSION}-${APPLICATION_VERSION}"
                        currentBuild.description = "Version: ${APPLICATION_VERSION} | Commit: ${env.GIT_COMMIT}"
                        
                        echo "✅ Version control completed successfully"
                    } catch (Exception e) {
                        echo "❌ Version control failed: ${e.getMessage()}"
                        error "Version control failed: ${e.getMessage()}"
                    }
                }
            }
        }

        stage('Terraform Create ECR') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "🚀 Starting Terraform ECR creation..."
                            cd terraform/ecr
                            
                            # Initialize Terraform
                            echo "Initializing Terraform..."
                            terraform init -input=false
                            
                            # Validate Terraform configuration
                            echo "Validating Terraform configuration..."
                            terraform validate
                            
                            # Plan Terraform changes
                            echo "Planning Terraform changes..."
                            terraform plan -out=tfplan -input=false
                            
                            # Apply Terraform changes
                            echo "Applying Terraform changes to create ECR repositories..."
                            terraform apply -input=false -auto-approve tfplan
                            
                            echo "✅ Terraform ECR creation completed successfully"
                            
                            # Display created ECR repositories
                            echo "Created ECR repositories:"
                            aws ecr describe-repositories --region ${AWS_REGION} --query "repositories[?contains(repositoryName, 'ecommerce')].repositoryName" --output table
                        """
                    }
                }
            }
        }

        stage('Build User Service') {
            steps {
                script {
                    buildServiceSequential('user-service')
                }
            }
        }

        stage('Build Product Service') {
            steps {
                script {
                    buildServiceSequential('product-service')
                }
            }
        }

        stage('Build Order Service') {
            steps {
                script {
                    buildServiceSequential('order-service')
                }
            }
        }

        stage('Build Payment Service') {
            steps {
                script {
                    buildServiceSequential('payment-service')
                }
            }
        }

        stage('Build Inventory Service') {
            steps {
                script {
                    buildServiceSequential('inventory-service')
                }
            }
        }

        stage('Build Notification Service') {
            steps {
                script {
                    buildServiceSequential('notification-service')
                }
            }
        }

        stage('Build Frontend') {
            steps {
                dir('frontend') {
                    sh '''
                        echo "Building Frontend..."
                        npm ci
                        npm run build
                        echo "Frontend build completed"
                    '''
                }
            }
        }

        stage('ECR Login') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "Logging into ECR..."
                            aws ecr get-login-password --region ${AWS_REGION} | docker login --username AWS --password-stdin ${DOCKER_REGISTRY}
                            echo "✅ ECR login successful"
                        """
                    }
                }
            }
        }

        stage('Docker Build Frontend') {
            steps {
                script {
                    dockerBuildPushSequential('frontend', "${FRONTEND_IMAGE}")
                }
            }
        }

        stage('Docker Build User Service') {
            steps {
                script {
                    dockerBuildPushSequential('user-service', "${USER_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Product Service') {
            steps {
                script {
                    dockerBuildPushSequential('product-service', "${PRODUCT_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Order Service') {
            steps {
                script {
                    dockerBuildPushSequential('order-service', "${ORDER_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Payment Service') {
            steps {
                script {
                    dockerBuildPushSequential('payment-service', "${PAYMENT_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Inventory Service') {
            steps {
                script {
                    dockerBuildPushSequential('inventory-service', "${INVENTORY_SERVICE_IMAGE}")
                }
            }
        }

        stage('Docker Build Notification Service') {
            steps {
                script {
                    dockerBuildPushSequential('notification-service', "${NOTIFICATION_SERVICE_IMAGE}")
                }
            }
        }

        stage('Create Namespace') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "🏗️ Creating namespace if not exists..."
                            
                            # 创建命名空间（如果不存在）
                            kubectl create namespace ${NAMESPACE} --dry-run=client -o yaml | kubectl apply -f -
                            
                            echo "✅ Namespace ${NAMESPACE} created/verified"
                        """
                    }
                }
            }
        }

        stage('Create Image Pull Secret') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh '''
                            echo "🔑 Creating ECR image pull secret..."
                            
                            # 获取 ECR 登录密码
                            ECR_PASSWORD=$(aws ecr get-login-password --region us-east-1)
                            
                            # 创建或更新镜像拉取 Secret
                            kubectl create secret docker-registry regcred \\
                              --docker-server=319998871902.dkr.ecr.us-east-1.amazonaws.com \\
                              --docker-username=AWS \\
                              --docker-password="$ECR_PASSWORD" \\
                              --namespace ecommerce --dry-run=client -o yaml | kubectl apply -f -
                            
                            echo "✅ ECR image pull secret created/updated successfully"
                        '''
                    }
                }
            }
        }

        stage('Generate App Version ConfigMap') {
            steps {
                script {
                    // 动态生成 app-version-configmap.yaml
                    def configMapContent = """
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-version-info
  namespace: ${NAMESPACE}
  labels:
    app.kubernetes.io/name: app-version-info
    app.kubernetes.io/part-of: ecommerce
    app.kubernetes.io/version: "${APPLICATION_VERSION}"
data:
  # 应用版本信息
  application.version: "${APPLICATION_VERSION}"
  application.name: "${APPLICATION_NAME}"
  application.description: "${APPLICATION_DESCRIPTION}"
  
  # 构建信息
  build.timestamp: "${new Date().format("yyyy-MM-dd'T'HH:mm:ss'Z'", TimeZone.getTimeZone('UTC'))}"
  build.number: "${BUILD_VERSION}"
  build.commit: "${env.GIT_COMMIT}"
  build.commit.short: "${GIT_COMMIT_SHORT}"
  build.branch: "${env.BRANCH_NAME}"
  build.java.version: "17"
  build.node.version: "18"
  build.gradle.version: "7.6"
  
  # 服务版本信息
  service.user-service.version: "${USER_SERVICE_VERSION}"
  service.user-service.description: "User Management Service"
  service.user-service.component: "backend"
  service.user-service.team: "identity-team"
  
  service.product-service.version: "${PRODUCT_SERVICE_VERSION}"
  service.product-service.description: "Product Management Service"
  service.product-service.component: "backend"
  service.product-service.team: "catalog-team"
  
  service.order-service.version: "${ORDER_SERVICE_VERSION}"
  service.order-service.description: "Order Management Service"
  service.order-service.component: "backend"
  service.order-service.team: "order-team"
  
  service.payment-service.version: "${PAYMENT_SERVICE_VERSION}"
  service.payment-service.description: "Payment Processing Service"
  service.payment-service.component: "backend"
  service.payment-service.team: "payment-team"
  
  service.inventory-service.version: "${INVENTORY_SERVICE_VERSION}"
  service.inventory-service.description: "Inventory Management Service"
  service.inventory-service.component: "backend"
  service.inventory-service.team: "inventory-team"
  
  service.notification-service.version: "${NOTIFICATION_SERVICE_VERSION}"
  service.notification-service.description: "Notification Service"
  service.notification-service.component: "backend"
  service.notification-service.team: "notification-team"
  
  service.frontend.version: "${FRONTEND_VERSION}"
  service.frontend.description: "React Frontend Application"
  service.frontend.component: "frontend"
  service.frontend.team: "frontend-team"
"""
                    
                    writeFile file: 'kubernetes/app-version-configmap.yaml', text: configMapContent
                    echo "✅ App version ConfigMap generated dynamically"
                }
            }
        }

        stage('Generate JWT Secret') {
            steps {
                script {
                    // 生成 JWT Secret - 使用安全的随机值
                    def randomSuffix = (System.currentTimeMillis() + new Random().nextInt(1000)).toString()
                    def jwtKey = "ecommerce-jwt-${APPLICATION_VERSION}-${BUILD_VERSION}-${randomSuffix}"
                    
                    // 使用 shell 命令进行 base64 编码
                    sh """
                        echo -n "${jwtKey}" | base64 > /tmp/jwt-key.txt
                    """
                    
                    def encodedJwtKey = readFile('/tmp/jwt-key.txt').trim()
                    
                    def jwtSecretContent = """
apiVersion: v1
kind: Secret
metadata:
  name: jwt-secret
  namespace: ${NAMESPACE}
  labels:
    app.kubernetes.io/name: jwt-secret
    app.kubernetes.io/part-of: ecommerce
type: Opaque
data:
  secret: ${encodedJwtKey}
"""
                    
                    writeFile file: 'kubernetes/jwt-secret.yaml', text: jwtSecretContent
                    echo "✅ JWT Secret generated dynamically"
                    
                    // 清理临时文件
                    sh "rm -f /tmp/jwt-key.txt"
                }
            }
        }

        stage('Update Deployment Versions') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh '''
                            echo "🔧 Updating deployment versions to: ''' + DEPLOYMENT_VERSION + '''"
                            
                            # Update kubeconfig
                            aws eks update-kubeconfig --region ''' + AWS_REGION + ''' --name ''' + EKS_CLUSTER_NAME + '''
                            
                            echo "Updating deployment files with version variables..."
                            
                            # 处理微服务
                            services="user-service product-service order-service payment-service inventory-service notification-service"
                            
                            for service in $services; do
                                echo "Processing $service..."
                                deployment_file="kubernetes/microservices/$service/deployment.yaml"
                                
                                if [ -f "$deployment_file" ]; then
                                    # 创建临时文件
                                    temp_file=$(mktemp)
                                    
                                    # 根据服务名称选择正确的镜像
                                    case "$service" in
                                        "user-service")
                                            image_name="''' + USER_SERVICE_IMAGE + '''" ;;
                                        "product-service")
                                            image_name="''' + PRODUCT_SERVICE_IMAGE + '''" ;;
                                        "order-service")
                                            image_name="''' + ORDER_SERVICE_IMAGE + '''" ;;
                                        "payment-service")
                                            image_name="''' + PAYMENT_SERVICE_IMAGE + '''" ;;
                                        "inventory-service")
                                            image_name="''' + INVENTORY_SERVICE_IMAGE + '''" ;;
                                        "notification-service")
                                            image_name="''' + NOTIFICATION_SERVICE_IMAGE + '''" ;;
                                        *)
                                            image_name="''' + USER_SERVICE_IMAGE + '''" ;;
                                    esac
                                    
                                    echo "Updating $service deployment variables..."
                                    
                                    # 替换所有变量到临时文件
                                    sed -e "s|\\$(APP_VERSION)|''' + DEPLOYMENT_VERSION + '''|g" \
                                        -e "s|319998871902.dkr.ecr.us-east-1.amazonaws.com/ecommerce-$service:.*|$image_name:''' + DEPLOYMENT_VERSION + '''|g" \
                                        -e "s|\\$(BUILD_VERSION)|''' + BUILD_VERSION + '''|g" \
                                        -e "s|\\$(GIT_COMMIT)|''' + env.GIT_COMMIT + '''|g" \
                                        "$deployment_file" > "$temp_file"
                                    
                                    # 用临时文件替换原始文件
                                    mv "$temp_file" "$deployment_file"
                                    
                                    echo "✅ $service deployment variables updated"
                                else
                                    echo "❌ Deployment file not found: $deployment_file"
                                fi
                            done
                            
                            # 处理 frontend
                            frontend_file="kubernetes/frontend/deployment.yaml"
                            if [ -f "$frontend_file" ]; then
                                temp_file=$(mktemp)
                                echo "Updating frontend deployment variables..."
                                sed -e "s|\\$(APP_VERSION)|''' + DEPLOYMENT_VERSION + '''|g" \
                                    -e "s|319998871902.dkr.ecr.us-east-1.amazonaws.com/ecommerce-frontend:.*|''' + FRONTEND_IMAGE + ''':''' + DEPLOYMENT_VERSION + '''|g" \
                                    -e "s|\\$(BUILD_VERSION)|''' + BUILD_VERSION + '''|g" \
                                    -e "s|\\$(GIT_COMMIT)|''' + env.GIT_COMMIT + '''|g" \
                                    "$frontend_file" > "$temp_file"
                                mv "$temp_file" "$frontend_file"
                                echo "✅ frontend deployment variables updated"
                            else
                                echo "❌ Frontend deployment file not found: $frontend_file"
                            fi
                            
                            echo "✅ All deployment files updated with version: ''' + DEPLOYMENT_VERSION + '''"
                        '''
                    }
                }
            }
        }

        stage('Apply Version ConfigMap') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "📝 Applying version ConfigMap to Kubernetes..."
                            
                            # Update kubeconfig
                            aws eks update-kubeconfig --region ${AWS_REGION} --name ${EKS_CLUSTER_NAME}
                            
                            # Apply the generated version ConfigMap
                            kubectl apply -f ${VERSION_CONFIGMAP_FILE} -n ${NAMESPACE}
                            
                            echo "✅ Version ConfigMap applied successfully"
                        """
                    }
                }
            }
        }

        stage('Record Version Info') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        sh """
                            echo "📝 Recording version information..."
                            
                            # Create version info ConfigMap
                            kubectl create configmap version-info \\
                              --from-literal=build-number=${BUILD_VERSION} \\
                              --from-literal=git-commit=${env.GIT_COMMIT} \\
                              --from-literal=git-commit-short=${GIT_COMMIT_SHORT} \\
                              --from-literal=docker-tag=${DOCKER_TAG} \\
                              --from-literal=deployment-version=${DEPLOYMENT_VERSION} \\
                              --from-literal=application-version=${APPLICATION_VERSION} \\
                              --from-literal=build-time=\$(date -u +"%Y-%m-%dT%H:%M:%SZ") \\
                              --from-literal=deploy-time=\$(date -u +"%Y-%m-%dT%H:%M:%SZ") \\
                              -n ${NAMESPACE} --dry-run=client -o yaml | kubectl apply -f -
                              
                            echo "✅ Version information recorded"
                        """
                    }
                }
            }
        }

        stage('Deploy to EKS') {
            steps {
                withCredentials([[
                    $class: 'AmazonWebServicesCredentialsBinding',
                    credentialsId: 'dev-user-aws-credentials',
                    accessKeyVariable: 'AWS_ACCESS_KEY_ID',
                    secretKeyVariable: 'AWS_SECRET_ACCESS_KEY'
                ]]) {
                    script {
                        // 使用单引号字符串避免 Groovy 插值问题
                        sh '''#!/bin/bash
                            echo "🚀 Starting deployment to EKS..."
                            echo "Application Version: ''' + APPLICATION_VERSION + '''"
                            echo "Deployment Version: ''' + DEPLOYMENT_VERSION + '''"
                            
                            # Update kubeconfig
                            aws eks update-kubeconfig --region ''' + AWS_REGION + ''' --name ''' + EKS_CLUSTER_NAME + '''
                            
                            # 首先应用必要的 ConfigMap 和 Secret
                            echo "=== Applying required ConfigMaps and Secrets ==="
                            kubectl apply -f kubernetes/app-version-configmap.yaml -n ''' + NAMESPACE + '''
                            kubectl apply -f kubernetes/jwt-secret.yaml -n ''' + NAMESPACE + '''
                            
                            # 然后应用所有其他 Kubernetes 资源
                            echo "=== Applying all Kubernetes resources ==="
                            
                            # 应用所有服务的所有资源
                            services_list="user-service product-service order-service payment-service inventory-service notification-service"
                            
                            for service in $services_list; do
                                echo "Applying all resources for $service..."
                                find "kubernetes/microservices/$service" -name "*.yaml" -o -name "*.yml" 2>/dev/null | while read file; do
                                    if [ -f "$file" ]; then
                                        echo "Applying: $file"
                                        kubectl apply -f "$file" -n ''' + NAMESPACE + '''
                                    fi
                                done
                            done
                            
                            # 应用 frontend 资源
                            if [ -d "kubernetes/frontend" ]; then
                                find "kubernetes/frontend" -name "*.yaml" -o -name "*.yml" | while read file; do
                                    kubectl apply -f "$file" -n ''' + NAMESPACE + '''
                                done
                            fi
                            
                            # 应用基础设施资源
                            echo "=== Applying infrastructure resources ==="
                            if [ -d "kubernetes/databases" ]; then
                                kubectl apply -f kubernetes/databases/ -n ''' + NAMESPACE + ''' --recursive=true || echo "No databases configuration found or applied"
                            fi
                            
                            if [ -d "kubernetes/message-queue" ]; then
                                kubectl apply -f kubernetes/message-queue/ -n ''' + NAMESPACE + ''' --recursive=true || echo "No message queue configuration found or applied"
                            fi
                            
                            if [ -d "kubernetes/networking" ]; then
                                kubectl apply -f kubernetes/networking/ -n ''' + NAMESPACE + ''' --recursive=true || echo "No networking configuration found or applied"
                            fi
                            
                            # 等待基础设施就绪
                            echo "=== Waiting for infrastructure to be ready (60 seconds) ==="
                            sleep 60
                            
                            # 检查所有 deployment 的状态
                            echo "=== Checking deployment status ==="
                            kubectl get deployments -n ''' + NAMESPACE + ''' -o wide
                            echo ""
                            echo "=== Checking pod status ==="
                            kubectl get pods -n ''' + NAMESPACE + ''' -o wide
                            echo ""
                            echo "=== Checking events ==="
                            kubectl get events -n ''' + NAMESPACE + ''' --sort-by='.lastTimestamp' | tail -10
                            
                            # 等待核心部署完成
                            echo "=== Waiting for core deployments to be ready ==="
                            core_deployments="user-service product-service"
                            
                            for deployment in $core_deployments; do
                                echo "Waiting for $deployment rollout..."
                                if kubectl rollout status deployment/$deployment -n ''' + NAMESPACE + ''' --timeout=600s; then
                                    echo "✅ $deployment rollout completed"
                                else
                                    echo "⚠️ $deployment rollout failed or timed out, checking details..."
                                    kubectl describe deployment/$deployment -n ''' + NAMESPACE + '''
                                    kubectl get pods -n ''' + NAMESPACE + ''' -l app=$deployment
                                    # 继续而不是失败
                                fi
                            done
                            
                            echo "✅ Deployment completed!"
                            
                            # Final status check
                            echo "=== Final Deployment Status ==="
                            kubectl get deployments -n ''' + NAMESPACE + '''
                            kubectl get pods -n ''' + NAMESPACE + '''
                            kubectl get services -n ''' + NAMESPACE + '''
                        '''
                    }
                }
            }
        }
    }

    post {
        always {
            // Archive build artifacts
            archiveArtifacts artifacts: '**/build/libs/*.jar', fingerprint: true
            
            // Clean up Docker to free space
            sh '''
                echo "Cleaning up Docker resources..."
                docker system prune -f || true
                echo "Cleanup completed"
            '''
            
            // Log disk space after build
            sh '''
                echo "Disk space after build:"
                df -h
            '''
        }
        success {
            echo "🎉 Build and deployment successful!"
            script {
                sh '''
                    echo "✅ All tasks completed successfully"
                    echo "📊 Build Information:"
                    echo "   Application Version: '${APPLICATION_VERSION}'"
                    echo "   Build Number: '${BUILD_VERSION}'"
                    echo "   Docker Tag: '${DOCKER_TAG}'"
                    echo "   Deployment Version: '${DEPLOYMENT_VERSION}'"
                    echo "   Git Commit: '${GIT_COMMIT}'"
                    echo "📊 Final resource usage:"
                    df -h
                    echo "🚀 Application deployed successfully!"
                '''
            }
        }
        failure {
            echo "❌ Build failed! Check the logs for details."
            sh '''
                echo "💡 Troubleshooting tips:"
                echo "1. Check disk space: df -h"
                echo "2. Check Docker: docker system df"
                echo "3. Check Gradle cache: du -sh ~/.gradle/"
                echo "4. Check Kubernetes resources: kubectl get pods -n ecommerce"
                echo "5. Check ECR repositories: aws ecr describe-repositories --region us-east-1"
                echo "6. Check specific service logs: kubectl logs -n ecommerce <pod-name>"
                echo "7. Check deployment status: kubectl get deployments -n ecommerce"
                echo "8. Check version info: kubectl get configmap version-info -n ecommerce -o yaml"
            '''
        }
    }
}

// 串行构建微服务的函数
def buildServiceSequential(serviceName) {
    echo "🔨 Building ${serviceName}..."
    dir("microservices/${serviceName}") {
        // 添加重试机制和资源监控
        retry(2) {
            sh """
                echo "=== Starting Gradle build for ${serviceName} ==="
                echo "Current directory: \$(pwd)"
                echo "Java version:"
                java -version
                echo "Gradle version:"
                gradle --version
                
                # 清理 Gradle 缓存以防万一
                echo "Cleaning project..."
                gradle clean --no-daemon
                
                # 构建项目（跳过测试以减少资源使用）
                echo "Building project..."
                gradle build -x test --no-daemon --stacktrace
                
                echo "✅ ${serviceName} build completed"
                echo "Build artifacts:"
                ls -la build/libs/
            """
        }
    }
    echo "✅ ${serviceName} build completed successfully"
}

// 串行构建和推送 Docker 镜像的函数 - 现在使用语义化版本号
def dockerBuildPushSequential(serviceDir, imageName) {
    echo "🐳 Building and pushing Docker image for ${serviceDir}..."
    
    def contextDir = serviceDir == 'frontend' ? 'frontend' : "microservices/${serviceDir}"
    def serviceVersion = env."${serviceDir.toUpperCase().replace('-', '_')}_VERSION"
    
    dir(contextDir) {
        retry(2) {
            sh """
                echo "=== Building Docker image for ${serviceDir} ==="
                echo "Image: ${imageName}"
                echo "Service Version: ${serviceVersion}"
                echo "Build context: \$(pwd)"
                
                # 检查 Dockerfile 是否存在
                echo "Checking for Dockerfile..."
                ls -la Dockerfile || echo "Dockerfile not found, listing all files:"
                ls -la
                
                # 构建 Docker 镜像 - 使用语义化版本号
                echo "Building Docker image with semantic versioning..."
                docker build -t ${imageName}:${serviceVersion} -t ${imageName}:latest .
                
                # 推送版本标签到 ECR
                echo "Pushing version tag: ${serviceVersion}"
                docker push ${imageName}:${serviceVersion}
                
                echo "Pushing latest tag"
                docker push ${imageName}:latest
                
                echo "✅ ${serviceDir} Docker images pushed successfully"
                echo "   - ${imageName}:${serviceVersion}"
                echo "   - ${imageName}:latest"
                
                # 清理本地镜像以节省空间
                echo "Cleaning up local Docker images..."
                docker rmi ${imageName}:${serviceVersion} || true
                docker rmi ${imageName}:latest || true
                
                echo "=== ${serviceDir} Docker build completed ==="
            """
        }
    }
}

// 版本控制相关函数
def loadVersionConfig() {
    echo "📖 Loading version configuration from ${VERSION_FILE}"
    
    if (!fileExists(VERSION_FILE)) {
        error "Version file ${VERSION_FILE} not found!"
    }
    
    // 读取版本文件内容
    def versionContent = readYaml file: VERSION_FILE
    
    // 设置全局版本信息
    env.APPLICATION_VERSION = "${versionContent.versions.application.major}.${versionContent.versions.application.minor}.${versionContent.versions.application.patch}"
    env.APPLICATION_NAME = versionContent.versions.application.name
    env.APPLICATION_DESCRIPTION = versionContent.versions.application.description
    
    // 设置服务版本信息
    versionContent.versions.services.each { serviceName, serviceConfig ->
        def envVarName = serviceName.toUpperCase().replace('-', '_') + "_VERSION"
        env."${envVarName}" = serviceConfig.version
        echo "Set ${envVarName} = ${serviceConfig.version}"
    }
    
    // 设置基础设施版本
    versionContent.versions.infrastructure.each { infraName, infraConfig ->
        env."${infraName.toUpperCase()}_VERSION" = infraConfig.version
    }
    
    // 设置Docker标签和部署版本 - 现在使用语义化版本号
    env.DOCKER_TAG = "${env.APPLICATION_VERSION}-${env.GIT_COMMIT_SHORT}"
    env.DEPLOYMENT_VERSION = env.APPLICATION_VERSION
    
    echo "✅ Version configuration loaded:"
    echo "   Application: ${env.APPLICATION_VERSION} - ${env.APPLICATION_NAME}"
    echo "   Docker Tag: ${env.DOCKER_TAG}"
    echo "   Deployment Version: ${env.DEPLOYMENT_VERSION}"
    versionContent.versions.services.each { serviceName, serviceConfig ->
        echo "   ${serviceName}: ${serviceConfig.version}"
    }
}

def generateVersionConfigMap() {
    echo "📝 Generating version ConfigMap"
    
    try {
        def versionContent = readYaml file: VERSION_FILE
        
        // 使用shell命令直接生成ConfigMap文件，避免writeYaml的问题
        sh """
            cat > ${VERSION_CONFIGMAP_FILE} << EOF
apiVersion: v1
kind: ConfigMap
metadata:
  name: ecommerce-version-info
  namespace: ${NAMESPACE}
data:
  application.version: "${APPLICATION_VERSION}"
  application.name: "${APPLICATION_NAME}"
  application.description: "${APPLICATION_DESCRIPTION}"
  build.timestamp: "`date -u +"%Y-%m-%dT%H:%M:%SZ"`"
  build.number: "${BUILD_VERSION}"
  build.commit: "${env.GIT_COMMIT}"
  build.commit.short: "${GIT_COMMIT_SHORT}"
  build.branch: "${env.BRANCH_NAME}"
  docker.tag: "${DOCKER_TAG}"
  deployment.version: "${DEPLOYMENT_VERSION}"
  build.java.version: "${versionContent.versions.build.java_version}"
  build.node.version: "${versionContent.versions.build.node_version}"
  build.gradle.version: "${versionContent.versions.build.gradle_version}"
EOF
        """
        
        // 添加服务版本信息
        versionContent.versions.services.each { serviceName, serviceConfig ->
            def serviceKey = serviceName.replace('-', '.').toLowerCase()
            sh """
                echo "  service.${serviceKey}.version: \\\"${serviceConfig.version}\\\"" >> ${VERSION_CONFIGMAP_FILE}
                echo "  service.${serviceKey}.description: \\\"${serviceConfig.description}\\\"" >> ${VERSION_CONFIGMAP_FILE}
                echo "  service.${serviceKey}.component: \\\"${serviceConfig.component}\\\"" >> ${VERSION_CONFIGMAP_FILE}
                echo "  service.${serviceKey}.team: \\\"${serviceConfig.team}\\\"" >> ${VERSION_CONFIGMAP_FILE}
            """
        }
        
        // 添加基础设施版本信息
        versionContent.versions.infrastructure.each { infraName, infraConfig ->
            sh """
                echo "  infrastructure.${infraName}.version: \\\"${infraConfig.version}\\\"" >> ${VERSION_CONFIGMAP_FILE}
                echo "  infrastructure.${infraName}.description: \\\"${infraConfig.description}\\\"" >> ${VERSION_CONFIGMAP_FILE}
            """
        }
        
        echo "✅ Version ConfigMap generated: ${VERSION_CONFIGMAP_FILE}"
        sh "cat ${VERSION_CONFIGMAP_FILE}"
        
    } catch (Exception e) {
        echo "❌ Failed to generate version ConfigMap: ${e.getMessage()}"
        throw e
    }
}