Initial commit

backend/src/bin/maintenance.rs

@@ -0,0 +1,75 @@
+use std::env;
+
+use anyhow::{Context, Result};
+use diesel::prelude::*;
+
+use backend::{
+    config::AppConfig,
+    db,
+    models::DocumentAsset,
+    s3,
+    schema::document_assets,
+    storage::{ObjectStorage, S3Storage},
+};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let mut args = env::args().skip(1);
+    match args.next().as_deref() {
+        Some("delete-assets") => delete_all_assets().await?,
+        Some(cmd) => {
+            eprintln!("Unknown command: {cmd}\nUsage: maintenance delete-assets");
+            std::process::exit(1);
+        }
+        None => {
+            eprintln!("Usage: maintenance delete-assets");
+            std::process::exit(1);
+        }
+    }
+
+    Ok(())
+}
+
+async fn delete_all_assets() -> Result<()> {
+    let config = AppConfig::from_env()?;
+    tracing::info!(
+        component = "maintenance",
+        database_url = %config.redacted_database_url(),
+        pool_size = config.database_max_pool_size,
+        s3_bucket = %config.s3_bucket,
+        "loaded backend configuration"
+    );
+    let pool = db::init_pool_with_size(&config.database_url, config.database_max_pool_size)?;
+
+    let s3_client = s3::build_client(&config).await?;
+    let storage = S3Storage::new(s3_client, config.s3_bucket.clone());
+
+    let mut conn = pool.get().context("failed to get database connection")?;
+
+    let assets: Vec<DocumentAsset> = document_assets::table
+        .load(&mut conn)
+        .context("failed to load document assets")?;
+
+    if assets.is_empty() {
+        println!("No assets found.");
+        return Ok(());
+    }
+
+    println!("Deleting {} assets…", assets.len());
+
+    for asset in &assets {
+        if let Err(err) = storage.delete_object(&asset.s3_key).await {
+            eprintln!(
+                "Failed to delete object {} from storage: {err}",
+                asset.s3_key
+            );
+        }
+    }
+
+    diesel::delete(document_assets::table)
+        .execute(&mut conn)
+        .context("failed to remove asset records")?;
+
+    println!("Asset records deleted.");
+    Ok(())
+}

backend/src/bin/webdav.rs

@@ -0,0 +1,60 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use tokio::net::TcpListener;
+use tower::make::Shared;
+use tracing_subscriber::EnvFilter;
+
+use backend::auth::jwt::JwtService;
+use backend::config::AppConfig;
+use backend::db;
+use backend::routes::webdav;
+use backend::s3::build_client;
+use backend::state::AppState;
+use backend::storage::S3Storage;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    dotenv::dotenv().ok();
+    init_tracing();
+
+    let config = AppConfig::from_env()?;
+    tracing::info!(
+        component = "webdav",
+        database_url = %config.redacted_database_url(),
+        pool_size = config.database_max_pool_size,
+        server_host = %config.server_host,
+        server_port = config.server_port,
+        webdav_host = %config.webdav_host,
+        webdav_port = config.webdav_port,
+        quickwit_enabled = config.quickwit_endpoint.is_some(),
+        s3_bucket = %config.s3_bucket,
+        "loaded backend configuration"
+    );
+    let pool = db::init_pool_with_size(&config.database_url, config.database_max_pool_size)?;
+    let s3_client = build_client(&config).await?;
+    let storage = Arc::new(S3Storage::new(s3_client, config.s3_bucket.clone()));
+    let jwt = JwtService::from_config(&config)?;
+
+    let state = AppState::new(pool, config, storage, jwt);
+    let listen_addr: SocketAddr = {
+        let config = state.config.clone();
+        format!("{}:{}", config.webdav_host, config.webdav_port).parse()?
+    };
+    let router = webdav::create_router().with_state(state);
+
+    let listener = TcpListener::bind(listen_addr).await?;
+    tracing::info!("listening for WebDAV on {}", listen_addr);
+
+    axum::serve(listener, Shared::new(router)).await?;
+    Ok(())
+}
+
+fn init_tracing() {
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+    tracing_subscriber::fmt()
+        .with_env_filter(filter)
+        .with_target(false)
+        .compact()
+        .init();
+}

backend/src/bin/worker.rs

@@ -0,0 +1,50 @@
+use std::{sync::Arc, time::Duration};
+
+use tokio::signal;
+use tracing_subscriber::EnvFilter;
+
+use backend::{
+    auth::jwt::JwtService, config::AppConfig, db, default_handlers, s3::build_client,
+    state::AppState, storage::S3Storage, Worker,
+};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    dotenv::dotenv().ok();
+    init_tracing();
+
+    let config = AppConfig::from_env()?;
+    tracing::info!(
+        component = "worker",
+        database_url = %config.redacted_database_url(),
+        pool_size = 1,
+        quickwit_enabled = config.quickwit_endpoint.is_some(),
+        s3_bucket = %config.s3_bucket,
+        "loaded backend configuration"
+    );
+    let pool = db::init_pool_with_size(&config.database_url, 1)?;
+    let s3_client = build_client(&config).await?;
+    let storage = Arc::new(S3Storage::new(s3_client, config.s3_bucket.clone()));
+    let jwt = JwtService::from_config(&config)?;
+
+    let state = Arc::new(AppState::new(pool, config, storage, jwt));
+    let worker = Worker::new(state, default_handlers(), Duration::from_secs(2));
+
+    tokio::select! {
+        _ = worker.run() => {}
+        _ = signal::ctrl_c() => {
+            tracing::info!("worker received shutdown signal");
+        }
+    }
+
+    Ok(())
+}
+
+fn init_tracing() {
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+    tracing_subscriber::fmt()
+        .with_env_filter(filter)
+        .with_target(false)
+        .compact()
+        .init();
+}