2 (#38)

* use redis

* update frontend and switch sanitize library

* changelog

* theming

* docker image

* documentation

* changelog

* clear up limit sizes

* version bump

* version bump

backend/src/store.rs

@@ -1,36 +1,55 @@
-use memcache;
+use redis;
+use redis::Commands;
 
 use crate::note::now;
 use crate::note::Note;
 
 lazy_static! {
-    static ref CLIENT: memcache::Client = memcache::connect(format!(
-        "memcache://{}?timeout=10&tcp_nodelay=true",
-        std::env::var("MEMCACHE").unwrap_or("127.0.0.1:11211".to_string())
-    ))
-    .unwrap();
+    static ref REDIS_CLIENT: String = std::env::var("REDIS")
+        .unwrap_or("redis://127.0.0.1/".to_string())
+        .parse()
+        .unwrap();
 }
 
-pub fn set(id: &String, note: &Note) {
+fn get_connection() -> Result<redis::Connection, &'static str> {
+    let client =
+        redis::Client::open(REDIS_CLIENT.to_string()).map_err(|_| "Unable to connect to redis")?;
+    client
+        .get_connection()
+        .map_err(|_| "Unable to connect to redis")
+}
+
+pub fn set(id: &String, note: &Note) -> Result<(), &'static str> {
     let serialized = serde_json::to_string(&note.clone()).unwrap();
-    let expiration: u32 = match note.expiration {
-        Some(e) => e - now(),
-        None => 0,
+    let mut conn = get_connection()?;
+
+    conn.set(id, serialized)
+        .map_err(|_| "Unable to set note in redis")?;
+    match note.expiration {
+        Some(e) => {
+            let seconds = e - now();
+            conn.expire(id, seconds as usize)
+                .map_err(|_| "Unable to set expiration on notion")?
+        }
+        None => {}
     };
-    CLIENT.set(id, serialized, expiration).unwrap();
+    Ok(())
 }
 
-pub fn get(id: &String) -> Option<Note> {
-    let value: Option<String> = CLIENT.get(&id).unwrap();
+pub fn get(id: &String) -> Result<Option<Note>, &'static str> {
+    let mut conn = get_connection()?;
+    let value: Option<String> = conn.get(id).map_err(|_| "Could not load note in redis")?;
     match value {
-        None => return None,
+        None => return Ok(None),
         Some(s) => {
             let deserialize: Note = serde_json::from_str(&s).unwrap();
-            return Some(deserialize);
+            return Ok(Some(deserialize));
         }
     }
 }
 
-pub fn del(id: &String) {
-    CLIENT.delete(id).unwrap();
+pub fn del(id: &String) -> Result<(), &'static str> {
+    let mut conn = get_connection()?;
+    conn.del(id).map_err(|_| "Unable to delete note in redis")?;
+    Ok(())
 }