ci: integration tests

Author: evansims

Dockerfile.integration

@@ -0,0 +1,69 @@
+# Dockerfile for Management API Integration Tests
+# Multi-stage build for running management API in integration environment
+
+FROM rustlang/rust:nightly-bookworm-slim AS builder
+
+# Install build dependencies
+RUN apt-get update && apt-get install -y \
+    pkg-config \
+    libssl-dev \
+    curl \
+    wget \
+    clang \
+    libclang-dev \
+    protobuf-compiler \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install FoundationDB client libraries (required for compilation)
+# Note: FDB uses _aarch64 naming for ARM64, not _arm64
+# Version 7.3.69 matches the FDB server in docker-compose
+ARG TARGETARCH
+RUN echo "Installing FDB clients for architecture: ${TARGETARCH:-amd64}" && \
+    if [ "$TARGETARCH" = "arm64" ]; then \
+        wget -q https://github.com/apple/foundationdb/releases/download/7.3.69/foundationdb-clients_7.3.69-1_aarch64.deb -O /tmp/fdb-clients.deb; \
+    else \
+        wget -q https://github.com/apple/foundationdb/releases/download/7.3.69/foundationdb-clients_7.3.69-1_amd64.deb -O /tmp/fdb-clients.deb; \
+    fi && \
+    dpkg -i /tmp/fdb-clients.deb || (apt-get update && apt-get install -f -y) && \
+    rm /tmp/fdb-clients.deb && \
+    ldconfig && \
+    # Verify installation
+    ls -la /usr/include/foundationdb/ && \
+    test -f /usr/include/foundationdb/fdb.options
+
+WORKDIR /workspace
+
+# Copy dependency manifests
+COPY Cargo.toml Cargo.lock ./
+COPY crates ./crates
+
+# Build dependencies first (cached layer)
+RUN cargo build --release --bin inferadb-management
+
+# Final stage - minimal runtime image
+FROM debian:bookworm-slim
+
+# Install runtime dependencies
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    libssl3 \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy built binary
+COPY --from=builder /workspace/target/release/inferadb-management /app/inferadb-management
+
+# Copy integration test config file
+COPY config.integration.yaml /app/config.yaml
+
+# Expose management API port
+EXPOSE 8081
+
+# Health check
+HEALTHCHECK --interval=5s --timeout=3s --retries=10 --start-period=15s \
+    CMD curl -f http://localhost:8081/health || exit 1
+
+# Run management API
+CMD ["/app/inferadb-management", "--config", "/app/config.yaml"]

config.integration.yaml

@@ -0,0 +1,50 @@
+# InferaDB Management API Configuration - Integration Tests
+# This config is optimized for Docker container E2E testing
+
+frontend_base_url: "http://localhost:3000"
+
+server:
+  http_host: "0.0.0.0"  # Bind to all interfaces for Docker
+  http_port: 8081        # Match docker-compose exposed port
+  grpc_host: "0.0.0.0"
+  grpc_port: 8082
+  worker_threads: 2      # Reduced for test environment
+
+storage:
+  backend: "memory"      # In-memory for fast tests
+
+auth:
+  session_ttl_web: 3600       # 1 hour for tests
+  session_ttl_cli: 7200       # 2 hours for tests
+  session_ttl_sdk: 7200       # 2 hours for tests
+  password_min_length: 8      # Relaxed for tests
+  max_sessions_per_user: 5
+  webauthn:
+    rp_id: "localhost"
+    rp_name: "InferaDB Test"
+    origin: "http://localhost:3000"
+
+email:
+  smtp_host: "localhost"
+  smtp_port: 1025
+  from_email: "test@inferadb.local"
+  from_name: "InferaDB Test"
+
+rate_limiting:
+  login_attempts_per_ip_per_hour: 1000     # Relaxed for tests
+  registrations_per_ip_per_day: 100
+  email_verification_tokens_per_hour: 100
+  password_reset_tokens_per_hour: 100
+
+observability:
+  log_level: "debug"     # Verbose logging for tests
+  metrics_enabled: true
+  tracing_enabled: false
+
+id_generation:
+  worker_id: 0
+  max_clock_skew_ms: 5000
+
+server_api:
+  grpc_endpoint: "http://server:8080"  # Docker service name
+  tls_enabled: false

crates/infera-management-api/src/lib.rs

@@ -1,5 +1,11 @@
 // REST API handlers and routes
 
+use infera_management_core::ManagementConfig;
+use infera_management_grpc::ServerApiClient;
+use infera_management_storage::Backend;
+use std::sync::Arc;
+use tracing::info;
+
 pub mod audit;
 pub mod handlers;
 pub mod middleware;
@@ -15,3 +21,79 @@ pub use middleware::{
 };
 pub use pagination::{Paginated, PaginationMeta, PaginationParams, PaginationQuery};
 pub use routes::create_router_with_state;
+
+/// Graceful shutdown signal handler
+async fn shutdown_signal() {
+    use tokio::signal;
+
+    let ctrl_c = async {
+        signal::ctrl_c()
+            .await
+            .expect("failed to install Ctrl+C handler");
+    };
+
+    #[cfg(unix)]
+    let terminate = async {
+        signal::unix::signal(signal::unix::SignalKind::terminate())
+            .expect("failed to install SIGTERM handler")
+            .recv()
+            .await;
+    };
+
+    #[cfg(not(unix))]
+    let terminate = std::future::pending::<()>();
+
+    tokio::select! {
+        _ = ctrl_c => {
+            info!("Received Ctrl+C signal, initiating shutdown");
+        }
+        _ = terminate => {
+            info!("Received SIGTERM signal, initiating shutdown");
+        }
+    }
+}
+
+/// Start the Management API HTTP server
+pub async fn serve(
+    storage: Arc<Backend>,
+    config: Arc<ManagementConfig>,
+    server_client: Arc<ServerApiClient>,
+    worker_id: u16,
+    leader: Option<Arc<infera_management_core::LeaderElection<Backend>>>,
+    email_service: Option<Arc<infera_management_core::EmailService>>,
+) -> anyhow::Result<()> {
+    // Create AppState with services
+    let state = AppState::new(
+        storage,
+        config.clone(),
+        server_client,
+        worker_id,
+        leader,
+        email_service,
+    );
+
+    let app = create_router_with_state(state);
+
+    let addr = format!("{}:{}", config.server.http_host, config.server.http_port);
+    info!("Starting Management API HTTP server on {}", addr);
+
+    let listener = tokio::net::TcpListener::bind(&addr).await?;
+
+    // Setup graceful shutdown
+    let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel::<()>();
+
+    // Spawn task to handle shutdown signals
+    tokio::spawn(async move {
+        shutdown_signal().await;
+        let _ = shutdown_tx.send(());
+    });
+
+    // Serve with graceful shutdown
+    axum::serve(listener, app)
+        .with_graceful_shutdown(async {
+            shutdown_rx.await.ok();
+        })
+        .await?;
+
+    Ok(())
+}

crates/infera-management-core/src/repository_context.rs

@@ -4,15 +4,15 @@ use infera_management_storage::StorageBackend;
 /// Consolidated repository context to reduce boilerplate in handlers.
 ///
 /// Instead of manually instantiating repositories in every handler:
-/// ```rust
+/// ```rust,ignore
 /// let org_repo = OrganizationRepository::new((*state.storage).clone());
 /// let member_repo = OrganizationMemberRepository::new((*state.storage).clone());
 /// let team_repo = OrganizationTeamRepository::new((*state.storage).clone());
 /// // ... repeated 10-20 times
 /// ```
 ///
 /// You can now use:
-/// ```rust
+/// ```rust,ignore
 /// let repos = RepositoryContext::new(state.storage.clone());
 /// repos.org.create(...).await?;
 /// repos.member.list(...).await?;
@@ -59,7 +59,7 @@ impl<S: StorageBackend + Clone> RepositoryContext<S> {
     /// * `storage` - The storage backend to use for all repositories
     ///
     /// # Example
-    /// ```rust
+    /// ```rust,ignore
     /// let repos = RepositoryContext::new((*state.storage).clone());
     /// let user = repos.user.get(user_id).await?;
     /// ```

crates/infera-management/src/main.rs

@@ -1,6 +1,9 @@
 use anyhow::Result;
 use clap::Parser;
 use infera_management_core::{logging, ManagementConfig};
+use infera_management_grpc::ServerApiClient;
+use infera_management_storage::factory::{create_storage_backend, StorageConfig};
+use std::sync::Arc;
 
 #[derive(Parser, Debug)]
 #[command(name = "inferadb-management")]
@@ -42,15 +45,38 @@ async fn main() -> Result<()> {
         "Starting InferaDB Management API"
     );
 
-    // TODO: Initialize storage
-    // TODO: Start HTTP server
-    // TODO: Start gRPC server
+    // Initialize storage backend
+    tracing::info!(backend = %config.storage.backend, "Initializing storage backend");
+    let storage_config = match config.storage.backend.as_str() {
+        "memory" => StorageConfig::memory(),
+        "foundationdb" => StorageConfig::foundationdb(config.storage.fdb_cluster_file.clone()),
+        _ => anyhow::bail!("Invalid storage backend: {}", config.storage.backend),
+    };
+    let storage = Arc::new(create_storage_backend(&storage_config).await?);
+    tracing::info!("Storage backend initialized successfully");
 
-    tracing::info!("Management API started successfully");
+    // Initialize server API client (for gRPC communication with @server)
+    tracing::info!(endpoint = %config.server_api.grpc_endpoint, "Initializing server API client");
+    let server_client = Arc::new(ServerApiClient::new(config.server_api.grpc_endpoint.clone())?);
+    tracing::info!("Server API client initialized successfully");
 
-    // Keep running until interrupted
-    tokio::signal::ctrl_c().await?;
-    tracing::info!("Shutting down gracefully");
+    // Wrap config in Arc for sharing across services
+    let config = Arc::new(config);
+
+    // Start HTTP server
+    // Note: Leader election and email service are optional for now
+    // They can be initialized and passed when needed for multi-node deployments
+    tracing::info!("Starting HTTP server");
+    infera_management_api::serve(
+        storage.clone(),
+        config.clone(),
+        server_client.clone(),
+        config.id_generation.worker_id,
+        None, // leader election (optional, for multi-node)
+        None, // email service (optional, can be initialized later)
+    )
+    .await?;
 
+    tracing::info!("Shutting down gracefully");
     Ok(())
 }