Marius Mutu
12ac2b671e
Frontend: - Refactored CSS architecture with new utility classes - Updated dashboard components styling - Improved responsive grid system - Enhanced typography and variables - Updated E2E and integration tests Added: - Claude Code slash commands for validation - SSH tunnel and start test scripts 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
822 lines
25 KiB
Bash
822 lines
25 KiB
Bash
#!/bin/bash
|
|
|
|
# ROA2WEB Testing Starter Script
|
|
# Starts SSH tunnel, backend, and frontend services
|
|
|
|
set -e # Exit on any error
|
|
|
|
# Colors for output
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[1;33m'
|
|
BLUE='\033[0;34m'
|
|
NC='\033[0m' # No Color
|
|
|
|
# Function to print colored messages
|
|
print_message() {
|
|
echo -e "${BLUE}[ROA2WEB]${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 check if requirements.txt has changed
|
|
check_requirements_changed() {
|
|
local requirements_file=$1
|
|
local checksum_file="${requirements_file}.checksum"
|
|
|
|
if [ ! -f "$requirements_file" ]; then
|
|
return 1 # Requirements file doesn't exist
|
|
fi
|
|
|
|
# Calculate current checksum
|
|
current_checksum=$(md5sum "$requirements_file" | cut -d' ' -f1)
|
|
|
|
# Check if checksum file exists and compare
|
|
if [ -f "$checksum_file" ]; then
|
|
stored_checksum=$(cat "$checksum_file")
|
|
if [ "$current_checksum" = "$stored_checksum" ]; then
|
|
return 1 # No change
|
|
fi
|
|
fi
|
|
|
|
return 0 # Changed or first time
|
|
}
|
|
|
|
# Function to save requirements checksum
|
|
save_requirements_checksum() {
|
|
local requirements_file=$1
|
|
local checksum_file="${requirements_file}.checksum"
|
|
|
|
if [ -f "$requirements_file" ]; then
|
|
md5sum "$requirements_file" | cut -d' ' -f1 > "$checksum_file"
|
|
fi
|
|
}
|
|
|
|
# Function to install or update Python dependencies
|
|
install_python_dependencies() {
|
|
local project_name=$1
|
|
local venv_path=$2
|
|
local requirements_file=$3
|
|
|
|
# Check if venv exists
|
|
if [ ! -d "$venv_path" ]; then
|
|
print_message "Creating Python virtual environment for $project_name..."
|
|
python3 -m venv "$venv_path"
|
|
fi
|
|
|
|
# Activate virtual environment
|
|
source "$venv_path/bin/activate"
|
|
|
|
# Check if requirements have changed or dependencies are missing
|
|
local should_install=false
|
|
|
|
if check_requirements_changed "$requirements_file"; then
|
|
print_message "Requirements changed for $project_name - updating dependencies..."
|
|
should_install=true
|
|
elif ! python -c "import sys; import importlib; [importlib.import_module(line.split('>=')[0].split('==')[0]) for line in open('$requirements_file').read().splitlines() if line and not line.startswith('#')]" 2>/dev/null; then
|
|
print_message "Missing dependencies detected for $project_name - installing..."
|
|
should_install=true
|
|
fi
|
|
|
|
if [ "$should_install" = true ]; then
|
|
print_message "Installing/updating $project_name dependencies..."
|
|
pip install --upgrade pip > /dev/null 2>&1
|
|
pip install -r "$requirements_file"
|
|
save_requirements_checksum "$requirements_file"
|
|
print_success "$project_name dependencies installed/updated successfully"
|
|
else
|
|
print_message "$project_name dependencies are up to date"
|
|
fi
|
|
}
|
|
|
|
# Function to cleanup processes on exit
|
|
cleanup() {
|
|
print_message "Stopping services..."
|
|
|
|
# Kill background processes
|
|
if [[ -n $BACKEND_PID ]]; then
|
|
kill $BACKEND_PID 2>/dev/null || true
|
|
fi
|
|
|
|
if [[ -n $FRONTEND_PID ]]; then
|
|
kill $FRONTEND_PID 2>/dev/null || true
|
|
fi
|
|
|
|
if [[ -n $TELEGRAM_BOT_PID ]]; then
|
|
kill $TELEGRAM_BOT_PID 2>/dev/null || true
|
|
fi
|
|
|
|
# Stop SSH tunnel - try the same paths as in stop_services
|
|
SSH_TUNNEL_PATHS=(
|
|
"/mnt/d/PROIECTE/roa-flask/roa2web/ssh-tunnel-test.sh"
|
|
"/mnt/e/proiecte/roa2web/roa2web/ssh-tunnel-test.sh"
|
|
"./ssh-tunnel-test.sh"
|
|
)
|
|
|
|
for tunnel_path in "${SSH_TUNNEL_PATHS[@]}"; do
|
|
if [[ -f "$tunnel_path" ]]; then
|
|
$tunnel_path stop
|
|
break
|
|
fi
|
|
done
|
|
|
|
print_success "All services stopped."
|
|
exit 0
|
|
}
|
|
|
|
# Function to stop all services
|
|
stop_services() {
|
|
print_message "Stopping all ROA2WEB services..."
|
|
|
|
# Stop processes running on specific ports
|
|
print_message "Checking for backend processes on port 8001..."
|
|
if check_port 8001; then
|
|
BACKEND_PIDS=$(lsof -ti:8001)
|
|
if [[ -n $BACKEND_PIDS ]]; then
|
|
echo $BACKEND_PIDS | xargs kill -TERM 2>/dev/null || true
|
|
sleep 2
|
|
echo $BACKEND_PIDS | xargs kill -KILL 2>/dev/null || true
|
|
print_success "Backend processes stopped"
|
|
fi
|
|
else
|
|
print_message "No backend processes found on port 8001"
|
|
fi
|
|
|
|
print_message "Checking for frontend processes on common ports..."
|
|
FRONTEND_STOPPED=false
|
|
for port in 3000 3001 3002 3003 3004 3005; do
|
|
if check_port $port; then
|
|
FRONTEND_PIDS=$(lsof -ti:$port)
|
|
if [[ -n $FRONTEND_PIDS ]]; then
|
|
# Kill the main process listening on port
|
|
echo $FRONTEND_PIDS | xargs kill -TERM 2>/dev/null || true
|
|
sleep 2
|
|
echo $FRONTEND_PIDS | xargs kill -KILL 2>/dev/null || true
|
|
|
|
# Also kill parent npm processes that might have spawned vite
|
|
for pid in $FRONTEND_PIDS; do
|
|
PARENT_PID=$(ps -o ppid= -p $pid 2>/dev/null | tr -d ' ')
|
|
if [[ -n $PARENT_PID ]] && [[ $PARENT_PID != "1" ]]; then
|
|
PARENT_CMD=$(ps -o comm= -p $PARENT_PID 2>/dev/null)
|
|
if [[ $PARENT_CMD == "npm" ]] || [[ $PARENT_CMD == "node" ]]; then
|
|
kill -TERM $PARENT_PID 2>/dev/null || true
|
|
sleep 1
|
|
kill -KILL $PARENT_PID 2>/dev/null || true
|
|
fi
|
|
fi
|
|
done
|
|
|
|
print_success "Frontend processes stopped on port $port"
|
|
FRONTEND_STOPPED=true
|
|
fi
|
|
fi
|
|
done
|
|
|
|
if [[ $FRONTEND_STOPPED == false ]]; then
|
|
print_message "No frontend processes found on common ports"
|
|
fi
|
|
|
|
# Stop Telegram Bot
|
|
print_message "Checking for Telegram bot processes on port 8002..."
|
|
if check_port 8002; then
|
|
TELEGRAM_BOT_PIDS=$(lsof -ti:8002)
|
|
if [[ -n $TELEGRAM_BOT_PIDS ]]; then
|
|
echo $TELEGRAM_BOT_PIDS | xargs kill -TERM 2>/dev/null || true
|
|
sleep 2
|
|
echo $TELEGRAM_BOT_PIDS | xargs kill -KILL 2>/dev/null || true
|
|
print_success "Telegram bot processes stopped"
|
|
fi
|
|
else
|
|
print_message "No Telegram bot processes found on port 8002"
|
|
fi
|
|
|
|
# Stop SSH tunnel
|
|
print_message "Stopping SSH tunnel..."
|
|
# Try both possible paths for SSH tunnel
|
|
SSH_TUNNEL_PATHS=(
|
|
"/mnt/d/PROIECTE/roa-flask/roa2web/ssh-tunnel-test.sh"
|
|
"/mnt/d/proiecte/roa2web/roa2web/ssh-tunnel-test.sh"
|
|
"./ssh-tunnel-test.sh"
|
|
)
|
|
|
|
SSH_TUNNEL_STOPPED=false
|
|
for tunnel_path in "${SSH_TUNNEL_PATHS[@]}"; do
|
|
if [[ -f "$tunnel_path" ]]; then
|
|
if $tunnel_path stop; then
|
|
print_success "SSH tunnel stopped"
|
|
SSH_TUNNEL_STOPPED=true
|
|
break
|
|
fi
|
|
fi
|
|
done
|
|
|
|
if [[ $SSH_TUNNEL_STOPPED == false ]]; then
|
|
print_warning "SSH tunnel script not found or may not have been running"
|
|
fi
|
|
|
|
# Kill any remaining processes related to ROA2WEB
|
|
print_message "Cleaning up any remaining ROA2WEB processes..."
|
|
|
|
# More comprehensive cleanup patterns
|
|
pkill -f "uvicorn.*roa2web" 2>/dev/null || true
|
|
pkill -f "uvicorn.*app.main:app" 2>/dev/null || true
|
|
pkill -f "node.*roa.*frontend" 2>/dev/null || true
|
|
pkill -f "vite.*roa" 2>/dev/null || true
|
|
pkill -f "npm.*run.*dev.*roa" 2>/dev/null || true
|
|
pkill -f "python.*telegram-bot" 2>/dev/null || true
|
|
pkill -f "python.*app.main" 2>/dev/null || true
|
|
|
|
# Kill processes in the specific directory structure
|
|
pkill -f "/mnt/e/proiecte/roa2web/roa2web/reports-app/frontend" 2>/dev/null || true
|
|
pkill -f "/mnt/e/proiecte/roa2web/roa2web/reports-app/backend" 2>/dev/null || true
|
|
pkill -f "/mnt/e/proiecte/roa2web/roa2web/reports-app/telegram-bot" 2>/dev/null || true
|
|
|
|
print_success "✅ All ROA2WEB services have been stopped!"
|
|
exit 0
|
|
}
|
|
|
|
# Function to stop individual service
|
|
stop_service() {
|
|
local service=$1
|
|
|
|
case $service in
|
|
tunnel)
|
|
print_message "Stopping SSH tunnel..."
|
|
SSH_TUNNEL_PATHS=(
|
|
"/mnt/d/PROIECTE/roa-flask/roa2web/ssh-tunnel-test.sh"
|
|
"/mnt/e/proiecte/roa2web/roa2web/ssh-tunnel-test.sh"
|
|
"./ssh-tunnel-test.sh"
|
|
)
|
|
for tunnel_path in "${SSH_TUNNEL_PATHS[@]}"; do
|
|
if [[ -f "$tunnel_path" ]]; then
|
|
$tunnel_path stop
|
|
print_success "SSH tunnel stopped"
|
|
return 0
|
|
fi
|
|
done
|
|
print_warning "SSH tunnel script not found"
|
|
;;
|
|
backend)
|
|
print_message "Stopping backend..."
|
|
if check_port 8001; then
|
|
BACKEND_PIDS=$(lsof -ti:8001)
|
|
if [[ -n $BACKEND_PIDS ]]; then
|
|
echo $BACKEND_PIDS | xargs kill -TERM 2>/dev/null || true
|
|
sleep 2
|
|
echo $BACKEND_PIDS | xargs kill -KILL 2>/dev/null || true
|
|
print_success "Backend stopped"
|
|
else
|
|
print_message "Backend not running"
|
|
fi
|
|
else
|
|
print_message "Backend not running on port 8001"
|
|
fi
|
|
;;
|
|
frontend)
|
|
print_message "Stopping frontend..."
|
|
for port in 3000 3001 3002 3003 3004 3005; do
|
|
if check_port $port; then
|
|
FRONTEND_PIDS=$(lsof -ti:$port)
|
|
if [[ -n $FRONTEND_PIDS ]]; then
|
|
echo $FRONTEND_PIDS | xargs kill -TERM 2>/dev/null || true
|
|
sleep 2
|
|
echo $FRONTEND_PIDS | xargs kill -KILL 2>/dev/null || true
|
|
print_success "Frontend stopped on port $port"
|
|
return 0
|
|
fi
|
|
fi
|
|
done
|
|
print_message "Frontend not running"
|
|
;;
|
|
telegram|bot)
|
|
print_message "Stopping Telegram bot..."
|
|
if check_port 8002; then
|
|
TELEGRAM_BOT_PIDS=$(lsof -ti:8002)
|
|
if [[ -n $TELEGRAM_BOT_PIDS ]]; then
|
|
echo $TELEGRAM_BOT_PIDS | xargs kill -TERM 2>/dev/null || true
|
|
sleep 2
|
|
echo $TELEGRAM_BOT_PIDS | xargs kill -KILL 2>/dev/null || true
|
|
print_success "Telegram bot stopped"
|
|
else
|
|
print_message "Telegram bot not running"
|
|
fi
|
|
else
|
|
print_message "Telegram bot not running on port 8002"
|
|
fi
|
|
;;
|
|
*)
|
|
print_error "Unknown service: $service"
|
|
print_message "Valid services: tunnel, backend, frontend, telegram"
|
|
exit 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Function to start individual service
|
|
start_service() {
|
|
local service=$1
|
|
|
|
case $service in
|
|
tunnel)
|
|
print_message "Starting SSH tunnel..."
|
|
if ./ssh-tunnel-test.sh start; then
|
|
print_success "SSH Tunnel started successfully"
|
|
else
|
|
print_error "Failed to start SSH tunnel"
|
|
exit 1
|
|
fi
|
|
;;
|
|
backend)
|
|
print_message "Starting backend..."
|
|
if check_port 8001; then
|
|
print_warning "Port 8001 already in use. Backend might be running."
|
|
return 1
|
|
fi
|
|
|
|
# Load TEST environment variables from .env.test
|
|
print_message "Loading TEST environment from .env.test..."
|
|
if [ -f "reports-app/backend/.env.test" ]; then
|
|
set -a
|
|
source reports-app/backend/.env.test
|
|
set +a
|
|
print_success "TEST Oracle configuration: ${ORACLE_USER}@${ORACLE_DSN}"
|
|
else
|
|
print_error ".env.test not found!"
|
|
exit 1
|
|
fi
|
|
|
|
cd reports-app/backend/
|
|
install_python_dependencies "Backend" "venv" "requirements.txt"
|
|
|
|
print_message "Starting uvicorn server..."
|
|
# NOTE: --reload disabled for cache to work properly (global variables issue)
|
|
nohup uvicorn app.main:app --host 0.0.0.0 --port 8001 > /tmp/roa2web_backend.log 2>&1 &
|
|
|
|
sleep 2
|
|
for i in {1..10}; do
|
|
if check_port 8001; then
|
|
print_success "Backend started on http://localhost:8001"
|
|
cd - > /dev/null
|
|
return 0
|
|
fi
|
|
sleep 1
|
|
done
|
|
print_error "Backend failed to start"
|
|
cd - > /dev/null
|
|
exit 1
|
|
;;
|
|
frontend)
|
|
print_message "Starting frontend..."
|
|
for port in 3000 3001 3002 3003 3004 3005; do
|
|
if check_port $port; then
|
|
print_warning "Port $port already in use"
|
|
fi
|
|
done
|
|
|
|
cd reports-app/frontend/
|
|
|
|
# Check node_modules
|
|
NEED_REINSTALL=false
|
|
if [ ! -d "node_modules" ] || [ ! -f "node_modules/.bin/vite" ] || [ -f "node_modules/.bin/vite.cmd" ]; then
|
|
NEED_REINSTALL=true
|
|
fi
|
|
|
|
if [ "$NEED_REINSTALL" = true ]; then
|
|
print_message "Reinstalling frontend dependencies for WSL..."
|
|
rm -rf node_modules package-lock.json
|
|
npm install
|
|
fi
|
|
|
|
print_message "Starting Vite development server..."
|
|
nohup npm run dev > /tmp/roa2web_frontend.log 2>&1 &
|
|
|
|
sleep 3
|
|
FRONTEND_PORT=""
|
|
for i in {1..10}; do
|
|
for port in 3000 3001 3002 3003 3004 3005; do
|
|
if check_port $port; then
|
|
FRONTEND_PORT=$port
|
|
break 2
|
|
fi
|
|
done
|
|
sleep 1
|
|
done
|
|
|
|
if [[ -n $FRONTEND_PORT ]]; then
|
|
print_success "Frontend started on http://localhost:$FRONTEND_PORT"
|
|
cd - > /dev/null
|
|
return 0
|
|
else
|
|
print_error "Frontend failed to start"
|
|
cat /tmp/roa2web_frontend.log
|
|
cd - > /dev/null
|
|
exit 1
|
|
fi
|
|
;;
|
|
telegram|bot)
|
|
print_message "Starting Telegram bot..."
|
|
if check_port 8002; then
|
|
print_warning "Port 8002 already in use. Telegram bot might be running."
|
|
return 1
|
|
fi
|
|
|
|
cd reports-app/telegram-bot/
|
|
|
|
if [ ! -f ".env" ]; then
|
|
print_error "Telegram bot .env file not found!"
|
|
print_message "Please create .env file from .env.example"
|
|
cd - > /dev/null
|
|
exit 1
|
|
fi
|
|
|
|
install_python_dependencies "Telegram Bot" "venv" "requirements.txt"
|
|
|
|
print_message "Starting Telegram bot..."
|
|
nohup python -m app.main > /tmp/roa2web_telegram.log 2>&1 &
|
|
|
|
sleep 3
|
|
for i in {1..10}; do
|
|
if check_port 8002; then
|
|
print_success "Telegram bot started (Internal API: http://localhost:8002)"
|
|
cd - > /dev/null
|
|
return 0
|
|
fi
|
|
sleep 1
|
|
done
|
|
print_error "Telegram bot failed to start"
|
|
cat /tmp/roa2web_telegram.log
|
|
cd - > /dev/null
|
|
exit 1
|
|
;;
|
|
*)
|
|
print_error "Unknown service: $service"
|
|
print_message "Valid services: tunnel, backend, frontend, telegram"
|
|
exit 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Function to restart individual service
|
|
restart_service() {
|
|
local service=$1
|
|
print_message "Restarting $service..."
|
|
stop_service $service
|
|
sleep 2
|
|
start_service $service
|
|
print_success "$service restarted successfully"
|
|
}
|
|
|
|
# Function to show service status
|
|
show_status() {
|
|
echo -e "${BLUE}ROA2WEB Services Status${NC}"
|
|
echo
|
|
|
|
# Check SSH tunnel
|
|
if pgrep -f "ssh.*1526.*1521" > /dev/null; then
|
|
echo -e " SSH Tunnel: ${GREEN}✓ Running${NC}"
|
|
else
|
|
echo -e " SSH Tunnel: ${RED}✗ Stopped${NC}"
|
|
fi
|
|
|
|
# Check backend
|
|
if check_port 8001; then
|
|
echo -e " Backend: ${GREEN}✓ Running${NC} (http://localhost:8001)"
|
|
else
|
|
echo -e " Backend: ${RED}✗ Stopped${NC}"
|
|
fi
|
|
|
|
# Check frontend
|
|
FRONTEND_PORT=""
|
|
for port in 3000 3001 3002 3003 3004 3005; do
|
|
if check_port $port; then
|
|
FRONTEND_PORT=$port
|
|
break
|
|
fi
|
|
done
|
|
if [[ -n $FRONTEND_PORT ]]; then
|
|
echo -e " Frontend: ${GREEN}✓ Running${NC} (http://localhost:$FRONTEND_PORT)"
|
|
else
|
|
echo -e " Frontend: ${RED}✗ Stopped${NC}"
|
|
fi
|
|
|
|
# Check Telegram bot
|
|
if check_port 8002; then
|
|
echo -e " Telegram Bot: ${GREEN}✓ Running${NC} (http://localhost:8002)"
|
|
else
|
|
echo -e " Telegram Bot: ${RED}✗ Stopped${NC}"
|
|
fi
|
|
echo
|
|
}
|
|
|
|
# Function to show usage
|
|
show_usage() {
|
|
echo -e "${BLUE}ROA2WEB Testing Script${NC}"
|
|
echo
|
|
echo "Usage:"
|
|
echo " ./start-dev.sh Start all services"
|
|
echo " ./start-dev.sh start Start all services"
|
|
echo " ./start-dev.sh stop Stop all services"
|
|
echo " ./start-dev.sh status Show services status"
|
|
echo
|
|
echo " ./start-dev.sh restart <service> Restart specific service"
|
|
echo " ./start-dev.sh start <service> Start specific service"
|
|
echo " ./start-dev.sh stop <service> Stop specific service"
|
|
echo
|
|
echo "Services:"
|
|
echo " tunnel - SSH Tunnel (Oracle DB connection)"
|
|
echo " backend - FastAPI (port 8001)"
|
|
echo " frontend - Vue.js/Vite (port 3000-3005)"
|
|
echo " telegram - Telegram Bot (port 8002)"
|
|
echo
|
|
echo "Examples:"
|
|
echo " ./start-dev.sh restart telegram Restart only Telegram bot"
|
|
echo " ./start-dev.sh stop backend Stop only backend"
|
|
echo " ./start-dev.sh start frontend Start only frontend"
|
|
echo
|
|
}
|
|
|
|
# Check command line arguments
|
|
case $1 in
|
|
stop)
|
|
if [[ -n $2 ]]; then
|
|
# Stop specific service
|
|
stop_service $2
|
|
exit 0
|
|
else
|
|
# Stop all services
|
|
stop_services
|
|
fi
|
|
;;
|
|
start)
|
|
if [[ -n $2 ]]; then
|
|
# Start specific service
|
|
start_service $2
|
|
exit 0
|
|
else
|
|
# Continue with normal start process (start all)
|
|
true
|
|
fi
|
|
;;
|
|
restart)
|
|
if [[ -z $2 ]]; then
|
|
print_error "Please specify which service to restart"
|
|
echo
|
|
show_usage
|
|
exit 1
|
|
fi
|
|
restart_service $2
|
|
exit 0
|
|
;;
|
|
status)
|
|
show_status
|
|
exit 0
|
|
;;
|
|
help|--help|-h)
|
|
show_usage
|
|
exit 0
|
|
;;
|
|
"")
|
|
# No parameter - start all services
|
|
true
|
|
;;
|
|
*)
|
|
print_error "Unknown parameter: $1"
|
|
echo
|
|
show_usage
|
|
exit 1
|
|
;;
|
|
esac
|
|
|
|
# Set up signal handlers
|
|
trap cleanup SIGINT SIGTERM
|
|
|
|
print_message "Starting ROA2WEB Testing Environment..."
|
|
echo
|
|
|
|
# Step 1: Start SSH Tunnel
|
|
print_message "1. Starting SSH Tunnel..."
|
|
if ./ssh-tunnel-test.sh start; then
|
|
print_success "SSH Tunnel started successfully"
|
|
else
|
|
print_error "Failed to start SSH tunnel"
|
|
exit 1
|
|
fi
|
|
|
|
# Wait a moment for tunnel to establish
|
|
sleep 2
|
|
|
|
# ============================================================================
|
|
# EXPORT TEST ENVIRONMENT VARIABLES
|
|
# ============================================================================
|
|
# Load TEST environment variables from .env.test
|
|
# Oracle TEST server: LXC 10.0.20.121 with Oracle in Docker
|
|
print_message "Loading TEST environment from .env.test..."
|
|
if [ -f "reports-app/backend/.env.test" ]; then
|
|
set -a # Export all variables
|
|
source reports-app/backend/.env.test
|
|
set +a
|
|
print_success "TEST Oracle configuration: ${ORACLE_USER}@${ORACLE_DSN}"
|
|
else
|
|
print_error ".env.test not found! Create reports-app/backend/.env.test"
|
|
exit 1
|
|
fi
|
|
|
|
# Step 2: Start Backend
|
|
print_message "2. Starting Backend (FastAPI)..."
|
|
|
|
# Check if backend port is already in use
|
|
if check_port 8001; then
|
|
print_warning "Port 8001 is already in use. Backend might already be running."
|
|
read -p "Continue anyway? (y/n): " -n 1 -r
|
|
echo
|
|
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
|
|
cleanup
|
|
fi
|
|
fi
|
|
|
|
cd reports-app/backend/
|
|
|
|
# Check if virtual environment exists
|
|
if [ ! -d "venv" ]; then
|
|
print_message "Creating Python virtual environment..."
|
|
python3 -m venv venv
|
|
fi
|
|
|
|
# Activate virtual environment
|
|
source venv/bin/activate
|
|
|
|
# Check if dependencies are installed in virtual environment
|
|
if ! python -c "import fastapi, uvicorn" 2>/dev/null; then
|
|
print_message "Installing backend dependencies in virtual environment..."
|
|
pip install -r requirements.txt
|
|
fi
|
|
|
|
# Start backend in background
|
|
print_message "Starting uvicorn server..."
|
|
# NOTE: --reload disabled for cache to work properly (global variables issue)
|
|
uvicorn app.main:app --host 0.0.0.0 --port 8001 &
|
|
BACKEND_PID=$!
|
|
|
|
# Wait for backend to start and check multiple times
|
|
sleep 2
|
|
for i in {1..10}; do
|
|
if check_port 8001; then
|
|
print_success "Backend started successfully on http://localhost:8001"
|
|
break
|
|
fi
|
|
if [ $i -eq 10 ]; then
|
|
print_error "Backend failed to start after 10 attempts"
|
|
cleanup
|
|
fi
|
|
sleep 1
|
|
done
|
|
|
|
# Step 3: Start Frontend
|
|
print_message "3. Starting Frontend (Vue.js)..."
|
|
|
|
cd ../frontend/
|
|
|
|
# Check if node_modules exists and is valid for WSL
|
|
NEED_REINSTALL=false
|
|
|
|
if [ ! -d "node_modules" ]; then
|
|
print_message "node_modules not found"
|
|
NEED_REINSTALL=true
|
|
elif [ ! -f "node_modules/.bin/vite" ]; then
|
|
print_warning "vite not found (possibly Windows node_modules detected)"
|
|
NEED_REINSTALL=true
|
|
elif [ -f "node_modules/.bin/vite.cmd" ]; then
|
|
print_warning "Windows node_modules detected (contains .cmd files)"
|
|
NEED_REINSTALL=true
|
|
fi
|
|
|
|
if [ "$NEED_REINSTALL" = true ]; then
|
|
print_message "Reinstalling frontend dependencies for WSL..."
|
|
print_message "This happens after Windows deployment builds. Please wait..."
|
|
rm -rf node_modules package-lock.json
|
|
npm install
|
|
print_success "Frontend dependencies installed for WSL"
|
|
fi
|
|
|
|
# Start frontend in background and capture output
|
|
print_message "Starting Vite development server..."
|
|
npm run dev > /tmp/vite_output.log 2>&1 &
|
|
FRONTEND_PID=$!
|
|
|
|
# Wait for frontend to start and detect the actual port
|
|
sleep 3
|
|
FRONTEND_PORT=""
|
|
for i in {1..10}; do
|
|
# Check for common Vite ports
|
|
for port in 3000 3001 3002 3003 3004 3005; do
|
|
if check_port $port; then
|
|
FRONTEND_PORT=$port
|
|
break 2
|
|
fi
|
|
done
|
|
sleep 1
|
|
done
|
|
|
|
# Check if frontend is running
|
|
if [[ -n $FRONTEND_PORT ]]; then
|
|
print_success "Frontend started successfully on http://localhost:$FRONTEND_PORT"
|
|
else
|
|
print_error "Frontend failed to start"
|
|
cat /tmp/vite_output.log
|
|
cleanup
|
|
fi
|
|
|
|
# Step 4: Start Telegram Bot
|
|
print_message "4. Starting Telegram Bot..."
|
|
|
|
# Check if telegram bot port is already in use
|
|
if check_port 8002; then
|
|
print_warning "Port 8002 is already in use. Telegram bot might already be running."
|
|
read -p "Continue anyway? (y/n): " -n 1 -r
|
|
echo
|
|
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
|
|
cleanup
|
|
fi
|
|
fi
|
|
|
|
cd ../telegram-bot/
|
|
|
|
# Check if .env file exists
|
|
if [ ! -f ".env" ]; then
|
|
print_error "Telegram bot .env file not found!"
|
|
print_message "Please create .env file from .env.example and configure TELEGRAM_BOT_TOKEN"
|
|
cleanup
|
|
fi
|
|
|
|
# Check if virtual environment exists
|
|
if [ ! -d "venv" ]; then
|
|
print_message "Creating Python virtual environment for Telegram bot..."
|
|
python3 -m venv venv
|
|
fi
|
|
|
|
# Activate virtual environment
|
|
source venv/bin/activate
|
|
|
|
# Check if dependencies are installed
|
|
if ! python -c "import telegram" 2>/dev/null; then
|
|
print_message "Installing Telegram bot dependencies in virtual environment..."
|
|
pip install -r requirements.txt
|
|
fi
|
|
|
|
# Start Telegram bot in background
|
|
print_message "Starting Telegram bot..."
|
|
python -m app.main > /tmp/telegram_bot_output.log 2>&1 &
|
|
TELEGRAM_BOT_PID=$!
|
|
|
|
# Wait for Telegram bot to start
|
|
sleep 3
|
|
for i in {1..10}; do
|
|
if check_port 8002; then
|
|
print_success "Telegram bot started successfully (Internal API on http://localhost:8002)"
|
|
break
|
|
fi
|
|
if [ $i -eq 10 ]; then
|
|
print_error "Telegram bot failed to start after 10 attempts"
|
|
print_message "Check log at /tmp/telegram_bot_output.log for details"
|
|
cat /tmp/telegram_bot_output.log
|
|
cleanup
|
|
fi
|
|
sleep 1
|
|
done
|
|
|
|
# Summary
|
|
echo
|
|
print_success "🚀 ROA2WEB Testing Environment is now running!"
|
|
echo
|
|
echo -e "${BLUE}Services:${NC}"
|
|
echo " • SSH Tunnel: Active (Oracle DB connection)"
|
|
echo " • Backend: http://localhost:8001"
|
|
echo " • Frontend: http://localhost:${FRONTEND_PORT:-3000}"
|
|
echo " • Telegram Bot: http://localhost:8002 (Internal API)"
|
|
echo " • API Docs: http://localhost:8001/docs"
|
|
echo
|
|
echo -e "${YELLOW}Press Ctrl+C to stop all services${NC}"
|
|
echo
|
|
|
|
# Keep script running and wait for user interrupt
|
|
wait |