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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use std::{convert::TryFrom, time::Duration};

#[derive(Debug)]
pub(crate) struct QueueDescriptor {
    pub vt: Duration,
    pub delay: Duration,
    pub maxsize: i64,
    pub ts: u64,
    pub uid: Option<String>,
}

/// Options for creating a new RSMQ instance.
#[derive(Debug, Clone)]
pub struct RsmqOptions {
    /// Redis host
    pub host: String,
    /// Redis port
    pub port: u16,
    /// Redis db
    pub db: u8,
    /// If true, it will use redis pubsub to notify clients about new messages.
    /// More info in the general crate description
    pub realtime: bool,
    /// Redis username
    pub username: Option<String>,
    /// Redis password
    pub password: Option<String>,
    /// RSMQ namespace (you can have several. "rsmq" by default)
    pub ns: String,
}

impl Default for RsmqOptions {
    fn default() -> Self {
        RsmqOptions {
            host: "localhost".to_string(),
            port: 6379,
            db: 0,
            realtime: false,
            username: None,
            password: None,
            ns: "rsmq".to_string(),
        }
    }
}

/// A new RSMQ message. You will get this when using pop_message or receive_message methods
#[derive(Debug, Clone)]
pub struct RsmqMessage<T: TryFrom<RedisBytes> = String> {
    /// Message id. Used later for change_message_visibility and delete_message
    pub id: String,
    /// Message content.
    pub message: T,
    /// Number of times the message was received by a client
    pub rc: u64,
    /// Timestamp (epoch in seconds) of when was this message received
    pub fr: u64,
    /// Timestamp (epoch in seconds) of when was this message sent
    pub sent: u64,
}

/// Struct defining a queue. They are set on "create_queue" and "set_queue_attributes"
#[derive(Debug, Clone)]
pub struct RsmqQueueAttributes {
    /// How long the message will be hidden when is received by a client
    pub vt: Duration,
    /// How many second will take until the message is delivered to a client
    /// since it was sent
    pub delay: Duration,
    /// Max size of the message in bytes in the queue
    pub maxsize: i64,
    /// Number of messages received by the queue
    pub totalrecv: u64,
    /// Number of messages sent by the queue
    pub totalsent: u64,
    /// When was this queue created. Timestamp (epoch in seconds)
    pub created: u64,
    /// When was this queue last modified. Timestamp (epoch in seconds)
    pub modified: u64,
    /// How many messages the queue contains
    pub msgs: u64,
    /// How many messages are hidden from the queue. This number depends of
    /// the "vt" attribute and messages with a different hidden time modified
    /// by "change_message_visibility" method
    pub hiddenmsgs: u64,
}

/// Internal value representing the redis bytes.
/// It implements `TryFrom` `String` and `Vec<u8>`
/// and `From String`, `&str`, `Vec<u8>` and `&[u8]` to
/// itself.
///
/// You can add your custom TryFrom and From
/// implementation in order to make automatically
/// transform you value to yours when executing a
/// command in redis.
///
/// As example, the current String implementation:
///
/// ```rust,ignore
/// use std::convert::TryFrom;
/// use rsmq_async::RedisBytes;
///  
/// impl TryFrom<RedisBytes> for String {
///     type Error = Vec<u8>;
///
///     fn try_from(bytes: RedisBytes) -> Result<Self, Self::Error> {
///         String::from_utf8(bytes.0).map_err(|e| e.into_bytes())
///     }
/// }
/// ```
#[derive(Debug)]
pub struct RedisBytes(pub(crate) Vec<u8>);

impl RedisBytes {
    /// Consumes the value and returns the raw bytes as `Vec<u8>`
    pub fn into_bytes(self) -> Vec<u8> {
        self.0
    }
}

impl TryFrom<RedisBytes> for String {
    type Error = Vec<u8>;

    fn try_from(bytes: RedisBytes) -> Result<Self, Self::Error> {
        // For the library user, they can just call into_bytes
        // for getting the original Vec<u8>
        String::from_utf8(bytes.0).map_err(|e| e.into_bytes())
    }
}

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

    fn try_from(bytes: RedisBytes) -> Result<Self, Vec<u8>> {
        Ok(bytes.0)
    }
}

impl From<String> for RedisBytes {
    fn from(t: String) -> RedisBytes {
        RedisBytes(t.into())
    }
}

impl From<&str> for RedisBytes {
    fn from(t: &str) -> RedisBytes {
        RedisBytes(t.into())
    }
}

impl From<Vec<u8>> for RedisBytes {
    fn from(t: Vec<u8>) -> RedisBytes {
        RedisBytes(t)
    }
}

impl From<&[u8]> for RedisBytes {
    fn from(t: &[u8]) -> RedisBytes {
        RedisBytes(t.into())
    }
}