Crate axum_starter

Expand description

§Axum Starter

§Why axum-starter

With the growing of the server functions, the code which prepare multiply infrastructures for the server in the main become more and more complex.
For example, I need connect to Mysql and Redis, start MessageQuery , start GracefulShutdown and so on.
In other to simplify the start up code with my server project, there comes the axum-starter

§Safety

the outer attribute #![forbid(unsafe_code)] enable

§Simple Example

The following example using axum-starter starting a web server which server on http://127.0.0.1:5050

It can do

show info before launch (with logger feature)
using simple_logger and adding TraceLayer as logger middleware
request http://127.0.0.1:5050/greet/{name} will respond greet with your name

use axum::{extract::Path, routing::get};
use axum_starter::{prepare, router::Route, ServerPrepare};
use config::Conf;
use tower_http::trace::TraceLayer;

#[tokio::main]
async fn main() {
    start().await;
}

async fn start() {
    ServerPrepare::with_config(Conf::default())
        .init_logger()
        .expect("Init Logger Error")
        .prepare_route(GreetRoute)
        .layer(TraceLayer::new_for_http())
        .no_state()
        .prepare_start()
        .await
        .expect("Prepare for Start Error")
        .launch()
        .await
        .expect("Server Error");
}

mod config {
    use std::net::Ipv4Addr;

    use axum_starter::{Configure, Provider};
    use log::LevelFilter;
    use log::SetLoggerError;
    use simple_logger::SimpleLogger;

    // prepare the init configure
    #[derive(Debug, Default, Provider, Configure)]
    #[conf(
        address(func(
            path = "||(Ipv4Addr::LOCALHOST, 5050)",
            ty = "(Ipv4Addr, u16)",
            associate,
        )),
        logger(
            func = "||SimpleLogger::new().with_level(LevelFilter::Debug).init()",
            error = "SetLoggerError",
            associate,
        ),
        server
    )]
    pub(super) struct Conf {}
}

async fn greet(Path(name): Path<String>) -> String {
    format!("Welcome {name} !")
}

#[prepare(GreetRoute)]
fn greet_route<S, B>() -> Route<S, B>
where
    B: http_body::Body + Send + 'static,
    S: Clone + Send + Sync + 'static,
{
    Route::new("/greet/:name", get(greet))
}

§Core Concept

Each task before starting the server call Prepare. Each Prepare will Return a PreparedEffect for ServerPrepare to apply each prepare’s effect on the server. Finally, all Prepare are done and the server can be launch

§`Prepare` trait

the trait define the prepare task, after prepare down, it return a PreparedEffect

§`PreparedEffect` trait family

the trait family will apply multiply effect on the server. include the following

§`Concurrently` or `Serially`

Prepares will run one by one in default, in another word, they running serially, if you want run some Prepares concurrently, you can call ServerPrepare::prepare_concurrent, to give a group of Prepares running concurrently

§Set Middleware

if you want to adding a middleware on the root of server Router, using ServerPrepare::layer then giving the Layer

or using PrepareMiddlewareEffect apply middleware in Prepare

Modules§

router: help types for apply effect on Router
state: help types for apply effect on State

Structs§

ConcurrentPrepareSet: apply all Prepare task concurrently
PrepareError: the error while prepare for each Prepare task
Ready: Future for the ready function.
SerialPrepareSet: a set of Prepare task executing one by one
ServerPrepare: type for prepare starting
StateCollector: collect all state during prepare
TestResponse
TypeNotInState: then type not in the state collector

Enums§

PrepareStartError: error during the ServerPrepare::prepare_start
ServerReady: all prepare task are done , the server is ready for launch

Traits§

BindServe: binding address provided by ServeAddress
FromStateCollector: Mapping type form StateCollector to special Type
LoggerInitialization: init the logger of this server by the Config
Prepare: Prepare Task witch may return any kind of effect
PrepareDecorator: add decorator for each prepare ’s Future
PrepareMiddlewareEffect: prepare for Middleware
PrepareRouteEffect: prepare side effect of Router
PrepareStateEffect: Prepare for Global State
Provider: the Config that can provide config info T the T can be either returning Ownership or Reference
ServeAddress: get the address this server are going to bind with

Functions§

ready: Creates a future that is immediately ready with a value.

Attribute Macros§

prepare: make a function can apply as a Prepare

Derive Macros§

Configure: help macro from impl ServeAddress, LoggerInitialization, ConfigureServerEffect
FromStateCollector: impl FromStateCollector for special type
Provider: implement Provider<T> for each field of the struct

Crate axum_starterCopy item path