rustzmq2 0.1.0

A native async Rust implementation of ZeroMQ
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

//! Implements a codec for ZMQ, providing a way to convert from a byte-oriented
//! io device to a protocal comprised of [`Message`] frames. See [`FramedIo`]

mod command;
pub(crate) mod framed;
mod greeting;
pub(crate) mod handshake;
pub(crate) mod mechanism;
pub(crate) mod zmq_codec;

pub(crate) use crate::error::CodecError;
#[cfg(any(feature = "tcp", all(feature = "ipc", target_family = "unix")))]
pub(crate) use crate::error::CodecResult;
#[cfg(feature = "curve")]
pub(crate) use command::CurveFrame;
pub use command::HeartbeatFrame;
#[cfg(any(feature = "tcp", all(feature = "ipc", target_family = "unix")))]
pub(crate) use command::PlainFrame;
pub(crate) use command::ZmqCommand;
#[cfg(any(feature = "tcp", all(feature = "ipc", target_family = "unix")))]
pub(crate) use command::ZmqCommandName;
#[cfg(all(feature = "smol", not(feature = "tokio"), feature = "tcp"))]
pub(crate) use framed::smol::SmolFramedIo;
#[cfg(all(
    feature = "tokio",
    any(feature = "tcp", all(feature = "ipc", target_family = "unix"))
))]
pub(crate) use framed::TcpFramedIo as DefaultFramedIo;
pub use framed::{FramedIo, IntoEngineWriter};

/// Runtime-neutral concrete `FramedIo` alias: `DefaultFramedIo` under tokio,
/// `SmolFramedIo` under smol. The two runtimes are mutually exclusive.
/// Only used by wire transports (TCP/IPC); inproc bypasses framing entirely.
#[cfg(all(
    feature = "tokio",
    any(feature = "tcp", all(feature = "ipc", target_family = "unix"))
))]
pub(crate) type RuntimeFramedIo = DefaultFramedIo;
#[cfg(all(
    feature = "smol",
    not(feature = "tokio"),
    any(feature = "tcp", all(feature = "ipc", target_family = "unix"))
))]
pub(crate) type RuntimeFramedIo = SmolFramedIo;
pub(crate) use greeting::{ZmqGreeting, ZmtpVersion};
#[cfg(any(feature = "tcp", all(feature = "ipc", target_family = "unix")))]
pub(crate) use zmq_codec::ZmqCodec;

use crate::message::ZmqMessage;

use std::sync::Arc;

#[allow(clippy::enum_variant_names)]
#[non_exhaustive]
#[derive(Debug, Clone)]
pub enum Message {
    Greeting(ZmqGreeting),
    Command(ZmqCommand),
    Message(ZmqMessage),
    /// Shared broadcast payload. Used by PUB/XPUB to fan one message out to N
    /// subscribers via a single `Arc::clone` instead of cloning the `VecDeque`
    /// plus every Bytes refcount per subscriber.
    ///
    /// Protocol-level semantics are identical to `Message`; the only
    /// difference is ownership.
    Shared(Arc<ZmqMessage>),
    /// ZMTP PING/PONG heartbeat frame. The `#[non_exhaustive]` attribute
    /// on `Message` prevents downstream `match` arms from breaking on this
    /// addition.
    Heartbeat(HeartbeatFrame),
    /// Raw security handshake command frame (HELLO/WELCOME/INITIATE/READY/ERROR).
    /// Emitted by the codec for all mechanism-specific command names so
    /// that `mechanism.rs` can parse them with mechanism context rather
    /// than the codec needing to know which mechanism is active.
    SecurityRaw(bytes::Bytes),
}