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

//! Routing layer: registry of services plus a pluggable load balancer
//! driving the [`Router`], which turns [`Envelope`] destinations into
//! concrete [`Service`](crate::Service) instances.

mod builder;

pub use builder::Builder;

use crate::{
    Balancer,
    Envelope,
    Error,
    Registry,
    Reply,
    Result,
};

/// Routes [`Envelope`]s to registered [`Service`](crate::Service) with
/// load balancing.
///
/// The `Router` looks up [`Service`](crate::Service) instances in the
/// [`Registry`] based on the [`Envelope`] destination
/// [`Address`](crate::Address) string representation, then delegates
/// instance selection to the internal [`Balancer`] before calling
/// [`process()`](crate::Service::process) on the chosen
/// instance.
///
/// # Examples
///
/// ```ignore
/// let mut router = Router::builder()
///     .registry(registry)
///     .balancer("least_connections")
///     .build();
///
/// let reply = router.route(envelope)?;
/// ```
pub struct Router {
    registry: Registry,
    balancer: Balancer,
}

impl Router {
    /// Returns a new `Builder` with default configuration.
    pub fn builder() -> Builder { Builder::default() }

    /// Routes a [`message`](Envelope) to a registered
    /// [`Service`](crate::Service) and returns its [`Reply`].
    ///
    /// This method:
    /// 1. Looks up instances for
    ///    [`msg.destination()`](Envelope::destination) in the
    ///    [`Registry`].
    /// 2. Uses the [`Balancer`] to select one instance.
    /// 3. Calls [`process()`](crate::Service::process) on that instance.
    ///
    /// Returns [`Error::ServiceNotFound`] if no
    /// [`Service`](crate::Service) is registered under the destination
    /// [`Address`](crate::Address) string representation.
    pub fn route(&mut self, msg: Envelope) -> Result<Reply> {
        let instances = self
            .registry
            .get(
                msg.destination()
                    .to_string()
                    .as_str(),
            )
            .ok_or(Error::ServiceNotFound)?;

        let service = self
            .balancer
            .select(instances)?;

        service.process(msg)
    }

    /// Returns a reference to the underlying [`Service`](crate::Service)
    /// [`Registry`].
    pub fn registry(&self) -> &Registry { &self.registry }

    /// Returns the active balancing `Strategy` as a string.
    pub fn balancing_strategy(&self) -> &str { self.balancer.strategy() }
}

//  +------------+
//  | UNIT TESTS |
//  +------------+

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn build_default_router() {
        let router = Router::builder().build();
        let list = router.registry.list();

        assert_eq!(router.balancer.strategy(), "round_robin");
        assert!(list.is_empty());
    }

    #[test]
    fn build_router_with_balancer() {
        let strategy = "least_connections";
        let router = Router::builder()
            .balancer(strategy)
            .build();

        let list = router.registry.list();

        assert_eq!(router.balancer.strategy(), strategy);
        assert!(list.is_empty());
    }

    #[test]
    fn build_router_with_registry() {
        let registry = Registry::builder().build();
        let router = Router::builder()
            .registry(registry)
            .build();

        let list = router.registry.list();

        assert!(list.is_empty());
        assert_eq!(router.balancer.strategy(), "round_robin");
    }
}