cd.yml

name: 🚀 Continuous Deployment

on:
  workflow_dispatch:
    inputs:
      environment:
        description: 'Deployment environment'
        required: true
        default: 'test'
        type: choice
        options:
          - test
          - staging
          - production
      force_deploy:
        description: 'Force deployment (skip checks)'
        required: false
        default: false
        type: boolean

env:
  REGISTRY: docker.io
  REGISTRY_NAMESPACE: websoft9

jobs:
  # Pre-deployment check
  pre-deployment-check:
    name: 🔍 Pre-deployment Check
    runs-on: ubuntu-latest
    outputs:
      deploy_environment: ${{ steps.determine-env.outputs.environment }}
      should_deploy: ${{ steps.check-conditions.outputs.should_deploy }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Determine deployment environment
        id: determine-env
        run: |
          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
            echo "environment=${{ inputs.environment }}" >> $GITHUB_OUTPUT
          else
            echo "environment=test" >> $GITHUB_OUTPUT
          fi

      - name: Check deployment conditions
        id: check-conditions
        run: |
          environment="${{ steps.determine-env.outputs.environment }}"
          force_deploy="${{ inputs.force_deploy }}"

          echo "Deployment environment: $environment"
          echo "Force deployment: $force_deploy"

          # Check if deployment should proceed
          should_deploy="true"

          if [ "$force_deploy" != "true" ]; then
            # Check recent CI status
            echo "Checking recent CI status..."

            # Here you can add more check logic
            # For example: check recent test results, security scan results, etc.
          fi

          echo "should_deploy=$should_deploy" >> $GITHUB_OUTPUT

      - name: Validate deployment target
        run: |
          environment="${{ steps.determine-env.outputs.environment }}"

          case $environment in
            test)
              echo "✅ Deploy to test environment"
              ;;
            staging)
              echo "✅ Deploy to staging environment"
              ;;
            production)
              echo "✅ Deploy to production environment"
              echo "⚠️ Production environment deployment requires additional approval"
              ;;
            *)
              echo "❌ Invalid deployment environment: $environment"
              exit 1
              ;;
          esac

  # Build deployment images
  build-deployment-images:
    name: 🔨 Build Deployment Images
    runs-on: ubuntu-latest
    needs: [pre-deployment-check]
    if: needs.pre-deployment-check.outputs.should_deploy == 'true'
    strategy:
      matrix:
        service: ['api-service', 'websoft9-agent']
        include:
          - service: api-service
            context: api-service
          - service: websoft9-agent
            context: websoft9-agent
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Log in to Docker Hub
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.REGISTRY_NAMESPACE }}/${{ matrix.service }}
          tags: |
            type=ref,event=branch
            type=sha,prefix={{branch}}-
            type=raw,value=deploy-${{ needs.pre-deployment-check.outputs.deploy_environment }}-{{sha}}

      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: ${{ matrix.context }}
          file: ${{ matrix.context }}/Dockerfile
          platforms: linux/amd64,linux/arm64
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

  # Deploy to test environment
  deploy-to-test:
    name: 🧪 Deploy to Test Environment
    runs-on: ubuntu-latest
    needs: [pre-deployment-check, build-deployment-images]
    if: needs.pre-deployment-check.outputs.deploy_environment == 'test'
    environment:
      name: ${{ needs.pre-deployment-check.outputs.deploy_environment }}
      url: https://test.websoft9.com
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up deployment configuration
        run: |
          echo "Configuring test environment deployment parameters..."

          # Create deployment configuration
          mkdir -p deploy/test

          cat > deploy/test/docker-compose.yml << 'EOF'
          version: '3.8'

          services:
            api-service:
              image: ${{ env.REGISTRY }}/${{ env.REGISTRY_NAMESPACE }}/api-service:deploy-test-${{ github.sha }}
              ports:
                - "8080:8080"
                - "9090:9090"
              environment:
                - GIN_MODE=release
                - DB_TYPE=sqlite
                - DB_DSN=/app/data/websoft9.db
                - REDIS_URL=redis://redis:6379
                - JWT_SECRET=${{ secrets.TEST_JWT_SECRET }}
              depends_on:
                - redis
              restart: unless-stopped
              volumes:
                - api_data:/app/data
              healthcheck:
                test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
                interval: 30s
                timeout: 10s
                retries: 3

            websoft9-agent:
              image: ${{ env.REGISTRY }}/${{ env.REGISTRY_NAMESPACE }}/websoft9-agent:deploy-test-${{ github.sha }}
              environment:
                - LOG_LEVEL=info
                - SERVER_URL=http://api-service:8080
                - AGENT_ID=test-agent-1
              depends_on:
                - api-service
              restart: unless-stopped
              volumes:
                - /var/run/docker.sock:/var/run/docker.sock
              privileged: true

            redis:
              image: redis:7.0
              ports:
                - "6379:6379"
              volumes:
                - redis_data:/data
              restart: unless-stopped
              healthcheck:
                test: ["CMD", "redis-cli", "ping"]
                interval: 30s
                timeout: 10s
                retries: 3

          volumes:
            api_data:
            redis_data:
          EOF

      - name: Deploy to test environment
        run: |
          echo "Deploying to test environment..."

          # This should be the actual deployment logic
          # For example: SSH to test server, pull images, update services, etc.

          # Simulate deployment process
          echo "1. Stopping existing services..."
          # docker-compose -f deploy/test/docker-compose.yml down

          echo "2. Pulling latest images..."
          # docker-compose -f deploy/test/docker-compose.yml pull

          echo "3. Starting services..."
          # docker-compose -f deploy/test/docker-compose.yml up -d

          echo "✅ Test environment deployment completed"

      - name: Wait for services to be ready
        run: |
          echo "Waiting for services to start..."

          # Wait for health checks to pass
          max_attempts=30
          attempt=1

          while [ $attempt -le $max_attempts ]; do
            echo "Checking service status... ($attempt/$max_attempts)"

            # This should check actual service status
            # For example: curl health check endpoints

            # Simulate health check
            if [ $attempt -ge 5 ]; then
              echo "✅ All services are ready"
              break
            fi

            sleep 10
            attempt=$((attempt + 1))
          done

          if [ $attempt -gt $max_attempts ]; then
            echo "❌ Service startup timeout"
            exit 1
          fi

      - name: Run deployment verification tests
        run: |
          echo "Running deployment verification tests..."

          # Basic connectivity test
          echo "1. API service connectivity test..."
          # curl -f http://test.websoft9.com/health || exit 1

          echo "2. SQLite database connection test..."
          # Test SQLite database connection

          echo "3. Functional verification test..."
          # Run verification tests for key functions

          echo "✅ Deployment verification tests passed"

  # Deploy to staging environment
  deploy-to-staging:
    name: 🎭 Deploy to Staging Environment
    runs-on: ubuntu-latest
    needs: [pre-deployment-check, build-deployment-images]
    if: needs.pre-deployment-check.outputs.deploy_environment == 'staging'
    environment:
      name: ${{ needs.pre-deployment-check.outputs.deploy_environment }}
      url: https://staging.websoft9.com
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Deploy to staging environment
        run: |
          echo "Deploying to staging environment..."

          # Staging environment deployment logic
          # Usually includes stricter validation and monitoring

          echo "✅ Staging environment deployment completed"

      - name: Run staging verification tests
        run: |
          echo "Running staging environment verification tests..."

          # More comprehensive verification tests
          echo "✅ Staging environment verification tests passed"

  # Deploy to production environment
  deploy-to-production:
    name: 🌟 Deploy to Production Environment
    runs-on: ubuntu-latest
    needs: [pre-deployment-check, build-deployment-images]
    if: needs.pre-deployment-check.outputs.deploy_environment == 'production'
    environment:
      name: ${{ needs.pre-deployment-check.outputs.deploy_environment }}
      url: https://websoft9.com
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Create deployment backup
        run: |
          echo "Creating deployment backup..."

          # Backup current production environment configuration and data
          backup_timestamp=$(date +%Y%m%d_%H%M%S)
          echo "backup_timestamp=$backup_timestamp" >> $GITHUB_ENV

          echo "✅ Backup created: $backup_timestamp"

      - name: Deploy to production environment
        run: |
          echo "Deploying to production environment..."

          # Production environment deployment logic
          # Includes blue-green deployment, rolling updates, etc.

          echo "✅ Production environment deployment completed"

      - name: Run production verification tests
        run: |
          echo "Running production environment verification tests..."

          # Production environment verification tests
          echo "✅ Production environment verification tests passed"

      - name: Enable production traffic
        run: |
          echo "Enabling production environment traffic..."

          # Switch traffic to new version
          echo "✅ Production environment traffic enabled"

  # Post-deployment health check
  post-deployment-health-check:
    name: 🏥 Post-deployment Health Check
    runs-on: ubuntu-latest
    needs: [pre-deployment-check, deploy-to-test, deploy-to-staging, deploy-to-production]
    if: always() && (needs.deploy-to-test.result == 'success' || needs.deploy-to-staging.result == 'success' || needs.deploy-to-production.result == 'success')
    steps:
      - name: Comprehensive health check
        run: |
          environment="${{ needs.pre-deployment-check.outputs.deploy_environment }}"

          echo "Performing comprehensive health check for $environment environment..."

          # Set environment URL
          case $environment in
            test)
              base_url="https://test.websoft9.com"
              ;;
            staging)
              base_url="https://staging.websoft9.com"
              ;;
            production)
              base_url="https://websoft9.com"
              ;;
          esac

          echo "Checking URL: $base_url"

          # Health check items
          checks=(
            "API Service Status"
            "SQLite Database Connection"
            "Redis Connection"
            "Key Function Verification"
            "Performance Metrics Check"
          )

          failed_checks=()

          for check in "${checks[@]}"; do
            echo "Performing check: $check"

            # This should be actual health check logic
            # Simulate check results
            if [ "$check" = "Performance Metrics Check" ] && [ "$environment" = "production" ]; then
              # Simulate that production environment performance check might fail
              if [ $((RANDOM % 10)) -lt 2 ]; then
                failed_checks+=("$check")
                echo "❌ $check failed"
                continue
              fi
            fi

            echo "✅ $check passed"
          done

          if [ ${#failed_checks[@]} -gt 0 ]; then
            echo ""
            echo "❌ The following health checks failed:"
            for check in "${failed_checks[@]}"; do
              echo "  - $check"
            done

            # Set output for subsequent steps to handle
            echo "health_check_failed=true" >> $GITHUB_ENV
            echo "failed_checks=${failed_checks[*]}" >> $GITHUB_ENV
          else
            echo ""
            echo "✅ All health checks passed"
            echo "health_check_failed=false" >> $GITHUB_ENV
          fi

      - name: Handle health check failures
        if: env.health_check_failed == 'true'
        run: |
          environment="${{ needs.pre-deployment-check.outputs.deploy_environment }}"

          echo "Handling health check failures..."

          if [ "$environment" = "production" ]; then
            echo "⚠️ Production environment health check failed, consider rollback"

            # This can trigger automatic rollback logic
            echo "Triggering rollback process..."

            # Send emergency notification
            echo "Sending emergency notification..."
          else
            echo "⚠️ $environment environment health check failed, manual intervention required"
          fi

  # Deployment notification
  deployment-notification:
    name: 📢 Deployment Notification
    runs-on: ubuntu-latest
    needs: [pre-deployment-check, deploy-to-test, deploy-to-staging, deploy-to-production, post-deployment-health-check]
    if: always()
    steps:
      - name: Determine deployment result
        id: result
        run: |
          environment="${{ needs.pre-deployment-check.outputs.deploy_environment }}"

          # Determine deployment result
          case $environment in
            test)
              deploy_result="${{ needs.deploy-to-test.result }}"
              ;;
            staging)
              deploy_result="${{ needs.deploy-to-staging.result }}"
              ;;
            production)
              deploy_result="${{ needs.deploy-to-production.result }}"
              ;;
          esac

          health_check_result="${{ needs.post-deployment-health-check.result }}"

          echo "environment=$environment" >> $GITHUB_OUTPUT
          echo "deploy_result=$deploy_result" >> $GITHUB_OUTPUT
          echo "health_check_result=$health_check_result" >> $GITHUB_OUTPUT

          # Determine overall status
          if [ "$deploy_result" = "success" ] && [ "$health_check_result" = "success" ]; then
            echo "overall_status=success" >> $GITHUB_OUTPUT
            echo "status_message=Deployment successful" >> $GITHUB_OUTPUT
          elif [ "$deploy_result" = "success" ] && [ "$health_check_result" = "failure" ]; then
            echo "overall_status=warning" >> $GITHUB_OUTPUT
            echo "status_message=Deployment successful but health check failed" >> $GITHUB_OUTPUT
          else
            echo "overall_status=failure" >> $GITHUB_OUTPUT
            echo "status_message=Deployment failed" >> $GITHUB_OUTPUT
          fi

      - name: Prepare email content
        id: email
        run: |
          status="${{ steps.result.outputs.overall_status }}"
          message="${{ steps.result.outputs.status_message }}"
          environment="${{ steps.result.outputs.environment }}"

          # Set email subject
          if [ "$status" = "success" ]; then
            subject="✅ Deployment Successful - ${{ github.repository }} ($environment)"
          elif [ "$status" = "warning" ]; then
            subject="⚠️ Deployment Warning - ${{ github.repository }} ($environment)"
          else
            subject="❌ Deployment Failed - ${{ github.repository }} ($environment)"
          fi

          echo "subject=$subject" >> $GITHUB_OUTPUT

          # Set environment URL
          case $environment in
            test)
              env_url="https://test.websoft9.com"
              ;;
            staging)
              env_url="https://staging.websoft9.com"
              ;;
            production)
              env_url="https://websoft9.com"
              ;;
            *)
              env_url="N/A"
              ;;
          esac

          # Generate email body
          cat > email_body.html << EOF
          <!DOCTYPE html>
          <html>
          <head>
              <meta charset="UTF-8">
              <style>
                  body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; }
                  .header { background-color: #f4f4f4; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
                  .status-success { color: #28a745; }
                  .status-warning { color: #ffc107; }
                  .status-failure { color: #dc3545; }
                  .env-badge {
                      display: inline-block;
                      padding: 4px 8px;
                      border-radius: 4px;
                      font-size: 12px;
                      font-weight: bold;
                      text-transform: uppercase;
                  }
                  .env-test { background-color: #17a2b8; color: white; }
                  .env-staging { background-color: #ffc107; color: black; }
                  .env-production { background-color: #dc3545; color: white; }
                  .info-table { width: 100%; border-collapse: collapse; margin: 20px 0; }
                  .info-table th, .info-table td { border: 1px solid #ddd; padding: 12px; text-align: left; }
                  .info-table th { background-color: #f2f2f2; }
                  .footer { margin-top: 30px; padding-top: 20px; border-top: 1px solid #ddd; font-size: 12px; color: #666; }
              </style>
          </head>
          <body>
              <div class="header">
                  <h2>🚀 Deployment Execution Report</h2>
                  <p><strong>Repository:</strong> ${{ github.repository }}</p>
                  <p><strong>Environment:</strong> <span class="env-badge env-$environment">$environment</span></p>
                  <p><strong>Status:</strong> <span class="status-$(echo $status | tr '[:upper:]' '[:lower:]')">$message</span></p>
              </div>

              <h3>📋 Deployment Information</h3>
              <table class="info-table">
                  <tr><th>Target Environment</th><td>$environment</td></tr>
                  <tr><th>Environment URL</th><td><a href="$env_url">$env_url</a></td></tr>
                  <tr><th>Branch</th><td>${{ github.ref_name }}</td></tr>
                  <tr><th>Commit</th><td>${{ github.sha }}</td></tr>
                  <tr><th>Deployer</th><td>${{ github.actor }}</td></tr>
                  <tr><th>Execution Time</th><td>$(date)</td></tr>
              </table>

              <h3>🔍 Execution Results</h3>
              <table class="info-table">
                  <tr><th>Stage</th><th>Status</th></tr>
                  <tr><td>Pre-deployment Check</td><td>success</td></tr>
                  <tr><td>Image Build</td><td>success</td></tr>
                  <tr><td>Environment Deployment</td><td>${{ steps.result.outputs.deploy_result }}</td></tr>
                  <tr><td>Health Check</td><td>${{ steps.result.outputs.health_check_result }}</td></tr>
              </table>

              <h3>🔗 Related Links</h3>
              <ul>
                  <li><a href="${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}">View Workflow Run Details</a></li>
                  <li><a href="${{ github.server_url }}/${{ github.repository }}/commit/${{ github.sha }}">View Commit Details</a></li>
                  <li><a href="$env_url">Access Deployment Environment</a></li>
                  <li><a href="${{ github.server_url }}/${{ github.repository }}">Access Repository</a></li>
              </ul>

              <div class="footer">
                  <p>This email is automatically sent by GitHub Actions, please do not reply.</p>
                  <p>If you have any questions, please contact the development team.</p>
              </div>
          </body>
          </html>
          EOF



      - name: Create deployment record
        uses: actions/github-script@v6
        with:
          script: |
            const environment = '${{ steps.result.outputs.environment }}';
            const deployResult = '${{ steps.result.outputs.deploy_result }}';
            const healthCheckResult = '${{ steps.result.outputs.health_check_result }}';
            const overallStatus = '${{ steps.result.outputs.overall_status }}';

            // Create deployment record Issue
            const title = `[Deployment] ${environment} - ${overallStatus} - ${new Date().toISOString().split('T')[0]}`;
            const body = `## 🚀 Deployment Record

            **Environment:** ${environment}
            **Status:** ${overallStatus}
            **Time:** ${new Date().toISOString()}
            **Branch:** ${{ github.ref_name }}
            **Commit:** ${{ github.sha }}
            **Deployer:** ${{ github.actor }}

            ### Deployment Results
            - **Deployment Status:** ${deployResult}
            - **Health Check:** ${healthCheckResult}

            ### Related Links
            - [Workflow Run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
            - [Commit Details](${{ github.server_url }}/${{ github.repository }}/commit/${{ github.sha }})

            ---
            *This record was automatically created by the deployment workflow*`;

            await github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: title,
              body: body,
              labels: ['deployment', environment, overallStatus]
            });

  # Deployment summary
  deployment-summary:
    name: 📊 Deployment Summary
    runs-on: ubuntu-latest
    needs: [pre-deployment-check, deploy-to-test, deploy-to-staging, deploy-to-production, post-deployment-health-check]
    if: always()
    steps:
      - name: Generate deployment summary
        run: |
          environment="${{ needs.pre-deployment-check.outputs.deploy_environment }}"

          echo "# 🚀 Deployment Execution Report" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "**Target Environment:** $environment" >> $GITHUB_STEP_SUMMARY
          echo "**Branch:** ${{ github.ref_name }}" >> $GITHUB_STEP_SUMMARY
          echo "**Commit:** ${{ github.sha }}" >> $GITHUB_STEP_SUMMARY
          echo "**Deployer:** ${{ github.actor }}" >> $GITHUB_STEP_SUMMARY
          echo "**Execution Time:** $(date)" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY

          echo "## 📋 Execution Results" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "| Stage | Status |" >> $GITHUB_STEP_SUMMARY
          echo "|------|------|" >> $GITHUB_STEP_SUMMARY
          echo "| Pre-deployment Check | ${{ needs.pre-deployment-check.result }} |" >> $GITHUB_STEP_SUMMARY

          case $environment in
            test)
              echo "| Test Environment Deployment | ${{ needs.deploy-to-test.result }} |" >> $GITHUB_STEP_SUMMARY
              ;;
            staging)
              echo "| Staging Environment Deployment | ${{ needs.deploy-to-staging.result }} |" >> $GITHUB_STEP_SUMMARY
              ;;
            production)
              echo "| Production Environment Deployment | ${{ needs.deploy-to-production.result }} |" >> $GITHUB_STEP_SUMMARY
              ;;
          esac

          echo "| Post-deployment Health Check | ${{ needs.post-deployment-health-check.result }} |" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY

          # Determine overall status and add appropriate summary
          if [[ "${{ needs.post-deployment-health-check.result }}" == "success" ]]; then
            echo "## ✅ Deployment Successful" >> $GITHUB_STEP_SUMMARY
            echo "" >> $GITHUB_STEP_SUMMARY
            echo "Application has been successfully deployed to $environment environment, all health checks have passed." >> $GITHUB_STEP_SUMMARY
          else
            echo "## ❌ Deployment Issues" >> $GITHUB_STEP_SUMMARY
            echo "" >> $GITHUB_STEP_SUMMARY
            echo "There were issues during the deployment process, please check detailed logs." >> $GITHUB_STEP_SUMMARY
          fi

          echo "" >> $GITHUB_STEP_SUMMARY
          echo "## 📎 Related Links" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "- [Workflow Run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})" >> $GITHUB_STEP_SUMMARY
          echo "- [Commit Details](${{ github.server_url }}/${{ github.repository }}/commit/${{ github.sha }})" >> $GITHUB_STEP_SUMMARY

          case $environment in
            test)
              echo "- [Test Environment](https://test.websoft9.com)" >> $GITHUB_STEP_SUMMARY
              ;;
            staging)
              echo "- [Staging Environment](https://staging.websoft9.com)" >> $GITHUB_STEP_SUMMARY
              ;;
            production)
              echo "- [Production Environment](https://websoft9.com)" >> $GITHUB_STEP_SUMMARY
              ;;
          esac