Updated how api is structured in codora-framework-bot

Author: westshgit

crates/codora-framework-bot/__dump.rs

@@ -0,0 +1,52 @@
+use std::time::Duration;
+use tokio::sync::watch;
+use tracing::{info, trace};
+use tracing_subscriber::EnvFilter;
+
+#[allow(unreachable_code)]
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::new("trace"))
+        .init();
+
+    let ctrl_handler = async {
+        tokio::signal::ctrl_c()
+            .await
+            .inspect(|_| trace!("Signal Recieved, Resolving now!!!"))
+            .expect("Failed to install CTRL-C handler");
+    };
+    let (signal_sender, signal_reciever) = watch::channel(());
+
+    // This will resolve to drop the reciever when recieved
+    tokio::task::spawn(async {
+        ctrl_handler.await;
+        drop(signal_reciever);
+    });
+
+    let worker = async {
+        // This will continue running
+        loop {
+            tokio::time::sleep(Duration::from_secs(1)).await;
+            info!("[Worker]: working ...")
+        }
+    };
+
+    let close_signal_sender = async {
+        // Update all the reciever;
+        signal_sender
+            .send(())
+            .expect("Failed to send");
+        signal_sender.closed().await;
+    };
+
+    tokio::select! {
+        _ = worker => {
+            info!("[Worker]: should never execute");
+        }
+        result = close_signal_sender => {
+            info!("[Signal]: {:?}, shutting down and this is called because there's no reciever", result);
+        }
+    }
+    Ok(())
+}

crates/codora-framework-bot/examples/graceful.rs

@@ -0,0 +1,50 @@
+use http_body_util::Full;
+use hyper::{Request, Response, body::Bytes, server::conn::http2, service::service_fn};
+use hyper_util::rt::{TokioExecutor, TokioIo};
+use std::{convert::Infallible, pin::pin};
+use tokio::net::TcpListener;
+
+async fn handler(_: Request<impl hyper::body::Body>) -> Result<Response<Full<Bytes>>, Infallible> {
+    Ok(Response::new(Full::new(Bytes::from("Hello World!"))))
+}
+
+#[allow(unreachable_code)]
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt::init();
+
+    let listener = TcpListener::bind("127.0.0.1:3000").await?;
+
+    loop {
+        let (io, _) = listener.accept().await?;
+        let tokio_io = TokioIo::new(io);
+        // let resolve_now = async {};
+
+        tokio::task::spawn(async move {
+            let conn = http2::Builder::new(TokioExecutor::new())
+                .enable_connect_protocol()
+                .serve_connection(tokio_io, service_fn(handler));
+
+            let mut conn = pin!(conn);
+            // let mut resolve_now = pin!(resolve_now);
+
+            loop {
+                tokio::select! {
+                    result = conn.as_mut() =>  {
+                        if let Err(_err) = result {
+                            tracing::trace!("failed to serve connection: {_err:#}");
+                        }
+                        break;
+                    }
+                    // _ = &mut resolve_now => {
+                    //     tracing::trace!("signal received in task, starting graceful shutdown");
+                    //     conn.as_mut().graceful_shutdown();
+                    // }
+                }
+            }
+
+            Ok::<_, anyhow::Error>(())
+        });
+    }
+    Ok(())
+}

crates/codora-framework-bot/examples/hyper.rs

@@ -2,4 +2,6 @@
 pub mod discord;
 
 #[cfg(feature = "codora-framework-bot-telegram")]
+/// Telegram
+///
 pub mod telegram;

crates/codora-framework-bot/src/adapter/mod.rs

@@ -0,0 +1 @@
+pub mod message;

crates/codora-framework-worker/src/lib.rs …src/adapter/telegram/data/message/mod.rscrates/codora-framework-worker/src/lib.rs renamed to crates/codora-framework-bot/src/adapter/telegram/data/message/mod.rs crates/codora-framework-worker/src/lib.rs renamed to crates/codora-framework-bot/src/adapter/telegram/data/message/mod.rs

@@ -0,0 +1,29 @@
+pub trait Handler {
+    type Error;
+
+    fn handle(&self) -> impl Future<Output = Result<(), Self::Error>>;
+}
+
+#[derive(Debug)]
+pub struct HandlerFromFunc<F> {
+    handler: F,
+    // interceptor and other's goes in here
+}
+
+pub fn handler_from_func<F, Fut>(func: F) -> HandlerFromFunc<F>
+where
+    F: FnOnce() -> Fut,
+    // This is just a template fix later
+    Fut: Future<Output = Result<(), &'static str>>,
+{
+    HandlerFromFunc { handler: func }
+}
+
+impl<T> Handler for HandlerFromFunc<T> {
+    // Change this to valid error
+    type Error = &'static str;
+
+    async fn handle(&self) -> Result<(), Self::Error> {
+        todo!()
+    }
+}

crates/codora-framework-bot/src/adapter/telegram/data/mod.rs

@@ -0,0 +1,7 @@
+pub fn from_fn<F, Future>(func: F)
+where
+    F: FnOnce() -> Future,
+    Future: std::future::Future<Output = ()>,
+{
+    todo!()
+}

crates/codora-framework-bot/src/adapter/telegram/handler/mod.rs

@@ -0,0 +1 @@
+pub(super) mod from_fn;