service-async 0.2.4

A Service like tower in async style
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::{any::Any, convert::Infallible};

#[cfg(unix)]
use monoio::main as main_macro;
use service_async::{
    layer::{layer_fn, FactoryLayer},
    stack::FactoryStack,
    AsyncMakeService, BoxedService, MakeService, Service,
};
#[cfg(not(unix))]
use tokio::main as main_macro;

struct SvcA;

impl Service<()> for SvcA {
    type Response = ();
    type Error = Infallible;
    async fn call(&self, _req: ()) -> Result<Self::Response, Self::Error> {
        println!("SvcA called!");
        Ok(())
    }
}

struct SvcAFactory;

impl MakeService for SvcAFactory {
    type Service = SvcA;
    type Error = Infallible;
    fn make_via_ref(&self, _old: Option<&Self::Service>) -> Result<Self::Service, Self::Error> {
        println!("SvcAFactory make");
        Ok(SvcA)
    }
}
impl AsyncMakeService for SvcAFactory {
    type Service = SvcA;
    type Error = Infallible;
    async fn make_via_ref(
        &self,
        _old: Option<&Self::Service>,
    ) -> Result<Self::Service, Self::Error> {
        println!("SvcAFactory make async");
        Ok(SvcA)
    }
}

struct SvcB<T> {
    inner: T,
}

impl<T: Service<()>> Service<()> for SvcB<T> {
    type Response = ();
    type Error = T::Error;
    async fn call(&self, req: ()) -> Result<Self::Response, Self::Error> {
        println!("SvcB called!");
        self.inner.call(req).await?;
        Ok(())
    }
}

struct SvcBFactory<T>(T);

impl<T: AsyncMakeService> AsyncMakeService for SvcBFactory<T> {
    type Service = SvcB<T::Service>;
    type Error = T::Error;
    async fn make_via_ref(
        &self,
        _old: Option<&Self::Service>,
    ) -> Result<Self::Service, Self::Error> {
        println!("SvcBFactory make async");
        Ok(SvcB {
            inner: self.0.make_via_ref(None).await?,
        })
    }
}

impl SvcAFactory {
    fn layer<C>() -> impl FactoryLayer<C, (), Factory = Self> {
        layer_fn(|_c: &C, ()| SvcAFactory)
    }
}
impl<T> SvcBFactory<T> {
    fn layer<C>() -> impl FactoryLayer<C, T, Factory = Self> {
        layer_fn(|_: &C, inner| SvcBFactory(inner))
    }
}

#[main_macro]
async fn main() {
    // Demo for normal async make service.
    let stack = FactoryStack::new(())
        .push(SvcAFactory::layer())
        .push(SvcBFactory::layer());
    let svc = stack.make_async().await.unwrap();
    svc.call(()).await.unwrap();

    // Demo for convert make service to async make service.
    let stack = FactoryStack::new(())
        .push(SvcAFactory::layer())
        .check_make_svc()
        .into_async()
        .check_async_make_svc()
        .push(SvcBFactory::layer());
    let svc = stack.make_async().await.unwrap();
    svc.call(()).await.unwrap();

    // Demo for convert service type to BoxedService and factory to BoxedAsyncMakeService<S, E>.
    let stack = FactoryStack::new(())
        .push(SvcAFactory::layer())
        .push(SvcBFactory::layer())
        .into_boxed_service()
        .into_async_boxed_factory();
    let svc = stack.make_async().await.unwrap();
    assert!(svc.type_id() == std::any::TypeId::of::<BoxedService<(), (), Infallible>>());
    svc.call(()).await.unwrap();
}