rumqttd 0.20.0

rumqttd is a high performance MQTT broker written in Rust which is light weight and embeddable
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

use crate::router::{Event, Meter};
use crate::ConnectionId;
use flume::{Receiver, RecvError, RecvTimeoutError, SendError, Sender, TryRecvError, TrySendError};

#[derive(Debug, thiserror::Error)]
pub enum LinkError {
    #[error("Channel try send error")]
    TrySend(#[from] TrySendError<(ConnectionId, Event)>),
    #[error("Channel send error")]
    Send(#[from] SendError<(ConnectionId, Event)>),
    #[error("Channel recv error")]
    Recv(#[from] RecvError),
    #[error("Channel timeout recv error")]
    RecvTimeout(#[from] RecvTimeoutError),
    #[error("Timeout = {0}")]
    Elapsed(#[from] tokio::time::error::Elapsed),
    #[error("Channel try_recv error")]
    TryRecv(#[from] TryRecvError),
}

pub struct MetersLink {
    router_rx: Receiver<Vec<Meter>>,
}

impl MetersLink {
    pub fn new(router_tx: Sender<(ConnectionId, Event)>) -> Result<MetersLink, LinkError> {
        let (tx, rx) = flume::bounded(100);

        router_tx.send((0, Event::NewMeter(tx)))?;
        let link = MetersLink { router_rx: rx };
        Ok(link)
    }

    pub async fn init(router_tx: Sender<(ConnectionId, Event)>) -> Result<MetersLink, LinkError> {
        let (tx, rx) = flume::bounded(100);

        router_tx.send_async((0, Event::NewMeter(tx))).await?;
        let link = MetersLink { router_rx: rx };
        Ok(link)
    }

    pub fn recv(&self) -> Result<Vec<Meter>, LinkError> {
        let o = self.router_rx.try_recv()?;
        Ok(o)
    }

    pub async fn next(&self) -> Result<Vec<Meter>, LinkError> {
        let o = self.router_rx.recv_async().await?;
        Ok(o)
    }
}