Jenkinsfile

pipeline {
    agent any
    
    environment {
        AWS_REGION = 'us-east-1'
        AWS_ACCOUNT_ID = credentials('aws-account-id')
        ECR_BACKEND = "${AWS_ACCOUNT_ID}.dkr.ecr.${AWS_REGION}.amazonaws.com/myapp-backend"
        ECR_FRONTEND = "${AWS_ACCOUNT_ID}.dkr.ecr.${AWS_REGION}.amazonaws.com/myapp-frontend"
        IMAGE_TAG = "${BUILD_NUMBER}"
        CLUSTER_NAME = 'myapp-eks-cluster'
        NAMESPACE = 'production'
    }
    
    stages {
        stage('Checkout') {
            steps {
                checkout scm
                script {
                    env.GIT_COMMIT_SHORT = sh(
                        script: "git rev-parse --short HEAD",
                        returnStdout: true
                    ).trim()
                }
            }
        }
        
        stage('Build Backend') {
            steps {
                dir('backend') {
                    sh '''
                        mvn clean package -DskipTests
                    '''
                }
            }
        }
        
        stage('Build Frontend') {
            steps {
                dir('frontend') {
                    sh '''
                        npm ci
                        npm run build
                    '''
                }
            }
        }
        
        stage('Run Tests') {
            parallel {
                stage('Backend Tests') {
                    steps {
                        dir('backend') {
                            sh 'mvn test'
                        }
                    }
                }
                stage('Frontend Tests') {
                    steps {
                        dir('frontend') {
                            sh 'npm test -- --watchAll=false'
                        }
                    }
                }
            }
        }
        
        stage('Code Quality & Security Scan') {
            parallel {
                stage('SonarQube Analysis') {
                    steps {
                        script {
                            withSonarQubeEnv('SonarQube') {
                                dir('backend') {
                                    sh 'mvn sonar:sonar'
                                }
                            }
                        }
                    }
                }
                stage('Trivy Scan') {
                    steps {
                        sh '''
                            docker build -t temp-backend:${IMAGE_TAG} ./backend
                            docker build -t temp-frontend:${IMAGE_TAG} ./frontend
                            trivy image --severity HIGH,CRITICAL temp-backend:${IMAGE_TAG}
                            trivy image --severity HIGH,CRITICAL temp-frontend:${IMAGE_TAG}
                        '''
                    }
                }
            }
        }
        
        stage('Build & Push Docker Images') {
            steps {
                script {
                    // Login to ECR
                    sh '''
                        aws ecr get-login-password --region ${AWS_REGION} | \
                        docker login --username AWS --password-stdin ${AWS_ACCOUNT_ID}.dkr.ecr.${AWS_REGION}.amazonaws.com
                    '''
                    
                    // Build and push backend
                    dir('backend') {
                        sh """
                            docker build -t ${ECR_BACKEND}:${IMAGE_TAG} .
                            docker tag ${ECR_BACKEND}:${IMAGE_TAG} ${ECR_BACKEND}:latest
                            docker push ${ECR_BACKEND}:${IMAGE_TAG}
                            docker push ${ECR_BACKEND}:latest
                        """
                    }
                    
                    // Build and push frontend
                    dir('frontend') {
                        sh """
                            docker build -t ${ECR_FRONTEND}:${IMAGE_TAG} .
                            docker tag ${ECR_FRONTEND}:${IMAGE_TAG} ${ECR_FRONTEND}:latest
                            docker push ${ECR_FRONTEND}:${IMAGE_TAG}
                            docker push ${ECR_FRONTEND}:latest
                        """
                    }
                }
            }
        }
        
        stage('Update Kubernetes Manifests') {
            steps {
                sh """
                    sed -i 's|image: .*myapp-backend.*|image: ${ECR_BACKEND}:${IMAGE_TAG}|g' k8s/backend-deployment.yaml
                    sed -i 's|image: .*myapp-frontend.*|image: ${ECR_FRONTEND}:${IMAGE_TAG}|g' k8s/frontend-deployment.yaml
                """
            }
        }
        
        stage('Deploy to Kubernetes') {
            steps {
                script {
                    sh """
                        aws eks update-kubeconfig --name ${CLUSTER_NAME} --region ${AWS_REGION}
                        
                        # Apply configurations
                        kubectl apply -f k8s/namespace.yaml
                        kubectl apply -f k8s/configmap.yaml
                        kubectl apply -f k8s/secret.yaml
                        
                        # Deploy applications
                        kubectl apply -f k8s/backend-deployment.yaml
                        kubectl apply -f k8s/frontend-deployment.yaml
                        kubectl apply -f k8s/hpa.yaml
                        kubectl apply -f k8s/ingress.yaml
                        
                        # Wait for rollout
                        kubectl rollout status deployment/backend -n ${NAMESPACE} --timeout=5m
                        kubectl rollout status deployment/frontend -n ${NAMESPACE} --timeout=5m
                    """
                }
            }
        }
        
        stage('Verify Deployment') {
            steps {
                sh """
                    kubectl get pods -n ${NAMESPACE}
                    kubectl get services -n ${NAMESPACE}
                    kubectl get ingress -n ${NAMESPACE}
                """
            }
        }
        
        stage('Run Smoke Tests') {
            steps {
                script {
                    sh """
                        # Get the load balancer URL
                        INGRESS_URL=\$(kubectl get ingress app-ingress -n ${NAMESPACE} -o jsonpath='{.status.loadBalancer.ingress[0].hostname}')
                        
                        # Wait for load balancer to be ready
                        sleep 30
                        
                        # Test backend health
                        curl -f http://\$INGRESS_URL/api/actuator/health || exit 1
                        
                        # Test frontend
                        curl -f http://\$INGRESS_URL/ || exit 1
                    """
                }
            }
        }
    }
    
    post {
        success {
            echo 'Deployment successful!'
            // Send Slack notification
            slackSend(
                color: 'good',
                message: "Deployment successful: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
            )
        }
        failure {
            echo 'Deployment failed!'
            // Rollback
            sh """
                kubectl rollout undo deployment/backend -n ${NAMESPACE}
                kubectl rollout undo deployment/frontend -n ${NAMESPACE}
            """
            slackSend(
                color: 'danger',
                message: "Deployment failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
            )
        }
        always {
            // Clean up
            sh 'docker system prune -af'
            cleanWs()
        }
    }
}