[MOD-5769] Open RedisJSON key with flags (RedisJSON#1095)

DvirDukhan · oshadmi · alonre24 · web-flow · commit 1823d74f3933 · 2023-10-22T22:14:47.000+03:00
* wip

* compile with redismodule-rs 2.0.5

* open key with flags

* cargo fmt

* redis 7.2 at circle

* Bump json api version

* Export shared api names using static lifetime

* Update readies

* Attemp fixing san failures

* Attemp redismodule-rs from master

* Bump dep redismodule-rs to 2.0.7

---------

Co-authored-by: Omer Shadmi &lt;omer.shadmi@redis.com&gt;
Co-authored-by: alonre24 &lt;alonreshef24@gmail.com&gt;
diff --git a/.circleci/config.yml b/.circleci/config.yml
@@ -78,7 +78,7 @@ commands:
     parameters:
       redis_version:
         type: string
-        default: "7"
+        default: "7.2"
       getredis_params:
         type: string
         default: ""
diff --git a/.gitignore b/.gitignore
@@ -33,3 +33,5 @@
 .settings/
 
 wordlist.dic
+
+venv/
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/deps/readies b/deps/readies
@@ -1 +1 @@
-Subproject commit 3b1d2f256f76d03534d7424ef71936fa1a572676
+Subproject commit eef12bc28fcb62c00b5550d705aa7b544f3111ca
diff --git a/redis_json/Cargo.toml b/redis_json/Cargo.toml
@@ -25,9 +25,11 @@ ijson.workspace = true
 serde_json.workspace = true
 serde.workspace = true
 libc = "0.2"
-redis-module = "2.0"
+redis-module ={ version = "^2.0.7", default-features = false, features = ["min-redis-compatibility-version-7-2"] }
+redis-module-macros = "^2.0.7"
 itertools = "0.10"
 json_path = {path="../json_path"}
+linkme = "0.3"
 
 [features]
 as-library = []
diff --git a/redis_json/src/c_api.rs b/redis_json/src/c_api.rs
@@ -18,7 +18,7 @@ use crate::key_value::KeyValue;
 use json_path::select_value::{SelectValue, SelectValueType};
 use json_path::{compile, create};
 use redis_module::raw as rawmod;
-use redis_module::{Context, RedisString, Status};
+use redis_module::{key::KeyFlags, Context, RedisString, Status};
 
 use crate::manager::{Manager, ReadHolder};
 
@@ -78,6 +78,21 @@ pub fn json_api_open_key_internal<M: Manager>(
     null()
 }
 
+pub fn json_api_open_key_with_flags_internal<M: Manager>(
+    manager: M,
+    ctx: *mut rawmod::RedisModuleCtx,
+    key: RedisString,
+    flags: KeyFlags,
+) -> *const M::V {
+    let ctx: Context = Context::new(ctx);
+    if let Ok(h) = manager.open_key_read_with_flags(&ctx, &key, flags) {
+        if let Ok(Some(v)) = h.get_value() {
+            return v;
+        }
+    }
+    null()
+}
+
 pub fn json_api_get_at<M: Manager>(_: M, json: *const c_void, index: size_t) -> *const c_void {
     let json = unsafe { &*(json.cast::<M::V>()) };
     match json.get_type() {
@@ -313,6 +328,7 @@ macro_rules! redis_json_module_export_shared_api {
         pre_command_function: $pre_command_function_expr:expr,
     ) => {
         use std::ptr::NonNull;
+        use std::ffi::CString;
 
         #[no_mangle]
         pub extern "C" fn JSONAPI_openKey(
@@ -326,6 +342,26 @@ macro_rules! redis_json_module_export_shared_api {
             )
         }
 
+        #[no_mangle]
+        pub extern "C" fn JSONAPI_openKey_withFlags(
+            ctx: *mut rawmod::RedisModuleCtx,
+            key_str: *mut rawmod::RedisModuleString,
+            flags: c_int,
+        ) -> *mut c_void {
+            run_on_manager!(
+                pre_command: ||$pre_command_function_expr(&get_llapi_ctx(), &Vec::new()),
+                get_mngr: $get_manager_expr,
+                run: |mngr| {
+                    json_api_open_key_with_flags_internal(
+                        mngr,
+                        ctx,
+                        RedisString::new(NonNull::new(ctx), key_str),
+                        KeyFlags::from_bits_truncate(flags as i32),
+                    ) as *mut c_void
+                },
+            )
+        }
+
         #[no_mangle]
         #[allow(clippy::not_unsafe_ptr_arg_deref)]
         pub extern "C" fn JSONAPI_openKeyFromStr(
@@ -543,39 +579,24 @@ macro_rules! redis_json_module_export_shared_api {
             )
         }
 
-        static REDISJSON_GETAPI_V1: &str = concat!("RedisJSON_V1", "\0");
-        static REDISJSON_GETAPI_V2: &str = concat!("RedisJSON_V2", "\0");
-        static REDISJSON_GETAPI_V3: &str = concat!("RedisJSON_V3", "\0");
-        static REDISJSON_GETAPI_V4: &str = concat!("RedisJSON_V4", "\0");
+        // The apiname argument of export_shared_api should be a string literal with static lifetime
+        static mut VEC_EXPORT_SHARED_API_NAME : Vec<CString> = Vec::new();
 
         pub fn export_shared_api(ctx: &Context) {
             unsafe {
                 LLAPI_CTX = Some(rawmod::RedisModule_GetThreadSafeContext.unwrap()(
                     std::ptr::null_mut(),
                 ));
-                ctx.export_shared_api(
-                    (&JSONAPI_CURRENT as *const RedisJSONAPI_CURRENT).cast::<c_void>(),
-                    REDISJSON_GETAPI_V1.as_ptr().cast::<c_char>(),
-                );
-                ctx.log_notice("Exported RedisJSON_V1 API");
-
-                ctx.export_shared_api(
-                    (&JSONAPI_CURRENT as *const RedisJSONAPI_CURRENT).cast::<c_void>(),
-                    REDISJSON_GETAPI_V2.as_ptr().cast::<c_char>(),
-                );
-                ctx.log_notice("Exported RedisJSON_V2 API");
-
-                ctx.export_shared_api(
-                    (&JSONAPI_CURRENT as *const RedisJSONAPI_CURRENT).cast::<c_void>(),
-                    REDISJSON_GETAPI_V3.as_ptr().cast::<c_char>(),
-                );
-                ctx.log_notice("Exported RedisJSON_V3 API");
-
-                ctx.export_shared_api(
-                    (&JSONAPI_CURRENT as *const RedisJSONAPI_CURRENT).cast::<c_void>(),
-                    REDISJSON_GETAPI_V4.as_ptr().cast::<c_char>(),
-                );
-                ctx.log_notice("Exported RedisJSON_V4 API");
+
+                for v in 1..6 {
+                    let version = format!("RedisJSON_V{}", v);
+                    VEC_EXPORT_SHARED_API_NAME.push(CString::new(version.as_str()).unwrap());
+                    ctx.export_shared_api(
+                        (&JSONAPI_CURRENT as *const RedisJSONAPI_CURRENT).cast::<c_void>(),
+                        VEC_EXPORT_SHARED_API_NAME[v-1].as_ptr().cast::<c_char>(),
+                    );
+                    ctx.log_notice(&format!("Exported {} API", version));
+                }
             };
         }
 
@@ -608,6 +629,8 @@ macro_rules! redis_json_module_export_shared_api {
             getKeyValues: JSONAPI_getKeyValues,
             nextKeyValue: JSONAPI_nextKeyValue,
             freeKeyValuesIter: JSONAPI_freeKeyValuesIter,
+            // V5 entries
+            openKeyWithFlags: JSONAPI_openKey_withFlags,
         };
 
         #[repr(C)]
@@ -657,6 +680,13 @@ macro_rules! redis_json_module_export_shared_api {
                 str: *mut *mut rawmod::RedisModuleString
             ) -> *const c_void,
             pub freeKeyValuesIter: extern "C" fn(iter: *mut c_void),
+            // V5
+            pub openKeyWithFlags: extern "C" fn(
+                ctx: *mut rawmod::RedisModuleCtx,
+                key_str: *mut rawmod::RedisModuleString,
+                flags: c_int,
+            ) -> *mut c_void,
+
         }
     };
 }
diff --git a/redis_json/src/include/rejson_api.h b/redis_json/src/include/rejson_api.h
@@ -115,8 +115,15 @@ typedef struct RedisJSONAPI {
   // Free the iterator
   void (*freeKeyValuesIter)(JSONKeyValuesIterator iter);
 
+  ////////////////
+  // V5 entries //
+  ////////////////
+
+  RedisJSON (*openKeyWithFlags)(RedisModuleCtx *ctx, RedisModuleString *key_name, int flags);
+
 } RedisJSONAPI;
 
+#define RedisJSONAPI_LATEST_API_VER 5
 #ifdef __cplusplus
 }
 #endif
diff --git a/redis_json/src/ivalue_manager.rs b/redis_json/src/ivalue_manager.rs
@@ -13,7 +13,7 @@ use crate::REDIS_JSON_TYPE;
 use bson::decode_document;
 use ijson::object::Entry;
 use ijson::{DestructuredMut, INumber, IObject, IString, IValue, ValueType};
-use redis_module::key::{verify_type, RedisKey, RedisKeyWritable};
+use redis_module::key::{verify_type, KeyFlags, RedisKey, RedisKeyWritable};
 use redis_module::raw::{RedisModuleKey, Status};
 use redis_module::rediserror::RedisError;
 use redis_module::{Context, NotifyEvent, RedisResult, RedisString};
@@ -586,6 +586,16 @@ impl<'a> Manager for RedisIValueJsonKeyManager<'a> {
         Ok(IValueKeyHolderRead { key })
     }
 
+    fn open_key_read_with_flags(
+        &self,
+        ctx: &Context,
+        key: &RedisString,
+        flags: KeyFlags,
+    ) -> Result<Self::ReadHolder, RedisError> {
+        let key = ctx.open_key_with_flags(key, flags);
+        Ok(IValueKeyHolderRead { key })
+    }
+
     fn open_key_write(
         &self,
         ctx: &Context,
diff --git a/redis_json/src/lib.rs b/redis_json/src/lib.rs
@@ -18,13 +18,17 @@ use redis_module::Status;
 #[cfg(not(feature = "as-library"))]
 use redis_module::{Context, RedisResult};
 
+#[cfg(not(feature = "as-library"))]
+use redis_module::key::KeyFlags;
+
 #[cfg(not(feature = "as-library"))]
 use crate::c_api::{
     get_llapi_ctx, json_api_free_iter, json_api_free_key_values_iter, json_api_get,
     json_api_get_at, json_api_get_boolean, json_api_get_double, json_api_get_int,
     json_api_get_json, json_api_get_json_from_iter, json_api_get_key_value, json_api_get_len,
     json_api_get_string, json_api_get_type, json_api_is_json, json_api_len, json_api_next,
-    json_api_next_key_value, json_api_open_key_internal, json_api_reset_iter, LLAPI_CTX,
+    json_api_next_key_value, json_api_open_key_internal, json_api_open_key_with_flags_internal,
+    json_api_reset_iter, LLAPI_CTX,
 };
 use crate::redisjson::Format;
 
@@ -75,6 +79,7 @@ pub static REDIS_JSON_TYPE: RedisType = RedisType::new(
         unlink2: None,
         copy2: None,
         mem_usage2: None,
+        aux_save2: None,
     },
 );
 /////////////////////////////////////////////////////
@@ -109,11 +114,13 @@ macro_rules! redis_json_module_create {(
         info: $info_func:ident,
     ) => {
 
-        use redis_module::{redis_module, RedisString};
+        use redis_module::RedisString;
         use std::marker::PhantomData;
         use std::os::raw::{c_double, c_int, c_longlong};
-        use redis_module::{raw as rawmod, LogLevel};
+        use redis_module::raw as rawmod;
+        use redis_module::logging::RedisLogLevel;
         use rawmod::ModuleOptions;
+        use redis_module::redis_module;
 
         use std::{
             ffi::CStr,
@@ -168,7 +175,7 @@ macro_rules! redis_json_module_create {(
 
         fn json_init_config(ctx: &Context, args: &[RedisString]) -> Status{
             if args.len() % 2 != 0 {
-                ctx.log(LogLevel::Warning, "RedisJson arguments must be key:value pairs");
+                ctx.log(RedisLogLevel::Warning, "RedisJson arguments must be key:value pairs");
                 return Status::Err;
             }
             let mut args_map = HashMap::<String, String>::new();
diff --git a/redis_json/src/manager.rs b/redis_json/src/manager.rs
@@ -5,6 +5,7 @@
  */
 
 use json_path::select_value::SelectValue;
+use redis_module::key::KeyFlags;
 use serde_json::Number;
 
 use redis_module::raw::RedisModuleKey;
@@ -80,6 +81,12 @@ pub trait Manager {
         ctx: &Context,
         key: &RedisString,
     ) -> Result<Self::ReadHolder, RedisError>;
+    fn open_key_read_with_flags(
+        &self,
+        ctx: &Context,
+        key: &RedisString,
+        flags: KeyFlags,
+    ) -> Result<Self::ReadHolder, RedisError>;
     fn open_key_write(
         &self,
         ctx: &Context,
