axum-starter 0.11.0

A help crate for simplify the code of starting a axum server
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
116
117
118
119
120
121
122
123
124
125
126
127

#[allow(unused_imports)]
use std::any::type_name;
use std::{future::IntoFuture, sync::Arc};

use futures::{
    future::{join, ok},
    FutureExt, TryFutureExt,
};
use tap::Pipe;

use crate::server_prepare::PrepareDecorator;
use crate::{
    prepare_behave::{
        effect_traits::{Prepare, PrepareStateEffect},
        StateCollector,
    },
    PrepareError,
};

use super::{BoxFuture, StateContainerFuture, StateContainerResult};

/// apply all [Prepare](Prepare) task concurrently
///
/// ## Note
/// the sync part of [Prepare] will be run immediately
pub struct ConcurrentPrepareSet<'d, C, Decorator, T = StateContainerResult> {
    prepare_fut: BoxFuture<T>,
    configure: Arc<C>,
    decorator: &'d Decorator,
}

impl<'d, C, Decorator> ConcurrentPrepareSet<'d, C, Decorator> {
    /// get the [Future]
    pub(crate) fn into_internal_future(self) -> StateContainerFuture {
        self.prepare_fut
    }
}

impl<'d, C, Decorator> ConcurrentPrepareSet<'d, C, Decorator>
where
    C: 'static,
    Decorator: PrepareDecorator,
{
    /// join a [Prepare] into concurrent execute set
    ///
    /// concurrent only support state prepare
    pub fn join_state<P>(self, prepare: P) -> ConcurrentPrepareSet<'d, C, Decorator>
    where
        P: Prepare<C> + 'static,
        P::Effect: PrepareStateEffect,
    {
        debug!(
            mode = "concurrently",
            action = "Adding Prepare State",
            prepare = type_name::<P>(),
        );

        let configure = Arc::clone(&self.configure);
        let prepare_fut = join(
            self.prepare_fut,
            prepare
                .prepare(configure)
                .into_future()
                .map_err(PrepareError::to_prepare_error::<P, _>)
                .pipe(|fut| self.decorator.prepare_decorator::<C, P, _>(fut)),
        )
        .map(|(l, r)| {
            Ok({
                let mut states = l?;
                let effect = r?;
                effect.take_state(&mut states);

                states
            })
        })
        .boxed_local();

        ConcurrentPrepareSet {
            prepare_fut,
            configure: self.configure,
            decorator: self.decorator,
        }
    }

    /// join a [Prepare] without effect
    pub fn join<P>(self, prepare: P) -> ConcurrentPrepareSet<'d, C, Decorator>
    where
        P: Prepare<C, Effect = ()> + 'static,
    {
        debug!(
            mode = "concurrently",
            action = "Adding Prepare",
            prepare = type_name::<P>(),
        );

        let configure = Arc::clone(&self.configure);
        let prepare_fut = join(
            self.prepare_fut,
            prepare
                .prepare(configure)
                .into_future()
                .map_err(PrepareError::to_prepare_error::<P, _>)
                .pipe(|fut| self.decorator.prepare_decorator::<C, P, _>(fut)),
        )
        .map(|(l, r)| {
            r?;
            l
        })
        .boxed_local();

        ConcurrentPrepareSet {
            prepare_fut,
            configure: self.configure,
            decorator: self.decorator,
        }
    }
}

impl<'d, C: 'static, Decorator> ConcurrentPrepareSet<'d, C, Decorator> {
    pub(crate) fn new(configure: Arc<C>, decorator: &'d Decorator) -> Self {
        Self {
            prepare_fut: ok(StateCollector::new()).boxed_local(),
            configure,
            decorator,
        }
    }
}