malkuth 0.1.0

A composable service-supervision toolkit for Rust
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

//! Minimal malkuth service: drain controller + JSON-RPC server + lifecycle methods.
//!
//! Run: `cargo run --example minimal_server --features tcp,signals`

use serde_json::json;
use std::sync::Arc;

use malkuth::{Client, Router, Supervised, Transport, transport::TcpTransport};

#[tokio::main]
async fn main() {
    // 1. Bind a TCP listener for JSON-RPC.
    let listener = TcpTransport
        .listen("tcp://127.0.0.1:0")
        .await
        .expect("bind failed");
    let addr = listener.local_addr().unwrap();
    println!("JSON-RPC listening on tcp://{addr}");

    // 2. Build the supervised service: signal handling + drain + custom routes.
    let supervised = Supervised::new().signals();
    let ctrl = supervised.drain_controller();

    let router = Arc::new(
        Router::new()
            .lifecycle(ctrl.clone(), None)
            .route("ping", |_| Box::pin(async { Ok(json!("pong")) })),
    );

    // 3. Serve until SIGTERM/SIGINT, then run drain hooks.
    println!("Press Ctrl-C to stop…");
    supervised
        .serve_rpc_listener(listener, router)
        .await
        .expect("serve failed");
    println!("Service stopped.");

    // --- demonstrate the client side ---
    let mut client = Client::connect(&TcpTransport, &format!("tcp://{addr}"))
        .await
        .expect("connect failed");
    let resp = client.call("ping", json!({})).await.unwrap();
    println!("ping → {resp}");
}