main: refactor Kittybox construction

This allows proper separation of backend initialization and Kittybox
construction code. Some boilerplate is still present, but there's much
less of it now thanks to functions being generic.

1 files changed, 200 insertions, 192 deletions

diff --git a/kittybox-rs/src/main.rs b/kittybox-rs/src/main.rs
index 395bb31..3136924 100644
--- a/kittybox-rs/src/main.rs
+++ b/kittybox-rs/src/main.rs
@@ -2,39 +2,88 @@ use kittybox::database::FileStorage;
 use std::{env, time::Duration};
 use tracing::{debug, error, info};
 
-#[tokio::main]
-async fn main() {
-    use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Registry};
-    Registry::default()
-        .with(EnvFilter::from_default_env())
-        .with(tracing_subscriber::fmt::layer().json())
-        .init();
+fn init_media<A: kittybox::indieauth::backend::AuthBackend>(auth_backend: A, blobstore_uri: &str) -> axum::Router {
+    match blobstore_uri.split_once(':').unwrap().0 {
+        "file" => {
+            let folder = std::path::PathBuf::from(
+                blobstore_uri.strip_prefix("file://").unwrap()
+            );
+            let blobstore = kittybox::media::storage::file::FileStore::new(folder);
 
-    info!("Starting the kittybox server...");
+            kittybox::media::router::<_, _>(blobstore, auth_backend)
+        },
+        other => unimplemented!("Unsupported backend: {other}")
+    }
+}
 
-    let backend_uri: String = match env::var("BACKEND_URI") {
-        Ok(val) => {
-            debug!("Backend URI: {}", val);
-            val
-        }
-        Err(_) => {
-            error!("BACKEND_URI is not set, cannot find a database");
-            std::process::exit(1);
-        }
-    };
+async fn compose_kittybox_with_auth<A>(
+    http: reqwest::Client,
+    auth_backend: A,
+    backend_uri: &str,
+    blobstore_uri: &str
+) -> axum::Router
+where A: kittybox::indieauth::backend::AuthBackend
+{
+    match backend_uri.split_once(':').unwrap().0 {
+        "file" => {
+            let database = {
+                let folder = backend_uri.strip_prefix("file://").unwrap();
+                let path = std::path::PathBuf::from(folder);
+
+                match kittybox::database::FileStorage::new(path).await {
+                    Ok(db) => db,
+                    Err(err) => {
+                        error!("Error creating database: {:?}", err);
+                        std::process::exit(1);
+                    }
+                }
+            };
 
-    let listen_addr = match env::var("SERVE_AT")
-        .ok()
-        .unwrap_or_else(|| "[::]:8080".to_string())
-        .parse::<std::net::SocketAddr>()
-    {
-        Ok(addr) => addr,
-        Err(e) => {
-            error!("Cannot parse SERVE_AT: {}", e);
-            std::process::exit(1);
-        }
-    };
+            // Technically, if we don't construct the micropub router,
+            // we could use some wrapper that makes the database
+            // read-only.
+            //
+            // This would allow to exclude all code to write to the
+            // database and separate reader and writer processes of
+            // Kittybox to improve security.
+            let homepage: axum::routing::MethodRouter<_> = axum::routing::get(
+                kittybox::frontend::homepage::<FileStorage>
+            )
+                .layer(axum::Extension(database.clone()));
+            let fallback = axum::routing::get(
+                kittybox::frontend::catchall::<FileStorage>
+            )
+                .layer(axum::Extension(database.clone()));
+
+            let micropub = kittybox::micropub::router(
+                database.clone(),
+                http.clone(),
+                auth_backend.clone()
+            );
+            let onboarding = kittybox::frontend::onboarding::router(
+                database.clone(), http.clone()
+            );
+
+            axum::Router::new()
+                .route("/", homepage)
+                .fallback(fallback)
+                .route("/.kittybox/micropub", micropub)
+                .route("/.kittybox/onboarding", onboarding)
+                .nest("/.kittybox/media", init_media(auth_backend.clone(), blobstore_uri))
+                .merge(kittybox::indieauth::router(auth_backend.clone(), database.clone(), http.clone()))
+                .route(
+                    "/.kittybox/health",
+                    axum::routing::get(health_check::<kittybox::database::FileStorage>)
+                        .layer(axum::Extension(database))
+                )
+        },
+        "redis" => unimplemented!("Redis backend is not supported."),
 
+        other => unimplemented!("Unsupported backend: {other}")
+    }
+}
+
+async fn compose_kittybox(backend_uri: &str, blobstore_uri: &str, authstore_uri: &str) -> axum::Router {
     let http: reqwest::Client = {
         #[allow(unused_mut)]
         let mut builder = reqwest::Client::builder().user_agent(concat!(
@@ -48,178 +97,137 @@ async fn main() {
         builder.build().unwrap()
     };
 
-    if backend_uri.starts_with("redis") {
-        println!("The Redis backend is deprecated.");
-        std::process::exit(1);
-    } else if backend_uri.starts_with("file") {
-        let database = {
-            let folder = backend_uri.strip_prefix("file://").unwrap();
-            let path = std::path::PathBuf::from(folder);
-            match kittybox::database::FileStorage::new(path).await {
-                Ok(db) => db,
-                Err(err) => {
-                    error!("Error creating database: {:?}", err);
-                    std::process::exit(1);
-                }
-            }
-        };
+    let router = match authstore_uri.split_once(':').unwrap().0 {
+        "file" => {
+            let auth_backend = {
+                let folder = authstore_uri
+                    .strip_prefix("file://")
+                    .unwrap();
+                kittybox::indieauth::backend::fs::FileBackend::new(folder)
+            };
 
-        let blobstore = {
-            let variable = std::env::var("BLOBSTORE_URI")
-                .unwrap();
-            let folder = variable
-                .strip_prefix("file://")
-                .unwrap();
-            let path = std::path::PathBuf::from(folder);
-            kittybox::media::storage::file::FileStore::new(path)
-        };
+            compose_kittybox_with_auth(http, auth_backend, backend_uri, blobstore_uri).await
+        }
+        other => unimplemented!("Unsupported backend: {other}")
+    };
 
-        let auth_backend = {
-            let variable = std::env::var("AUTH_STORE_URI")
-                .unwrap();
-            let folder = variable
-                .strip_prefix("file://")
-                .unwrap();
-            kittybox::indieauth::backend::fs::FileBackend::new(folder)
-        };
+    router
+        .route(
+            "/.kittybox/static/:path",
+            axum::routing::get(kittybox::frontend::statics)
+        )
+        .route("/.kittybox/coffee", teapot_route())
+        .nest("/.kittybox/micropub/client", kittybox::companion::router())
+        .layer(tower::ServiceBuilder::new()
+            .layer(tower_http::trace::TraceLayer::new_for_http())
+            .into_inner())
+        .layer(tower_http::catch_panic::CatchPanicLayer::new())
+}
 
+fn teapot_route() -> axum::routing::MethodRouter {
+    axum::routing::get(|| async {
+        use axum::http::{header, StatusCode};
+        (StatusCode::IM_A_TEAPOT, [(header::CONTENT_TYPE, "text/plain")], "Sorry, can't brew coffee yet!")
+    })
+}
 
-        // This code proves that different components of Kittybox can
-        // be split up without hurting the app
-        //
-        // If needed, some features could be omitted from the binary
-        // or just not spun up in the future
-        //
-        // For example, the frontend code could run spearately from
-        // Micropub and only have read access to the database folder
-        let frontend = axum::Router::new()
-            .route(
-                "/",
-                axum::routing::get(kittybox::frontend::homepage::<FileStorage>)
-                    .layer(axum::Extension(database.clone())))
-            .route("/.kittybox/static/:path", axum::routing::get(kittybox::frontend::statics))
-            .fallback(
-                axum::routing::get(kittybox::frontend::catchall::<FileStorage>)
-                    .layer(axum::Extension(database.clone())));
-
-        // Onboarding is a bit of a special case. One might argue that
-        // the onboarding makes Kittybox a monolith. This is wrong.
-        // The "onboarding receiver" doesn't need any code from the
-        // onboarding form - they're grouped in a single module for
-        // convenience only, since modifying one usually requires
-        // updating the other to match.
-        //
-        // For example, this "router" just groups two separate methods
-        // in one request, because logically they live in the same
-        // subtree. But one could manually construct only one but not
-        // the other, to receive a "frontend-only" application. Of
-        // course, in this scenario, one must employ a reverse proxy
-        // to distinguish between GET and POST requests to the same
-        // path, and route them to the correct set of endpoints with
-        // write access.
-        let onboarding = axum::Router::new()
-            .route("/.kittybox/onboarding", kittybox::frontend::onboarding::router(
-                database.clone(), http.clone()
-            ));
+async fn health_check</*A, B, */D>(
+    //axum::Extension(auth): axum::Extension<A>,
+    //axum::Extension(blob): axum::Extension<B>,
+    axum::Extension(data): axum::Extension<D>,
+) -> impl axum::response::IntoResponse
+where
+    //A: kittybox::indieauth::backend::AuthBackend,
+    //B: kittybox::media::storage::MediaStore,
+    D: kittybox::database::Storage
+{
+    (axum::http::StatusCode::OK, std::borrow::Cow::Borrowed("OK"))
+}
 
-        let micropub = axum::Router::new()
-            .route("/.kittybox/micropub", kittybox::micropub::router(
-                database.clone(),
-                http.clone(),
-                auth_backend.clone()
-            ))
-            .nest("/.kittybox/micropub/client", kittybox::companion::router());
-
-        let media = axum::Router::new()
-            .nest("/.kittybox/media", kittybox::media::router(blobstore, auth_backend.clone()));
-
-        let indieauth = kittybox::indieauth::router(auth_backend, database.clone(), http.clone());
-
-        let technical = axum::Router::new()
-            .route(
-                "/.kittybox/coffee",
-                axum::routing::get(|| async {
-                    use axum::http::{header, StatusCode};
-                    (
-                        StatusCode::IM_A_TEAPOT,
-                        [(header::CONTENT_TYPE, "text/plain")],
-                        "Sorry, can't brew coffee yet!",
-                    )
-                }),
-            )
-            .route(
-                "/.kittybox/health",
-                axum::routing::get(
-                    |axum::Extension(db): axum::Extension<FileStorage>| async move {
-                        // TODO health-check the database
-                        "OK"
-                    }
-                )
-                    .layer(axum::Extension(database))
-            )
-            .route(
-                "/.kittybox/metrics",
-                axum::routing::get(|| async { todo!() }),
-            );
+#[tokio::main]
+async fn main() {
+    use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Registry};
+    Registry::default()
+        .with(EnvFilter::from_default_env())
+        .with(tracing_subscriber::fmt::layer().json())
+        .init();
 
-        let svc = axum::Router::new()
-            .merge(frontend)
-            .merge(onboarding)
-            .merge(micropub)
-            .merge(media)
-            .merge(indieauth)
-            .merge(technical)
-            .layer(tower::ServiceBuilder::new()
-                   .layer(tower_http::trace::TraceLayer::new_for_http())
-                   .into_inner())
-            .layer(tower_http::catch_panic::CatchPanicLayer::new());
-
-        // A little dance to turn a potential file descriptor into
-        // a guaranteed async network socket
-        let tcp_listener: std::net::TcpListener = {
-            let mut listenfd = listenfd::ListenFd::from_env();
-
-            let tcp_listener = if let Ok(Some(listener)) = listenfd.take_tcp_listener(0) {
-                listener
-            } else {
-                std::net::TcpListener::bind(listen_addr).unwrap()
-            };
-            // Set the socket to non-blocking so tokio can poll it
-            // properly -- this is the async magic!
-            tcp_listener.set_nonblocking(true).unwrap();
+    info!("Starting the kittybox server...");
 
-            tcp_listener
-        };
-        info!("Listening on {}", tcp_listener.local_addr().unwrap());
-
-        let server = hyper::server::Server::from_tcp(tcp_listener)
-            .unwrap()
-            // Otherwise Chrome keeps connections open for too long
-            .tcp_keepalive(Some(Duration::from_secs(30 * 60)))
-            .serve(svc.into_make_service())
-            .with_graceful_shutdown(async move {
-                // Defer to C-c handler whenever we're not on Unix
-                // TODO consider using a diverging future here
-                #[cfg(not(unix))]
-                return tokio::signal::ctrl_c().await.unwrap();
-                #[cfg(unix)]
-                {
-                    use tokio::signal::unix::{signal, SignalKind};
-
-                    signal(SignalKind::terminate())
-                        .unwrap()
-                        .recv()
-                        .await
-                        .unwrap()
-                }
-            });
+    let backend_uri: String = env::var("BACKEND_URI")
+        .unwrap_or_else(|_| {
+            error!("BACKEND_URI is not set, cannot find a database");
+            std::process::exit(1);
+        });
+    let blobstore_uri: String = env::var("BLOBSTORE_URI")
+        .unwrap_or_else(|_| {
+            error!("BLOBSTORE_URI is not set, can't find media store");
+            std::process::exit(1);
+        });
 
-        if let Err(err) = server.await {
-            error!("Error serving requests: {}", err);
+    let authstore_uri: String = env::var("AUTH_STORE_URI")
+        .unwrap_or_else(|_| {
+            error!("AUTH_STORE_URI is not set, can't find authentication store");
             std::process::exit(1);
-        }
-    } else {
-        println!("Unknown backend, not starting.");
+        });
+
+    let listen_addr = env::var("SERVE_AT")
+        .ok()
+        .unwrap_or_else(|| "[::]:8080".to_string())
+        .parse::<std::net::SocketAddr>()
+        .unwrap_or_else(|e| {
+            error!("Cannot parse SERVE_AT: {}", e);
+            std::process::exit(1);
+        });
+
+    let router = compose_kittybox(
+        backend_uri.as_str(),
+        blobstore_uri.as_str(),
+        authstore_uri.as_str()
+    ).await;
+
+    // A little dance to turn a potential file descriptor into
+    // a guaranteed async network socket
+    let tcp_listener: std::net::TcpListener = {
+        let mut listenfd = listenfd::ListenFd::from_env();
+
+        let tcp_listener = if let Ok(Some(listener)) = listenfd.take_tcp_listener(0) {
+            listener
+        } else {
+            std::net::TcpListener::bind(listen_addr).unwrap()
+        };
+        // Set the socket to non-blocking so tokio can poll it
+        // properly -- this is the async magic!
+        tcp_listener.set_nonblocking(true).unwrap();
+
+        tcp_listener
+    };
+    info!("Listening on {}", tcp_listener.local_addr().unwrap());
+
+    let server = hyper::server::Server::from_tcp(tcp_listener)
+        .unwrap()
+        // Otherwise Chrome keeps connections open for too long
+        .tcp_keepalive(Some(Duration::from_secs(30 * 60)))
+        .serve(router.into_make_service())
+        .with_graceful_shutdown(async move {
+            // Defer to C-c handler whenever we're not on Unix
+            // TODO consider using a diverging future here
+            #[cfg(not(unix))]
+            return tokio::signal::ctrl_c().await.unwrap();
+            #[cfg(unix)]
+            {
+                use tokio::signal::unix::{signal, SignalKind};
+
+                signal(SignalKind::terminate())
+                    .unwrap()
+                    .recv()
+                    .await
+                    .unwrap()
+            }
+        });
+
+    if let Err(err) = server.await {
+        error!("Error serving requests: {}", err);
         std::process::exit(1);
     }
 }