Merge pull request #65 from RedisLabsModules/gavrie-is_keys_position_request

Add support for RedisModule_IsKeysPositionRequest

Author: gavrie

examples/hello.rs

@@ -1,13 +1,22 @@
 #[macro_use]
 extern crate redis_module;
 
-use redis_module::{parse_integer, Context, RedisError, RedisResult};
+use redis_module::{parse_integer, Context, RedisError, RedisResult, RedisValue};
 
-fn hello_mul(_: &Context, args: Vec<String>) -> RedisResult {
+fn hello_mul(ctx: &Context, args: Vec<String>) -> RedisResult {
     if args.len() < 2 {
         return Err(RedisError::WrongArity);
     }
 
+    if ctx.is_keys_position_request() {
+        for i in 1..args.len() {
+            if i % 2 == 0 {
+                ctx.key_at_pos(i as i32);
+            }
+        }
+        return Ok(RedisValue::NoReply);
+    }
+
     let nums = args
         .into_iter()
         .skip(1)
@@ -29,7 +38,7 @@ redis_module! {
     version: 1,
     data_types: [],
     commands: [
-        ["hello.mul", hello_mul, "", 1, 1, 1],
+        ["hello.mul", hello_mul, "getkeys-api", 1, 1, 1],
     ],
 }
 

src/context.rs

@@ -1,5 +1,5 @@
 use std::ffi::CString;
-use std::os::raw::c_long;
+use std::os::raw::{c_long, c_int};
 use std::ptr;
 
 use crate::key::{RedisKey, RedisKeyWritable};
@@ -56,6 +56,22 @@ impl Context {
         }
     }
 
+    pub fn is_keys_position_request(&self) -> bool {
+        let result = unsafe {
+            raw::RedisModule_IsKeysPositionRequest.unwrap()(self.ctx)
+        };
+
+        result != 0
+    }
+
+    pub fn key_at_pos(&self, pos: i32) {
+        // TODO: This will crash redis if `pos` is out of range.
+        // Think of a way to make this safe by checking the range.
+        unsafe {
+            raw::RedisModule_KeyAtPos.unwrap()(self.ctx, pos as c_int);
+        }
+    }
+
     pub fn call(&self, command: &str, args: &[&str]) -> RedisResult {
         let terminated_args: Vec<RedisString> = args
             .iter()
@@ -99,7 +115,7 @@ impl Context {
             }
             raw::ReplyType::Integer => Ok(RedisValue::Integer(raw::call_reply_integer(reply))),
             raw::ReplyType::String => Ok(RedisValue::SimpleString(raw::call_reply_string(reply))),
-            raw::ReplyType::Nil => Ok(RedisValue::None),
+            raw::ReplyType::Null => Ok(RedisValue::Null),
         }
     }
 
@@ -145,12 +161,19 @@ impl Context {
                 raw::Status::Ok
             }
 
-            Ok(RedisValue::None) => unsafe {
+            Ok(RedisValue::Null) => unsafe {
                 raw::RedisModule_ReplyWithNull.unwrap()(self.ctx).into()
             },
 
+            Ok(RedisValue::NoReply) => raw::Status::Ok,
+
             Err(RedisError::WrongArity) => unsafe {
-                raw::RedisModule_WrongArity.unwrap()(self.ctx).into()
+                if self.is_keys_position_request() {
+                    // We can't return a result since we don't have a client
+                    raw::Status::Err
+                } else {
+                    raw::RedisModule_WrongArity.unwrap()(self.ctx).into()
+                }
             },
 
             Err(RedisError::String(s)) => unsafe {

src/raw.rs

@@ -59,7 +59,7 @@ pub enum ReplyType {
     Error = REDISMODULE_REPLY_ERROR_ISIZE,
     Integer = REDISMODULE_REPLY_INTEGER_ISIZE,
     Array = REDISMODULE_REPLY_ARRAY_ISIZE,
-    Nil = REDISMODULE_REPLY_NULL_ISIZE,
+    Null = REDISMODULE_REPLY_NULL_ISIZE,
 }
 
 impl From<c_int> for ReplyType {

src/redisvalue.rs

@@ -6,12 +6,13 @@ pub enum RedisValue {
     Integer(i64),
     Float(f64),
     Array(Vec<RedisValue>),
-    None,
+    Null,
+    NoReply, // No reply at all (as opposed to a Null reply)
 }
 
 impl From<()> for RedisValue {
     fn from(_: ()) -> Self {
-        RedisValue::None
+        RedisValue::Null
     }
 }
 
@@ -55,7 +56,7 @@ impl<T: Into<RedisValue>> From<Option<T>> for RedisValue {
     fn from(s: Option<T>) -> Self {
         match s {
             Some(v) => v.into(),
-            None => RedisValue::None,
+            None => RedisValue::Null,
         }
     }
 }
@@ -106,6 +107,6 @@ mod tests {
 
     #[test]
     fn from_option_none() {
-        assert_eq!(RedisValue::from(None::<()>), RedisValue::None,);
+        assert_eq!(RedisValue::from(None::<()>), RedisValue::Null,);
     }
 }