feat: add add_fn to execute immediate lambdas

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

crates/mad/examples/basic/main.rs

@@ -0,0 +1,40 @@
+use async_trait::async_trait;
+use rand::Rng;
+use tokio_util::sync::CancellationToken;
+use tracing::Level;
+
+struct WaitServer {}
+#[async_trait]
+impl mad::Component for WaitServer {
+    fn name(&self) -> Option<String> {
+        Some("WaitServer".into())
+    }
+
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+        let millis_wait = rand::thread_rng().gen_range(500..3000);
+
+        tracing::debug!("waiting: {}ms", millis_wait);
+
+        // Simulates a server running for some time. Is normally supposed to be futures blocking indefinitely
+        tokio::time::sleep(std::time::Duration::from_millis(millis_wait)).await;
+
+        Ok(())
+    }
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_max_level(Level::TRACE)
+        .init();
+
+    mad::Mad::builder()
+        .add(WaitServer {})
+        .add(WaitServer {})
+        .add(WaitServer {})
+        .add(WaitServer {})
+        .run()
+        .await?;
+
+    Ok(())
+}

crates/mad/examples/error_log/main.rs

@@ -0,0 +1,42 @@
+use async_trait::async_trait;
+use rand::Rng;
+use tokio_util::sync::CancellationToken;
+use tracing::Level;
+
+struct ErrorServer {}
+#[async_trait]
+impl mad::Component for ErrorServer {
+    fn name(&self) -> Option<String> {
+        Some("ErrorServer".into())
+    }
+
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+        let millis_wait = rand::thread_rng().gen_range(500..3000);
+
+        tracing::debug!("waiting: {}ms", millis_wait);
+
+        // Simulates a server running for some time. Is normally supposed to be futures blocking indefinitely
+        tokio::time::sleep(std::time::Duration::from_millis(millis_wait)).await;
+
+        Err(mad::MadError::Inner(anyhow::anyhow!("expected error")))
+    }
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_max_level(Level::TRACE)
+        .init();
+
+    // Do note that only the first server which returns an error is guaranteed to be handled. This is because if servers don't respect cancellation, they will be dropped
+
+    mad::Mad::builder()
+        .add(ErrorServer {})
+        .add(ErrorServer {})
+        .add(ErrorServer {})
+        .add(ErrorServer {})
+        .run()
+        .await?;
+
+    Ok(())
+}

crates/mad/examples/fn/main.rs

@@ -0,0 +1,47 @@
+use async_trait::async_trait;
+use rand::Rng;
+use tokio_util::sync::CancellationToken;
+use tracing::Level;
+
+struct WaitServer {}
+#[async_trait]
+impl mad::Component for WaitServer {
+    fn name(&self) -> Option<String> {
+        Some("WaitServer".into())
+    }
+
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+        let millis_wait = rand::thread_rng().gen_range(500..3000);
+
+        tracing::debug!("waiting: {}ms", millis_wait);
+
+        // Simulates a server running for some time. Is normally supposed to be futures blocking indefinitely
+        tokio::time::sleep(std::time::Duration::from_millis(millis_wait)).await;
+
+        Ok(())
+    }
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_max_level(Level::TRACE)
+        .init();
+
+    mad::Mad::builder()
+        .add(WaitServer {})
+        .add_fn(|cancel| async move {
+            let millis_wait = 50;
+
+            tracing::debug!("waiting: {}ms", millis_wait);
+
+            // Simulates a server running for some time. Is normally supposed to be futures blocking indefinitely
+            tokio::time::sleep(std::time::Duration::from_millis(millis_wait)).await;
+
+            Ok(())
+        })
+        .run()
+        .await?;
+
+    Ok(())
+}

crates/mad/examples/signals/main.rs

@@ -0,0 +1,69 @@
+use async_trait::async_trait;
+use rand::Rng;
+use tokio_util::sync::CancellationToken;
+use tracing::Level;
+
+struct WaitServer {}
+#[async_trait]
+impl mad::Component for WaitServer {
+    fn name(&self) -> Option<String> {
+        Some("WaitServer".into())
+    }
+
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+        let millis_wait = rand::thread_rng().gen_range(500..3000);
+
+        tracing::debug!("waiting: {}ms", millis_wait);
+
+        // Simulates a server running for some time. Is normally supposed to be futures blocking indefinitely
+        tokio::time::sleep(std::time::Duration::from_millis(millis_wait)).await;
+
+        Ok(())
+    }
+}
+
+struct RespectCancel {}
+#[async_trait]
+impl mad::Component for RespectCancel {
+    fn name(&self) -> Option<String> {
+        Some("RespectCancel".into())
+    }
+
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+        cancellation.cancelled().await;
+        tracing::debug!("stopping because job is cancelled");
+
+        Ok(())
+    }
+}
+
+struct NeverStopServer {}
+#[async_trait]
+impl mad::Component for NeverStopServer {
+    fn name(&self) -> Option<String> {
+        Some("NeverStopServer".into())
+    }
+
+    async fn run(&self, cancellation: CancellationToken) -> Result<(), mad::MadError> {
+        // Simulates a server running for some time. Is normally supposed to be futures blocking indefinitely
+        tokio::time::sleep(std::time::Duration::from_millis(999999999)).await;
+
+        Ok(())
+    }
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_max_level(Level::TRACE)
+        .init();
+
+    mad::Mad::builder()
+        .add(WaitServer {})
+        .add(NeverStopServer {})
+        .add(RespectCancel {})
+        .run()
+        .await?;
+
+    Ok(())
+}