02786968348d09e5373f4f7249331bff2ed2a8f5-PR-108

Build # 02786968348d09e5373f4f7249331bff2ed2a8f5-PR-108

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/aisk/rust-memcache/commit/<a class=hub.com/aisk/rust-memcache/commit/<a class="double-link" href="https://git"><a class=hub.com/aisk/rust-memcache/commit/<a class="double-link" href="https://git"><a class=hub.com/aisk/rust-memcache/commit/02786968348d09e5373f4f7249331bff2ed2a8f5">027869683<a href="https://github.com/aisk/rust-memcache/commit/02786968348d09e5373f4f7249331bff2ed2a8f5">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/aisk/rust-memcache/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/aisk/rust-memcache/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/aisk/rust-memcache/commit/02786968348d09e5373f4f7249331bff2ed2a8f5&quot;&gt;027869683&lt;/a&gt;&lt;a href=&quot;https://github.com/aisk/rust-memcache/commit/02786968348d09e5373f4f7249331bff2ed2a8f5&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/aisk/rust-memcache/commit/02786968348d09e5373f4f7249331bff&lt;/a&gt;2ed2a8f5">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/aisk/rust-memcache/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/aisk/rust-memcache/commit/<a class="double-link" href="https://github.com/aisk/rust-memcache/commit/1158d7a04daf539b3b16b7ed6975d9c8b95efdf8">1158d7a04</a><a href="https://github.com/aisk/rust-memcache/commit/02786968348d09e5373f4f7249331bff2ed2a8f5">&amp;quot;&amp;gt;1158d7a04&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;1158d7a04&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/aisk/rust-memcache/commit/02786968348d09e5373f4f7249331bff2ed2a&lt;/a&gt;8f5&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/aisk/rust-memcache/commit/<a class="double-link" href="https://github.com/aisk/rust-memcache/commit/faed4e117">faed4e117">faed4e117</a>

Pull Request Pull Request #108: WIP: Add ClientBuilder

Run Details

74 of 116 new or added lines in 3 files covered. (63.79%)

1203 of 1880 relevant lines covered (63.99%)

5221.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.23

/src/client.rs

use std::collections::hash_map::DefaultHasher;
use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use std::time::Duration;

use url::Url;

use connection::{ConnCustomizer, ConnectionManager};
use error::MemcacheError;
use protocol::ProtocolTrait;
use r2d2::Pool;
use stream::Stream;
use value::{FromMemcacheValueExt, ToMemcacheValue};

pub type Stats = HashMap<String, String>;

pub trait Connectable {
    fn get_urls(self) -> Vec<String>;
}

impl Connectable for String {
    fn get_urls(self) -> Vec<String> {
        return vec![self];
    }
}

impl Connectable for Vec<String> {
    fn get_urls(self) -> Vec<String> {
        return self;
    }
}

impl Connectable for &str {
    fn get_urls(self) -> Vec<String> {
        return vec![self.to_string()];
    }
}

impl Connectable for Vec<&str> {
    fn get_urls(self) -> Vec<String> {
        let mut urls = vec![];
        for url in self {
            urls.push(url.to_string());
        }
        return urls;
    }
}

#[derive(Clone)]
pub struct Client {
    connections: Vec<Pool<ConnectionManager>>,
    pub hash_function: fn(&str) -> u64,
}

unsafe impl Send for Client {}

fn default_hash_function(key: &str) -> u64 {
    let mut hasher = DefaultHasher::new();
    key.hash(&mut hasher);
    return hasher.finish();
}

pub struct ClientBuilder<C> {
    target: C,
    max_size: u32,
    min_idle: Option<u32>,
    max_lifetime: Option<Duration>,
    read_timeout: Option<Duration>,
    write_timeout: Option<Duration>,
    pool_wait_timeout: Duration,
}

impl<C: Connectable> ClientBuilder<C> {
    pub fn new(target: C) -> Self {
        Self {
            target,
            max_size: 1,
            min_idle: None,
            max_lifetime: None,
            read_timeout: None,
            write_timeout: None,
            pool_wait_timeout: Duration::new(30, 0),
        }
    }

    pub fn with_min_idle(mut self, min_idle: Option<u32>) -> Self {
        self.min_idle = min_idle;
        self
    }

    pub fn with_max_lifetime(mut self, max_lifetime: Option<Duration>) -> Self {
        self.max_lifetime = max_lifetime;
        self
    }

    pub fn with_max_size(mut self, size: u32) -> Self {
        self.max_size = size;
        self
    }

    pub fn with_read_timeout(mut self, read_timeout: Option<Duration>) -> Self {
        self.read_timeout = read_timeout;
        self
    }

    pub fn with_pool_wait_timeout(mut self, pool_wait_timeout: Duration) -> Self {
        self.pool_wait_timeout = pool_wait_timeout;
        self
    }

    pub fn with_write_timeout(mut self, write_timeout: Option<Duration>) -> Self {
        self.write_timeout = write_timeout;
        self
    }

    pub fn build(self) -> Result<Client, MemcacheError> {
        let urls = self.target.get_urls();
        let mut connections = vec![];
        for url in urls {
            let parsed = Url::parse(url.as_str())?;
            let pool = Pool::builder()
                .max_size(self.max_size)
                .min_idle(self.min_idle)
                .max_lifetime(self.max_lifetime)
                .connection_timeout(self.pool_wait_timeout)
                .connection_customizer(Box::new(ConnCustomizer::new(self.read_timeout, self.write_timeout)))
                .build(ConnectionManager::new(parsed))?;
            connections.push(pool);
        }
        Ok(Client {
            connections,
            hash_function: default_hash_function,
        })
    }
}

impl Client {
    #[deprecated(since = "0.10.0", note = "please use `connect` instead")]
    pub fn new<C: Connectable>(target: C) -> Result<Self, MemcacheError> {
        return Self::connect(target);
    }

    pub fn connect<C: Connectable>(target: C) -> Result<Self, MemcacheError> {
        ClientBuilder::new(target).with_max_size(1).build()
    }

    fn get_connection(&self, key: &str) -> Pool<ConnectionManager> {
        let connections_count = self.connections.len();
        return self.connections[(self.hash_function)(key) as usize % connections_count].clone();
    }

    /// Get the memcached server version.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// client.version().unwrap();
    /// ```
    pub fn version(&self) -> Result<Vec<(String, String)>, MemcacheError> {
        let mut result = Vec::with_capacity(self.connections.len());
        for connection in self.connections.iter() {
            let mut connection = connection.get()?;
            let url = connection.get_url();
            result.push((url, connection.version()?));
        }
        Ok(result)
    }

    /// Flush all cache on memcached server immediately.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// client.flush().unwrap();
    /// ```
    pub fn flush(&self) -> Result<(), MemcacheError> {
        for connection in self.connections.iter() {
            connection.get()?.flush()?;
        }
        return Ok(());
    }

    /// Flush all cache on memcached server with a delay seconds.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// client.flush_with_delay(10).unwrap();
    /// ```
    pub fn flush_with_delay(&self, delay: u32) -> Result<(), MemcacheError> {
        for connection in self.connections.iter() {
            connection.get()?.flush_with_delay(delay)?;
        }
        return Ok(());
    }

    /// Get a key from memcached server.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// let _: Option<String> = client.get("foo").unwrap();
    /// ```
    pub fn get<V: FromMemcacheValueExt>(&self, key: &str) -> Result<Option<V>, MemcacheError> {
        return self.get_connection(key).get()?.get(key);
    }

    /// Get multiple keys from memcached server. Using this function instead of calling `get` multiple times can reduce netwark workloads.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// client.set("foo", "42", 0).unwrap();
    /// let result: std::collections::HashMap<String, String> = client.gets(&["foo", "bar", "baz"]).unwrap();
    /// assert_eq!(result.len(), 1);
    /// assert_eq!(result["foo"], "42");
    /// ```
    pub fn gets<V: FromMemcacheValueExt>(&self, keys: &[&str]) -> Result<HashMap<String, V>, MemcacheError> {
        let mut con_keys: HashMap<usize, Vec<&str>> = HashMap::new();
        let mut result: HashMap<String, V> = HashMap::new();
        let connections_count = self.connections.len();

        for key in keys {
            let connection_index = (self.hash_function)(key) as usize % connections_count;
            let array = con_keys.entry(connection_index).or_insert_with(Vec::new);
            array.push(key);
        }
        for (&connection_index, keys) in con_keys.iter() {
            let connection = self.connections[connection_index].clone();
            result.extend(connection.get()?.gets(keys)?);
        }
        return Ok(result);
    }

    /// Set a key with associate value into memcached server with expiration seconds.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// client.set("foo", "bar", 10).unwrap();
    /// # client.flush().unwrap();
    /// ```
    pub fn set<V: ToMemcacheValue<Stream>>(&self, key: &str, value: V, expiration: u32) -> Result<(), MemcacheError> {
        return self.get_connection(key).get()?.set(key, value, expiration);
    }

    /// Compare and swap a key with the associate value into memcached server with expiration seconds.
    /// `cas_id` should be obtained from a previous `gets` call.
    ///
    /// Example:
    ///
    /// ```rust
    /// use std::collections::HashMap;
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// client.set("foo", "bar", 10).unwrap();
    /// let result: HashMap<String, (Vec<u8>, u32, Option<u64>)> = client.gets(&["foo"]).unwrap();
    /// let (_, _, cas) = result.get("foo").unwrap();
    /// let cas = cas.unwrap();
    /// assert_eq!(true, client.cas("foo", "bar2", 10, cas).unwrap());
    /// # client.flush().unwrap();
    /// ```
    pub fn cas<V: ToMemcacheValue<Stream>>(
        &self,
        key: &str,
        value: V,
        expiration: u32,
        cas_id: u64,
    ) -> Result<bool, MemcacheError> {
        self.get_connection(key).get()?.cas(key, value, expiration, cas_id)
    }

    /// Add a key with associate value into memcached server with expiration seconds.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// let key = "add_test";
    /// client.delete(key).unwrap();
    /// client.add(key, "bar", 100000000).unwrap();
    /// # client.flush().unwrap();
    /// ```
    pub fn add<V: ToMemcacheValue<Stream>>(&self, key: &str, value: V, expiration: u32) -> Result<(), MemcacheError> {
        return self.get_connection(key).get()?.add(key, value, expiration);
    }

    /// Replace a key with associate value into memcached server with expiration seconds.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// let key = "replace_test";
    /// client.set(key, "bar", 0).unwrap();
    /// client.replace(key, "baz", 100000000).unwrap();
    /// # client.flush().unwrap();
    /// ```
    pub fn replace<V: ToMemcacheValue<Stream>>(
        &self,
        key: &str,
        value: V,
        expiration: u32,
    ) -> Result<(), MemcacheError> {
        return self.get_connection(key).get()?.replace(key, value, expiration);
    }

    /// Append value to the key.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// let key = "key_to_append";
    /// client.set(key, "hello", 0).unwrap();
    /// client.append(key, ", world!").unwrap();
    /// let result: String = client.get(key).unwrap().unwrap();
    /// assert_eq!(result, "hello, world!");
    /// # client.flush().unwrap();
    /// ```
    pub fn append<V: ToMemcacheValue<Stream>>(&self, key: &str, value: V) -> Result<(), MemcacheError> {
        return self.get_connection(key).get()?.append(key, value);
    }

    /// Prepend value to the key.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// let key = "key_to_append";
    /// client.set(key, "world!", 0).unwrap();
    /// client.prepend(key, "hello, ").unwrap();
    /// let result: String = client.get(key).unwrap().unwrap();
    /// assert_eq!(result, "hello, world!");
    /// # client.flush().unwrap();
    /// ```
    pub fn prepend<V: ToMemcacheValue<Stream>>(&self, key: &str, value: V) -> Result<(), MemcacheError> {
        return self.get_connection(key).get()?.prepend(key, value);
    }

    /// Delete a key from memcached server.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// client.delete("foo").unwrap();
    /// # client.flush().unwrap();
    /// ```
    pub fn delete(&self, key: &str) -> Result<bool, MemcacheError> {
        return self.get_connection(key).get()?.delete(key);
    }

    /// Increment the value with amount.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// client.increment("counter", 42).unwrap();
    /// # client.flush().unwrap();
    /// ```
    pub fn increment(&self, key: &str, amount: u64) -> Result<u64, MemcacheError> {
        return self.get_connection(key).get()?.increment(key, amount);
    }

    /// Decrement the value with amount.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// client.decrement("counter", 42).unwrap();
    /// # client.flush().unwrap();
    /// ```
    pub fn decrement(&self, key: &str, amount: u64) -> Result<u64, MemcacheError> {
        return self.get_connection(key).get()?.decrement(key, amount);
    }

    /// Set a new expiration time for a exist key.
    ///
    /// Example:
    ///
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// assert_eq!(client.touch("not_exists_key", 12345).unwrap(), false);
    /// client.set("foo", "bar", 123).unwrap();
    /// assert_eq!(client.touch("foo", 12345).unwrap(), true);
    /// # client.flush().unwrap();
    /// ```
    pub fn touch(&self, key: &str, expiration: u32) -> Result<bool, MemcacheError> {
        return self.get_connection(key).get()?.touch(key, expiration);
    }

    /// Get all servers' statistics.
    ///
    /// Example:
    /// ```rust
    /// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
    /// let stats = client.stats().unwrap();
    /// ```
    pub fn stats(&self) -> Result<Vec<(String, Stats)>, MemcacheError> {
        let mut result: Vec<(String, HashMap<String, String>)> = vec![];
        for connection in self.connections.iter() {
            let mut connection = connection.get()?;
            let stats_info = connection.stats()?;
            let url = connection.get_url();
            result.push((url, stats_info));
        }
        return Ok(result);
    }
}

#[cfg(test)]
mod tests {
    #[cfg(unix)]
    #[test]
    fn unix() {
        let client = super::Client::connect("memcache:///tmp/memcached.sock").unwrap();
        assert!(client.version().unwrap()[0].1 != "");
    }

    #[cfg(feature = "tls")]
    #[test]
    fn ssl_noverify() {
        let client = super::Client::connect("memcache+tls://localhost:12350?verify_mode=none").unwrap();
        assert!(client.version().unwrap()[0].1 != "");
    }

    #[cfg(feature = "tls")]
    #[test]
    fn ssl_verify() {
        let client =
            super::Client::connect("memcache+tls://localhost:12350?ca_path=tests/assets/RUST_MEMCACHE_TEST_CERT.crt")
                .unwrap();
        assert!(client.version().unwrap()[0].1 != "");
    }

    #[cfg(feature = "tls")]
    #[test]
    fn ssl_client_certs() {
        let client = super::Client::connect("memcache+tls://localhost:12351?key_path=tests/assets/client.key&cert_path=tests/assets/client.crt&ca_path=tests/assets/RUST_MEMCACHE_TEST_CERT.crt").unwrap();
        assert!(client.version().unwrap()[0].1 != "");
    }

    #[test]
    fn delete() {
        let client = super::Client::connect("memcache://localhost:12345").unwrap();
        client.set("an_exists_key", "value", 0).unwrap();
        assert_eq!(client.delete("an_exists_key").unwrap(), true);
        assert_eq!(client.delete("a_not_exists_key").unwrap(), false);
    }

    #[test]
    fn increment() {
        let client = super::Client::connect("memcache://localhost:12345").unwrap();
        client.delete("counter").unwrap();
        client.set("counter", 321, 0).unwrap();
        assert_eq!(client.increment("counter", 123).unwrap(), 444);
    }
}

1	use std::collections::hash_map::DefaultHasher;
2	use std::collections::HashMap;
3	use std::hash::{Hash, Hasher};
4	use std::time::Duration;
5
6	use url::Url;
7
8	use connection::{ConnCustomizer, ConnectionManager};
9	use error::MemcacheError;
10	use protocol::ProtocolTrait;
11	use r2d2::Pool;
12	use stream::Stream;
13	use value::{FromMemcacheValueExt, ToMemcacheValue};
14
15	pub type Stats = HashMap<String, String>;
16
17	pub trait Connectable {
18	fn get_urls(self) -> Vec<String>;
19	}
20
21	impl Connectable for String {
22	fn get_urls(self) -> Vec<String> {	×
23	return vec![self];	×
24	}	×
25	}
26
27	impl Connectable for Vec<String> {
28	fn get_urls(self) -> Vec<String> {	×
29	return self;	×
30	}	×
31	}
32
33	impl Connectable for &str {
34	fn get_urls(self) -> Vec<String> {	38✔
35	return vec![self.to_string()];	76✔
36	}	38✔
37	}
38
39	impl Connectable for Vec<&str> {
40	fn get_urls(self) -> Vec<String> {	2✔
41	let mut urls = vec![];	2✔
42	for url in self {	9✔
43	urls.push(url.to_string());	14✔
44	}	2✔
45	return urls;	2✔
46	}	2✔
47	}
48
49	#[derive(Clone)]	×
50	pub struct Client {
51	connections: Vec<Pool<ConnectionManager>>,	×
52	pub hash_function: fn(&str) -> u64,	×
53	}
54
55	unsafe impl Send for Client {}
56
57	fn default_hash_function(key: &str) -> u64 {	10,608✔
58	let mut hasher = DefaultHasher::new();	10,608✔
59	key.hash(&mut hasher);	10,613✔
60	return hasher.finish();	10,609✔
61	}	10,613✔
62
63	pub struct ClientBuilder<C> {
64	target: C,
65	max_size: u32,
66	min_idle: Option<u32>,
67	max_lifetime: Option<Duration>,
68	read_timeout: Option<Duration>,
69	write_timeout: Option<Duration>,
70	pool_wait_timeout: Duration,
71	}
72
73	impl<C: Connectable> ClientBuilder<C> {
74	pub fn new(target: C) -> Self {	6✔
75	Self {	6✔
76	target,	6✔
77	max_size: 1,
78	min_idle: None,	6✔
79	max_lifetime: None,	6✔
80	read_timeout: None,	6✔
81	write_timeout: None,	6✔
82	pool_wait_timeout: Duration::new(30, 0),	6✔
83	}
84	}	6✔
85
86	pub fn with_min_idle(mut self, min_idle: Option<u32>) -> Self {
87	self.min_idle = min_idle;
88	self
89	}
90
91	pub fn with_max_lifetime(mut self, max_lifetime: Option<Duration>) -> Self {
92	self.max_lifetime = max_lifetime;
93	self
94	}
95
NEW 96	pub fn with_max_size(mut self, size: u32) -> Self {	×
NEW 97	self.max_size = size;	×
NEW 98	self	×
NEW 99	}	×
100
101	pub fn with_read_timeout(mut self, read_timeout: Option<Duration>) -> Self {
102	self.read_timeout = read_timeout;
103	self
104	}
105
106	pub fn with_pool_wait_timeout(mut self, pool_wait_timeout: Duration) -> Self {
107	self.pool_wait_timeout = pool_wait_timeout;
108	self
109	}
110
111	pub fn with_write_timeout(mut self, write_timeout: Option<Duration>) -> Self {
112	self.write_timeout = write_timeout;
113	self
114	}
115
116	pub fn build(self) -> Result<Client, MemcacheError> {	6✔
117	let urls = self.target.get_urls();	6✔
118	let mut connections = vec![];	12✔
119	for url in urls {	24✔
120	let parsed = Url::parse(url.as_str())?;	6✔
121	let pool = Pool::builder()	24✔
122	.max_size(self.max_size)	6✔
123	.min_idle(self.min_idle)	6✔
124	.max_lifetime(self.max_lifetime)	6✔
125	.connection_timeout(self.pool_wait_timeout)	6✔
126	.connection_customizer(Box::new(ConnCustomizer::new(self.read_timeout, self.write_timeout)))	12✔
127	.build(ConnectionManager::new(parsed))?;	18✔
128	connections.push(pool);	6✔
129	}	12✔
130	Ok(Client {	6✔
131	connections,	6✔
132	hash_function: default_hash_function,
133	})
134	}	6✔
135	}
136
137	impl Client {
138	#[deprecated(since = "0.10.0", note = "please use `connect` instead")]
139	pub fn new<C: Connectable>(target: C) -> Result<Self, MemcacheError> {
140	return Self::connect(target);
141	}
142
143	pub fn connect<C: Connectable>(target: C) -> Result<Self, MemcacheError> {	6✔
144	ClientBuilder::new(target).with_max_size(1).build()	6✔
145	}	6✔
146
147	fn get_connection(&self, key: &str) -> Pool<ConnectionManager> {	10,598✔
148	let connections_count = self.connections.len();	21,196✔
149	return self.connections[(self.hash_function)(key) as usize % connections_count].clone();	21,196✔
150	}	10,596✔
151
152	/// Get the memcached server version.
153	///
154	/// Example:
155	///
156	/// ```rust
157	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
158	/// client.version().unwrap();
159	/// ```
160	pub fn version(&self) -> Result<Vec<(String, String)>, MemcacheError> {	7✔
161	let mut result = Vec::with_capacity(self.connections.len());	14✔
162	for connection in self.connections.iter() {	19✔
163	let mut connection = connection.get()?;	12✔
164	let url = connection.get_url();	12✔
165	result.push((url, connection.version()?));	12✔
166	}	12✔
167	Ok(result)	7✔
168	}	7✔
169
170	/// Flush all cache on memcached server immediately.
171	///
172	/// Example:
173	///
174	/// ```rust
175	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
176	/// client.flush().unwrap();
177	/// ```
178	pub fn flush(&self) -> Result<(), MemcacheError> {	19✔
179	for connection in self.connections.iter() {	43✔
180	connection.get()?.flush()?;	24✔
181	}
182	return Ok(());	19✔
183	}	19✔
184
185	/// Flush all cache on memcached server with a delay seconds.
186	///
187	/// Example:
188	///
189	/// ```rust
190	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
191	/// client.flush_with_delay(10).unwrap();
192	/// ```
193	pub fn flush_with_delay(&self, delay: u32) -> Result<(), MemcacheError> {	4✔
194	for connection in self.connections.iter() {	13✔
195	connection.get()?.flush_with_delay(delay)?;	9✔
196	}
197	return Ok(());	4✔
198	}	4✔
199
200	/// Get a key from memcached server.
201	///
202	/// Example:
203	///
204	/// ```rust
205	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
206	/// let _: Option<String> = client.get("foo").unwrap();
207	/// ```
208	pub fn get<V: FromMemcacheValueExt>(&self, key: &str) -> Result<Option<V>, MemcacheError> {
209	return self.get_connection(key).get()?.get(key);
210	}
211
212	/// Get multiple keys from memcached server. Using this function instead of calling `get` multiple times can reduce netwark workloads.
213	///
214	/// Example:
215	///
216	/// ```rust
217	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
218	/// client.set("foo", "42", 0).unwrap();
219	/// let result: std::collections::HashMap<String, String> = client.gets(&["foo", "bar", "baz"]).unwrap();
220	/// assert_eq!(result.len(), 1);
221	/// assert_eq!(result["foo"], "42");
222	/// ```
223	pub fn gets<V: FromMemcacheValueExt>(&self, keys: &[&str]) -> Result<HashMap<String, V>, MemcacheError> {
224	let mut con_keys: HashMap<usize, Vec<&str>> = HashMap::new();
225	let mut result: HashMap<String, V> = HashMap::new();
226	let connections_count = self.connections.len();
227
228	for key in keys {
229	let connection_index = (self.hash_function)(key) as usize % connections_count;
230	let array = con_keys.entry(connection_index).or_insert_with(Vec::new);
231	array.push(key);
232	}
233	for (&connection_index, keys) in con_keys.iter() {
234	let connection = self.connections[connection_index].clone();
235	result.extend(connection.get()?.gets(keys)?);
236	}
237	return Ok(result);
238	}
239
240	/// Set a key with associate value into memcached server with expiration seconds.
241	///
242	/// Example:
243	///
244	/// ```rust
245	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
246	/// client.set("foo", "bar", 10).unwrap();
247	/// # client.flush().unwrap();
248	/// ```
249	pub fn set<V: ToMemcacheValue<Stream>>(&self, key: &str, value: V, expiration: u32) -> Result<(), MemcacheError> {	2✔
250	return self.get_connection(key).get()?.set(key, value, expiration);	2✔
251	}	2✔
252
253	/// Compare and swap a key with the associate value into memcached server with expiration seconds.
254	/// `cas_id` should be obtained from a previous `gets` call.
255	///
256	/// Example:
257	///
258	/// ```rust
259	/// use std::collections::HashMap;
260	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
261	/// client.set("foo", "bar", 10).unwrap();
262	/// let result: HashMap<String, (Vec<u8>, u32, Option<u64>)> = client.gets(&["foo"]).unwrap();
263	/// let (_, _, cas) = result.get("foo").unwrap();
264	/// let cas = cas.unwrap();
265	/// assert_eq!(true, client.cas("foo", "bar2", 10, cas).unwrap());
266	/// # client.flush().unwrap();
267	/// ```
268	pub fn cas<V: ToMemcacheValue<Stream>>(
269	&self,
270	key: &str,
271	value: V,
272	expiration: u32,
273	cas_id: u64,
274	) -> Result<bool, MemcacheError> {
275	self.get_connection(key).get()?.cas(key, value, expiration, cas_id)
276	}
277
278	/// Add a key with associate value into memcached server with expiration seconds.
279	///
280	/// Example:
281	///
282	/// ```rust
283	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
284	/// let key = "add_test";
285	/// client.delete(key).unwrap();
286	/// client.add(key, "bar", 100000000).unwrap();
287	/// # client.flush().unwrap();
288	/// ```
289	pub fn add<V: ToMemcacheValue<Stream>>(&self, key: &str, value: V, expiration: u32) -> Result<(), MemcacheError> {
290	return self.get_connection(key).get()?.add(key, value, expiration);
291	}
292
293	/// Replace a key with associate value into memcached server with expiration seconds.
294	///
295	/// Example:
296	///
297	/// ```rust
298	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
299	/// let key = "replace_test";
300	/// client.set(key, "bar", 0).unwrap();
301	/// client.replace(key, "baz", 100000000).unwrap();
302	/// # client.flush().unwrap();
303	/// ```
304	pub fn replace<V: ToMemcacheValue<Stream>>(
305	&self,
306	key: &str,
307	value: V,
308	expiration: u32,
309	) -> Result<(), MemcacheError> {
310	return self.get_connection(key).get()?.replace(key, value, expiration);
311	}
312
313	/// Append value to the key.
314	///
315	/// Example:
316	///
317	/// ```rust
318	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
319	/// let key = "key_to_append";
320	/// client.set(key, "hello", 0).unwrap();
321	/// client.append(key, ", world!").unwrap();
322	/// let result: String = client.get(key).unwrap().unwrap();
323	/// assert_eq!(result, "hello, world!");
324	/// # client.flush().unwrap();
325	/// ```
326	pub fn append<V: ToMemcacheValue<Stream>>(&self, key: &str, value: V) -> Result<(), MemcacheError> {
327	return self.get_connection(key).get()?.append(key, value);
328	}
329
330	/// Prepend value to the key.
331	///
332	/// Example:
333	///
334	/// ```rust
335	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
336	/// let key = "key_to_append";
337	/// client.set(key, "world!", 0).unwrap();
338	/// client.prepend(key, "hello, ").unwrap();
339	/// let result: String = client.get(key).unwrap().unwrap();
340	/// assert_eq!(result, "hello, world!");
341	/// # client.flush().unwrap();
342	/// ```
343	pub fn prepend<V: ToMemcacheValue<Stream>>(&self, key: &str, value: V) -> Result<(), MemcacheError> {
344	return self.get_connection(key).get()?.prepend(key, value);
345	}
346
347	/// Delete a key from memcached server.
348	///
349	/// Example:
350	///
351	/// ```rust
352	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
353	/// client.delete("foo").unwrap();
354	/// # client.flush().unwrap();
355	/// ```
356	pub fn delete(&self, key: &str) -> Result<bool, MemcacheError> {	509✔
357	return self.get_connection(key).get()?.delete(key);	509✔
358	}	509✔
359
360	/// Increment the value with amount.
361	///
362	/// Example:
363	///
364	/// ```rust
365	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
366	/// client.increment("counter", 42).unwrap();
367	/// # client.flush().unwrap();
368	/// ```
369	pub fn increment(&self, key: &str, amount: u64) -> Result<u64, MemcacheError> {	6✔
370	return self.get_connection(key).get()?.increment(key, amount);	6✔
371	}	6✔
372
373	/// Decrement the value with amount.
374	///
375	/// Example:
376	///
377	/// ```rust
378	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
379	/// client.decrement("counter", 42).unwrap();
380	/// # client.flush().unwrap();
381	/// ```
382	pub fn decrement(&self, key: &str, amount: u64) -> Result<u64, MemcacheError> {	3✔
383	return self.get_connection(key).get()?.decrement(key, amount);	3✔
384	}	3✔
385
386	/// Set a new expiration time for a exist key.
387	///
388	/// Example:
389	///
390	/// ```rust
391	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
392	/// assert_eq!(client.touch("not_exists_key", 12345).unwrap(), false);
393	/// client.set("foo", "bar", 123).unwrap();
394	/// assert_eq!(client.touch("foo", 12345).unwrap(), true);
395	/// # client.flush().unwrap();
396	/// ```
397	pub fn touch(&self, key: &str, expiration: u32) -> Result<bool, MemcacheError> {	5✔
398	return self.get_connection(key).get()?.touch(key, expiration);	5✔
399	}	5✔
400
401	/// Get all servers' statistics.
402	///
403	/// Example:
404	/// ```rust
405	/// let client = memcache::Client::connect("memcache://localhost:12345").unwrap();
406	/// let stats = client.stats().unwrap();
407	/// ```
408	pub fn stats(&self) -> Result<Vec<(String, Stats)>, MemcacheError> {	2✔
409	let mut result: Vec<(String, HashMap<String, String>)> = vec![];	4✔
410	for connection in self.connections.iter() {	4✔
411	let mut connection = connection.get()?;	2✔
412	let stats_info = connection.stats()?;	2✔
413	let url = connection.get_url();	2✔
414	result.push((url, stats_info));	2✔
415	}	2✔
416	return Ok(result);	2✔
417	}	2✔
418	}
419
420	#[cfg(test)]
421	mod tests {
422	#[cfg(unix)]
423	#[test]
424	fn unix() {	2✔
425	let client = super::Client::connect("memcache:///tmp/memcached.sock").unwrap();	2✔
426	assert!(client.version().unwrap()[0].1 != "");	3✔
427	}	2✔
428
429	#[cfg(feature = "tls")]
430	#[test]
431	fn ssl_noverify() {	2✔
432	let client = super::Client::connect("memcache+tls://localhost:12350?verify_mode=none").unwrap();	2✔
433	assert!(client.version().unwrap()[0].1 != "");	3✔
434	}	2✔
435
436	#[cfg(feature = "tls")]
437	#[test]
438	fn ssl_verify() {	2✔
439	let client =
440	super::Client::connect("memcache+tls://localhost:12350?ca_path=tests/assets/RUST_MEMCACHE_TEST_CERT.crt")	2✔
441	.unwrap();
442	assert!(client.version().unwrap()[0].1 != "");	3✔
443	}	2✔
444
445	#[cfg(feature = "tls")]
446	#[test]
447	fn ssl_client_certs() {	2✔
448	let client = super::Client::connect("memcache+tls://localhost:12351?key_path=tests/assets/client.key&cert_path=tests/assets/client.crt&ca_path=tests/assets/RUST_MEMCACHE_TEST_CERT.crt").unwrap();	2✔
449	assert!(client.version().unwrap()[0].1 != "");	3✔
450	}	2✔
451
452	#[test]
453	fn delete() {	2✔
454	let client = super::Client::connect("memcache://localhost:12345").unwrap();	2✔
455	client.set("an_exists_key", "value", 0).unwrap();	2✔
456	assert_eq!(client.delete("an_exists_key").unwrap(), true);	2✔
457	assert_eq!(client.delete("a_not_exists_key").unwrap(), false);	2✔
458	}	2✔
459
460	#[test]
461	fn increment() {	2✔
462	let client = super::Client::connect("memcache://localhost:12345").unwrap();	2✔
463	client.delete("counter").unwrap();	2✔
464	client.set("counter", 321, 0).unwrap();	2✔
465	assert_eq!(client.increment("counter", 123).unwrap(), 444);	2✔
466	}	2✔
467	}

aisk / rust-memcache / 02786968348d09e5373f4f7249331bff2ed2a8f5-PR-108

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous