modrun 1.0.1

Modular application composer for Tokio: domain modules, typed wiring, lifecycle
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

//! Axum HTTP server assembled with modrun.
//!
//! [`modrun::task_with`] binds during OnStart so `AddrInUse` fails start, then
//! owns the server task so OnStop can shut it down without smuggling channel
//! ends between two closures.
//!
//! ```bash
//! cargo run --example axum
//! curl http://127.0.0.1:3000/
//! curl http://127.0.0.1:3000/hello/modrun
//! # Ctrl-C for graceful shutdown
//! ```

use std::net::SocketAddr;

use axum::Router;
use axum::extract::{Path, State};
use axum::routing::get;
use modrun::logging::init;
use modrun::{Error, Lifecycle, Modrun, Module, task_with};
use tokio::net::TcpListener;

#[derive(Clone)]
struct Config {
    addr: SocketAddr,
}

#[derive(Clone)]
struct Greeter {
    prefix: String,
}

#[derive(Clone)]
struct AppState {
    greeter: Greeter,
}

fn new_greeter() -> Greeter {
    Greeter {
        prefix: "hello".into(),
    }
}

fn new_state(greeter: Greeter) -> AppState {
    AppState { greeter }
}

async fn index(State(state): State<AppState>) -> String {
    format!("{} from modrun + axum\n", state.greeter.prefix)
}

async fn hello(State(state): State<AppState>, Path(name): Path<String>) -> String {
    format!("{}, {name}!\n", state.greeter.prefix)
}

fn register_http(lc: Lifecycle, cfg: Config, state: AppState) -> modrun::Result<()> {
    let addr = cfg.addr;
    lc.append(task_with(
        "http.serve",
        move || async move {
            let listener = TcpListener::bind(addr)
                .await
                .map_err(|e| Error::io(format!("bind {addr}"), e))?;
            println!("listening on http://{addr}");
            Ok(listener)
        },
        move |listener, stopped| async move {
            let app = Router::new()
                .route("/", get(index))
                .route("/hello/{name}", get(hello))
                .with_state(state);
            axum::serve(listener, app)
                .with_graceful_shutdown(stopped)
                .await
                .map_err(|e| Error::io(format!("serve {addr}"), e))
        },
    ))
}

fn http_domain() -> Module {
    Module::builder("http")
        .provide_private(new_greeter)
        .provide(new_state)
        .invoke(register_http)
}

#[tokio::main]
async fn main() -> modrun::Result<()> {
    init();

    Modrun::builder()
        .supply(Config {
            addr: SocketAddr::from(([127, 0, 0, 1], 3000)),
        })
        .module(http_domain())
        .run()
        .await
}