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

1. show info before launch (with logger feature)
2. using simple_logger and adding TraceLayer as logger middleware
3. 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

• Router
• State
• Middleware

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