Crate rumqttc

A pure rust mqtt client which strives to be robust, efficient and easy to use.

• Eventloop is just an async Stream which can be polled by tokio
• Requests to eventloop is also a Stream. Solves both bounded an unbounded usecases
• Robustness just a loop away
• Flexible access to the state of eventloop to control its behaviour

Accepts any stream of Requests

Build bounded, unbounded, interruptible or any other stream (that fits your need) to feed the eventloop.

Few of our real world use cases

• A stream which orchestrates data between disk and memory by detecting backpressure and never (practically) loose data
• A stream which juggles data between several channels based on priority of the data

#[tokio::main(core_threads = 1)]
async fn main() {
    let mut mqttoptions = MqttOptions::new("test-1", "localhost", 1883);
    let requests = Vec::new::<Request>();

    let mut eventloop = eventloop(mqttoptions, requests_rx);
    let mut stream = eventloop.connect().await.unwrap();
    while let Some(item) = stream.next().await {
        println!("Received = {:?}", item);
    }
}

Robustness a loop away

Networks are unreliable. But robustness is easy

• Just create a new stream from the existing eventloop
• Resumes from where it left
• Access the state of the eventloop to customize the behaviour of the next connection

#[tokio::main(core_threads = 1)]
async fn main() {
    let mut mqttoptions = MqttOptions::new("test-1", "localhost", 1883);
    let requests = Vec::new::<Request>();

    let mut eventloop = eventloop(mqttoptions, requests_rx);

    // loop to reconnect and resume
    loop {
        let mut stream = eventloop.connect().await.unwrap();
        while let Some(item) = stream.next().await {
            println!("Received = {:?}", item);
        }

        time::delay_for(Duration::from_secs(1)).await;
    }
}

Eventloop is just a stream which can be polled with tokio

• Plug it into select! join! to interleave with other streams on the the same thread

#[tokio::main(core_threads = 1)]
async fn main() {
    let mut mqttoptions = MqttOptions::new("test-1", "localhost", 1883);
    let requests = Vec::new::<Request>();

    let mut eventloop = eventloop(mqttoptions, requests_rx);

    // plug it into tokio ecosystem
    let mut stream = eventloop.connect().await.unwrap();
}

Powerful notification system to control the runtime

Eventloop stream yields all the interesting event ranging for data on the network to disconnections and reconnections. Use it the way you see fit

• Resubscribe after reconnection
• Stop after receiving Nth puback

#[tokio::main(core_threads = 1)]
async fn main() {
    let mut mqttoptions = MqttOptions::new("test-1", "localhost", 1883);
    let (requests_tx, requests_rx) = channel(10);

    let mut eventloop = eventloop(mqttoptions, requests_rx);

    // loop to reconnect and resume
    loop {
        let mut stream = eventloop.connect().await.unwrap();
        while let Some(notification) = stream.next().await {
            println!("Received = {:?}", item);
            match notification {
                Notification::Connect => requests_tx.send(subscribe).unwrap(),
            }
        }

        time::delay_for(Duration::from_secs(1)).await;
    }
}

Structs

Client	Client can communicate with MQTT eventloop Connection. Client is cloneable and can be used to synchronously Publish, Subscribe as well as receive incoming MQTT messages
ConnAck
Connect
EventLoop	Complete state of the eventloop
LastWill
MqttCodec
MqttOptions	Options to configure the behaviour of mqtt connection
MqttState	State of the mqtt connection.
PubAck
PubComp
PubRec
PubRel
Publish
SubAck
Subscribe
SubscribeTopic
UnsubAck
Unsubscribe

Enums

Command	Commands sent by the client to mqtt event loop. Commands are of higher priority and will be selected along with [request]s
ConnectReturnCode
ConnectionError	Critical errors during eventloop polling
Error
Error
Incoming	Includes incoming packets from the network and other interesting events happening in the eventloop
Key
Outgoing
Packet
PacketType
Protocol
QoS
Request	Requests by the client to mqtt event loop. Request are handle one by one
SecurityOptions	Client authentication option for mqtt connect packet
SubscribeReturnCodes

Functions

has_wildcards
matches	checks if topic matches a filter. topic and filter validation isn't done here. NOTE: 'topic' is a misnomer in the arg. this can also be used to match 2 wild subscriptions NOTE: make sure a topic is validated during a publish and filter is validated during a subscribe
mqtt_read
mqtt_write
packet_type	7 3 0 +--------------------------+--------------------------+ byte 1 | MQTT Control Packet Type | Flags for each type | +--------------------------+--------------------------+ | Remaining Bytes Len (1 - 4 bytes) | +-----------------------------------------------------+
qos
valid_filter	checks if the filter is valid https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc398718106
valid_topic	checks if a topic is valid