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

//! MQTT Client Trait for Mockability
//!
//! This module provides a trait interface for the MQTT client to enable
//! mocking and testing without a real broker connection.

use crate::error::Result;
use crate::types::{
    ConnectOptions, ConnectResult, Message, PublishOptions, PublishResult, SubscribeOptions,
};
use crate::QoS;
use std::future::Future;

/// Trait defining the interface for an MQTT client
///
/// This trait enables mocking for testing and provides a clean interface
/// for different MQTT client implementations.
pub trait MqttClientTrait: Send + Sync {
    /// Checks if the client is connected to the broker
    ///
    /// # Errors
    ///
    /// Returns an error if the operation fails
    fn is_connected(&self) -> impl Future<Output = bool> + Send + '_;

    /// Gets the client ID
    fn client_id(&self) -> impl Future<Output = String> + Send + '_;

    /// Connects to the MQTT broker with default options
    fn connect<'a>(&'a self, address: &'a str) -> impl Future<Output = Result<()>> + Send + 'a;

    /// Connects to the MQTT broker with custom options
    fn connect_with_options<'a>(
        &'a self,
        address: &'a str,
        options: ConnectOptions,
    ) -> impl Future<Output = Result<ConnectResult>> + Send + 'a;

    /// Disconnects from the MQTT broker
    fn disconnect(&self) -> impl Future<Output = Result<()>> + Send + '_;

    /// Publishes a message to a topic with default options
    fn publish<'a>(
        &'a self,
        topic: impl Into<String> + Send + 'a,
        payload: impl Into<Vec<u8>> + Send + 'a,
    ) -> impl Future<Output = Result<PublishResult>> + Send + 'a;

    /// Publishes a message to a topic with specific `QoS`
    fn publish_qos<'a>(
        &'a self,
        topic: impl Into<String> + Send + 'a,
        payload: impl Into<Vec<u8>> + Send + 'a,
        qos: QoS,
    ) -> impl Future<Output = Result<PublishResult>> + Send + 'a;

    /// Publishes a message with custom options
    fn publish_with_options<'a>(
        &'a self,
        topic: impl Into<String> + Send + 'a,
        payload: impl Into<Vec<u8>> + Send + 'a,
        options: PublishOptions,
    ) -> impl Future<Output = Result<PublishResult>> + Send + 'a;

    /// Subscribes to a topic with a callback, returning (`packet_id`, `granted_qos`)
    fn subscribe<'a, F>(
        &'a self,
        topic_filter: impl Into<String> + Send + 'a,
        callback: F,
    ) -> impl Future<Output = Result<(u16, QoS)>> + Send + 'a
    where
        F: Fn(Message) + Send + Sync + 'static;

    /// Subscribes to a topic with custom options and a callback
    fn subscribe_with_options<'a, F>(
        &'a self,
        topic_filter: impl Into<String> + Send + 'a,
        options: SubscribeOptions,
        callback: F,
    ) -> impl Future<Output = Result<(u16, QoS)>> + Send + 'a
    where
        F: Fn(Message) + Send + Sync + 'static;

    /// Unsubscribes from a topic
    fn unsubscribe<'a>(
        &'a self,
        topic_filter: impl Into<String> + Send + 'a,
    ) -> impl Future<Output = Result<()>> + Send + 'a;

    /// Subscribe to multiple topics at once
    fn subscribe_many<'a, F>(
        &'a self,
        topics: Vec<(&'a str, QoS)>,
        callback: F,
    ) -> impl Future<Output = Result<Vec<(u16, QoS)>>> + Send + 'a
    where
        F: Fn(Message) + Send + Sync + 'static + Clone;

    /// Unsubscribe from multiple topics at once
    ///
    /// Returns a vector of results, one for each topic
    fn unsubscribe_many<'a>(
        &'a self,
        topics: Vec<&'a str>,
    ) -> impl Future<Output = Result<Vec<(String, Result<()>)>>> + Send + 'a;

    /// Publish a retained message
    fn publish_retain<'a>(
        &'a self,
        topic: impl Into<String> + Send + 'a,
        payload: impl Into<Vec<u8>> + Send + 'a,
    ) -> impl Future<Output = Result<PublishResult>> + Send + 'a;

    /// Publish with `QoS` 0 (convenience method)
    fn publish_qos0<'a>(
        &'a self,
        topic: impl Into<String> + Send + 'a,
        payload: impl Into<Vec<u8>> + Send + 'a,
    ) -> impl Future<Output = Result<PublishResult>> + Send + 'a;

    /// Publish with `QoS` 1 (convenience method)
    fn publish_qos1<'a>(
        &'a self,
        topic: impl Into<String> + Send + 'a,
        payload: impl Into<Vec<u8>> + Send + 'a,
    ) -> impl Future<Output = Result<PublishResult>> + Send + 'a;

    /// Publish with `QoS` 2 (convenience method)
    fn publish_qos2<'a>(
        &'a self,
        topic: impl Into<String> + Send + 'a,
        payload: impl Into<Vec<u8>> + Send + 'a,
    ) -> impl Future<Output = Result<PublishResult>> + Send + 'a;

    /// Check if message queuing is enabled
    fn is_queue_on_disconnect(&self) -> impl Future<Output = bool> + Send + '_;

    /// Set whether to queue messages when disconnected
    fn set_queue_on_disconnect(&self, enabled: bool) -> impl Future<Output = ()> + Send + '_;
}