Merge pull request #362 from RedisLabsModules/dvirdu_add_openkey_flags

open key with flags

Author: DvirDukhan

.circleci/config.yml

@@ -71,7 +71,7 @@ commands:
     parameters:
       redis_version:
         type: string
-        default: "7.2-rc1"
+        default: "7.2"
       getredis_params:
         type: string
         default: ""
@@ -101,7 +101,7 @@ commands:
         default: ""
       redis_version:
         type: string
-        default: "7.2-rc1"
+        default: "7.2"
       getredis_params:
         type: string
         default: ""
@@ -111,6 +111,11 @@ commands:
       - install-prerequisites:
           redis_version: <<parameters.redis_version>>
           getredis_params: <<parameters.getredis_params>>
+      - run:
+          name: patch macos tests # Avoid AVX with Regex with CircleCI since virtualization layer doesn't support it. Use sed to replace the relevant entry in cargo.toml
+          command: |
+            if [[ $(uname -s) == Darwin ]]; then sed -i 's/regex = "1"/regex = { version = "1", features = ["perf", "unicode"] }/g' Cargo.toml; fi
+            cat Cargo.toml
       - restore_cache:
           keys:
             - v3-dependencies-{{ arch }}-{{ checksum "Cargo.toml" }}
@@ -203,7 +208,7 @@ jobs:
 
   build-macos-x64:
     macos:
-      xcode: 13.2.1
+      xcode: 13.4.1
     resource_class: macos.x86.medium.gen2
     steps:
       - build-steps

.gitignore

@@ -21,3 +21,5 @@ dump.rdb
 
 # Debugger-related files:
 .gdb_history
+
+venv/

Cargo.toml

@@ -112,6 +112,10 @@ crate-type = ["cdylib"]
 name = "response"
 crate-type = ["cdylib"]
 
+[[example]]
+name = "open_key_with_flags"
+crate-type = ["cdylib"]
+
 [dependencies]
 bitflags = "2"
 libc = "0.2"

build.sh

@@ -1,4 +1,4 @@
 #!/usr/bin/env sh
-cargo build --features experimental-api,test --all --all-targets
+cargo build --all --all-targets --no-default-features
 
 

examples/open_key_with_flags.rs

@@ -0,0 +1,67 @@
+use redis_module::{
+    key::KeyFlags, raw, redis_module, Context, NextArg, RedisError, RedisResult, RedisString,
+    RedisValue,
+};
+use redis_module_macros::command;
+
+#[command(
+    {
+        name: "open_key_with_flags.read",
+        flags: [Write, DenyOOM],
+        arity: 2,
+        key_spec: [
+            {
+                flags: [ReadOnly, Access],
+                begin_search: Index({ index : 1 }),
+                find_keys: Range({ last_key : 1, steps : 1, limit : 1}),
+            }
+        ]
+
+    }
+)]
+fn read(ctx: &Context, args: Vec<RedisString>) -> RedisResult {
+    if args.len() < 2 {
+        return Err(RedisError::WrongArity);
+    }
+
+    let mut args = args.into_iter().skip(1);
+    let key_name = args.next_arg()?;
+    let _ = ctx.open_key_with_flags(&key_name, KeyFlags::NOEFFECTS);
+    Ok(RedisValue::SimpleStringStatic("OK"))
+}
+
+#[command(
+    {
+        name: "open_key_with_flags.write",
+        flags: [Write, DenyOOM],
+        arity: 2,
+        key_spec: [
+            {
+                flags: [ReadWrite, Access],
+                begin_search: Index({ index : 1 }),
+                find_keys: Range({ last_key : 1, steps : 1, limit : 1}),
+            }
+        ]
+
+    }
+)]
+fn write(ctx: &Context, args: Vec<RedisString>) -> RedisResult {
+    if args.len() < 2 {
+        return Err(RedisError::WrongArity);
+    }
+
+    let mut args = args.into_iter().skip(1);
+    let key_name = args.next_arg()?;
+    let _ = ctx.open_key_writable_with_flags(&key_name, KeyFlags::NOEFFECTS);
+    Ok(RedisValue::SimpleStringStatic("OK"))
+}
+
+//////////////////////////////////////////////////////
+
+redis_module! {
+    name: "open_key_with_flags",
+    version: 1,
+    allocator: (redis_module::alloc::RedisAlloc, redis_module::alloc::RedisAlloc),
+    data_types: [],
+    commands: [],
+}

src/context/mod.rs

@@ -7,7 +7,7 @@ use std::os::raw::{c_char, c_int, c_long, c_longlong};
 use std::ptr::{self, NonNull};
 use std::sync::atomic::{AtomicPtr, Ordering};
 
-use crate::key::{RedisKey, RedisKeyWritable};
+use crate::key::{KeyFlags, RedisKey, RedisKeyWritable};
 use crate::logging::RedisLogLevel;
 use crate::raw::{ModuleOptions, Version};
 use crate::redisvalue::RedisValueKey;
@@ -614,11 +614,25 @@ impl Context {
         RedisKey::open(self.ctx, key)
     }
 
+    #[must_use]
+    pub fn open_key_with_flags(&self, key: &RedisString, flags: KeyFlags) -> RedisKey {
+        RedisKey::open_with_flags(self.ctx, key, flags)
+    }
+
     #[must_use]
     pub fn open_key_writable(&self, key: &RedisString) -> RedisKeyWritable {
         RedisKeyWritable::open(self.ctx, key)
     }
 
+    #[must_use]
+    pub fn open_key_writable_with_flags(
+        &self,
+        key: &RedisString,
+        flags: KeyFlags,
+    ) -> RedisKeyWritable {
+        RedisKeyWritable::open_with_flags(self.ctx, key, flags)
+    }
+
     pub fn replicate_verbatim(&self) {
         raw::replicate_verbatim(self.ctx);
     }

src/key.rs

@@ -7,16 +7,19 @@ use std::ptr::NonNull;
 use std::time::Duration;
 
 use libc::size_t;
+use std::os::raw::c_int;
 
 use raw::KeyType;
 
 use crate::native_types::RedisType;
 use crate::raw;
 use crate::redismodule::REDIS_OK;
+pub use crate::redisraw::bindings::*;
 use crate::stream::StreamIterator;
 use crate::RedisError;
 use crate::RedisResult;
 use crate::RedisString;
+use bitflags::bitflags;
 
 /// `RedisKey` is an abstraction over a Redis key that allows readonly
 /// operations.
@@ -32,6 +35,21 @@ pub enum KeyMode {
     ReadWrite,
 }
 
+bitflags! {
+    pub struct KeyFlags: c_int {
+        /// Avoid touching the LRU/LFU of the key when opened.
+        const NOTOUCH = REDISMODULE_OPEN_KEY_NOTOUCH as c_int;
+        /// Don't trigger keyspace event on key misses.
+        const NONOTIFY = REDISMODULE_OPEN_KEY_NONOTIFY as c_int;
+        /// Don't update keyspace hits/misses counters.
+        const NOSTATS = REDISMODULE_OPEN_KEY_NOSTATS as c_int;
+        /// Avoid deleting lazy expired keys.
+        const NOEXPIRE = REDISMODULE_OPEN_KEY_NOEXPIRE as c_int;
+        /// Avoid any effects from fetching the key.
+        const NOEFFECTS = REDISMODULE_OPEN_KEY_NOEFFECTS as c_int;
+    }
+}
+
 #[derive(Debug)]
 pub struct RedisKey {
     pub(crate) ctx: *mut raw::RedisModuleCtx,
@@ -50,6 +68,16 @@ impl RedisKey {
         Self { ctx, key_inner }
     }
 
+    pub(crate) fn open_with_flags(
+        ctx: *mut raw::RedisModuleCtx,
+        key: &RedisString,
+        flags: KeyFlags,
+    ) -> Self {
+        let key_inner =
+            raw::open_key_with_flags(ctx, key.inner, to_raw_mode(KeyMode::Read), flags.bits());
+        Self { ctx, key_inner }
+    }
+
     pub(crate) const fn from_raw_parts(
         ctx: *mut raw::RedisModuleCtx,
         key_inner: *mut raw::RedisModuleKey,
@@ -176,6 +204,20 @@ impl RedisKeyWritable {
         Self { ctx, key_inner }
     }
 
+    pub(crate) fn open_with_flags(
+        ctx: *mut raw::RedisModuleCtx,
+        key: &RedisString,
+        flags: KeyFlags,
+    ) -> Self {
+        let key_inner = raw::open_key_with_flags(
+            ctx,
+            key.inner,
+            to_raw_mode(KeyMode::ReadWrite),
+            flags.bits(),
+        );
+        Self { ctx, key_inner }
+    }
+
     /// Detects whether the value stored in a Redis key is empty.
     ///
     /// Note that an empty key can be reliably detected by looking for a null

src/raw.rs

@@ -348,6 +348,19 @@ pub fn open_key(
     unsafe { RedisModule_OpenKey.unwrap()(ctx, keyname, mode.bits()).cast::<RedisModuleKey>() }
 }
 
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[inline]
+pub(crate) fn open_key_with_flags(
+    ctx: *mut RedisModuleCtx,
+    keyname: *mut RedisModuleString,
+    mode: KeyMode,
+    flags: c_int,
+) -> *mut RedisModuleKey {
+    unsafe {
+        RedisModule_OpenKey.unwrap()(ctx, keyname, mode.bits() | flags).cast::<RedisModuleKey>()
+    }
+}
+
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[inline]
 pub fn reply_with_array(ctx: *mut RedisModuleCtx, len: c_long) -> Status {

test.sh

@@ -1,2 +1,2 @@
 #!/usr/bin/env sh
-cargo test --all-targets --features test,experimental-api
+cargo test --all --all-targets --no-default-features

tests/integration.rs

@@ -1,3 +1,6 @@
+use std::thread;
+use std::time::Duration;
+
 use crate::utils::{get_redis_connection, start_redis_server_with_module};
 use anyhow::Context;
 use anyhow::Result;
@@ -646,3 +649,59 @@ fn test_call_blocking() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_open_key_with_flags() -> Result<()> {
+    let port: u16 = 6501;
+    let _guards = vec![start_redis_server_with_module("open_key_with_flags", port)
+        .with_context(|| "failed to start redis server")?];
+    let mut con =
+        get_redis_connection(port).with_context(|| "failed to connect to redis server")?;
+
+    // Avoid active expriation
+    redis::cmd("DEBUG")
+        .arg(&["SET-ACTIVE-EXPIRE", "0"])
+        .query(&mut con)
+        .with_context(|| "failed to run DEBUG SET-ACTIVE-EXPIRE")?;
+
+    for cmd in ["open_key_with_flags.write", "open_key_with_flags.read"].into_iter() {
+        redis::cmd("set")
+            .arg(&["x", "1"])
+            .query(&mut con)
+            .with_context(|| "failed to run string.set")?;
+
+        // Set experition time to 1 second.
+        redis::cmd("pexpire")
+            .arg(&["x", "1"])
+            .query(&mut con)
+            .with_context(|| "failed to run expire")?;
+
+        // Sleep for 2 seconds, ensure expiration time has passed.
+        thread::sleep(Duration::from_millis(500));
+
+        // Open key as read only or ReadWrite with NOEFFECTS flag.
+        let res = redis::cmd(cmd).arg(&["x"]).query(&mut con);
+        assert_eq!(res, Ok(()));
+
+        // Get the number of expired keys.
+        let stats: String = redis::cmd("info").arg(&["stats"]).query(&mut con)?;
+
+        // Find the number of expired keys, x,  according to the substring "expired_keys:{x}"
+        let expired_keys = stats
+            .match_indices("expired_keys:")
+            .next()
+            .map(|(i, _)| &stats[i..i + "expired_keys:".len() + 1])
+            .and_then(|s| s.split(':').nth(1))
+            .and_then(|s| s.parse::<i32>().ok())
+            .unwrap_or(-1);
+
+        // Ensure that no keys were expired.
+        assert_eq!(expired_keys, 0);
+
+        // Delete key and reset stats
+        redis::cmd("del").arg(&["x"]).query(&mut con)?;
+        redis::cmd("config").arg(&["RESETSTAT"]).query(&mut con)?;
+    }
+
+    Ok(())
+}