distributed 4.0.2

CQRS/ES framework for Rust using Plain Old Rust Structs — append-only events, replay, snapshots, outbox, service bus, and pluggable infrastructure
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

//! `microsvc::Service` as a transport [`MessageRouter`].
//!
//! This is the bridge that lets the bus consume side run a service without the
//! bus naming `Service`. Handler-error classification into the transport's
//! retryable/permanent vocabulary happens here, on the microsvc side, so the
//! bus-core runner only ever sees an already-classified `TransportError`.

use crate::bus::{MessageRouter, OrderedDelivery, TransportError};
use crate::microsvc::{Message, MessageKind, Service, SubscriptionPlan};

impl MessageRouter for Service {
    fn consumer_group(&self) -> Option<&str> {
        self.name()
    }

    fn handles(&self, kind: MessageKind, name: &str) -> bool {
        self.handles_message(kind, name)
    }

    fn subscription_plan(&self) -> SubscriptionPlan {
        // Call the inherent method, not this trait method (which would recurse).
        Service::subscription_plan(self)
    }

    async fn dispatch(&self, message: &Message) -> Result<(), TransportError> {
        self.dispatch_message(message)
            .await
            .map(|_| ())
            .map_err(TransportError::from)
    }

    async fn dispatch_ordered(
        &self,
        message: &Message,
        ordered: Option<&OrderedDelivery>,
    ) -> Result<(), TransportError> {
        self.dispatch_ordered_message(message, ordered)
            .await
            .map(|_| ())
            .map_err(TransportError::from)
    }
}