Configure Deno application clustering with load balancing for high availability

#!/usr/bin/env bash

set -euo pipefail

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

# Default configuration
WORKER_COUNT=${1:-4}
BASE_PORT=8001
HAPROXY_PORT=8000
INSTALL_DIR="/opt/deno-cluster"
DENO_USER="deno"

# Print usage
usage() {
    echo "Usage: $0 [worker_count]"
    echo "  worker_count: Number of Deno workers to spawn (default: 4)"
    exit 1
}

# Validate arguments
if [[ $# -gt 1 ]] || [[ "${1:-}" =~ ^-h|--help$ ]]; then
    usage
fi

if [[ "${1:-}" =~ ^[0-9]+$ ]] && [[ $1 -gt 0 ]] && [[ $1 -le 16 ]]; then
    WORKER_COUNT=$1
elif [[ $# -eq 1 ]]; then
    echo -e "${RED}Error: Worker count must be a number between 1-16${NC}"
    usage
fi

# Cleanup function
cleanup() {
    echo -e "${RED}Installation failed. Cleaning up...${NC}"
    systemctl stop haproxy 2>/dev/null || true
    systemctl stop deno-cluster 2>/dev/null || true
    rm -rf "${INSTALL_DIR}" 2>/dev/null || true
    userdel "${DENO_USER}" 2>/dev/null || true
}

trap cleanup ERR

# Check if running as root
if [[ $EUID -ne 0 ]]; then
    echo -e "${RED}Error: This script must be run as root${NC}"
    exit 1
fi

# Detect OS and set package manager
echo -e "${YELLOW}[1/9] Detecting operating system...${NC}"
if [[ -f /etc/os-release ]]; then
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_INSTALL="apt install -y"
            PKG_UPDATE="apt update && apt upgrade -y"
            HAPROXY_CONFIG="/etc/haproxy/haproxy.cfg"
            ;;
        almalinux|rocky|centos|rhel|ol)
            PKG_MGR="dnf"
            PKG_INSTALL="dnf install -y"
            PKG_UPDATE="dnf update -y"
            HAPROXY_CONFIG="/etc/haproxy/haproxy.cfg"
            ;;
        fedora)
            PKG_MGR="dnf"
            PKG_INSTALL="dnf install -y"
            PKG_UPDATE="dnf update -y"
            HAPROXY_CONFIG="/etc/haproxy/haproxy.cfg"
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_INSTALL="yum install -y"
            PKG_UPDATE="yum update -y"
            HAPROXY_CONFIG="/etc/haproxy/haproxy.cfg"
            ;;
        *)
            echo -e "${RED}Error: Unsupported distribution: $ID${NC}"
            exit 1
            ;;
    esac
    echo -e "${GREEN}Detected: $PRETTY_NAME${NC}"
else
    echo -e "${RED}Error: Cannot detect operating system${NC}"
    exit 1
fi

# Update system packages
echo -e "${YELLOW}[2/9] Updating system packages...${NC}"
$PKG_UPDATE

# Install dependencies
echo -e "${YELLOW}[3/9] Installing dependencies...${NC}"
$PKG_INSTALL curl unzip haproxy

# Install Deno
echo -e "${YELLOW}[4/9] Installing Deno runtime...${NC}"
curl -fsSL https://deno.land/install.sh | sh
cp ~/.deno/bin/deno /usr/local/bin/
chmod 755 /usr/local/bin/deno
echo -e "${GREEN}Deno $(deno --version | head -n1) installed${NC}"

# Create system user
echo -e "${YELLOW}[5/9] Creating system user and directories...${NC}"
if ! id "${DENO_USER}" >/dev/null 2>&1; then
    useradd --system --no-create-home --shell /bin/false "${DENO_USER}"
fi

mkdir -p "${INSTALL_DIR}"
chown -R "${DENO_USER}:${DENO_USER}" "${INSTALL_DIR}"
chmod 755 "${INSTALL_DIR}"

# Create main application server
echo -e "${YELLOW}[6/9] Creating Deno application files...${NC}"
cat > "${INSTALL_DIR}/server.ts" << 'EOF'
import { serve } from "https://deno.land/std@0.208.0/http/server.ts";

const PORT = parseInt(Deno.env.get("PORT") || "8000");
const WORKER_ID = Deno.env.get("WORKER_ID") || "main";

const handler = async (request: Request): Promise<Response> => {
  const url = new URL(request.url);
  const startTime = Date.now();
  
  if (url.pathname === "/health") {
    return new Response(JSON.stringify({
      status: "healthy",
      worker: WORKER_ID,
      timestamp: new Date().toISOString(),
      uptime: performance.now()
    }), {
      headers: { "content-type": "application/json" },
      status: 200
    });
  }
  
  if (url.pathname === "/status") {
    return new Response(JSON.stringify({
      worker: WORKER_ID,
      port: PORT,
      memory: Deno.memoryUsage(),
      timestamp: new Date().toISOString()
    }), {
      headers: { "content-type": "application/json" }
    });
  }
  
  const responseTime = Date.now() - startTime;
  const response = `Hello from Deno Worker ${WORKER_ID} on port ${PORT}\nRequest processed in ${responseTime}ms\nPath: ${url.pathname}`;
  
  console.log(`[${WORKER_ID}] ${request.method} ${url.pathname} - ${responseTime}ms`);
  
  return new Response(response, {
    headers: { "content-type": "text/plain" }
  });
};

serve(handler, { port: PORT });
console.log(`Worker ${WORKER_ID} listening on port ${PORT}`);
EOF

# Create cluster manager
cat > "${INSTALL_DIR}/cluster.ts" << 'EOF'
const WORKER_COUNT = parseInt(Deno.env.get("WORKER_COUNT") || "4");
const BASE_PORT = 8001;

const workers: Array<{ id: string; port: number; process?: Deno.ChildProcess }> = [];

for (let i = 0; i < WORKER_COUNT; i++) {
  workers.push({
    id: `worker-${i + 1}`,
    port: BASE_PORT + i
  });
}

const startWorker = async (config: typeof workers[0]) => {
  const cmd = new Deno.Command("deno", {
    args: ["run", "--allow-net", "--allow-env", "server.ts"],
    env: {
      PORT: config.port.toString(),
      WORKER_ID: config.id,
    },
    cwd: "/opt/deno-cluster",
  });
  
  config.process = cmd.spawn();
  console.log(`Started ${config.id} on port ${config.port}`);
  
  config.process.status.then(() => {
    console.log(`${config.id} exited, restarting...`);
    setTimeout(() => startWorker(config), 1000);
  });
};

console.log(`Starting ${WORKER_COUNT} workers...`);
workers.forEach(startWorker);

const shutdown = () => {
  console.log("Shutting down cluster...");
  workers.forEach(w => {
    if (w.process) {
      w.process.kill("SIGTERM");
    }
  });
  Deno.exit(0);
};

Deno.addSignalListener("SIGTERM", shutdown);
Deno.addSignalListener("SIGINT", shutdown);
EOF

chown -R "${DENO_USER}:${DENO_USER}" "${INSTALL_DIR}"
chmod 644 "${INSTALL_DIR}"/*.ts

# Configure HAProxy
echo -e "${YELLOW}[7/9] Configuring HAProxy load balancer...${NC}"
cat > "${HAPROXY_CONFIG}" << EOF
global
    daemon
    user haproxy
    group haproxy
    log stdout local0

defaults
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms
    option httplog
    log global

frontend deno_frontend
    bind *:${HAPROXY_PORT}
    default_backend deno_workers

backend deno_workers
    balance roundrobin
    option httpchk GET /health
EOF

for ((i=1; i<=WORKER_COUNT; i++)); do
    echo "    server worker-$i 127.0.0.1:$((BASE_PORT + i - 1)) check inter 5s rise 2 fall 3" >> "${HAPROXY_CONFIG}"
done

# Create systemd service
echo -e "${YELLOW}[8/9] Creating systemd services...${NC}"
cat > /etc/systemd/system/deno-cluster.service << EOF
[Unit]
Description=Deno Cluster Application
After=network.target
Requires=network.target

[Service]
Type=simple
User=${DENO_USER}
Group=${DENO_USER}
WorkingDirectory=${INSTALL_DIR}
Environment=WORKER_COUNT=${WORKER_COUNT}
ExecStart=/usr/local/bin/deno run --allow-net --allow-env --allow-run cluster.ts
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

# Configure firewall if available
echo -e "${YELLOW}[9/9] Configuring services and firewall...${NC}"
if command -v ufw >/dev/null 2>&1; then
    ufw allow "${HAPROXY_PORT}/tcp"
elif command -v firewall-cmd >/dev/null 2>&1; then
    firewall-cmd --permanent --add-port="${HAPROXY_PORT}/tcp"
    firewall-cmd --reload
fi

# Enable and start services
systemctl daemon-reload
systemctl enable deno-cluster
systemctl enable haproxy
systemctl start deno-cluster
systemctl start haproxy

# Wait for services to start
sleep 5

# Verify installation
echo -e "${YELLOW}Verifying installation...${NC}"
if systemctl is-active --quiet deno-cluster && systemctl is-active --quiet haproxy; then
    if curl -s "http://localhost:${HAPROXY_PORT}/health" | grep -q "healthy"; then
        echo -e "${GREEN}✓ Installation completed successfully!${NC}"
        echo -e "${GREEN}✓ Deno cluster with ${WORKER_COUNT} workers running${NC}"
        echo -e "${GREEN}✓ HAProxy load balancer running on port ${HAPROXY_PORT}${NC}"
        echo -e "${GREEN}✓ Health check: http://localhost:${HAPROXY_PORT}/health${NC}"
        echo -e "${GREEN}✓ Status check: http://localhost:${HAPROXY_PORT}/status${NC}"
    else
        echo -e "${RED}✗ Services started but health check failed${NC}"
        exit 1
    fi
else
    echo -e "${RED}✗ Failed to start services${NC}"
    systemctl status deno-cluster haproxy
    exit 1
fi