axum-starter-macro

Crates.ioaxum-starter-macro
lib.rsaxum-starter-macro
version0.10.0
sourcesrc
created_at2022-10-15 10:06:23.061586
updated_at2024-04-21 02:35:10.583976
descriptionA help crate for simplify the code of starting axum server
homepagehttps://github.com/Goodjooy/axum-server-starter
repository
max_upload_size
id688885
size54,772
凊弦凝绝 (Goodjooy)

documentation

https://docs.rs/axum-starter

README

Axum Starter

Github Crates.io License

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

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

Commit count: 0

cargo fmt