Implement Lighttpd 1.4 load balancing with multiple backend servers for high availability

#!/usr/bin/env bash
set -euo pipefail

# Lighttpd Load Balancer Installation Script
# Configures Lighttpd 1.4 with load balancing across multiple backend servers

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

# Usage function
usage() {
    echo "Usage: $0 [backend1_ip:port] [backend2_ip:port] [backend3_ip:port]"
    echo "Example: $0 192.168.1.10:8080 192.168.1.11:8080 192.168.1.12:8080"
    echo "If no backends specified, will use example IPs"
    exit 1
}

# Cleanup function for rollback
cleanup() {
    echo -e "${RED}[ERROR] Installation failed. Rolling back changes...${NC}"
    systemctl stop lighttpd 2>/dev/null || true
    rm -f /etc/lighttpd/conf.d/50-loadbalancer.conf 2>/dev/null || true
    rm -f /etc/lighttpd/conf-available/50-loadbalancer.conf 2>/dev/null || true
    rm -f /etc/lighttpd/healthcheck.lua 2>/dev/null || true
    exit 1
}

trap cleanup ERR

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

# Parse backend arguments or use defaults
BACKENDS=()
if [ $# -eq 0 ]; then
    BACKENDS=("192.168.1.10:8080" "192.168.1.11:8080" "192.168.1.12:8080")
    echo -e "${YELLOW}No backends specified, using defaults: ${BACKENDS[*]}${NC}"
elif [ $# -eq 3 ]; then
    BACKENDS=("$1" "$2" "$3")
else
    usage
fi

# Detect distribution
echo "[1/8] Detecting distribution..."
if [ -f /etc/os-release ]; then
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_UPDATE="apt update"
            PKG_INSTALL="apt install -y"
            LIGHTTPD_USER="www-data"
            LIGHTTPD_GROUP="www-data"
            CONF_DIR="/etc/lighttpd/conf-available"
            ENABLED_DIR="/etc/lighttpd/conf-enabled"
            ENABLE_CMD="lighttpd-enable-mod"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_UPDATE="dnf update -y"
            PKG_INSTALL="dnf install -y"
            LIGHTTPD_USER="lighttpd"
            LIGHTTPD_GROUP="lighttpd"
            CONF_DIR="/etc/lighttpd/conf.d"
            ENABLED_DIR="/etc/lighttpd/conf.d"
            ENABLE_CMD=""
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_UPDATE="yum update -y"
            PKG_INSTALL="yum install -y"
            LIGHTTPD_USER="lighttpd"
            LIGHTTPD_GROUP="lighttpd"
            CONF_DIR="/etc/lighttpd/conf.d"
            ENABLED_DIR="/etc/lighttpd/conf.d"
            ENABLE_CMD=""
            ;;
        *)
            echo -e "${RED}Unsupported distribution: $ID${NC}"
            exit 1
            ;;
    esac
    echo -e "${GREEN}Detected: $PRETTY_NAME${NC}"
else
    echo -e "${RED}Cannot detect distribution${NC}"
    exit 1
fi

# Update package manager
echo "[2/8] Updating package manager..."
$PKG_UPDATE

# Install Lighttpd and required packages
echo "[3/8] Installing Lighttpd and dependencies..."
if [[ "$ID" == "ubuntu" || "$ID" == "debian" ]]; then
    $PKG_INSTALL lighttpd lighttpd-mod-magnet curl lua5.1
else
    $PKG_INSTALL lighttpd lighttpd-mod-magnet curl lua
fi

# Create configuration directories if they don't exist
mkdir -p "$CONF_DIR"
mkdir -p "$ENABLED_DIR"
mkdir -p /var/cache/lighttpd/uploads
mkdir -p /var/log/lighttpd

# Set proper ownership
chown -R $LIGHTTPD_USER:$LIGHTTPD_GROUP /var/cache/lighttpd
chown -R $LIGHTTPD_USER:$LIGHTTPD_GROUP /var/log/lighttpd

# Enable required modules for Debian-based systems
if [[ "$ID" == "ubuntu" || "$ID" == "debian" ]]; then
    echo "[4/8] Enabling Lighttpd modules..."
    $ENABLE_CMD proxy
    $ENABLE_CMD magnet
    $ENABLE_CMD rewrite
fi

# Create backend server configuration
echo "[5/8] Creating load balancer configuration..."
cat > "$CONF_DIR/50-loadbalancer.conf" << EOF
server.modules += (
    "mod_proxy",
    "mod_magnet",
    "mod_rewrite"
)

# Backend server definitions
proxy.server = (
    "" => (
EOF

# Add backends to configuration
for i in "${!BACKENDS[@]}"; do
    IFS=':' read -r host port <<< "${BACKENDS[$i]}"
    cat >> "$CONF_DIR/50-loadbalancer.conf" << EOF
        "backend$((i+1))" => (
            "host" => "$host",
            "port" => $port,
            "check-local" => "disable"
        ),
EOF
done

# Complete the configuration
cat >> "$CONF_DIR/50-loadbalancer.conf" << 'EOF'
    )
)

# Load balancing method
proxy.balance = "fair"

# Connection settings
proxy.forwarded = (
    "for" => 1,
    "host" => 1,
    "proto" => 1,
    "remote_user" => 1
)

# Timeout settings
proxy.server.timeout = 30

# Enable health checking
magnet.attract-physical-path-to = ( "/etc/lighttpd/healthcheck.lua" )

# Access logging
accesslog.filename = "/var/log/lighttpd/access.log"
EOF

# Set proper permissions on config file
chmod 644 "$CONF_DIR/50-loadbalancer.conf"
chown root:root "$CONF_DIR/50-loadbalancer.conf"

# Enable configuration for Debian-based systems
if [[ "$ID" == "ubuntu" || "$ID" == "debian" ]]; then
    ln -sf "../conf-available/50-loadbalancer.conf" "$ENABLED_DIR/50-loadbalancer.conf"
fi

# Create health check Lua script
echo "[6/8] Creating health check script..."
cat > /etc/lighttpd/healthcheck.lua << 'EOF'
-- Backend health check configuration
local backends = {
EOF

# Add backends to Lua script
for i in "${!BACKENDS[@]}"; do
    IFS=':' read -r host port <<< "${BACKENDS[$i]}"
    cat >> /etc/lighttpd/healthcheck.lua << EOF
    {host = "$host", port = $port, name = "backend$((i+1))"},
EOF
done

cat >> /etc/lighttpd/healthcheck.lua << 'EOF'
}

-- Health check endpoint
local health_path = "/health"

-- Check if backend is healthy
function check_backend_health(backend)
    local handle = io.popen("curl -f -s -m 5 http://" .. backend.host .. ":" .. backend.port .. health_path .. " >/dev/null 2>&1; echo $?")
    local result = handle:read("*a")
    handle:close()
    return tonumber(result) == 0
end

-- Main health check logic
function health_check_handler()
    local healthy_backends = {}
    
    for i, backend in ipairs(backends) do
        if check_backend_health(backend) then
            table.insert(healthy_backends, backend)
        else
            lighty.r.log(3, "Backend " .. backend.name .. " is unhealthy")
        end
    end
    
    if #healthy_backends == 0 then
        lighty.r.status = 503
        lighty.r.header["Content-Type"] = "text/plain"
        lighty.r.content = "All backend servers are unavailable"
        return lighty.RESPONSE_FINISHED
    end
    
    return lighty.RESPONSE_GO_ON
end

-- Register the health check handler
if lighty.request and lighty.request.env then
    lighty.request.env["health_check"] = health_check_handler
end
EOF

# Set proper permissions on Lua script
chmod 644 /etc/lighttpd/healthcheck.lua
chown root:root /etc/lighttpd/healthcheck.lua

# Configure firewall
echo "[7/8] Configuring firewall..."
if command -v ufw >/dev/null 2>&1; then
    ufw --force enable
    ufw allow 80/tcp
    ufw allow 443/tcp
elif command -v firewall-cmd >/dev/null 2>&1; then
    systemctl enable --now firewalld
    firewall-cmd --permanent --add-service=http
    firewall-cmd --permanent --add-service=https
    firewall-cmd --reload
fi

# Start and enable Lighttpd
echo "[8/8] Starting and enabling Lighttpd..."
systemctl enable lighttpd
systemctl restart lighttpd

# Verify installation
echo "Verifying installation..."
if systemctl is-active --quiet lighttpd; then
    echo -e "${GREEN}✓ Lighttpd is running${NC}"
else
    echo -e "${RED}✗ Lighttpd failed to start${NC}"
    systemctl status lighttpd
    exit 1
fi

if lighttpd -t -f /etc/lighttpd/lighttpd.conf; then
    echo -e "${GREEN}✓ Configuration is valid${NC}"
else
    echo -e "${RED}✗ Configuration validation failed${NC}"
    exit 1
fi

# Display configuration summary
echo -e "\n${GREEN}Load balancer installation completed successfully!${NC}"
echo -e "\nConfiguration summary:"
echo "- Load balancer listening on port 80"
echo "- Backend servers:"
for i in "${!BACKENDS[@]}"; do
    echo "  - Backend$((i+1)): ${BACKENDS[$i]}"
done
echo "- Configuration files:"
echo "  - Main config: $CONF_DIR/50-loadbalancer.conf"
echo "  - Health check: /etc/lighttpd/healthcheck.lua"
echo "- Log files:"
echo "  - Access: /var/log/lighttpd/access.log"
echo "  - Error: /var/log/lighttpd/error.log"
echo ""
echo "Next steps:"
echo "1. Ensure your backend servers are running on the specified ports"
echo "2. Configure a /health endpoint on each backend server"
echo "3. Test the load balancer: curl http://localhost/"