feat: add churn v2

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/churn/Cargo.toml

@@ -15,3 +15,6 @@ axum.workspace = true
 serde = { version = "1.0.197", features = ["derive"] }
 uuid = { version = "1.7.0", features = ["v4"] }
 tower-http = { version = "0.5.2", features = ["cors", "trace"] }
+notmad = "0.5.0"
+tokio-util = "0.7.12"
+async-trait = "0.1.83"

crates/churn/src/api.rs

@@ -0,0 +1,65 @@
+use std::net::SocketAddr;
+
+use axum::{extract::MatchedPath, http::Request, routing::get, Router};
+use tokio_util::sync::CancellationToken;
+use tower_http::trace::TraceLayer;
+
+use crate::state::SharedState;
+
+pub struct Api {
+    state: SharedState,
+    host: SocketAddr,
+}
+
+impl Api {
+    pub fn new(state: impl Into<SharedState>, host: impl Into<SocketAddr>) -> Self {
+        Self {
+            state: state.into(),
+            host: host.into(),
+        }
+    }
+
+    pub async fn serve(&self) -> anyhow::Result<()> {
+        let app = Router::new()
+            .route("/", get(root))
+            .with_state(self.state.clone())
+            .layer(
+                TraceLayer::new_for_http().make_span_with(|request: &Request<_>| {
+                    // Log the matched route's path (with placeholders not filled in).
+                    // Use request.uri() or OriginalUri if you want the real path.
+                    let matched_path = request
+                        .extensions()
+                        .get::<MatchedPath>()
+                        .map(MatchedPath::as_str);
+
+                    tracing::info_span!(
+                        "http_request",
+                        method = ?request.method(),
+                        matched_path,
+                        some_other_field = tracing::field::Empty,
+                    )
+                }), // ...
+            );
+
+        tracing::info!("listening on {}", self.host);
+        let listener = tokio::net::TcpListener::bind(&self.host).await.unwrap();
+        axum::serve(listener, app.into_make_service())
+            .await
+            .unwrap();
+
+        Ok(())
+    }
+}
+
+async fn root() -> &'static str {
+    "Hello, churn!"
+}
+
+#[async_trait::async_trait]
+impl notmad::Component for Api {
+    async fn run(&self, _cancellation_token: CancellationToken) -> Result<(), notmad::MadError> {
+        self.serve().await.map_err(notmad::MadError::Inner)?;
+
+        Ok(())
+    }
+}

crates/churn/src/cli.rs

@@ -0,0 +1,36 @@
+use std::net::SocketAddr;
+
+use clap::{Parser, Subcommand};
+
+use crate::{api, state::SharedState};
+
+pub async fn execute() -> anyhow::Result<()> {
+    let state = SharedState::new().await?;
+
+    let cli = Command::parse();
+    if let Some(Commands::Serve { host }) = cli.command {
+        tracing::info!("Starting service");
+
+        notmad::Mad::builder()
+            .add(api::Api::new(&state, host))
+            .run()
+            .await?;
+    }
+
+    Ok(())
+}
+
+#[derive(Parser)]
+#[command(author, version, about, long_about = None, subcommand_required = true)]
+struct Command {
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    Serve {
+        #[arg(env = "SERVICE_HOST", long, default_value = "127.0.0.1:3000")]
+        host: SocketAddr,
+    },
+}

crates/churn/src/main.rs

@@ -1,91 +1,13 @@
-use std::{net::SocketAddr, ops::Deref, sync::Arc};
-
-use anyhow::Context;
-use axum::extract::MatchedPath;
-use axum::http::Request;
-use axum::Router;
-use axum::routing::get;
-use clap::{Parser, Subcommand};
-use tower_http::trace::TraceLayer;
-
-#[derive(Parser)]
-#[command(author, version, about, long_about = None, subcommand_required = true)]
-struct Command {
-    #[command(subcommand)]
-    command: Option<Commands>,
-}
-
-#[derive(Subcommand)]
-enum Commands {
-    Serve {
-        #[arg(env = "SERVICE_HOST", long, default_value = "127.0.0.1:3000")]
-        host: SocketAddr,
-    },
-}
+mod api;
+mod cli;
+mod state;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     dotenv::dotenv().ok();
     tracing_subscriber::fmt::init();
 
-    let cli = Command::parse();
-
-    if let Some(Commands::Serve { host }) = cli.command {
-        tracing::info!("Starting service");
-
-        let state = SharedState(Arc::new(State::new().await?));
-
-        let app = Router::new()
-            .route("/", get(root))
-            .with_state(state.clone())
-            .layer(
-                TraceLayer::new_for_http().make_span_with(|request: &Request<_>| {
-                    // Log the matched route's path (with placeholders not filled in).
-                    // Use request.uri() or OriginalUri if you want the real path.
-                    let matched_path = request
-                        .extensions()
-                        .get::<MatchedPath>()
-                        .map(MatchedPath::as_str);
-
-                    tracing::info_span!(
-                        "http_request",
-                        method = ?request.method(),
-                        matched_path,
-                        some_other_field = tracing::field::Empty,
-                    )
-                }), // ...
-            );
-
-        tracing::info!("listening on {}", host);
-        let listener = tokio::net::TcpListener::bind(host).await.unwrap();
-        axum::serve(listener, app.into_make_service())
-            .await
-            .unwrap();
-    }
+    cli::execute().await?;
 
     Ok(())
 }
-
-async fn root() -> &'static str {
-    "Hello, churn!"
-}
-
-#[derive(Clone)]
-pub struct SharedState(Arc<State>);
-
-impl Deref for SharedState {
-    type Target = Arc<State>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-pub struct State {}
-
-impl State {
-    pub async fn new() -> anyhow::Result<Self> {
-        Ok(Self {})
-    }
-}
-

crates/churn/src/state.rs

@@ -0,0 +1,32 @@
+use std::{ops::Deref, sync::Arc};
+
+#[derive(Clone)]
+pub struct SharedState(Arc<State>);
+
+impl SharedState {
+    pub async fn new() -> anyhow::Result<Self> {
+        Ok(Self(Arc::new(State::new().await?)))
+    }
+}
+
+impl From<&SharedState> for SharedState {
+    fn from(value: &SharedState) -> Self {
+        value.clone()
+    }
+}
+
+impl Deref for SharedState {
+    type Target = Arc<State>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+pub struct State {}
+
+impl State {
+    pub async fn new() -> anyhow::Result<Self> {
+        Ok(Self {})
+    }
+}