Deploy Deno applications with Docker containers and production optimization

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

# Production Deno Docker Deployment Script
# Supports Ubuntu/Debian and RHEL-based distributions

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

# Configuration
APP_NAME="${1:-deno-docker-app}"
APP_PORT="${2:-8000}"
APP_ENV="${3:-production}"

# Usage function
usage() {
    echo "Usage: $0 [app-name] [port] [environment]"
    echo "  app-name: Application name (default: deno-docker-app)"
    echo "  port: Application port (default: 8000)"
    echo "  environment: Environment (default: production)"
    exit 1
}

# Logging functions
log_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }

# Cleanup function for rollback
cleanup() {
    log_error "Installation failed. Performing cleanup..."
    systemctl stop docker 2>/dev/null || true
    rm -rf /home/$SUDO_USER/$APP_NAME 2>/dev/null || true
}

trap cleanup ERR

# Check prerequisites
check_prerequisites() {
    if [[ $EUID -eq 0 ]]; then
        log_error "Do not run as root. Use a user with sudo privileges."
        exit 1
    fi
    
    if ! command -v sudo &> /dev/null; then
        log_error "sudo is required but not installed."
        exit 1
    fi
    
    if ! sudo -n true 2>/dev/null; then
        log_error "User must have passwordless sudo or be in sudoers."
        exit 1
    fi
}

# Auto-detect distribution
detect_distro() {
    if [ ! -f /etc/os-release ]; then
        log_error "Cannot detect distribution. /etc/os-release not found."
        exit 1
    fi
    
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_UPDATE="apt update"
            PKG_INSTALL="apt install -y"
            PKG_UPGRADE="apt upgrade -y"
            DOCKER_REPO_SETUP="setup_docker_apt"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_UPDATE="dnf check-update || true"
            PKG_INSTALL="dnf install -y"
            PKG_UPGRADE="dnf update -y"
            DOCKER_REPO_SETUP="setup_docker_dnf"
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_UPDATE="yum check-update || true"
            PKG_INSTALL="yum install -y"
            PKG_UPGRADE="yum update -y"
            DOCKER_REPO_SETUP="setup_docker_yum"
            ;;
        *)
            log_error "Unsupported distribution: $ID"
            exit 1
            ;;
    esac
    
    log_info "Detected distribution: $PRETTY_NAME"
}

# Docker repository setup functions
setup_docker_apt() {
    sudo $PKG_INSTALL curl gnupg lsb-release
    sudo mkdir -p /etc/apt/keyrings
    curl -fsSL https://download.docker.com/linux/$ID/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
    sudo chmod 644 /etc/apt/keyrings/docker.gpg
    echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/$ID $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
    sudo chmod 644 /etc/apt/sources.list.d/docker.list
    sudo $PKG_UPDATE
}

setup_docker_dnf() {
    sudo $PKG_INSTALL curl
    sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
}

setup_docker_yum() {
    sudo $PKG_INSTALL curl
    sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
}

# Main installation steps
step1_update_system() {
    log_info "[1/7] Updating system packages..."
    sudo $PKG_UPDATE
    sudo $PKG_UPGRADE
    log_success "System packages updated"
}

step2_install_docker() {
    log_info "[2/7] Installing Docker..."
    $DOCKER_REPO_SETUP
    sudo $PKG_INSTALL docker-ce docker-ce-cli containerd.io docker-compose-plugin
    log_success "Docker installed"
}

step3_configure_docker() {
    log_info "[3/7] Configuring Docker service..."
    sudo systemctl enable --now docker
    sudo usermod -aG docker $USER
    
    # Configure Docker daemon for production
    sudo mkdir -p /etc/docker
    sudo tee /etc/docker/daemon.json > /dev/null <<EOF
{
    "log-driver": "json-file",
    "log-opts": {
        "max-size": "10m",
        "max-file": "3"
    },
    "storage-driver": "overlay2"
}
EOF
    sudo chmod 644 /etc/docker/daemon.json
    sudo systemctl restart docker
    log_success "Docker configured"
}

step4_install_deno() {
    log_info "[4/7] Installing Deno..."
    curl -fsSL https://deno.land/install.sh | sh
    echo 'export DENO_INSTALL="$HOME/.deno"' >> ~/.bashrc
    echo 'export PATH="$DENO_INSTALL/bin:$PATH"' >> ~/.bashrc
    export DENO_INSTALL="$HOME/.deno"
    export PATH="$DENO_INSTALL/bin:$PATH"
    log_success "Deno installed"
}

step5_create_app() {
    log_info "[5/7] Creating Deno application..."
    mkdir -p ~/$APP_NAME/src
    cd ~/$APP_NAME
    
    # Create deps.ts for better caching
    cat > src/deps.ts <<EOF
export { serve } from "https://deno.land/std@0.208.0/http/server.ts";
EOF
    
    # Create main application
    cat > src/main.ts <<EOF
import { serve } from "./deps.ts";

const port = parseInt(Deno.env.get("PORT") || "$APP_PORT");

const handler = (request: Request): Response => {
  const url = new URL(request.url);
  
  if (url.pathname === "/health") {
    return new Response(JSON.stringify({ status: "healthy", timestamp: Date.now() }), {
      headers: { "content-type": "application/json" },
    });
  }
  
  if (url.pathname === "/api/info") {
    return new Response(JSON.stringify({
      message: "Deno Docker Application",
      version: "1.0.0",
      deno: Deno.version.deno,
      env: Deno.env.get("ENVIRONMENT") || "$APP_ENV"
    }), {
      headers: { "content-type": "application/json" },
    });
  }
  
  return new Response("Welcome to Deno Docker App!", {
    headers: { "content-type": "text/plain" },
  });
};

console.log(\`HTTP server running on port \${port}\`);
await serve(handler, { port });
EOF
    
    chmod 644 src/*.ts
    log_success "Application created"
}

step6_create_dockerfile() {
    log_info "[6/7] Creating production Dockerfile..."
    cat > Dockerfile <<EOF
# Build stage
FROM denoland/deno:1.38.3 AS builder
WORKDIR /app
COPY src/deps.ts ./src/
RUN deno cache src/deps.ts
COPY src/ ./src/
RUN deno cache src/main.ts
RUN deno compile --allow-net --allow-env --output=server src/main.ts

# Production stage
FROM debian:12-slim AS production
RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
RUN groupadd -r denouser && useradd -r -g denouser denouser
COPY --from=builder --chown=denouser:denouser /app/server /usr/local/bin/server
RUN chmod 755 /usr/local/bin/server
USER denouser
EXPOSE $APP_PORT
ENV PORT=$APP_PORT
ENV ENVIRONMENT=$APP_ENV
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:$APP_PORT/health || exit 1
CMD ["/usr/local/bin/server"]
EOF

    cat > docker-compose.yml <<EOF
version: '3.8'
services:
  $APP_NAME:
    build: .
    ports:
      - "$APP_PORT:$APP_PORT"
    environment:
      - PORT=$APP_PORT
      - ENVIRONMENT=$APP_ENV
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    read_only: true
    tmpfs:
      - /tmp
EOF

    chmod 644 Dockerfile docker-compose.yml
    log_success "Docker files created"
}

step7_build_deploy() {
    log_info "[7/7] Building and deploying application..."
    newgrp docker <<EOF
docker build -t $APP_NAME .
docker compose up -d
EOF
    log_success "Application deployed"
}

verify_installation() {
    log_info "Verifying installation..."
    
    if ! command -v docker &> /dev/null; then
        log_error "Docker installation failed"
        return 1
    fi
    
    if ! $DENO_INSTALL/bin/deno --version &> /dev/null; then
        log_error "Deno installation failed"
        return 1
    fi
    
    sleep 5
    if curl -f http://localhost:$APP_PORT/health &> /dev/null; then
        log_success "Application is running and healthy"
        echo -e "${GREEN}Access your application at: http://localhost:$APP_PORT${NC}"
        echo -e "${GREEN}Health check: http://localhost:$APP_PORT/health${NC}"
        echo -e "${GREEN}API info: http://localhost:$APP_PORT/api/info${NC}"
    else
        log_warning "Application may still be starting. Check with: docker compose logs"
    fi
}

# Main execution
main() {
    log_info "Starting Deno Docker deployment for application: $APP_NAME"
    
    check_prerequisites
    detect_distro
    
    step1_update_system
    step2_install_docker
    step3_configure_docker
    step4_install_deno
    step5_create_app
    step6_create_dockerfile
    step7_build_deploy
    
    verify_installation
    
    log_success "Deno Docker deployment completed successfully!"
    log_info "Note: You may need to log out and back in for Docker group membership to take effect"
}

# Validate arguments
if [[ $# -gt 3 ]]; then
    usage
fi

main "$@"