brakes 0.1.1

A distributed rate limiting library
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

use super::{Backend, BackendError};

#[derive(Clone)]
pub struct MemCache {
    client: memcache::Client,
}

impl MemCache {
    pub fn new(client: memcache::Client) -> Self {
        MemCache { client }
    }
}

impl Backend for MemCache {
    fn get(&self, key: &str) -> Result<(Vec<u8>, Option<u64>), BackendError> {
        let (v, _, cas) = match self.client.get(key) {
            Ok(Some(v)) => v,
            Ok(None) => return Err(BackendError::KeyMissing),
            Err(e) => return Err(BackendError::MemCacheError(e)),
        };
        Ok((v, cas))
    }

    fn set(&self, key: &str, value: &[u8], cas: Option<u64>) -> Result<(), BackendError> {
        match cas {
            Some(cas) => match self.client.cas(key, value, u32::MAX, cas) {
                Ok(false) => Err(BackendError::ValueChanged),
                Err(e) => Err(BackendError::MemCacheError(e)),
                Ok(true) => Ok(()),
            },
            None => self
                .client
                .set(key, value, u32::MAX)
                .map_err(BackendError::MemCacheError),
        }
    }

    fn delete(&self, key: &str) -> Result<(), BackendError> {
        match self.client.delete(key) {
            Ok(_) => Ok(()),
            Err(e) => Err(BackendError::MemCacheError(e)),
        }
    }
}