bootstrap.sh

#!/usr/bin/env bash

# ----------------------------
# PyGem Bootstrap Script
# Quarkus-inspired
# ----------------------------

set -e

COMMAND="${1:-dev}"

PYTHON_EXE=""
PIP_EXE=""

# ----------------------------
# 🎯 Step Runner
# ----------------------------

run_step() {
    local message="$1"
    shift

    echo ""
    echo "========================================"
    echo "▶ $message"
    echo "========================================"

    local start_time
    start_time=$(date +%s)

    if "$@"; then
        local end_time
        end_time=$(date +%s)

        local elapsed=$((end_time - start_time))

        echo "✅ $message completed (${elapsed}s)"
    else
        echo "❌ $message failed"
        exit 1
    fi
}


# ----------------------------
# 🎯 Main Commands
# ----------------------------

start_development() {

    echo "🚀 Starting PyGem Development Environment..."

    run_step "Setting up environment" setup_environment

    run_step "Starting infrastructure services" start_services true

    run_step "Starting application" start_application
}


start_production() {

    echo "🏭 Starting PyGem Production Environment..."

    run_step "Setting up environment" setup_environment

    run_step "Starting production infrastructure" start_services false

    run_step "Starting application" start_application
}


start_testing() {

    echo "🧪 Starting PyGem Testing Environment..."

    run_step "Setting up environment" setup_environment

    run_step "Starting test infrastructure" start_services true

    run_step "Running tests" run_tests
}


build_application() {

    echo "🔨 Building PyGem Application..."

    run_step "Building Docker image" build_docker_image
}


deploy_application() {

    echo "🚀 Deploying PyGem Application..."

    run_step "Building application" build_application

    run_step "Deploying application" deploy_to_production
}


# ----------------------------
# 🔧 Environment Setup
# ----------------------------

setup_environment() {

    ensure_python

    setup_virtual_environment

    install_dependencies
}


ensure_python() {

    echo "🔍 Checking Python installation..."

    if command -v python >/dev/null 2>&1; then

        VERSION=$(python --version)

        echo "Python found: $VERSION"

    else

        echo "⚠️ Python not found. Install Python 3.11+"

        exit 1

    fi
}


setup_virtual_environment() {

    local venv_path="./venv"


    if [[ ! -d "$venv_path" ]]; then

        echo "📦 Creating virtual environment..."

        python3 -m venv "$venv_path"

    else

        echo "📦 Virtual environment already exists"

    fi


    PYTHON_EXE="$venv_path/bin/python"

    PIP_EXE="$venv_path/bin/pip"

    export PATH="$venv_path/bin:$PATH"
}


install_dependencies() {

    echo "📚 Installing dependencies..."

    "$PYTHON_EXE" -m pip install --upgrade pip

    "$PIP_EXE" install -r requirements.txt

}


# ----------------------------
# 🐳 Infrastructure
# ----------------------------

start_services() {

    local dev_mode="$1"


    if ! command -v docker >/dev/null 2>&1; then

        echo "⚠️ Docker not found"

        exit 1

    fi


    echo "🐳 Starting Docker services..."


    if [[ "$dev_mode" == "true" ]]; then

        create_dev_config

    fi


    docker compose -f docker-compose.yml up -d


    if [[ "$dev_mode" == "true" ]]; then

        wait_services_ready true

    else

        wait_services_ready false

    fi

}


create_dev_config() {

cat > pygem.yml <<EOF

profile: dev

server:

  host: 0.0.0.0

  port: 8080


messaging:

  transport: memory


logging:

  level: DEBUG

  format: structured


health:

  enabled: true

EOF


echo "📝 Created development configuration"

}


wait_services_ready() {

    local dev_mode="$1"


    if [[ "$dev_mode" == "true" ]]; then

        wait_postgres_ready

        wait_redis_ready

    else

        wait_postgres_ready

        wait_redis_ready

        wait_kafka_ready

    fi

}

# ----------------------------
# ⏳ Service Readiness Checks
# ----------------------------

wait_postgres_ready() {

    local container="pygem_postgres"
    local retries=15


    for ((i=1;i<=retries;i++)); do

        CID=$(docker ps -q -f "name=$container")


        if [[ -n "$CID" ]]; then

            RESULT=$(docker exec -i "$CID" pg_isready -U myuser 2>/dev/null || true)


            if [[ "$RESULT" == *"accepting connections"* ]]; then

                echo "✅ PostgreSQL ready"

                return

            fi

        fi


        echo "⏳ Waiting for PostgreSQL... ($i/$retries)"

        sleep 3

    done


    echo "⚠️ PostgreSQL not ready, continuing anyway"
}



wait_redis_ready() {

    local container="pygem_redis"
    local retries=10


    for ((i=1;i<=retries;i++)); do


        CID=$(docker ps -q -f "name=$container")


        if [[ -n "$CID" ]]; then


            RESULT=$(docker exec -i "$CID" redis-cli ping 2>/dev/null || true)


            if [[ "$RESULT" == "PONG" ]]; then

                echo "✅ Redis ready"

                return

            fi

        fi


        echo "⏳ Waiting for Redis... ($i/$retries)"

        sleep 2

    done


    echo "⚠️ Redis not ready, continuing anyway"
}



wait_kafka_ready() {

    local container="pygem_kafka"
    local retries=20


    for ((i=1;i<=retries;i++)); do


        CID=$(docker ps -q -f "name=$container")


        if [[ -n "$CID" ]]; then


            LOGS=$(docker logs "$CID" --tail 10 2>/dev/null || true)


            if [[ "$LOGS" == *"started (kafka.server.KafkaServer)"* ]]; then

                echo "✅ Kafka ready"

                return

            fi

        fi


        echo "⏳ Waiting for Kafka... ($i/$retries)"

        sleep 5

    done


    echo "⚠️ Kafka not ready, continuing anyway"
}



# ----------------------------
# 🚀 Application Management
# ----------------------------

start_application() {

    echo "🎯 Starting PyGem application..."


    export PYTHONPATH="$(pwd)"

    export PYGEM_CONFIG="pygem.yml"


    "$PYTHON_EXE" \
        -m uvicorn app.main:app \
        --host 0.0.0.0 \
        --port 8080 \
        --reload
}



run_tests() {

    echo "🧪 Running PyGem tests..."


    "$PIP_EXE" install pytest pytest-asyncio


    export PYTHONPATH="$(pwd)"

    export PYGEM_PROFILE="test"


    "$PYTHON_EXE" \
        -m pytest tests -v --tb=short
}



# ----------------------------
# 🐳 Docker Functions
# ----------------------------

build_docker_image() {

    local image="pygem-app:latest"


    docker build -t "$image" .


    echo "Docker image: $image"
}



deploy_to_production() {

    docker tag pygem-app:latest pygem-app:prod


    echo "Production deployment simulated"

}



# ----------------------------
# 🧹 Cleanup
# ----------------------------

stop_services() {

    echo "🛑 Stopping services..."

    docker compose -f docker-compose.yml down

}



clean_environment() {

    stop_services


    if [[ -d "./venv" ]]; then

        echo "🗑 Removing virtual environment..."

        rm -rf ./venv

    fi


    if [[ -f "pygem.yml" ]]; then

        echo "🗑 Removing generated configuration..."

        rm pygem.yml

    fi


    echo "✅ Cleanup complete"

}



# ----------------------------
# 🎮 Command Router
# ----------------------------

case "${COMMAND,,}" in


    dev)

        start_development

        ;;


    prod)

        start_production

        ;;


    test)

        start_testing

        ;;


    build)

        build_application

        ;;


    deploy)

        deploy_application

        ;;


    clean)

        clean_environment

        ;;


    *)

        echo "❌ Unknown command: $COMMAND"

        echo ""

        echo "Available commands:"

        echo "  dev      Start development environment"

        echo "  prod     Start production environment"

        echo "  test     Run tests"

        echo "  build    Build Docker image"

        echo "  deploy   Deploy application"

        echo "  clean    Cleanup environment"

        exit 1

        ;;

esac