Dockerfile.multi-stage

# Multi-stage Dockerfile for RustFS
# Supports cross-compilation for amd64 and arm64 architectures
ARG TARGETPLATFORM
ARG BUILDPLATFORM

# Build stage
FROM --platform=$BUILDPLATFORM rust:1.85-bookworm AS builder

# Install required build dependencies
RUN apt-get update && apt-get install -y \
    wget \
    git \
    curl \
    unzip \
    gcc \
    pkg-config \
    libssl-dev \
    lld \
    && rm -rf /var/lib/apt/lists/*

# Install cross-compilation tools for ARM64
RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
        apt-get update && \
        apt-get install -y gcc-aarch64-linux-gnu && \
        rm -rf /var/lib/apt/lists/*; \
    fi

# Install protoc
RUN wget https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protoc-31.1-linux-x86_64.zip \
    && unzip protoc-31.1-linux-x86_64.zip -d protoc3 \
    && mv protoc3/bin/* /usr/local/bin/ && chmod +x /usr/local/bin/protoc \
    && mv protoc3/include/* /usr/local/include/ && rm -rf protoc-31.1-linux-x86_64.zip protoc3

# Install flatc
RUN wget https://github.com/google/flatbuffers/releases/download/v25.2.10/Linux.flatc.binary.g++-13.zip \
    && unzip Linux.flatc.binary.g++-13.zip \
    && mv flatc /usr/local/bin/ && chmod +x /usr/local/bin/flatc && rm -rf Linux.flatc.binary.g++-13.zip

# Set up Rust targets based on platform
RUN case "$TARGETPLATFORM" in \
        "linux/amd64") rustup target add x86_64-unknown-linux-gnu ;; \
        "linux/arm64") rustup target add aarch64-unknown-linux-gnu ;; \
        *) echo "Unsupported platform: $TARGETPLATFORM" && exit 1 ;; \
    esac

# Set up environment for cross-compilation
ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
ENV CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc
ENV CXX_aarch64_unknown_linux_gnu=aarch64-linux-gnu-g++

WORKDIR /usr/src/rustfs

# Copy Cargo files for dependency caching
COPY Cargo.toml Cargo.lock ./
COPY */Cargo.toml ./*/

# Create dummy main.rs files for dependency compilation
RUN find . -name "Cargo.toml" -not -path "./Cargo.toml" | \
    xargs -I {} dirname {} | \
    xargs -I {} sh -c 'mkdir -p {}/src && echo "fn main() {}" > {}/src/main.rs'

# Build dependencies only (cache layer)
RUN case "$TARGETPLATFORM" in \
        "linux/amd64") cargo build --release --target x86_64-unknown-linux-gnu ;; \
        "linux/arm64") cargo build --release --target aarch64-unknown-linux-gnu ;; \
    esac

# Copy source code
COPY . .

# Generate protobuf code
RUN cargo run --bin gproto

# Build the actual application
RUN case "$TARGETPLATFORM" in \
        "linux/amd64") \
            cargo build --release --target x86_64-unknown-linux-gnu --bin rustfs && \
            cp target/x86_64-unknown-linux-gnu/release/rustfs /usr/local/bin/rustfs \
            ;; \
        "linux/arm64") \
            cargo build --release --target aarch64-unknown-linux-gnu --bin rustfs && \
            cp target/aarch64-unknown-linux-gnu/release/rustfs /usr/local/bin/rustfs \
            ;; \
    esac

# Runtime stage - Ubuntu minimal for better compatibility
FROM ubuntu:22.04

# Install runtime dependencies
RUN apt-get update && apt-get install -y \
    ca-certificates \
    tzdata \
    wget \
    && rm -rf /var/lib/apt/lists/*

# Create rustfs user and group
RUN groupadd -g 1000 rustfs && \
    useradd -d /app -g rustfs -u 1000 -s /bin/bash rustfs

WORKDIR /app

# Create data directories
RUN mkdir -p /data/rustfs{0,1,2,3} && \
    chown -R rustfs:rustfs /data /app

# Copy binary from builder stage
COPY --from=builder /usr/local/bin/rustfs /app/rustfs
RUN chmod +x /app/rustfs && chown rustfs:rustfs /app/rustfs

# Switch to non-root user
USER rustfs

# Expose ports
EXPOSE 9000 9001

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD wget --no-verbose --tries=1 --spider http://localhost:9000/health || exit 1

# Set default command
CMD ["/app/rustfs"]