add rdb backward load (RedisJSON#43)

gkorland · web-flow · commit babe11e5be90 · 2019-09-03T11:36:51.000+03:00
* add rdb backward load
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,4 +11,4 @@ crate-type = ["cdylib"]
 serde_json = "1.0"
 libc = "0.2"
 jsonpath_lib = { git="https://github.com/gkorland/jsonpath.git", branch="reaplce_with_ownership_parser" }
-redismodule = { git = "https://github.com/RedisLabsModules/redismodule-rs.git", branch = "master" }
+redismodule = { git="https://github.com/redislabsmodules/redismodule-rs.git", branch="load_rdb" }
diff --git a/src/backward.rs b/src/backward.rs
@@ -0,0 +1,77 @@
+use redismodule::raw;
+use serde_json::map::Map;
+use serde_json::Number;
+use serde_json::Value;
+use std::vec::Vec;
+
+#[derive(Debug, PartialEq)]
+enum NodeType {
+    Null, // used in masks and consistent type checking
+    String,
+    Number,
+    Integer,
+    Boolean,
+    Dict,
+    Array,
+    KeyVal, 
+    // N_DATETIME = 0x100
+    // N_BINARY = 0x200
+}
+
+impl From<u64> for NodeType {
+    fn from(n: u64) -> Self {
+        match n {
+            0x1u64 => NodeType::Null,
+            0x2u64 => NodeType::String,
+            0x4u64 => NodeType::Number,
+            0x8u64 => NodeType::Integer,
+            0x10u64 => NodeType::Boolean,
+            0x20u64 => NodeType::Dict,
+            0x40u64 => NodeType::Array,
+            0x80u64 => NodeType::KeyVal,
+            _ => panic!("Can't load old RedisJSON RDB1"),
+        }
+    }
+}
+
+pub unsafe fn json_rdb_load(rdb: *mut raw::RedisModuleIO) -> Value {
+    let node_type = raw::load_unsigned(rdb).into();
+    match node_type {
+        NodeType::Null => Value::Null,
+        NodeType::Boolean => {
+            let mut str_len = 0;
+            let str_buffer = raw::load_string_buffer(rdb, &mut str_len);
+            Value::Bool(str_buffer.starts_with("1"))
+        }
+        NodeType::Integer => Value::Number(raw::load_signed(rdb).into()),
+        NodeType::Number => Value::Number(Number::from_f64(raw::load_double(rdb)).unwrap()),
+        NodeType::String => {
+            let mut str_len = 0;
+            let str_buffer = raw::load_string_buffer(rdb, &mut str_len);
+            Value::String(str_buffer.to_string())
+        }
+        NodeType::Dict => {
+            let len = raw::load_unsigned(rdb);
+            let mut m = Map::with_capacity(len as usize);
+            for _ in 0..len {
+                let t: NodeType = raw::load_unsigned(rdb).into();
+                if t != NodeType::KeyVal {
+                    panic!("Can't load old RedisJSON RDB");
+                }
+                let mut str_len = 0;
+                let name = &raw::load_string_buffer(rdb, &mut str_len);
+                m.insert(name.to_string(), json_rdb_load(rdb));
+            }
+            Value::Object(m)
+        }
+        NodeType::Array => {
+            let len = raw::load_unsigned(rdb);
+            let mut v = Vec::with_capacity(len as usize);
+            for _ in 0..len {
+                v.push(json_rdb_load(rdb))
+            }
+            Value::Array(v)
+        }
+        NodeType::KeyVal => panic!("Can't load old RedisJSON RDB"),
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -6,6 +6,7 @@ use redismodule::{Context, NextArg, RedisError, RedisResult, RedisValue, REDIS_O
 use serde_json::{Number, Value};
 use std::{i64, usize};
 
+mod backward;
 mod index;
 mod nodevisitor;
 mod redisjson;
diff --git a/src/nodevisitor.rs b/src/nodevisitor.rs
@@ -16,7 +16,7 @@ pub struct NodeVisitorImpl {
 impl NodeVisitorImpl {
     ///
     /// Checks if path is static & valid
-    /// 
+    ///
     pub fn check(input: &str) -> Result<bool, String> {
         let node = Parser::compile(input)?;
         let mut visitor = NodeVisitorImpl {
diff --git a/src/redisjson.rs b/src/redisjson.rs
@@ -3,6 +3,7 @@
 // Translate between JSON and tree of Redis objects:
 // User-provided JSON is converted to a tree. This tree is stored transparently in Redis.
 // It can be operated on (e.g. INCR) and serialized back to JSON.
+use crate::backward;
 use crate::nodevisitor::NodeVisitorImpl;
 use jsonpath_lib::{JsonPathError, SelectorMut};
 use redismodule::raw;
@@ -14,7 +15,6 @@ pub struct Error {
     msg: String,
 }
 
-
 #[derive(Debug, PartialEq)]
 pub enum SetOptions {
     NotExists,
@@ -106,11 +106,16 @@ impl RedisJSON {
         Ok(Self { data: v })
     }
 
-    pub fn set_value(&mut self, data: &str, path: &str, option: &Option<SetOptions>) -> Result<bool, Error> {
+    pub fn set_value(
+        &mut self,
+        data: &str,
+        path: &str,
+        option: &Option<SetOptions>,
+    ) -> Result<bool, Error> {
         // Parse the string of data into serde_json::Value.
         let json: Value = serde_json::from_str(data)?;
 
-        if  path == "$" {
+        if path == "$" {
             if Some(SetOptions::NotExists) == *option {
                 Ok(false)
             } else {
@@ -283,10 +288,13 @@ impl RedisJSON {
 
 #[allow(non_snake_case, unused)]
 pub unsafe extern "C" fn json_rdb_load(rdb: *mut raw::RedisModuleIO, encver: c_int) -> *mut c_void {
-    if encver < 2 {
-        panic!("Can't load old RedisJSON RDB"); // TODO add support for backward
-    }
-    let json = RedisJSON::from_str(&raw::load_string(rdb)).unwrap();
+    let json = match encver {
+        0 => RedisJSON {
+            data: backward::json_rdb_load(rdb),
+        },
+        2 => RedisJSON::from_str(&raw::load_string(rdb)).unwrap(),
+        _ => panic!("Can't load old RedisJSON RDB"),
+    };
     Box::into_raw(Box::new(json)) as *mut c_void
 }
 
