fix: access to the internal service state by handlers

Author: rsfreitas

examples/services/http/src/main.rs

@@ -1,12 +1,10 @@
-use std::any::Any;
 use std::sync::Arc;
 
 use axum::extract::State;
 use axum::routing::get;
 use mikros::FutureMutex;
-use mikros::http::{ServiceInternalState, ServiceState};
+use mikros::http::ServiceState;
 use mikros::service::builder::ServiceBuilder;
-//use mikros::FutureMutex;
 
 #[derive(Clone, Default)]
 pub struct AppState {
@@ -19,18 +17,7 @@ impl AppState {
     }
 }
 
-impl ServiceInternalState for AppState {
-    fn clone_box(&self) -> Box<dyn ServiceInternalState> {
-        Box::new(self.clone())
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
 // Handler method for the first endpoint
-//async fn handler_one(ctx: Option<State<Arc<Context>>>) -> String {
 async fn handler_one(State(state): State<Arc<FutureMutex<ServiceState>>>) -> String {
     println!("Handler One");
     let context = state.lock().await.context();
@@ -43,11 +30,12 @@ async fn handler_one(State(state): State<Arc<FutureMutex<ServiceState>>>) -> Str
 async fn handler_two(State(state): State<Arc<FutureMutex<ServiceState>>>) -> String {
     println!("Handler Two");
 
-    if let Some(app_state) = state.lock().await.state::<AppState>().await {
-        println!("App State current value: {}", app_state.value);
-        app_state.increase();
-        let mut x = app_state.clone_box();
-        x.in
+    let context = state.lock().await.context();
+    if let Some(app_state) = &state.lock().await.app_state {
+        let mut locked = app_state.as_ref().lock().await;
+        let x = locked.downcast_mut::<AppState>().unwrap();
+        x.value += 1;
+        context.logger().info(format!("value: {}", x.value).as_str());
     }
 
     format!("Handler Two")
@@ -62,7 +50,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let state = AppState::default();
     let svc = ServiceBuilder::default()
         .http_with_state(api, Box::new(state))
-//        .http_with_state(api, Arc::new(FutureMutex::new(state)))
 //        .http(api)
         .build();
 

src/http/mod.rs

@@ -8,41 +8,55 @@ use crate::service::context::Context;
 #[derive(Clone)]
 pub struct ServiceState {
     context: Arc<Context>,
-    state: Arc<Mutex<Option<Box<dyn ServiceInternalState>>>>
+
+    /// This member gives access to the service own state (added when it is
+    /// created, with the ServiceBuilder::http_with_state API).
+    ///
+    /// One can retrieve the proper service state structure like the example:
+    ///
+    /// ```
+    /// use std::sync::Arc;
+    ///
+    /// use axum::extract::State;
+    /// use mikros::FutureMutex;
+    /// use mikros::http::ServiceState;
+    ///
+    /// #[derive(Clone)]
+    /// pub struct AppState;
+    ///
+    /// async fn handler(State(state): State<Arc<FutureMutex<ServiceState>>>) -> String {
+    ///     if let Some(app_state) = &state.lock().await.app_state {
+    ///         let mut locked = app_state.as_ref().lock().await;
+    ///         let svc_state = locked.downcast_mut::<AppState>().unwrap();
+    ///
+    ///         // svc_state can be manipulated from here.
+    ///     }
+    ///
+    ///     "Ok".to_string()
+    /// }
+    /// ```
+    ///
+    pub app_state: Option<Arc<Mutex<Box<dyn Any + Send + Sync>>>>,
 }
 
 impl ServiceState {
     pub(crate) fn new(context: &Context) -> Self {
         Self {
             context: Arc::new(context.clone()),
-            state: Arc::new(Mutex::new(None)),
+            app_state: None,
         }
     }
 
-    pub(crate) fn new_with_state(context: &Context, state: Box<dyn ServiceInternalState>) -> Self {
-        Self {
-            context: Arc::new(context.clone()),
-            state: Arc::new(Mutex::new(Some(state))),
-        }
+    pub(crate) fn new_with_state(context: &Context, internal_state: Arc<Mutex<Box<dyn Any + Send + Sync>>>) -> Self {
+        let mut s = Self::new(context);
+        s.app_state = Some(internal_state);
+        s
     }
 
+    /// Allows retrieving the mikros Context object from a handler state. Even
+    /// if the service was not initialized with state, the context will always
+    /// be available.
     pub fn context(&self) -> Arc<Context> {
         self.context.clone()
     }
-
-    pub async fn state<T: Clone + 'static>(&self) -> Option<Arc<T>> {
-        let state = self.state.lock().await;
-        state.as_ref()?.as_any().downcast_ref::<T>().map(|t|Arc::new(t.clone()))
-    }
-}
-
-pub trait ServiceInternalState: Send + Sync + 'static {
-    fn clone_box(&self) -> Box<dyn ServiceInternalState>;
-    fn as_any(&self) -> &dyn Any;
-}
-
-impl Clone for Box<dyn ServiceInternalState> {
-    fn clone(&self) -> Self {
-        self.clone_box()
-    }
 }

src/service/builder.rs

@@ -1,22 +1,26 @@
+use std::any::Any;
 use std::collections::HashMap;
-use std::sync::{Arc};
 use std::convert::Infallible;
+use std::sync::Arc;
 
 use axum::Router;
 use futures::lock::Mutex;
 use http::{request::Request, response::Response};
 use tonic::body::BoxBody;
 use tonic::server::NamedService;
 
-use crate::{definition, errors as merrors, plugin};
-use crate::http::{ServiceInternalState, ServiceState};
-use crate::service::native::{NativeService, Native};
-use crate::service::script::{ScriptService, Script};
+use crate::http::ServiceState;
+use crate::service::Service;
 use crate::service::grpc::Grpc;
 use crate::service::http::Http;
 use crate::service::lifecycle::Lifecycle;
-use crate::service::Service;
+use crate::service::native::{NativeService, Native};
+use crate::service::script::{ScriptService, Script};
+use crate::{definition, errors as merrors, plugin};
 
+/// The builder API to build a mikros service instance. It allows to initialize
+/// each type of configured service (inside the service.toml file) with its own
+/// data type.
 pub struct ServiceBuilder {
     pub(crate) servers: HashMap<String, Box<dyn plugin::service::Service>>,
     pub(crate) features: Vec<Box<dyn plugin::feature::Feature>>,
@@ -104,12 +108,19 @@ impl ServiceBuilder {
         self
     }
 
-    pub fn http_with_state(mut self, router: Router<Arc<Mutex<ServiceState>>>, state: Box<dyn ServiceInternalState>) -> Self {
+    /// 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 {
         self.servers.insert(definition::ServiceKind::Http.to_string(), Box::new(Http::new_with_state(router, state)));
         self
     }
 
-    pub fn http_with_lifecycle_and_state<L>(mut self, router: Router<Arc<Mutex<ServiceState>>>, lifecycle: Arc<Mutex<L>>, state: Box<dyn ServiceInternalState>) -> Self
+    /// Initializes the HTTP service type with the required structure
+    /// 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
     where
         L: Lifecycle + 'static,
     {

src/service/http/mod.rs

@@ -1,5 +1,5 @@
+use std::any::Any;
 use std::collections::HashMap;
-use std::ops::Deref;
 use std::sync::Arc;
 
 use axum::Router;
@@ -8,17 +8,17 @@ use logger::fields::FieldValue;
 use tokio::net::TcpListener;
 use tokio::sync::watch::Receiver;
 
-use crate::{definition, env, errors as merrors, plugin};
-use crate::http::{ServiceInternalState, ServiceState};
+use crate::http::ServiceState;
 use crate::service::context::Context;
 use crate::service::lifecycle::Lifecycle;
+use crate::{definition, env, errors as merrors, plugin};
 
 #[derive(Clone)]
 pub(crate) struct Http {
     port: i32,
     router: Router<Arc<Mutex<ServiceState>>>,
     lifecycle: Option<Box<Arc<Mutex<dyn Lifecycle>>>>,
-    internal_state: Arc<Mutex<Option<Box<dyn ServiceInternalState>>>>
+    app_state: Option<Arc<Mutex<Box<dyn Any + Send + Sync>>>>,
 }
 
 impl Http {
@@ -27,7 +27,7 @@ impl Http {
             port: 0,
             router,
             lifecycle: None,
-            internal_state: Arc::new(Mutex::new(None))
+            app_state: None,
         }
     }
 
@@ -40,19 +40,19 @@ impl Http {
         s
     }
 
-    pub fn new_with_state(router: Router<Arc<Mutex<ServiceState>>>, state: Box<dyn ServiceInternalState>) -> Self {
+    pub fn new_with_state(router: Router<Arc<Mutex<ServiceState>>>, state: Box<dyn Any + Send + Sync>) -> Self {
         let mut s = Self::new(router);
-        s.internal_state = Arc::new(Mutex::new(Some(state)));
+        s.app_state = Some(Arc::new(Mutex::new(state)));
         s
     }
 
-    pub fn new_with_lifecycle_and_state<L>(router: Router<Arc<Mutex<ServiceState>>>, lifecycle: Arc<Mutex<L>>, state: Box<dyn ServiceInternalState>) -> Self
+    pub fn new_with_lifecycle_and_state<L>(router: Router<Arc<Mutex<ServiceState>>>, lifecycle: Arc<Mutex<L>>, state: Box<dyn Any + Send + Sync>) -> Self
     where
         L: Lifecycle + 'static,
     {
         let mut s = Self::new(router);
         s.lifecycle = Some(Box::new(lifecycle));
-        s.internal_state = Arc::new(Mutex::new(Some(state)));
+        s.app_state = Some(Arc::new(Mutex::new(state)));
         s
     }
 }
@@ -108,10 +108,9 @@ impl plugin::service::Service for Http {
             shutdown_rx.changed().await.ok();
         };
 
-        let internal_state = self.internal_state.clone();
-        let state = match internal_state.lock().await.deref() {
+        let state = match &self.app_state {
             None => ServiceState::new(ctx),
-            Some(state) => ServiceState::new_with_state(ctx, state.clone_box())
+            Some(st) => ServiceState::new_with_state(ctx, st.clone())
         };
 
         let app = Router::new().merge(self.router.clone()).with_state(Arc::new(Mutex::new(state)));