Fix/http lifecycle (#2)

* fix: support for HTTP services lifecycle API

* style: remove unnecessary comments

Author: rsfreitas

examples/services/grpc/src/main.rs

@@ -12,13 +12,13 @@ use helloworld::{HelloReply, HelloRequest};
 
 #[derive(Clone)]
 pub struct MyGreeter {
-    ctx: Box<Arc<mikros::FutureMutex<Context>>>
+    ctx: Arc<mikros::FutureMutex<Context>>
 }
 
 impl MyGreeter {
     pub fn new(ctx: Arc<mikros::FutureMutex<Context>>) -> Self {
         Self { 
-            ctx: Box::new(ctx)
+            ctx: ctx.clone()
         }
     }
 }
@@ -38,6 +38,7 @@ impl Greeter for MyGreeter {
             message: format!("Hello, {}!", request.into_inner().name),
         };
 
+        self.ctx.lock().await.value += 1;
         Ok(Response::new(reply))
     }
 }

examples/services/http/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+async-trait = "0.1.83"
 axum = "0.7.7"
 mikros = { path = "../../../" }
 tokio = { version = "1.41.1", features = ["full"] }

examples/services/http/src/main.rs

@@ -1,10 +1,13 @@
+use std::any::Any;
 use std::sync::Arc;
 
 use axum::extract::State;
 use axum::routing::get;
+use futures::lock::Mutex;
 use mikros::FutureMutex;
 use mikros::http::ServiceState;
 use mikros::service::builder::ServiceBuilder;
+use mikros::service::lifecycle::Lifecycle;
 
 #[derive(Clone, Default)]
 pub struct AppState {
@@ -17,6 +20,39 @@ impl AppState {
     }
 }
 
+#[async_trait::async_trait]
+impl Lifecycle for AppState {
+    async fn on_start(&mut self) -> mikros::errors::Result<()> {
+        println!("service on_start");
+        self.value = 42;
+        Ok(())
+    }
+
+    async fn on_finish(&self) -> mikros::errors::Result<()> {
+        println!("service on_finish");
+        Ok(())
+    }
+}
+
+#[derive(Clone)]
+pub struct AppLifecycle {
+    state: Arc<Mutex<dyn Any + Send + Sync>>,
+}
+
+#[async_trait::async_trait]
+impl Lifecycle for AppLifecycle {
+    async fn on_start(&mut self) -> mikros::errors::Result<()> {
+        println!("service on_start");
+        self.state.lock().await.downcast_mut::<AppState>().unwrap().value = 42;
+        Ok(())
+    }
+    
+    async fn on_finish(&self) -> mikros::errors::Result<()> {
+        println!("service on_finish");
+        Ok(())
+    }
+}
+
 // Handler method for the first endpoint
 async fn handler_one(State(state): State<Arc<FutureMutex<ServiceState>>>) -> String {
     println!("Handler One");
@@ -47,9 +83,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .route("/one", get(handler_one))
         .route("/two", get(handler_two));
 
-    let state = AppState::default();
+    //let state = Arc::new(Mutex::new(Box::new(AppState::default()) as Box<dyn Any + Send + Sync>));
+    let state = Arc::new(Mutex::new(AppState::default()));
+//    let lifecycle = Arc::new(Mutex::new(AppLifecycle { state: state.clone(), }));
+
     let svc = ServiceBuilder::default()
-        .http_with_state(api, Box::new(state))
+        //.http_with_lifecycle_and_state(api, lifecycle.clone(), state.clone())
+        .http_with_lifecycle_and_state(api, state.clone(), state.clone())
+//        .http_with_lifecycle(api, Box::new(state))
+//        .http_with_state(api, Box::new(state))
 //        .http(api)
         .build();
 

examples/services/native/src/main.rs

@@ -1,19 +1,14 @@
 mod service;
 
-extern crate mikros;
-
-use std::sync::Arc;
-
-use mikros::FutureMutex;
 use mikros::service::builder::{ServiceBuilder};
 use service::Service as AppService;
 
 #[tokio::main]
 async fn main() {
-    let s = Arc::new(FutureMutex::new(AppService::new()));
+    let s = AppService::new();
     let svc = ServiceBuilder::default()
-        .script(s.clone())
-        .native(s.clone())
+//        .script(Box::new(s))
+        .native(Box::new(s))
         .build();
 
     match svc {

src/http/mod.rs

@@ -36,7 +36,7 @@ pub struct ServiceState {
     /// }
     /// ```
     ///
-    pub app_state: Option<Arc<Mutex<Box<dyn Any + Send + Sync>>>>,
+    pub app_state: Option<Arc<Mutex<dyn Any + Send + Sync>>>,
 }
 
 impl ServiceState {
@@ -47,9 +47,9 @@ impl ServiceState {
         }
     }
 
-    pub(crate) fn new_with_state(context: &Context, internal_state: Arc<Mutex<Box<dyn Any + Send + Sync>>>) -> Self {
+    pub(crate) fn new_with_state(context: &Context, internal_state: Arc<Mutex<dyn Any + Send + Sync>>) -> Self {
         let mut s = Self::new(context);
-        s.app_state = Some(internal_state);
+        s.app_state = Some(internal_state.clone());
         s
     }
 

src/service/builder.rs

@@ -38,20 +38,14 @@ impl ServiceBuilder {
 
     /// Initializes the native service type with the required structure
     /// implementing its API.
-    pub fn native<S>(mut self, svc: Arc<Mutex<S>>) -> Self
-    where
-        S: NativeService + 'static
-    {
+    pub fn native(mut self, svc: Box<dyn NativeService>) -> Self {
         self.servers.insert(definition::ServiceKind::Native.to_string(), Box::new(Native::new(svc)));
         self
     }
 
     /// Initializes the script service type with the required structure
     /// implementing its API.
-    pub fn script<S>(mut self, svc: Arc<Mutex<S>>) -> Self
-    where
-        S: ScriptService + 'static
-    {
+    pub fn script(mut self, svc: Box<dyn ScriptService>) -> Self {
         self.servers.insert(definition::ServiceKind::Script.to_string(), Box::new(Script::new(svc)));
         self
     }
@@ -75,7 +69,7 @@ impl ServiceBuilder {
     /// Initializes the gRPC service type with the required structure
     /// implementing its API and another with implementing the Lifecycle
     /// API.
-    pub fn grpc_with_lifecycle<S, B>(mut self, server: S, lifecycle: Arc<Mutex<B>>) -> Self
+    pub fn grpc_with_lifecycle<S, L>(mut self, server: S, lifecycle: Arc<Mutex<L>>) -> Self
     where
         S: tonic::codegen::Service<Request<BoxBody>, Response = Response<BoxBody>, Error = Infallible>
             + NamedService
@@ -84,7 +78,7 @@ impl ServiceBuilder {
             + Sync
             + 'static,
         S::Future: Send + 'static,
-        B: Lifecycle + 'static
+        L: Lifecycle + 'static
     {
         self.servers.insert(definition::ServiceKind::Grpc.to_string(), Box::new(Grpc::new_with_lifecycle(server, lifecycle)));
         self
@@ -111,7 +105,10 @@ impl ServiceBuilder {
     /// Initializes the HTTP service type with the required structure
     /// implementing the service endpoint handlers. It also receives an
     /// object that will be passed inside the handlers state.
-    pub fn http_with_state(mut self, router: Router<Arc<Mutex<ServiceState>>>, state: Box<dyn Any + Send + Sync>) -> Self {
+    pub fn http_with_state<S>(mut self, router: Router<Arc<Mutex<ServiceState>>>, state: Arc<Mutex<S>>) -> Self
+    where
+        S: Any + Send + Sync
+    {
         self.servers.insert(definition::ServiceKind::Http.to_string(), Box::new(Http::new_with_state(router, state)));
         self
     }
@@ -120,9 +117,10 @@ impl ServiceBuilder {
     /// implementing the service endpoint handlers and another with
     /// implementing the Lifecycle API. It also receives an object that
     /// will be passed inside the handlers state.
-    pub fn http_with_lifecycle_and_state<L>(mut self, router: Router<Arc<Mutex<ServiceState>>>, lifecycle: Arc<Mutex<L>>, state: Box<dyn Any + Send + Sync>) -> Self
+    pub fn http_with_lifecycle_and_state<L, S>(mut self, router: Router<Arc<Mutex<ServiceState>>>, lifecycle: Arc<Mutex<L>>, state: Arc<Mutex<S>>) -> Self
     where
         L: Lifecycle + 'static,
+        S: Any + Send + Sync
     {
         self.servers.insert(definition::ServiceKind::Http.to_string(), Box::new(Http::new_with_lifecycle_and_state(router, lifecycle, state)));
         self

src/service/grpc/mod.rs

@@ -21,7 +21,7 @@ use crate::service::lifecycle::Lifecycle;
 pub(crate) struct Grpc<S> {
     port: i32,
     server: S,
-    lifecycle: Option<Box<Arc<Mutex<dyn Lifecycle>>>>,
+    lifecycle: Option<Arc<Mutex<dyn Lifecycle>>>,
 }
 
 impl<S> Grpc<S>
@@ -34,11 +34,11 @@ where
         + 'static,
     S::Future: Send + 'static,
 {
-    pub(crate) fn new_with_lifecycle<B: Lifecycle + 'static>(server: S, lifecycle: Arc<Mutex<B>>) -> Self {
+    pub(crate) fn new_with_lifecycle<L: Lifecycle + 'static>(server: S, lifecycle: Arc<Mutex<L>>) -> Self {
         Self {
             port: 0,
             server,
-            lifecycle: Some(Box::new(lifecycle)),
+            lifecycle: Some(lifecycle.clone()),
         }
     }
 

src/service/http/mod.rs

@@ -17,8 +17,8 @@ use crate::{definition, env, errors as merrors, plugin};
 pub(crate) struct Http {
     port: i32,
     router: Router<Arc<Mutex<ServiceState>>>,
-    lifecycle: Option<Box<Arc<Mutex<dyn Lifecycle>>>>,
-    app_state: Option<Arc<Mutex<Box<dyn Any + Send + Sync>>>>,
+    lifecycle: Option<Arc<Mutex<dyn Lifecycle>>>,
+    app_state: Option<Arc<Mutex<dyn Any + Send + Sync>>>,
 }
 
 impl Http {
@@ -36,23 +36,23 @@ impl Http {
         L: Lifecycle + 'static,
     {
         let mut s = Self::new(router);
-        s.lifecycle = Some(Box::new(lifecycle));
+        s.lifecycle = Some(lifecycle.clone());
         s
     }
 
-    pub fn new_with_state(router: Router<Arc<Mutex<ServiceState>>>, state: Box<dyn Any + Send + Sync>) -> Self {
+    pub fn new_with_state(router: Router<Arc<Mutex<ServiceState>>>, state: Arc<Mutex<dyn Any + Send + Sync>>) -> Self {
         let mut s = Self::new(router);
-        s.app_state = Some(Arc::new(Mutex::new(state)));
+        s.app_state = Some(state.clone());
         s
     }
 
-    pub fn new_with_lifecycle_and_state<L>(router: Router<Arc<Mutex<ServiceState>>>, lifecycle: Arc<Mutex<L>>, state: Box<dyn Any + Send + Sync>) -> Self
+    pub fn new_with_lifecycle_and_state<L>(router: Router<Arc<Mutex<ServiceState>>>, lifecycle: Arc<Mutex<L>>, state: Arc<Mutex<dyn Any + Send + Sync>>) -> Self
     where
         L: Lifecycle + 'static,
     {
         let mut s = Self::new(router);
-        s.lifecycle = Some(Box::new(lifecycle));
-        s.app_state = Some(Arc::new(Mutex::new(state)));
+        s.lifecycle = Some(lifecycle.clone());
+        s.app_state = Some(state.clone());
         s
     }
 }

src/service/native/mod.rs

@@ -1,13 +1,13 @@
 use std::collections::HashMap;
-use std::sync::{Arc};
+use std::sync::Arc;
 
 use futures::lock::Mutex;
 use logger::fields::FieldValue;
 use tokio::sync::watch;
 
-use crate::{definition, env, errors as merrors, plugin};
 use crate::service::context::Context;
 use crate::service::lifecycle::Lifecycle;
+use crate::{definition, env, errors as merrors, plugin};
 
 #[async_trait::async_trait]
 pub trait NativeService: NativeServiceClone + Lifecycle + Send + Sync {
@@ -43,13 +43,13 @@ impl Clone for Box<dyn NativeService> {
 
 #[derive(Clone)]
 pub(crate) struct Native {
-    svc: Box<Arc<Mutex<dyn NativeService>>>,
+    svc: Arc<Mutex<Box<dyn NativeService>>>,
 }
 
 impl Native {
-    pub fn new<S: NativeService + 'static>(svc: Arc<Mutex<S>>) -> Self {
+    pub fn new(svc: Box<dyn NativeService>) -> Self {
         Self {
-            svc: Box::new(svc),
+            svc: Arc::new(Mutex::new(svc)),
         }
     }
 }

src/service/script/mod.rs

@@ -36,13 +36,13 @@ impl Clone for Box<dyn ScriptService> {
 
 #[derive(Clone)]
 pub(crate) struct Script {
-    svc: Box<Arc<Mutex<dyn ScriptService>>>,
+    svc: Arc<Mutex<Box<dyn ScriptService>>>,
 }
 
 impl Script {
-    pub fn new<S: ScriptService + 'static>(svc: Arc<Mutex<S>>) -> Self {
+    pub fn new(svc: Box<dyn ScriptService>) -> Self {
         Self {
-            svc: Box::new(svc),
+            svc: Arc::new(Mutex::new(svc)),
         }
     }
 }