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

use std::{convert::Infallible, sync::Arc};

use axum::{
    body::{Body, Bytes},
    handler::{Handler, HandlerService},
    response::Response,
    BoxError,
};
use http::Request;
use tap::Pipe;
use tokio::spawn;
use tower::{layer::util::Identity, util::MapResponseLayer, Layer, Service, ServiceBuilder};

use crate::{
    prepare_behave::effect_contain::TestRouter,
    prepare_sets::ContainerResult,
    server_prepare::{
        start_process::{
            graceful_shutdown::NoGraceful,
            logger::NoLog,
            state_ready::{StateNotReady, StateReady},
        },
        EmptyDecorator,
    },
    test_utils::TestResponse,
    FromStateCollector, PrepareStartError, SerialPrepareSet, ServerPrepare,
};

impl<C: 'static>
    ServerPrepare<
        C,
        ContainerResult<TestRouter, Identity>,
        NoLog,
        StateNotReady,
        NoGraceful,
        EmptyDecorator,
    >
{
    /// prepare staring the service with config
    pub fn test_with_config(config: C) -> Self {
        #[cfg(feature = "logger")]
        let span = tracing::debug_span!("prepare server start");
        #[cfg(not(feature = "logger"))]
        let span = crate::fake_span::FakeSpan;
        ServerPrepare::new(
            SerialPrepareSet::new_test(Arc::new(config), EmptyDecorator),
            NoGraceful,
            StateNotReady,
            span,
        )
    }
}

impl<C: 'static, Log, State, Graceful, L, Decorator>
    ServerPrepare<C, ContainerResult<TestRouter, L>, Log, StateReady<State>, Graceful, Decorator>
{
    /// prepare to a service for test
    ///
    /// this will consume `Self` then return a [Service](tower::Service) for the following test
    pub async fn preparing_test<NewResBody, H, T>(
        self,
        handler: H,
    ) -> Result<
        impl Service<Request<Body>, Response = TestResponse, Error = Infallible>,
        PrepareStartError,
    >
    where
        // middleware
        L: Send + 'static,
        L: Layer<HandlerService<H, T, State>>,
        L::Service: Service<Request<Body>, Response = Response<NewResBody>, Error = Infallible>
            + Send
            + Clone
            + 'static,
        NewResBody: http_body::Body<Data = Bytes> + Send + 'static,
        NewResBody::Error: Into<BoxError>,
        // state
        State: FromStateCollector,
        State: Clone + Send + 'static + Sync,
        // handler
        H: Handler<T, State>,
    {
        async {
            let (prepare_fut, _) = self.prepares.unwrap();
            debug!(execute = "Prepare");

            let (state, middleware, _) = prepare_fut.await?.unwrap();

            let state = State::fetch(state)?;

            let post_prepare_tasks = self.state.take();
            debug!(
                execute = "Post Prepare Tasks",
                numbers = post_prepare_tasks.len()
            );
            for task in post_prepare_tasks {
                spawn({
                    let local_state = state.clone();
                    async move {
                        (task)(local_state).await;
                    }
                });
            }

            let service = handler.with_state(state);
            Ok(ServiceBuilder::new()
                .layer(MapResponseLayer::new(TestResponse::new))
                .layer(middleware)
                .service(service))
        }
        .pipe(|fut| {
            #[cfg(feature = "logger")]
            {
                tracing::Instrument::instrument(fut, self.span)
            }
            #[cfg(not(feature = "logger"))]
            {
                fut
            }
        })
        .await
    }
}