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
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

//! Per-peer identity as defined by [ZMTP RFC 23](https://rfc.zeromq.org/spec/23/),
//! corresponding to libzmq's `ZMQ_ROUTING_ID` / historic `ZMQ_IDENTITY` option.

use crate::ZmqError;

use bytes::Bytes;
use uuid::Uuid;

use std::convert::TryFrom;
use std::ops::Deref;
use std::str::FromStr;

/// Per-peer identity (up to 255 bytes). Equivalent to libzmq's
/// `ZMQ_ROUTING_ID` — used to address a specific peer through a ROUTER
/// socket and surfaced in [`SocketEvent`](crate::SocketEvent)s.
///
/// # Examples
///
/// ```
/// use rustzmq2::PeerIdentity;
/// use std::str::FromStr;
///
/// // Identities are arbitrary bytes up to 255 long; > 255 errors out.
/// let id = PeerIdentity::try_from(&b"worker-1"[..]).unwrap();
/// assert_eq!(id.as_ref(), b"worker-1");
///
/// // Display is hex (safe for arbitrary bytes); use `as_ref()` for raw bytes.
/// assert_eq!(format!("{id}"), "776f726b65722d31");
///
/// // String parsing.
/// let parsed = PeerIdentity::from_str("worker-1").unwrap();
/// assert_eq!(id, parsed);
///
/// // No identity set → a fresh UUID is generated.
/// let _auto = PeerIdentity::new();
/// ```
#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Hash, Clone)]
pub struct PeerIdentity(Bytes);

impl PeerIdentity {
    pub const MAX_LENGTH: usize = 255;

    pub fn new() -> Self {
        let id = Uuid::new_v4();
        Self(Bytes::copy_from_slice(id.as_bytes()))
    }
}

impl AsRef<[u8]> for PeerIdentity {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl std::borrow::Borrow<[u8]> for PeerIdentity {
    fn borrow(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl std::fmt::Display for PeerIdentity {
    /// Render the identity as hex. Identities can be arbitrary bytes —
    /// hex is the safe lossless rendering. Use `as_ref()` if you need
    /// the raw bytes.
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for byte in self.0.as_ref() {
            write!(f, "{:02x}", byte)?;
        }
        Ok(())
    }
}

impl Deref for PeerIdentity {
    type Target = [u8];

    fn deref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl Default for PeerIdentity {
    fn default() -> Self {
        Self::new()
    }
}

impl FromStr for PeerIdentity {
    type Err = ZmqError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::try_from(s.as_bytes())
    }
}

impl TryFrom<Bytes> for PeerIdentity {
    type Error = ZmqError;

    fn try_from(data: Bytes) -> Result<Self, ZmqError> {
        if data.is_empty() {
            Ok(Self::new())
        } else if data.len() > Self::MAX_LENGTH {
            Err(ZmqError::PeerIdentity)
        } else {
            Ok(Self(data))
        }
    }
}

impl TryFrom<&[u8]> for PeerIdentity {
    type Error = ZmqError;

    fn try_from(data: &[u8]) -> Result<Self, ZmqError> {
        Self::try_from(Bytes::copy_from_slice(data))
    }
}

impl TryFrom<Vec<u8>> for PeerIdentity {
    type Error = ZmqError;

    fn try_from(data: Vec<u8>) -> Result<Self, ZmqError> {
        Self::try_from(Bytes::from(data))
    }
}

impl From<PeerIdentity> for Bytes {
    fn from(p_id: PeerIdentity) -> Self {
        p_id.0
    }
}

impl From<PeerIdentity> for Vec<u8> {
    fn from(p_id: PeerIdentity) -> Self {
        p_id.0.to_vec()
    }
}