roa2web-service-auto/start-prod.sh

#!/bin/bash

# ROA2WEB Ultrathin Monolith - PROD Starter Script
# Starts all services for the unified application:
# - Unified Backend (8000) with --reload - includes Reports, Data Entry, and Telegram
# - Unified Frontend (3000)

set -e  # Exit on any error

# Get the directory where this script is located
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# Function to print colored messages
print_message() {
    echo -e "${CYAN}[UNIFIED-PROD]${NC} $1"
}

print_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

print_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

print_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Function to check if port is in use
check_port() {
    local port=$1
    if lsof -Pi :$port -sTCP:LISTEN -t >/dev/null 2>&1; then
        return 0
    else
        return 1
    fi
}

# Function to cleanup processes on exit
cleanup() {
    print_message "Stopping all services..."

    # Stop run-with-restart.sh wrapper FIRST (prevents auto-restart)
    print_message "Stopping backend restart wrapper..."
    pkill -f "run-with-restart.sh" 2>/dev/null || true
    sleep 1

    # Stop Unified Backend (8000)
    if check_port 8000; then
        print_message "Stopping Unified Backend..."
        pkill -f "uvicorn main:app" 2>/dev/null || true
        sleep 2
        pkill -9 -f "uvicorn main:app" 2>/dev/null || true
        lsof -ti:8000 | xargs kill -KILL 2>/dev/null || true
    fi

    # Stop Unified Frontend (3000)
    if check_port 3000; then
        print_message "Stopping Unified Frontend..."
        lsof -ti:3000 | xargs kill -TERM 2>/dev/null || true
        sleep 1
        lsof -ti:3000 | xargs kill -KILL 2>/dev/null || true
    fi

    # Stop SSH tunnel
    if [ -f "./ssh-tunnel-prod.sh" ]; then
        print_message "Stopping SSH Tunnel..."
        ./ssh-tunnel-prod.sh stop 2>/dev/null || true
    fi

    print_success "All services stopped."
    exit 0
}

# Check command line arguments
if [ "$1" = "stop" ]; then
    cleanup
fi

# Set up signal handlers
trap cleanup SIGINT SIGTERM

print_message "Starting ROA2WEB Ultrathin Monolith (PROD Environment)..."
echo

# Step 1: Start SSH Tunnel
print_message "1. Starting SSH Tunnel..."
if [ -f "./ssh-tunnel-prod.sh" ]; then
    if ./ssh-tunnel-prod.sh start; then
        print_success "SSH Tunnel started"
    else
        print_warning "SSH tunnel may already be running or failed to start"
    fi
else
    print_warning "SSH tunnel script not found - skipping"
fi

sleep 2

# Step 1.5: Check and install poppler-utils (required for PDF OCR)
if ! command -v pdftoppm &> /dev/null; then
    print_warning "poppler-utils not found - required for PDF OCR processing"
    print_message "Installing poppler-utils..."
    if sudo apt-get update -qq && sudo apt-get install -y -qq poppler-utils; then
        print_success "poppler-utils installed"
    else
        print_warning "Could not install poppler-utils - PDF OCR may not work"
    fi
else
    print_success "poppler-utils found ($(pdftoppm -v 2>&1 | head -1))"
fi

# Step 2: Start Unified Backend (8000)
print_message "2. Starting Unified Backend on port 8000..."

if check_port 8000; then
    print_warning "Port 8000 already in use - Unified Backend may be running"
else
    cd backend/

    # Create venv if doesn't exist
    if [ ! -d "venv" ]; then
        print_message "Creating Python virtual environment..."
        python3 -m venv venv
    fi

    # Activate venv
    source venv/bin/activate

    # Install dependencies if needed
    if ! python -c "import fastapi, uvicorn" 2>/dev/null; then
        print_message "Installing dependencies (this may take 3-5 minutes for ML packages)..."
        pip install -r requirements.txt
    fi

    # Check for PROD environment configuration
    if [ ! -f ".env.prod" ]; then
        if [ -f ".env.prod.example" ]; then
            print_error ".env.prod not found!"
            print_warning "First-time setup required:"
            echo "  1. Copy template:  cp backend/.env.prod.example backend/.env.prod"
            echo "  2. Fill in your credentials in backend/.env.prod"
            echo "  3. Run ./start-prod.sh again"
            exit 1
        else
            print_error ".env.prod and .env.prod.example not found!"
            print_warning "Please check your backend/ directory structure"
            exit 1
        fi
    fi

    # Copy PROD environment to active .env
    print_message "Using PROD environment (.env.prod)..."
    cp .env.prod .env

    # Load environment
    set -a
    source .env
    set +a

    # Create logs directory if not exists
    mkdir -p "$SCRIPT_DIR/logs"

    # Clear old log files (use logs/ for ServerLogs UI, keep /tmp for quick access)
    > "$SCRIPT_DIR/logs/backend-stdout.log"
    > "$SCRIPT_DIR/logs/backend-stderr.log"
    > /tmp/unified_frontend_prod.log

    # Start backend with auto-restart on crash (OOM protection)
    # Logs go to logs/backend-stderr.log for ServerLogs UI
    print_message "Starting unified backend with auto-restart (includes Reports, Data Entry, and Telegram bot)..."
    nohup ./run-with-restart.sh 8000 "$SCRIPT_DIR/logs/backend-stderr.log" > /dev/null 2>&1 &

    cd - > /dev/null

    # Wait for backend to start (Oracle pool + cache + Telegram bot initialization)
    # OCR worker pre-warms in background (doesn't block startup)
    print_message "Waiting for Unified Backend to initialize (Oracle + Cache + DBs + Telegram)..."
    MAX_WAIT=45
    ELAPSED=0
    while [ $ELAPSED -lt $MAX_WAIT ]; do
        if check_port 8000; then
            print_success "Unified Backend started on http://localhost:8000 (auto-reload ✓)"
            break
        fi
        sleep 1
        ELAPSED=$((ELAPSED + 1))
        if [ $((ELAPSED % 5)) -eq 0 ]; then
            print_message "Still initializing... ($ELAPSED/${MAX_WAIT}s)"
        fi
    done

    if ! check_port 8000; then
        print_error "Unified Backend failed to start - check logs/backend-stderr.log"
        tail -n 30 "$SCRIPT_DIR/logs/backend-stderr.log"
        cleanup
    fi
fi

# Step 3: Start Unified Frontend (port 3000)
print_message "3. Starting Unified Frontend (port 3000)..."

if check_port 3000; then
    print_warning "Port 3000 already in use - Unified Frontend may be running"
else
    # Check if node_modules exists
    if [ ! -d "node_modules" ] || [ ! -f "node_modules/.bin/vite" ]; then
        print_message "Installing Unified Frontend dependencies..."
        npm install
    fi

    # Start frontend
    print_message "Starting Vite development server..."
    nohup npm run dev > /tmp/unified_frontend_prod.log 2>&1 &
    FRONTEND_PID=$!

    # Wait for frontend to start (Vite can take 8-10 seconds)
    print_message "Waiting for Vite to initialize..."
    MAX_WAIT=15
    ELAPSED=0
    while [ $ELAPSED -lt $MAX_WAIT ]; do
        if check_port 3000; then
            print_success "Unified Frontend started on http://localhost:3000"
            break
        fi
        sleep 2
        ELAPSED=$((ELAPSED + 2))
    done

    if ! check_port 3000; then
        print_error "Unified Frontend failed to start - check /tmp/unified_frontend_prod.log"
        cat /tmp/unified_frontend_prod.log
        cleanup
    fi
fi

# Summary
echo
print_success "🚀 ROA2WEB Ultrathin Monolith (PROD) is now running!"
echo
echo -e "${BLUE}Services:${NC}"
echo "  • SSH Tunnel:          Active (Oracle DB connection)"
echo "  • Unified Backend:     http://localhost:8000 (auto-reload ✓)"
echo "  •   ├── Reports API:   http://localhost:8000/api/reports/*"
echo "  •   ├── Data Entry:    http://localhost:8000/api/data-entry/*"
echo "  •   ├── Telegram:      http://localhost:8000/api/telegram/*"
echo "  •   └── Bot:           Running as background task"
echo "  • Unified Frontend:    http://localhost:3000"
echo
echo -e "${BLUE}API Documentation:${NC}"
echo "  • Unified API Docs:    http://localhost:8000/docs"
echo "  • Health Check:        http://localhost:8000/health"
echo
echo -e "${BLUE}Log Files:${NC}"
echo "  • Unified Backend:     logs/backend-stderr.log"
echo "  • Unified Frontend:    /tmp/unified_frontend_prod.log"
echo
echo -e "${YELLOW}Press Ctrl+C to stop all services${NC}"
echo

# Keep script running
wait