rs-zero 0.2.1

Rust-first microservice framework inspired by go-zero engineering practices
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

use std::{future::Future, net::SocketAddr};

use axum::Router;

use crate::rest::{RestConfig, middleware::apply_default_layers};

/// REST server wrapper that keeps axum's router available for extension.
#[derive(Debug, Clone)]
pub struct RestServer {
    config: RestConfig,
    router: Router,
}

impl RestServer {
    /// Creates a server from a config and router.
    pub fn new(config: RestConfig, router: Router) -> Self {
        Self { config, router }
    }

    /// Returns the raw router without applying default middleware.
    pub fn raw_router(&self) -> Router {
        self.router.clone()
    }

    /// Builds the router with rs-zero default middleware.
    pub fn into_router(self) -> Router {
        apply_default_layers(self.router, self.config)
    }

    /// Starts the server with graceful shutdown.
    pub async fn serve_with_shutdown<F>(self, addr: SocketAddr, shutdown: F) -> std::io::Result<()>
    where
        F: Future<Output = ()> + Send + 'static,
    {
        let listener = tokio::net::TcpListener::bind(addr).await?;
        axum::serve(listener, self.into_router())
            .with_graceful_shutdown(shutdown)
            .await
    }
}

#[cfg(test)]
mod tests {
    use super::RestServer;
    use crate::rest::{ApiResponse, RestConfig};
    use axum::{Router, routing::get};
    use tower::ServiceExt;

    #[tokio::test]
    async fn server_builds_router() {
        let router = Router::new().route("/ready", get(|| async { ApiResponse::success("ok") }));

        let service = RestServer::new(RestConfig::default(), router).into_router();
        let response = service
            .oneshot(
                axum::http::Request::builder()
                    .uri("/ready")
                    .body(axum::body::Body::empty())
                    .expect("request"),
            )
            .await
            .expect("response");

        assert_eq!(response.status(), axum::http::StatusCode::OK);
    }
}