Packaging & Deployment

# Debug build (default) - fast to compile, slow to run
cargo build
# → target/debug/webserver (15–30 MB, unoptimized)

# Release build - slow to compile, fast to run
cargo build --release
# → target/release/webserver (3–8 MB, fully optimized)

[profile.release]
opt-level = 3          # Maximum optimization (default)
lto = true             # Link-time optimization - slower build, smaller/faster binary
codegen-units = 1      # Single codegen unit - better optimization, slower build
strip = true           # Strip debug symbols from the binary
panic = "abort"        # Abort on panic instead of unwinding - smaller binary

# List available targets
rustup target list

# Add a target
rustup target add x86_64-unknown-linux-musl
rustup target add aarch64-unknown-linux-musl

# Build for that target
cargo build --release --target x86_64-unknown-linux-musl

cargo install cross

# Build for Linux from macOS - cross handles the toolchain
cross build --release --target x86_64-unknown-linux-musl

# Stage 1: Build
FROM rust:1.82-slim AS builder

WORKDIR /app

# Cache dependencies - copy manifests first, build, then copy source
COPY Cargo.toml Cargo.lock ./
RUN mkdir src && echo "fn main() {}" > src/main.rs
RUN cargo build --release && rm -rf src

# Now copy real source and rebuild (only changed files recompile)
COPY src/ src/
COPY migrations/ migrations/
RUN touch src/main.rs && cargo build --release

# Stage 2: Runtime - minimal image
FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*

COPY --from=builder /app/target/release/webserver /usr/local/bin/webserver
COPY public/ /app/public/

WORKDIR /app

EXPOSE 8080

ENV HOST=0.0.0.0
ENV PORT=8080
ENV LOG_LEVEL=info

CMD ["webserver"]

# Stage 1: Build a fully static binary
FROM rust:1.82-slim AS builder

RUN rustup target add x86_64-unknown-linux-musl
RUN apt-get update && apt-get install -y musl-tools

WORKDIR /app
COPY Cargo.toml Cargo.lock ./
RUN mkdir src && echo "fn main() {}" > src/main.rs
RUN cargo build --release --target x86_64-unknown-linux-musl && rm -rf src

COPY src/ src/
COPY migrations/ migrations/
RUN touch src/main.rs && cargo build --release --target x86_64-unknown-linux-musl

# Stage 2: Scratch - literally empty, just the binary
FROM scratch

COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/webserver /webserver
COPY public/ /public/

EXPOSE 8080

ENTRYPOINT ["/webserver"]

# Build and run
docker build -t webserver .
docker run -p 8080:8080 webserver

# Check the image size
docker images webserver
# REPOSITORY   TAG     SIZE
# webserver    latest  12MB

target/
.git/
*.db
.env

use tokio::signal;
use tokio::sync::watch;

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt().init();

    let db = Db::connect("sqlite:todos.db?mode=rwc").await.unwrap();
    let app = Arc::new(build_app(db.clone()));

    let addr = "0.0.0.0:8080";
    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
    tracing::info!(addr, "Listening");

    // Shutdown signal channel
    let (shutdown_tx, shutdown_rx) = watch::channel(false);

    // Spawn the accept loop
    let server = tokio::spawn({
        let shutdown_rx = shutdown_rx.clone();
        async move {
            loop {
                tokio::select! {
                    result = listener.accept() => {
                        match result {
                            Ok((stream, _)) => {
                                let app = Arc::clone(&app);
                                let mut rx = shutdown_rx.clone();
                                tokio::spawn(async move {
                                    tokio::select! {
                                        _ = handle_connection(stream, app) => {}
                                        _ = rx.changed() => {
                                            tracing::debug!("Connection cancelled by shutdown");
                                        }
                                    }
                                });
                            }
                            Err(e) => tracing::error!(error = %e, "Accept failed"),
                        }
                    }
                    _ = shutdown_rx.clone().changed() => {
                        tracing::info!("Shutting down accept loop");
                        break;
                    }
                }
            }
        }
    });

    // Wait for shutdown signal
    shutdown_signal().await;
    tracing::info!("Shutdown signal received");

    // Signal all tasks to stop
    let _ = shutdown_tx.send(true);

    // Wait for the server task to finish
    let _ = server.await;

    // Cleanup
    tracing::info!("Server stopped");
}

async fn shutdown_signal() {
    let ctrl_c = async {
        signal::ctrl_c().await.expect("failed to listen for Ctrl+C");
    };

    #[cfg(unix)]
    let terminate = async {
        signal::unix::signal(signal::unix::SignalKind::terminate())
            .expect("failed to listen for SIGTERM")
            .recv()
            .await;
    };

    #[cfg(not(unix))]
    let terminate = std::future::pending::<()>();

    tokio::select! {
        _ = ctrl_c => tracing::info!("Received Ctrl+C"),
        _ = terminate => tracing::info!("Received SIGTERM"),
    }
}