michaelschiemer/.gitea/workflows/build-image.yml

name: Build Docker Image

run-name: Build Image - ${{ github.ref_name }} - ${{ github.sha }}

on:
  push:
    branches: [ main, develop, staging ]
    paths-ignore:
      - '**.md'
      - 'docs/**'
  workflow_dispatch:
    inputs:
      branch:
        description: 'Branch to build from'
        required: false
        default: 'main'

env:
  REGISTRY: registry.michaelschiemer.de
  IMAGE_NAME: framework

jobs:
  # Job 1: Run Tests
  test:
    name: Run Tests & Quality Checks
    runs-on: php-ci
    steps:
      - name: Checkout code
        run: |
          REF_NAME="${{ github.ref_name || inputs.branch || 'main' }}"
          REPO="${{ github.repository }}"
          
          if [ -n "${{ secrets.CI_TOKEN }}" ]; then
            git clone --depth 1 --branch "$REF_NAME" \
              "https://${{ secrets.CI_TOKEN }}@git.michaelschiemer.de/${REPO}.git" \
              /workspace/repo
          else
            git clone --depth 1 --branch "$REF_NAME" \
              "https://git.michaelschiemer.de/${REPO}.git" \
              /workspace/repo || \
            git clone --depth 1 \
              "https://git.michaelschiemer.de/${REPO}.git" \
              /workspace/repo
          fi
          
          cd /workspace/repo

      - name: Cache Composer dependencies
        run: |
          if [ -d "/tmp/composer-cache/vendor" ]; then
            echo "📦 Restoring cached dependencies..."
            cp -r /tmp/composer-cache/vendor /workspace/repo/vendor || true
          fi

      - name: Install dependencies
        run: |
          cd /workspace/repo
          composer install --no-interaction --prefer-dist --optimize-autoloader --ignore-platform-req=php

      - name: Save Composer cache
        run: |
          mkdir -p /tmp/composer-cache
          cp -r /workspace/repo/vendor /tmp/composer-cache/vendor || true

      - name: Tests temporarily skipped
        run: |
          echo "⚠️ Tests temporarily skipped due to PHP 8.5 compatibility issues"

  # Job 2: Build & Push Docker Image
  build:
    name: Build Docker Image
    needs: test
    runs-on: docker-build
    outputs:
      image_tag: ${{ steps.image_info.outputs.IMAGE_TAG }}
      commit_sha: ${{ steps.meta.outputs.commit_sha }}
      image_url: ${{ steps.image_info.outputs.IMAGE_URL }}
    steps:
      - name: Install git and setup environment
        shell: sh
        run: |
          if ! command -v bash >/dev/null 2>&1 || ! command -v git >/dev/null 2>&1; then
            apk add --no-cache git bash curl
          fi
          bash --version
          git --version
          
      - name: Checkout code
        shell: bash
        run: |
          REF_NAME="${{ github.ref_name || inputs.branch || 'main' }}"
          REPO="${{ github.repository }}"
          
          if [ -n "${{ secrets.CI_TOKEN }}" ]; then
            git clone --depth 1 --branch "$REF_NAME" \
              "https://${{ secrets.CI_TOKEN }}@git.michaelschiemer.de/${REPO}.git" \
              /workspace/repo
          else
            git clone --depth 1 --branch "$REF_NAME" \
              "https://git.michaelschiemer.de/${REPO}.git" \
              /workspace/repo || \
            git clone --depth 1 \
              "https://git.michaelschiemer.de/${REPO}.git" \
              /workspace/repo
          fi
          
          cd /workspace/repo

      - name: Setup Docker Buildx
        shell: bash
        run: |
          docker buildx version || echo "Buildx nicht gefunden"
          echo "🔧 DOCKER_HOST: ${DOCKER_HOST:-nicht gesetzt}"
          docker info | grep -E "Server Version|Registry" || true
          
          if ! docker ps >/dev/null 2>&1; then
            echo "❌ Fehler: Docker ist nicht verfügbar!"
            exit 1
          fi
          
          if ! docker buildx ls 2>/dev/null | grep -q builder; then
            echo "📦 Erstelle neuen Buildx Builder..."
            docker buildx create --name builder --use --driver docker-container
          else
            echo "✅ Builder existiert bereits"
            docker buildx use builder
          fi
          
          docker buildx inspect --bootstrap
          docker buildx ls

      - name: Generate image metadata
        id: meta
        run: |
          cd /workspace/repo
          COMMIT_SHA="${{ github.sha }}"
          if [ -z "$COMMIT_SHA" ]; then
            COMMIT_SHA=$(git rev-parse HEAD)
          fi
          SHORT_SHA=$(echo "$COMMIT_SHA" | cut -c1-7)
          TAG="${SHORT_SHA}-$(date +%s)"
          echo "tag=${TAG}" >> $GITHUB_OUTPUT
          echo "short_sha=${SHORT_SHA}" >> $GITHUB_OUTPUT
          echo "commit_sha=${COMMIT_SHA}" >> $GITHUB_OUTPUT
          echo "Generated tag: ${TAG}"

      - name: Login to Registry
        id: login
        shell: bash
        run: |
          REGISTRY_USER="${{ secrets.REGISTRY_USER }}"
          REGISTRY_PASSWORD="${{ secrets.REGISTRY_PASSWORD }}"
          REGISTRY_URL="${{ env.REGISTRY }}"
          DEPLOYMENT_HOST="94.16.110.151"
          
          if [ -z "$REGISTRY_USER" ] || [ -z "$REGISTRY_PASSWORD" ]; then
            echo "❌ Error: Registry credentials missing"
            exit 1
          fi
          
          echo "🔐 Logging in to registry..."
          
          HOST_IP=$(ip route | grep default | awk '{print $3}' 2>/dev/null | head -1 || echo "$DEPLOYMENT_HOST")
          
          REGISTRY_URLS=(
            "registry.michaelschiemer.de"
            "$REGISTRY_URL"
            "$DEPLOYMENT_HOST"
            "$DEPLOYMENT_HOST:5000"
            "${HOST_IP}:5000"
          )
          
          LOGIN_SUCCESS=false
          
          for TEST_URL in "${REGISTRY_URLS[@]}"; do
            echo "🔍 Testing registry: $TEST_URL"
            
            if [[ "$TEST_URL" == *":5000" ]]; then
              HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "http://$TEST_URL/v2/" 2>&1 || echo "000")
              
              if [ "$HTTP_CODE" = "401" ] || [ "$HTTP_CODE" = "200" ]; then
                set +e
                LOGIN_OUTPUT=$(echo "$REGISTRY_PASSWORD" | docker login "$TEST_URL" -u "$REGISTRY_USER" --password-stdin 2>&1)
                LOGIN_EXIT_CODE=$?
                set -e
                
                if [ $LOGIN_EXIT_CODE -eq 0 ]; then
                  REGISTRY_URL="$TEST_URL"
                  LOGIN_SUCCESS=true
                  break
                fi
              fi
            else
              HTTPS_CODE=$(curl -k -s -o /dev/null -w "%{http_code}" "https://$TEST_URL/v2/" 2>&1 || echo "000")
              
              if [ "$HTTPS_CODE" = "401" ] || [ "$HTTPS_CODE" = "200" ]; then
                set +e
                LOGIN_OUTPUT=$(echo "$REGISTRY_PASSWORD" | docker login "$TEST_URL" -u "$REGISTRY_USER" --password-stdin 2>&1)
                LOGIN_EXIT_CODE=$?
                set -e
                
                if [ $LOGIN_EXIT_CODE -eq 0 ]; then
                  REGISTRY_URL="$TEST_URL"
                  LOGIN_SUCCESS=true
                  break
                fi
              fi
            fi
          done
          
          if [ "$LOGIN_SUCCESS" = false ]; then
            echo "❌ Registry login failed"
            exit 1
          fi
          
          echo "✅ Registry login successful: $REGISTRY_URL"
          echo "REGISTRY_URL=$REGISTRY_URL" >> $GITHUB_ENV

      - name: Build and push Docker image
        shell: bash
        env:
          REGISTRY_URL: ${{ env.REGISTRY_URL }}
        run: |
          cd /workspace/repo
          
          REGISTRY_TO_USE="$REGISTRY_URL"
          IMAGE_NAME="${{ env.IMAGE_NAME }}"
          
          COMMIT_SHA="${{ github.sha }}"
          if [ -z "$COMMIT_SHA" ]; then
            COMMIT_SHA=$(git rev-parse HEAD)
          fi
          REF_NAME="${{ github.ref_name }}"
          if [ -z "$REF_NAME" ]; then
            REF_NAME=$(git rev-parse --abbrev-ref HEAD)
          fi
          SHORT_SHA=$(echo "$COMMIT_SHA" | cut -c1-7)
          TAG="${SHORT_SHA}-$(date +%s)"
          
          echo "🏗️ Building Docker image..."
          echo "   Registry: $REGISTRY_TO_USE"
          echo "   Image: $IMAGE_NAME"
          echo "   Tags: latest, $TAG, git-$SHORT_SHA"
          
          docker buildx build \
            --platform linux/amd64 \
            --file ./Dockerfile.production \
            --tag "${REGISTRY_TO_USE}/${IMAGE_NAME}:latest" \
            --tag "${REGISTRY_TO_USE}/${IMAGE_NAME}:${TAG}" \
            --tag "${REGISTRY_TO_USE}/${IMAGE_NAME}:git-${SHORT_SHA}" \
            --cache-from type=registry,ref="${REGISTRY_TO_USE}/${IMAGE_NAME}:buildcache" \
            --cache-from type=registry,ref="${REGISTRY_TO_USE}/${IMAGE_NAME}:latest" \
            --cache-to type=registry,ref="${REGISTRY_TO_USE}/${IMAGE_NAME}:buildcache",mode=max \
            --build-arg BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ') \
            --build-arg GIT_COMMIT=${COMMIT_SHA} \
            --build-arg GIT_BRANCH=${REF_NAME} \
            --push \
            .
          
          echo "✅ Image built and pushed successfully!"

      - name: Set image info
        id: image_info
        shell: bash
        run: |
          COMMIT_SHA="${{ github.sha }}"
          if [ -z "$COMMIT_SHA" ]; then
            COMMIT_SHA=$(cd /workspace/repo && git rev-parse HEAD)
          fi
          SHORT_SHA=$(echo "$COMMIT_SHA" | cut -c1-7)
          TAG="${SHORT_SHA}-$(date +%s)"
          
          REGISTRY_TO_USE="${{ env.REGISTRY_URL }}"
          IMAGE_NAME="${{ env.IMAGE_NAME }}"
          
          IMAGE_TAG="$TAG"
          IMAGE_URL="${REGISTRY_TO_USE}/${IMAGE_NAME}:${IMAGE_TAG}"
          
          echo "IMAGE_TAG=$IMAGE_TAG" >> $GITHUB_OUTPUT
          echo "IMAGE_URL=$IMAGE_URL" >> $GITHUB_OUTPUT
          
          echo "📦 Image info:"
          echo "   Tag: $IMAGE_TAG"
          echo "   URL: $IMAGE_URL"
          echo ""
          
          REF_NAME="${{ github.ref_name }}"
          if [ -z "$REF_NAME" ]; then
            REF_NAME=$(cd /workspace/repo && git rev-parse --abbrev-ref HEAD)
          fi
          
          if [ "$REF_NAME" = "staging" ]; then
            echo "🚀 Staging branch detected - will auto-deploy after build"
          else
            echo "💡 Image is ready for deployment!"
            echo "   Run the 'Deploy to Production' or 'Deploy to Staging' workflow to deploy this image."
          fi

  # Job 3: Auto-deploy to Staging (only for staging branch)
  deploy-staging:
    name: Auto-deploy to Staging
    needs: build
    runs-on: ubuntu-latest
    if: github.ref_name == 'staging' || github.head_ref == 'staging' || (github.ref_name == '' && contains(github.ref, 'staging'))
    environment:
      name: staging
      url: https://staging.michaelschiemer.de
    env:
      DEPLOYMENT_HOST: 94.16.110.151
    steps:
      - name: Determine branch name
        id: branch
        shell: bash
        run: |
          REF_NAME="${{ github.ref_name }}"
          if [ -z "$REF_NAME" ]; then
            REF_NAME=$(echo "${{ github.ref }}" | sed 's/refs\/heads\///')
          fi
          if [ -z "$REF_NAME" ]; then
            REF_NAME="staging"
          fi
          echo "BRANCH=$REF_NAME" >> $GITHUB_OUTPUT
          echo "📋 Branch: $REF_NAME"

      - name: Checkout deployment scripts
        run: |
          REF_NAME="${{ steps.branch.outputs.BRANCH }}"
          REPO="${{ github.repository }}"
          
          if [ -n "${{ secrets.CI_TOKEN }}" ]; then
            git clone --depth 1 --branch "$REF_NAME" \
              "https://${{ secrets.CI_TOKEN }}@git.michaelschiemer.de/${REPO}.git" \
              /workspace/repo
          else
            git clone --depth 1 --branch "$REF_NAME" \
              "https://git.michaelschiemer.de/${REPO}.git" \
              /workspace/repo || \
            git clone --depth 1 \
              "https://git.michaelschiemer.de/${REPO}.git" \
              /workspace/repo
          fi
          
          cd /workspace/repo

      - name: Setup SSH key
        run: |
          mkdir -p ~/.ssh
          echo "${{ secrets.SSH_PRIVATE_KEY }}" > ~/.ssh/production
          chmod 600 ~/.ssh/production
          ssh-keyscan -H ${{ env.DEPLOYMENT_HOST }} >> ~/.ssh/known_hosts

      - name: Deploy to Staging Server
        run: |
          set -e
          
          DEPLOYMENT_HOST="${{ env.DEPLOYMENT_HOST }}"
          REGISTRY="${{ env.REGISTRY }}"
          IMAGE_NAME="${{ env.IMAGE_NAME }}"
          IMAGE_TAG="latest"
          
          FULL_IMAGE="${REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}"
          STACK_PATH="~/deployment/stacks/staging"
          
          echo "🚀 Starting staging deployment..."
          echo "   Image: ${FULL_IMAGE}"
          echo "   Tag: ${IMAGE_TAG}"
          echo "   Host: ${DEPLOYMENT_HOST}"
          echo "   Stack: ${STACK_PATH}"
          
          ssh -i ~/.ssh/production \
              -o StrictHostKeyChecking=no \
              -o UserKnownHostsFile=/dev/null \
              deploy@${DEPLOYMENT_HOST} <<EOF
            set -e
            
            # Ensure staging stack directory exists
            mkdir -p ${STACK_PATH}
            cd ${STACK_PATH}
            
            echo "🔐 Logging in to Docker registry..."
            echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login ${REGISTRY} \
              -u "${{ secrets.REGISTRY_USER }}" \
              --password-stdin || echo "⚠️  Registry login failed, continuing..."
            
            echo "📥 Pulling image ${FULL_IMAGE}..."
            docker pull ${FULL_IMAGE} || {
              echo "❌ Failed to pull image ${FULL_IMAGE}"
              exit 1
            }
            
            # If docker-compose.yml doesn't exist, it will be created from repo
            if [ ! -f docker-compose.yml ]; then
              echo "⚠️  docker-compose.yml not found, copying from repo..."
              cp /workspace/repo/deployment/stacks/staging/docker-compose.yml . || {
                echo "❌ Failed to copy docker-compose.yml"
                exit 1
              }
            fi
            
            # Update docker-compose.yml with new image tag
            echo "📝 Updating docker-compose.yml..."
            sed -i "s|image:.*/${IMAGE_NAME}:.*|image: ${FULL_IMAGE}|g" docker-compose.yml
            
            echo "✅ Updated docker-compose.yml:"
            grep "image:" docker-compose.yml | head -5
            
            # Ensure networks exist
            echo "🔗 Ensuring Docker networks exist..."
            docker network create traefik-public 2>/dev/null || true
            docker network create staging-internal 2>/dev/null || true
            
            echo "🔄 Starting/updating services..."
            docker compose up -d --pull always --force-recreate || {
              echo "❌ Failed to start services"
              exit 1
            }
            
            echo "⏳ Waiting for services to start..."
            sleep 10
            
            echo "📊 Container status:"
            docker compose ps
            
            echo "✅ Staging deployment completed!"
          EOF

      - name: Wait for deployment to stabilize
        run: sleep 30

      - name: Health check
        id: health
        run: |
          for i in {1..10}; do
            if curl -f -k https://staging.michaelschiemer.de/health; then
              echo "✅ Health check passed"
              exit 0
            fi
            echo "⏳ Waiting for staging service... (attempt $i/10)"
            sleep 10
          done
          echo "❌ Health check failed"
          exit 1

      - name: Notify deployment success
        if: success()
        run: |
          echo "🚀 Staging deployment successful!"
          echo "URL: https://staging.michaelschiemer.de"
          echo "Image: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest"