Deploy Spring Boot applications with Jetty and Docker containers

#!/usr/bin/env bash

set -euo pipefail

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

# Configuration
readonly APP_NAME="springboot-jetty-app"
readonly APP_USER="jetty"
readonly APP_DIR="/opt/${APP_NAME}"
readonly SERVICE_NAME="springboot-jetty"

# Print colored output
print_status() {
    echo -e "${GREEN}[INFO]${NC} $1"
}

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

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

# Cleanup function for rollback
cleanup() {
    print_error "Installation failed. Performing cleanup..."
    systemctl stop docker 2>/dev/null || true
    userdel -r "$APP_USER" 2>/dev/null || true
    rm -rf "$APP_DIR" 2>/dev/null || true
    exit 1
}

trap cleanup ERR

# Check if running with sufficient privileges
check_privileges() {
    if [[ $EUID -ne 0 ]]; then
        print_error "This script must be run as root or with sudo"
        exit 1
    fi
}

# Detect distribution and set package manager
detect_distro() {
    if [[ ! -f /etc/os-release ]]; then
        print_error "Cannot detect Linux distribution"
        exit 1
    fi
    
    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_UPDATE="apt update && apt upgrade -y"
            PKG_INSTALL="apt install -y"
            JAVA_PKG="openjdk-21-jdk"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_UPDATE="dnf update -y"
            PKG_INSTALL="dnf install -y"
            JAVA_PKG="java-21-openjdk-devel"
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_UPDATE="yum update -y"
            PKG_INSTALL="yum install -y"
            JAVA_PKG="java-21-amazon-corretto-devel"
            ;;
        *)
            print_error "Unsupported distribution: $ID"
            exit 1
            ;;
    esac
    
    print_status "Detected distribution: $PRETTY_NAME"
    print_status "Using package manager: $PKG_MGR"
}

# Install Docker and Java development tools
install_dependencies() {
    print_status "[1/8] Installing Docker and Java development tools..."
    
    $PKG_UPDATE
    
    case "$PKG_MGR" in
        apt)
            $PKG_INSTALL docker.io docker-compose "$JAVA_PKG" maven curl wget
            ;;
        dnf|yum)
            $PKG_INSTALL docker docker-compose "$JAVA_PKG" maven curl wget
            ;;
    esac
    
    systemctl enable --now docker
    print_status "Docker and Java tools installed successfully"
}

# Create application user
create_app_user() {
    print_status "[2/8] Creating application user..."
    
    if ! id "$APP_USER" &>/dev/null; then
        useradd -r -s /bin/false -d "$APP_DIR" "$APP_USER"
        usermod -aG docker "$APP_USER"
        print_status "Created user: $APP_USER"
    else
        print_warning "User $APP_USER already exists"
    fi
}

# Verify installations
verify_installation() {
    print_status "[3/8] Verifying Java and Docker installation..."
    
    java --version
    mvn --version
    docker --version
    docker compose version
    
    print_status "All tools verified successfully"
}

# Create Spring Boot project structure
create_project_structure() {
    print_status "[4/8] Creating Spring Boot project structure..."
    
    mkdir -p "$APP_DIR"
    cd "$APP_DIR"
    
    # Create Maven project structure
    mkdir -p src/main/java/com/example
    mkdir -p src/main/resources
    mkdir -p target
    
    chown -R "$APP_USER:$APP_USER" "$APP_DIR"
}

# Create Maven configuration
create_maven_config() {
    print_status "[5/8] Creating Maven configuration..."
    
    cat > "$APP_DIR/pom.xml" << 'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.1</version>
        <relativePath/>
    </parent>
    
    <groupId>com.example</groupId>
    <artifactId>jetty-app</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
EOF
}

# Create Spring Boot application
create_application() {
    print_status "[6/8] Creating Spring Boot application..."
    
    cat > "$APP_DIR/src/main/java/com/example/Application.java" << 'EOF'
package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class Application {
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    
    @GetMapping("/")
    public String home() {
        return "Spring Boot with Jetty Server - Running in Docker Container";
    }
    
    @GetMapping("/health")
    public String health() {
        return "OK - Jetty Server is running";
    }
}
EOF
    
    cat > "$APP_DIR/src/main/resources/application.properties" << 'EOF'
# Server configuration
server.port=8080
server.jetty.threads.max=200
server.jetty.threads.min=10
server.jetty.threads.idle-timeout=60000
server.jetty.connection-idle-timeout=30000

# Actuator endpoints
management.endpoints.web.exposure.include=health,info,metrics
management.endpoint.health.show-details=always
management.server.port=8081

# Logging configuration
logging.level.org.eclipse.jetty=INFO
logging.level.com.example=DEBUG
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n
EOF
}

# Create Dockerfile
create_dockerfile() {
    print_status "[7/8] Creating multi-stage Dockerfile..."
    
    cat > "$APP_DIR/Dockerfile" << 'EOF'
# Build stage
FROM openjdk:21-jdk-slim AS build

WORKDIR /app

# Copy pom.xml and download dependencies
COPY pom.xml .
RUN mvn dependency:go-offline -B

# Copy source code and build
COPY src ./src
RUN mvn clean package -DskipTests

# Runtime stage
FROM openjdk:21-jre-slim

WORKDIR /app

# Create non-root user
RUN useradd -r -s /bin/false jetty

# Copy JAR from build stage
COPY --from=build /app/target/*.jar app.jar

# Set ownership
RUN chown jetty:jetty app.jar

USER jetty

EXPOSE 8080 8081

HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
    CMD curl -f http://localhost:8081/actuator/health || exit 1

CMD ["java", "-jar", "app.jar"]
EOF
    
    cat > "$APP_DIR/docker-compose.yml" << 'EOF'
version: '3.8'

services:
  jetty-app:
    build: .
    container_name: springboot-jetty-app
    ports:
      - "8080:8080"
      - "8081:8081"
    environment:
      - SPRING_PROFILES_ACTIVE=production
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8081/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
EOF
    
    # Set proper permissions
    chown -R "$APP_USER:$APP_USER" "$APP_DIR"
    chmod 644 "$APP_DIR"/{pom.xml,Dockerfile,docker-compose.yml}
    chmod 644 "$APP_DIR/src/main/java/com/example/Application.java"
    chmod 644 "$APP_DIR/src/main/resources/application.properties"
}

# Configure firewall
configure_firewall() {
    print_status "[8/8] Configuring firewall..."
    
    if command -v ufw &> /dev/null; then
        ufw allow 8080/tcp
        ufw allow 8081/tcp
    elif command -v firewall-cmd &> /dev/null; then
        firewall-cmd --permanent --add-port=8080/tcp
        firewall-cmd --permanent --add-port=8081/tcp
        firewall-cmd --reload
    fi
    
    print_status "Firewall configured for ports 8080 and 8081"
}

# Verify deployment
verify_deployment() {
    print_status "Verifying deployment..."
    
    cd "$APP_DIR"
    
    # Build and test the application
    sudo -u "$APP_USER" mvn clean package -DskipTests
    sudo -u "$APP_USER" docker build -t springboot-jetty-app .
    
    print_status "${GREEN}Installation completed successfully!${NC}"
    print_status "Project location: $APP_DIR"
    print_status "To start the application:"
    print_status "  cd $APP_DIR"
    print_status "  docker compose up -d"
    print_status "Application will be available at:"
    print_status "  Main app: http://localhost:8080"
    print_status "  Health check: http://localhost:8081/actuator/health"
}

# Main execution
main() {
    print_status "Starting Spring Boot with Jetty and Docker installation..."
    
    check_privileges
    detect_distro
    install_dependencies
    create_app_user
    verify_installation
    create_project_structure
    create_maven_config
    create_application
    create_dockerfile
    configure_firewall
    verify_deployment
    
    print_status "${GREEN}Spring Boot with Jetty deployment setup completed successfully!${NC}"
}

main "$@"