liminal-rs 0.16.0

A conversation-based messaging bus built on beamr
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

//! `Frame`'s `Debug`, written by hand (ACCESS-004 R5).
//!
//! A `Connect` carries a credential, a bearer token or a whole registry
//! pass, so its `Debug` names `auth_token` by its length only. Every other
//! variant prints exactly what the derived `Debug` printed: its name and
//! each field, in declaration order, listed once below.

use core::fmt;

use super::Frame;

/// A credential field: its length, never its bytes.
struct ByteLength(usize);

impl fmt::Debug for ByteLength {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "{} bytes", self.0)
    }
}

macro_rules! frame_debug {
    ($($variant:ident { $($field:ident),* }),* $(,)?) => {
        impl fmt::Debug for Frame {
            fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                match self {
                    Self::Connect {
                        flags,
                        min_version,
                        max_version,
                        auth_token,
                    } => formatter
                        .debug_struct("Connect")
                        .field("flags", flags)
                        .field("min_version", min_version)
                        .field("max_version", max_version)
                        .field("auth_token", &ByteLength(auth_token.len()))
                        .finish(),
                    $(Self::$variant { $($field),* } => {
                        let mut out = formatter.debug_struct(stringify!($variant));
                        $(out.field(stringify!($field), $field);)*
                        out.finish()
                    })*
                }
            }
        }
    };
}

frame_debug! {
    ConnectAck { flags, selected_version, capabilities },
    ConnectError { flags, reason_code, message },
    Disconnect { flags },
    DisconnectReason { flags, reason },
    Subscribe { flags, stream_id, channel, accepted_schemas, max_in_flight },
    SubscribeAck { flags, stream_id, subscription_id, selected_schema },
    SubscribeError { flags, stream_id, reason_code, message },
    Unsubscribe { flags, stream_id, subscription_id },
    Publish { flags, stream_id, channel, envelope, idempotency_key },
    PublishAck { flags, stream_id, message_id, durable_position },
    PublishError { flags, stream_id, reason_code, message },
    ConversationOpen { flags, stream_id, conversation_id, subject },
    ConversationMessage { flags, stream_id, conversation_id, envelope },
    ConversationClose { flags, stream_id, conversation_id, reason_code, message },
    ConversationError { flags, stream_id, conversation_id, reason_code, message },
    Accept { flags, stream_id, referenced_message_id },
    Defer { flags, stream_id, referenced_message_id, reason },
    Reject { flags, stream_id, referenced_message_id, reason },
    Ping { flags },
    Pong { flags },
    Push { flags, stream_id, correlation_id, payload },
    PushReply { flags, stream_id, correlation_id, payload },
    WorkerRegister { flags, registration },
    WorkerRegisterAck { flags, outcome },
    Deliver { flags, stream_id, delivery_seq, envelope, message },
    LinkOpen { flags, stream_id, offer },
    LinkOpenAck { flags, stream_id, outcome },
    LinkMessage { flags, stream_id, subject, sealed },
    Unknown { type_id, flags, stream_id, payload },
}