bakbon 0.1.2

BakBon is an infrastructure microkernel library in Rust that provides generic building blocks (Router, Registry, Balancer, Queue, Gateway, Cache, Middleware, Service/Processor) for message‑driven distributed systems.
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! BakBon - Infrastructure Microkernel for Distributed Systems
//!
//! BakBon provides protocol-agnostic building blocks for message-driven
//! distributed systems. Build microservices, IoT networks, or blockchain
//! infrastructure with composable, type-safe components.
//!
//! # Modules
//!
//! - `Balancer`: [`Balancer`] for load balancing.
//! - `Core`: [`Address`], [`Protocol`], [`Error`], [`Result`].
//! - `Discovery`: [`Registry`] for service discovery.
//! - `Gateway`: [`Gateway`] for network communication.
//! - `Message`: [`Envelope`], [`Headers`], [`Payload`], [`Reply`].
//! - `Infra`: [`Cache`], [`Middleware`].
//! - `Queue`: [`Queue`] and delivery semantics.
//! - `Routing`: [`Router`] for message routing.
//! - `Service`: [`Service`] and [`Processor`] traits.
//!
//! # Quick Example
//!
//! ```rust
//! use bakbon::prelude::*;
//!
//!     // Create addresses.
//!     let source = Address::parse("http://client-address.com");
//!     let destination = Address::parse("grpc://service.com/echo");
//!     assert!(source.is_ok());
//!     assert!(destination.is_ok());
//!     let src = source.unwrap();
//!     let dst = destination.unwrap();
//!
//!     // Create a payload from the bytes crate.
//!     let payload = Payload::from("Hello there");
//!
//!     // Create a message envelope.
//!     let message = Envelope::new(src, dst.clone() , payload);
//!
//!     // Create a service.
//!     #[derive(Debug)]
//!     struct NilService(Address);
//!
//!     impl Service for NilService {
//!         fn address(&self) -> &Address { &self.0 }
//!         fn duplicate(&self) -> ServiceBox { Box::new(Self(self.0.clone())) }
//!         fn process(&self, msg: Envelope) -> Result<Reply> { Ok(None) }
//!     }
//!
//!     let service = NilService(dst);
//!
//!     // Create a service registry.
//!     let registry = Registry::builder()
//!         .register(service)
//!         .build();
//!
//!     // Create a router.
//!     let mut router = Router::builder()
//!         .registry(registry)
//!         .build();
//!
//!     // Route the created message.
//!     let reply = router.route(message);
//!     assert!(reply.is_ok());
//!     let reply = reply.unwrap();
//!     assert!(reply.is_none());
//! ```
mod balancer;
mod cache;
mod core;
mod infra;
mod message;
mod queue;
mod registry;
mod router;

pub use {
    balancer::Balancer,
    bytes,
    cache::Cache,
    core::{
        Address,
        Error,
        Protocol,
        Result,
    },
    infra::{
        Gateway,
        Middleware,
        ProcMap,
        Processor,
        Service,
        ServiceBox,
        ServiceMap,
        ServiceVec,
        Storage,
    },
    message::{
        Envelope,
        Headers,
        Payload,
        Reply,
    },
    queue::Queue,
    registry::Registry,
    router::Router,
};

pub mod prelude {
    pub use crate::{
        Address,
        Balancer,
        Cache,
        Envelope,
        Error,
        Gateway,
        Headers,
        Middleware,
        Payload,
        ProcMap,
        Processor,
        Protocol,
        Queue,
        Registry,
        Reply,
        Result,
        Router,
        Service,
        ServiceBox,
        ServiceMap,
        ServiceVec,
        Storage,
    };
}