fix: grpc services lifecycle usage

Author: rsfreitas

examples/services/grpc/src/main.rs

@@ -12,12 +12,14 @@ use helloworld::{HelloReply, HelloRequest};
 
 #[derive(Clone)]
 pub struct MyGreeter {
-    ctx: Arc<mikros::FutureMutex<Box<Context>>>
+    ctx: Box<Arc<mikros::FutureMutex<Context>>>
 }
 
 impl MyGreeter {
-    pub fn new(ctx: Arc<mikros::FutureMutex<Box<Context>>>) -> Self {
-        Self { ctx }
+    pub fn new(ctx: Arc<mikros::FutureMutex<Context>>) -> Self {
+        Self { 
+            ctx: Box::new(ctx)
+        }
     }
 }
 
@@ -60,12 +62,13 @@ impl lifecycle::Lifecycle for Context {
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let ctx = Arc::new(mikros::FutureMutex::new(Box::new(Context{ value: 0 })));
+    let ctx = Arc::new(mikros::FutureMutex::new(Context{ value: 0 }));
     let greeter = Arc::new(MyGreeter::new(ctx.clone()));
     let greeter_service = GreeterServer::from_arc(greeter);
 
     let svc = ServiceBuilder::default()
-        .grpc(greeter_service, &ctx)
+//        .grpc(greeter_service)
+        .grpc_with_lifecycle(greeter_service, ctx.clone())
         .build();
 
     match svc {

src/plugin/service.rs

@@ -32,6 +32,6 @@ where
 
 impl Clone for Box<dyn Service> {
     fn clone(&self) -> Self {
-        self.clone_box()
+        ServiceClone::clone_box(self.as_ref())
     }
 }

src/service/builder.rs

@@ -29,19 +29,23 @@ impl ServiceBuilder {
         }
     }
 
-    /// Sets the current service as a native type.
+    /// Initializes the native service type with the required structure
+    /// implementing its API.
     pub fn native<S: NativeService + 'static>(mut self, svc: Arc<Mutex<S>>) -> Self {
         self.servers.insert(definition::ServiceKind::Native.to_string(), Box::new(Native::new(svc)));
         self
     }
 
-    /// Sets the current service as a script type.
+    /// Initializes the script service type with the required structure
+    /// implementing its API.
     pub fn script<S: ScriptService + 'static>(mut self, svc: Arc<Mutex<S>>) -> Self {
         self.servers.insert(definition::ServiceKind::Script.to_string(), Box::new(Script::new(svc)));
         self
     }
 
-    pub fn grpc<S, B>(mut self, server: S, lifecycle: &Arc<Mutex<Box<B>>>) -> Self
+    /// Initializes the grpc service type with the required structure
+    /// implementing its API.
+    pub fn grpc<S>(mut self, server: S) -> Self
     where
         S: tonic::codegen::Service<Request<BoxBody>, Response = Response<BoxBody>, Error = Infallible>
             + NamedService
@@ -50,12 +54,25 @@ impl ServiceBuilder {
             + Sync
             + 'static,
         S::Future: Send + 'static,
-        B: Lifecycle
+    {
+        self.servers.insert(definition::ServiceKind::Grpc.to_string(), Box::new(Grpc::new(server)));
+        self
+    }
+
+    /// 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: Lifecycle + 'static>(mut self, server: S, lifecycle: Arc<Mutex<B>>) -> Self
+    where
+        S: tonic::codegen::Service<Request<BoxBody>, Response = Response<BoxBody>, Error = Infallible>
+            + NamedService
             + Clone
             + Send
+            + Sync
             + 'static,
+        S::Future: Send + 'static,
     {
-        self.servers.insert(definition::ServiceKind::Grpc.to_string(), Box::new(Grpc::new(server, lifecycle)));
+        self.servers.insert(definition::ServiceKind::Grpc.to_string(), Box::new(Grpc::new_with_lifecycle(server, lifecycle)));
         self
     }
 

src/service/grpc/mod.rs

@@ -18,13 +18,13 @@ use crate::grpc;
 use crate::service::lifecycle::Lifecycle;
 
 #[derive(Clone)]
-pub(crate) struct Grpc<S, B> {
+pub(crate) struct Grpc<S> {
     port: i32,
     server: S,
-    lifecycle: Arc<Mutex<Box<B>>>,
+    lifecycle: Option<Box<Arc<Mutex<dyn Lifecycle>>>>,
 }
 
-impl<S, B> Grpc<S, B>
+impl<S> Grpc<S>
 where
     S: tonic::codegen::Service<Request<BoxBody>, Response = Response<BoxBody>, Error = Infallible>
         + NamedService
@@ -33,22 +33,26 @@ where
         + Sync
         + 'static,
     S::Future: Send + 'static,
-    B: Lifecycle
-        + Clone
-        + Send
-        + 'static,
 {
-    pub(crate) fn new(server: S, lifecycle: &Arc<Mutex<Box<B>>>) -> Self {
+    pub(crate) fn new_with_lifecycle<B: Lifecycle + 'static>(server: S, lifecycle: Arc<Mutex<B>>) -> Self {
         Self {
             port: 0,
             server,
-            lifecycle: lifecycle.clone(),
+            lifecycle: Some(Box::new(lifecycle)),
+        }
+    }
+
+    pub(crate) fn new(server: S) -> Self {
+        Self {
+            port: 0,
+            server,
+            lifecycle: None,
         }
     }
 }
 
 #[async_trait::async_trait]
-impl<S, B> Lifecycle for Grpc<S, B>
+impl<S> Lifecycle for Grpc<S>
 where
     S: tonic::codegen::Service<Request<BoxBody>, Response = Response<BoxBody>, Error = Infallible>
         + NamedService
@@ -57,22 +61,26 @@ where
         + Sync
         + 'static,
     S::Future: 'static + Send,
-    B: Lifecycle
-        + Clone
-        + Send
-        + 'static,
 {
     async fn on_start(&mut self) -> merrors::Result<()> {
-        self.lifecycle.lock().await.on_start().await
+        if let Some(lifecycle) = &self.lifecycle {
+            return lifecycle.lock().await.on_start().await
+        }
+
+        Ok(())
     }
 
     async fn on_finish(&self) -> merrors::Result<()> {
-        self.lifecycle.lock().await.on_finish().await
+        if let Some(lifecycle) = &self.lifecycle {
+            return lifecycle.lock().await.on_finish().await
+        }
+
+        Ok(())
     }
 }
 
 #[async_trait::async_trait]
-impl<S, B> plugin::service::Service for Grpc<S, B>
+impl<S> plugin::service::Service for Grpc<S>
 where
     S: tonic::codegen::Service<Request<BoxBody>, Response = Response<BoxBody>, Error = Infallible>
         + NamedService
@@ -81,10 +89,6 @@ where
         + Sync
         + 'static,
     S::Future: Send + 'static,
-    B: Lifecycle
-        + Clone
-        + Send
-        + 'static,
 {
     fn kind(&self) -> definition::ServiceKind {
         definition::ServiceKind::Grpc

src/service/lifecycle.rs

@@ -1,7 +1,7 @@
 use crate::errors as merrors;
 
 #[async_trait::async_trait]
-pub trait Lifecycle: Send + Sync {
+pub trait Lifecycle: LifecycleClone + Send + Sync {
     async fn on_start(&mut self) -> merrors::Result<()> {
         Ok(())
     }
@@ -10,3 +10,22 @@ pub trait Lifecycle: Send + Sync {
         Ok(())
     }
 }
+
+pub trait LifecycleClone {
+    fn clone_box(&self) -> Box<dyn Lifecycle>;
+}
+
+impl<T> LifecycleClone for T
+where
+    T: 'static + Lifecycle + Clone,
+{
+    fn clone_box(&self) -> Box<dyn Lifecycle> {
+        Box::new(self.clone())
+    }
+}
+
+impl Clone for Box<dyn Lifecycle> {
+    fn clone(&self) -> Self {
+        LifecycleClone::clone_box(self.as_ref())
+    }
+}