From fdd7f824fd1244226ca86f525f8439744676688f Mon Sep 17 00:00:00 2001 From: HampusM Date: Sat, 24 Sep 2022 17:31:16 +0200 Subject: feat: add bind async default factories to async DI container --- Cargo.toml | 2 +- examples/async-factory/main.rs | 62 +++++++++-- macros/src/factory/build_declare_interfaces.rs | 2 +- macros/src/factory/declare_default_args.rs | 2 +- macros/src/lib.rs | 39 +++++-- src/async_di_container.rs | 139 ++++++++++++++++++++----- src/castable_factory/mod.rs | 2 + src/castable_factory/threadsafe.rs | 4 +- src/interfaces/factory.rs | 9 ++ src/lib.rs | 5 + src/provider/async.rs | 37 +++++-- 11 files changed, 246 insertions(+), 57 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 360043a..54630aa 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -49,7 +49,7 @@ tokio = { version = "1.20.1", features = ["sync"], optional = true } mockall = "0.11.1" anyhow = "1.0.62" third-party-lib = { path = "./examples/with-3rd-party/third-party-lib" } -tokio = { version = "1.20.1", features = ["macros", "rt-multi-thread"] } +tokio = { version = "1.20.1", features = ["macros", "rt-multi-thread", "time"] } [workspace] members = [ diff --git a/examples/async-factory/main.rs b/examples/async-factory/main.rs index 74e12c7..715abf5 100644 --- a/examples/async-factory/main.rs +++ b/examples/async-factory/main.rs @@ -2,10 +2,14 @@ #![deny(clippy::pedantic)] #![allow(clippy::module_name_repetitions)] +use std::time::Duration; + use anyhow::Result; -use syrette::{async_closure, factory, AsyncDIContainer}; +use syrette::ptr::TransientPtr; +use syrette::{async_closure, declare_default_factory, factory, AsyncDIContainer}; +use tokio::time::sleep; -trait IFoo +trait IFoo: Send + Sync { fn bar(&self); } @@ -36,6 +40,34 @@ impl IFoo for Foo } } +trait IPerson: Send + Sync +{ + fn name(&self) -> String; +} + +struct Person +{ + name: String, +} + +impl Person +{ + fn new(name: String) -> Self + { + Self { name } + } +} + +impl IPerson for Person +{ + fn name(&self) -> String + { + self.name.clone() + } +} + +declare_default_factory!(dyn IPerson, async = true); + #[tokio::main] async fn main() -> Result<()> { @@ -45,9 +77,23 @@ async fn main() -> Result<()> .bind::() .to_async_factory(&|_| { async_closure!(|cnt| { - let foo = Box::new(Foo::new(cnt)); + let foo_ptr = Box::new(Foo::new(cnt)); - foo as Box + foo_ptr as Box + }) + }) + .await?; + + di_container + .bind::() + .to_async_default_factory(&|_| { + async_closure!(|| { + // Do some time demanding thing... + sleep(Duration::from_secs(1)).await; + + let person = TransientPtr::new(Person::new("Bob".to_string())); + + person as TransientPtr }) }) .await?; @@ -57,9 +103,13 @@ async fn main() -> Result<()> .await? .threadsafe_factory()?; - let foo = foo_factory(4).await; + let foo_ptr = foo_factory(4).await; + + foo_ptr.bar(); + + let person = di_container.get::().await?.transient()?; - foo.bar(); + println!("Person name is {}", person.name()); Ok(()) } diff --git a/macros/src/factory/build_declare_interfaces.rs b/macros/src/factory/build_declare_interfaces.rs index ac4ddd6..61e162f 100644 --- a/macros/src/factory/build_declare_interfaces.rs +++ b/macros/src/factory/build_declare_interfaces.rs @@ -14,7 +14,7 @@ pub fn build_declare_factory_interfaces( syrette::castable_factory::threadsafe::ThreadsafeCastableFactory< (std::sync::Arc,), #factory_interface - > -> syrette::interfaces::factory::IFactory< + > -> syrette::interfaces::factory::IThreadsafeFactory< (std::sync::Arc,), #factory_interface >, diff --git a/macros/src/factory/declare_default_args.rs b/macros/src/factory/declare_default_args.rs index 6450583..d19eba8 100644 --- a/macros/src/factory/declare_default_args.rs +++ b/macros/src/factory/declare_default_args.rs @@ -5,7 +5,7 @@ use syn::{Token, Type}; use crate::macro_flag::MacroFlag; use crate::util::iterator_ext::IteratorExt; -pub const FACTORY_MACRO_FLAGS: &[&str] = &["threadsafe"]; +pub const FACTORY_MACRO_FLAGS: &[&str] = &["threadsafe", "async"]; pub struct DeclareDefaultFactoryMacroArgs { diff --git a/macros/src/lib.rs b/macros/src/lib.rs index 07ee7a5..172a113 100644 --- a/macros/src/lib.rs +++ b/macros/src/lib.rs @@ -6,16 +6,20 @@ use proc_macro::TokenStream; use quote::quote; -use syn::{parse, parse_macro_input, parse_str}; +use syn::{parse, parse_macro_input}; mod declare_interface_args; -mod factory; -mod fn_trait; mod injectable; mod libs; mod macro_flag; mod util; +#[cfg(feature = "factory")] +mod factory; + +#[cfg(feature = "factory")] +mod fn_trait; + use crate::declare_interface_args::DeclareInterfaceArgs; use crate::injectable::implementation::InjectableImpl; use crate::injectable::macro_args::InjectableMacroArgs; @@ -188,7 +192,7 @@ pub fn injectable(args_stream: TokenStream, impl_stream: TokenStream) -> TokenSt pub fn factory(args_stream: TokenStream, type_alias_stream: TokenStream) -> TokenStream { use quote::ToTokens; - use syn::Type; + use syn::{parse_str, Type}; use crate::factory::build_declare_interfaces::build_declare_factory_interfaces; use crate::factory::macro_args::FactoryMacroArgs; @@ -266,6 +270,7 @@ pub fn factory(args_stream: TokenStream, type_alias_stream: TokenStream) -> Toke /// /// # Flags /// - `threadsafe` - Mark as threadsafe. +/// - `async` - Mark as async. Infers the `threadsafe` flag. /// /// # Panics /// If the provided arguments are invalid. @@ -285,20 +290,40 @@ pub fn factory(args_stream: TokenStream, type_alias_stream: TokenStream) -> Toke #[cfg(feature = "factory")] pub fn declare_default_factory(args_stream: TokenStream) -> TokenStream { + use syn::parse_str; + use crate::factory::build_declare_interfaces::build_declare_factory_interfaces; use crate::factory::declare_default_args::DeclareDefaultFactoryMacroArgs; use crate::fn_trait::FnTrait; let DeclareDefaultFactoryMacroArgs { interface, flags } = parse(args_stream).unwrap(); - let is_threadsafe = flags + let mut is_threadsafe = flags .iter() .find(|flag| flag.flag.to_string().as_str() == "threadsafe") .map_or(false, |flag| flag.is_on.value); + let is_async = flags + .iter() + .find(|flag| flag.flag.to_string().as_str() == "async") + .map_or(false, |flag| flag.is_on.value); + + if is_async { + is_threadsafe = true; + } + let mut factory_interface: FnTrait = parse( - quote! { - dyn Fn() -> syrette::ptr::TransientPtr<#interface> + if is_async { + quote! { + dyn Fn() -> syrette::future::BoxFuture< + 'static, + syrette::ptr::TransientPtr<#interface> + > + } + } else { + quote! { + dyn Fn() -> syrette::ptr::TransientPtr<#interface> + } } .into(), ) diff --git a/src/async_di_container.rs b/src/async_di_container.rs index d90cc0b..894b707 100644 --- a/src/async_di_container.rs +++ b/src/async_di_container.rs @@ -69,6 +69,7 @@ use crate::errors::async_di_container::{ AsyncBindingWhenConfiguratorError, AsyncDIContainerError, }; +use crate::future::BoxFuture; use crate::interfaces::async_injectable::AsyncInjectable; use crate::libs::intertrait::cast::error::CastError; use crate::libs::intertrait::cast::{CastArc, CastBox}; @@ -274,6 +275,8 @@ where > + Send + Sync, { + use crate::provider::r#async::AsyncFactoryVariant; + let mut bindings_lock = self.di_container.bindings.lock().await; if bindings_lock.has::(None) { @@ -289,7 +292,7 @@ where None, Box::new(crate::provider::r#async::AsyncFactoryProvider::new( crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), - false, + AsyncFactoryVariant::Normal, )), ); @@ -313,7 +316,8 @@ where where Args: 'static, Return: 'static + ?Sized, - Interface: Fn>, + Interface: + Fn> + Send + Sync, FactoryFunc: Fn< (Arc,), Output = Box< @@ -324,6 +328,8 @@ where > + Send + Sync, { + use crate::provider::r#async::AsyncFactoryVariant; + let mut bindings_lock = self.di_container.bindings.lock().await; if bindings_lock.has::(None) { @@ -339,7 +345,7 @@ where None, Box::new(crate::provider::r#async::AsyncFactoryProvider::new( crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), - false, + AsyncFactoryVariant::Normal, )), ); @@ -369,6 +375,58 @@ where > + Send + Sync, { + use crate::provider::r#async::AsyncFactoryVariant; + + let mut bindings_lock = self.di_container.bindings.lock().await; + + if bindings_lock.has::(None) { + return Err(AsyncBindingBuilderError::BindingAlreadyExists(type_name::< + Interface, + >( + ))); + } + + let factory_impl = ThreadsafeCastableFactory::new(factory_func); + + bindings_lock.set::( + None, + Box::new(crate::provider::r#async::AsyncFactoryProvider::new( + crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), + AsyncFactoryVariant::Default, + )), + ); + + Ok(AsyncBindingWhenConfigurator::new(self.di_container.clone())) + } + + /// Creates a binding of factory type `Interface` to a async factory inside of the + /// associated [`AsyncDIContainer`]. + /// + /// *This function is only available if Syrette is built with the "factory" and + /// "async" features.* + /// + /// # Errors + /// Will return Err if the associated [`AsyncDIContainer`] already have a binding for + /// the interface. + #[cfg(all(feature = "factory", feature = "async"))] + pub async fn to_async_default_factory( + &self, + factory_func: &'static FactoryFunc, + ) -> Result, AsyncBindingBuilderError> + where + Return: 'static + ?Sized, + FactoryFunc: Fn< + (Arc,), + Output = Box< + (dyn Fn<(), Output = crate::future::BoxFuture<'static, Return>> + + Send + + Sync), + >, + > + Send + + Sync, + { + use crate::provider::r#async::AsyncFactoryVariant; + let mut bindings_lock = self.di_container.bindings.lock().await; if bindings_lock.has::(None) { @@ -384,7 +442,7 @@ where None, Box::new(crate::provider::r#async::AsyncFactoryProvider::new( crate::ptr::ThreadsafeFactoryPtr::new(factory_impl), - true, + AsyncFactoryVariant::AsyncDefault, )), ); @@ -464,10 +522,10 @@ impl AsyncDIContainer .get_binding_providable::(name, dependency_history) .await?; - self.handle_binding_providable(binding_providable) + self.handle_binding_providable(binding_providable).await } - fn handle_binding_providable( + async fn handle_binding_providable( self: &Arc, binding_providable: AsyncProvidable, ) -> Result, AsyncDIContainerError> @@ -507,11 +565,10 @@ impl AsyncDIContainer } #[cfg(feature = "factory")] AsyncProvidable::Factory(factory_binding) => { + use crate::interfaces::factory::IThreadsafeFactory; + let factory = factory_binding - .cast::,), - Interface, - >>() + .cast::,), Interface>>() .map_err(|err| match err { CastError::NotArcCastable(_) => { AsyncDIContainerError::InterfaceNotAsync( @@ -531,33 +588,59 @@ impl AsyncDIContainer )) } #[cfg(feature = "factory")] - AsyncProvidable::DefaultFactory(default_factory_binding) => { - use crate::interfaces::factory::IFactory; + AsyncProvidable::DefaultFactory(binding) => { + use crate::interfaces::factory::IThreadsafeFactory; - let default_factory = default_factory_binding - .cast::,), dyn Fn<(), Output = TransientPtr> + Send + Sync, - >>() - .map_err(|err| match err { - CastError::NotArcCastable(_) => { - AsyncDIContainerError::InterfaceNotAsync( - type_name::(), - ) - } - CastError::CastFailed { from: _, to: _ } => { - AsyncDIContainerError::CastFailed { - interface: type_name::(), - binding_kind: "default factory", - } - } - })?; + >, + >(binding, "default factory")?; Ok(SomeThreadsafePtr::Transient(default_factory(self.clone())())) } + #[cfg(feature = "factory")] + AsyncProvidable::AsyncDefaultFactory(binding) => { + use crate::interfaces::factory::IThreadsafeFactory; + + let async_default_factory = Self::cast_factory_binding::< + dyn IThreadsafeFactory< + (Arc,), + dyn Fn<(), Output = BoxFuture<'static, TransientPtr>> + + Send + + Sync, + >, + >( + binding, "async default factory" + )?; + + Ok(SomeThreadsafePtr::Transient( + async_default_factory(self.clone())().await, + )) + } } } + #[cfg(feature = "factory")] + fn cast_factory_binding( + factory_binding: Arc, + binding_kind: &'static str, + ) -> Result, AsyncDIContainerError> + { + factory_binding.cast::().map_err(|err| match err { + CastError::NotArcCastable(_) => { + AsyncDIContainerError::InterfaceNotAsync(type_name::()) + } + CastError::CastFailed { from: _, to: _ } => { + AsyncDIContainerError::CastFailed { + interface: type_name::(), + binding_kind, + } + } + }) + } + async fn get_binding_providable( self: &Arc, name: Option<&'static str>, diff --git a/src/castable_factory/mod.rs b/src/castable_factory/mod.rs index 530cc82..e81b842 100644 --- a/src/castable_factory/mod.rs +++ b/src/castable_factory/mod.rs @@ -1,2 +1,4 @@ pub mod blocking; + +#[cfg(feature = "async")] pub mod threadsafe; diff --git a/src/castable_factory/threadsafe.rs b/src/castable_factory/threadsafe.rs index 7be055c..b91dceb 100644 --- a/src/castable_factory/threadsafe.rs +++ b/src/castable_factory/threadsafe.rs @@ -1,6 +1,6 @@ #![allow(clippy::module_name_repetitions)] use crate::interfaces::any_factory::{AnyFactory, AnyThreadsafeFactory}; -use crate::interfaces::factory::IFactory; +use crate::interfaces::factory::IThreadsafeFactory; use crate::ptr::TransientPtr; pub struct ThreadsafeCastableFactory @@ -26,7 +26,7 @@ where } } -impl IFactory +impl IThreadsafeFactory for ThreadsafeCastableFactory where Args: 'static, diff --git a/src/interfaces/factory.rs b/src/interfaces/factory.rs index b09db36..de1fca9 100644 --- a/src/interfaces/factory.rs +++ b/src/interfaces/factory.rs @@ -9,3 +9,12 @@ where ReturnInterface: 'static + ?Sized, { } + +/// Interface for a threadsafe factory. +#[cfg(feature = "async")] +pub trait IThreadsafeFactory: + Fn> + crate::libs::intertrait::CastFromSync +where + ReturnInterface: 'static + ?Sized, +{ +} diff --git a/src/lib.rs b/src/lib.rs index 247f907..082a93d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -125,4 +125,9 @@ macro_rules! async_closure { Box::pin(async move { $($inner)* }) }) }; + (|| { $($inner: stmt);* }) => { + Box::new(|| { + Box::pin(async move { $($inner)* }) + }) + }; } diff --git a/src/provider/async.rs b/src/provider/async.rs index df96b27..c9a5273 100644 --- a/src/provider/async.rs +++ b/src/provider/async.rs @@ -26,6 +26,12 @@ pub enum AsyncProvidable dyn crate::interfaces::any_factory::AnyThreadsafeFactory, >, ), + #[cfg(feature = "factory")] + AsyncDefaultFactory( + crate::ptr::ThreadsafeFactoryPtr< + dyn crate::interfaces::any_factory::AnyThreadsafeFactory, + >, + ), } #[async_trait] @@ -150,13 +156,21 @@ where } } +#[derive(Clone, Copy)] +pub enum AsyncFactoryVariant +{ + Normal, + Default, + AsyncDefault, +} + #[cfg(feature = "factory")] pub struct AsyncFactoryProvider { factory: crate::ptr::ThreadsafeFactoryPtr< dyn crate::interfaces::any_factory::AnyThreadsafeFactory, >, - is_default_factory: bool, + variant: AsyncFactoryVariant, } #[cfg(feature = "factory")] @@ -166,13 +180,10 @@ impl AsyncFactoryProvider factory: crate::ptr::ThreadsafeFactoryPtr< dyn crate::interfaces::any_factory::AnyThreadsafeFactory, >, - is_default_factory: bool, + variant: AsyncFactoryVariant, ) -> Self { - Self { - factory, - is_default_factory, - } + Self { factory, variant } } } @@ -186,10 +197,14 @@ impl IAsyncProvider for AsyncFactoryProvider _dependency_history: Vec<&'static str>, ) -> Result { - Ok(if self.is_default_factory { - AsyncProvidable::DefaultFactory(self.factory.clone()) - } else { - AsyncProvidable::Factory(self.factory.clone()) + Ok(match self.variant { + AsyncFactoryVariant::Normal => AsyncProvidable::Factory(self.factory.clone()), + AsyncFactoryVariant::Default => { + AsyncProvidable::DefaultFactory(self.factory.clone()) + } + AsyncFactoryVariant::AsyncDefault => { + AsyncProvidable::AsyncDefaultFactory(self.factory.clone()) + } }) } @@ -206,7 +221,7 @@ impl Clone for AsyncFactoryProvider { Self { factory: self.factory.clone(), - is_default_factory: self.is_default_factory.clone(), + variant: self.variant, } } } -- cgit v1.2.3-18-g5258