mqtt5 0.31.2

Complete MQTT v5.0 platform with high-performance async client and full-featured broker supporting TCP, TLS, WebSocket, authentication, bridging, and resource monitoring
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

use bytes::Bytes;
use mqtt5_protocol::packet::publish::PublishPacket;
use mqtt5_protocol::packet::suback::SubAckReasonCode as ProtocolSubAckReasonCode;
use mqtt5_protocol::types::ReasonCode;
use mqtt5_protocol::QoS;
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;

pub enum PublishAction {
    Continue,
    Handled,
    Transform(PublishPacket),
}

#[derive(Debug, Clone)]
pub struct ClientConnectEvent {
    pub client_id: Arc<str>,
    pub clean_start: bool,
    pub session_expiry_interval: u32,
    pub will_topic: Option<Arc<str>>,
    pub will_payload: Option<Bytes>,
    pub will_qos: Option<QoS>,
    pub will_retain: Option<bool>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SubAckReasonCode {
    GrantedQoS0,
    GrantedQoS1,
    GrantedQoS2,
    UnspecifiedError,
    ImplementationSpecificError,
    NotAuthorized,
    TopicFilterInvalid,
    PacketIdentifierInUse,
    QuotaExceeded,
    SharedSubscriptionsNotSupported,
    SubscriptionIdentifiersNotSupported,
    WildcardSubscriptionsNotSupported,
}

impl From<ProtocolSubAckReasonCode> for SubAckReasonCode {
    fn from(code: ProtocolSubAckReasonCode) -> Self {
        match code {
            ProtocolSubAckReasonCode::GrantedQoS0 => Self::GrantedQoS0,
            ProtocolSubAckReasonCode::GrantedQoS1 => Self::GrantedQoS1,
            ProtocolSubAckReasonCode::GrantedQoS2 => Self::GrantedQoS2,
            ProtocolSubAckReasonCode::UnspecifiedError => Self::UnspecifiedError,
            ProtocolSubAckReasonCode::ImplementationSpecificError => {
                Self::ImplementationSpecificError
            }
            ProtocolSubAckReasonCode::NotAuthorized => Self::NotAuthorized,
            ProtocolSubAckReasonCode::TopicFilterInvalid => Self::TopicFilterInvalid,
            ProtocolSubAckReasonCode::PacketIdentifierInUse => Self::PacketIdentifierInUse,
            ProtocolSubAckReasonCode::QuotaExceeded => Self::QuotaExceeded,
            ProtocolSubAckReasonCode::SharedSubscriptionsNotSupported => {
                Self::SharedSubscriptionsNotSupported
            }
            ProtocolSubAckReasonCode::SubscriptionIdentifiersNotSupported => {
                Self::SubscriptionIdentifiersNotSupported
            }
            ProtocolSubAckReasonCode::WildcardSubscriptionsNotSupported => {
                Self::WildcardSubscriptionsNotSupported
            }
        }
    }
}

#[derive(Debug, Clone)]
pub struct SubscriptionInfo {
    pub topic_filter: Arc<str>,
    pub qos: QoS,
    pub result: SubAckReasonCode,
}

#[derive(Debug, Clone)]
pub struct ClientSubscribeEvent {
    pub client_id: Arc<str>,
    pub subscriptions: Vec<SubscriptionInfo>,
}

#[derive(Debug, Clone)]
pub struct ClientUnsubscribeEvent {
    pub client_id: Arc<str>,
    pub topic_filters: Vec<Arc<str>>,
}

#[derive(Debug, Clone)]
pub struct ClientPublishEvent {
    pub client_id: Arc<str>,
    pub user_id: Option<Arc<str>>,
    pub topic: Arc<str>,
    pub payload: Bytes,
    pub qos: QoS,
    pub retain: bool,
    pub packet_id: Option<u16>,
    pub response_topic: Option<Arc<str>>,
    pub correlation_data: Option<Bytes>,
}

#[derive(Debug, Clone)]
pub struct ClientDisconnectEvent {
    pub client_id: Arc<str>,
    pub reason: ReasonCode,
    pub unexpected: bool,
}

#[derive(Debug, Clone)]
pub struct RetainedSetEvent {
    pub topic: Arc<str>,
    pub payload: Bytes,
    pub qos: QoS,
    pub cleared: bool,
}

#[derive(Debug, Clone)]
pub struct MessageDeliveredEvent {
    pub client_id: Arc<str>,
    pub packet_id: u16,
    pub qos: QoS,
}

pub trait BrokerEventHandler: Send + Sync {
    fn on_client_connect<'a>(
        &'a self,
        _event: ClientConnectEvent,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
        Box::pin(async {})
    }

    fn on_client_subscribe<'a>(
        &'a self,
        _event: ClientSubscribeEvent,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
        Box::pin(async {})
    }

    fn on_client_unsubscribe<'a>(
        &'a self,
        _event: ClientUnsubscribeEvent,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
        Box::pin(async {})
    }

    fn on_client_publish<'a>(
        &'a self,
        _event: ClientPublishEvent,
    ) -> Pin<Box<dyn Future<Output = PublishAction> + Send + 'a>> {
        Box::pin(async { PublishAction::Continue })
    }

    fn on_client_disconnect<'a>(
        &'a self,
        _event: ClientDisconnectEvent,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
        Box::pin(async {})
    }

    fn on_retained_set<'a>(
        &'a self,
        _event: RetainedSetEvent,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
        Box::pin(async {})
    }

    fn on_message_delivered<'a>(
        &'a self,
        _event: MessageDeliveredEvent,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
        Box::pin(async {})
    }
}