add support for Command filter

Cargo.toml

@@ -13,6 +13,10 @@ readme = "README.md"
 name = "hello"
 crate-type = ["cdylib"]
 
+[[example]]
+name = "command_filter"
+crate-type = ["cdylib"]
+
 [[example]]
 name = "keys_pos"
 crate-type = ["cdylib"]

examples/command_filter.rs

@@ -0,0 +1,40 @@
+#[macro_use]
+extern crate redis_module;
+
+use redis_module::{CommandFilterContext, RedisString};
+use std::time::SystemTime;
+
+fn filter(ctx: &CommandFilterContext) {
+    // Prints every command to the console
+    let cmd = ctx.args_get(0).unwrap();
+    eprint!("{} ", cmd);
+    let count = ctx.args_count();
+    for index in 1..count {
+        eprint!("{} ", ctx.args_get(index).unwrap());
+    }
+    eprintln!("");
+
+    // Add time field for every Hash
+    if let Ok("HSET") = cmd.try_as_str() {
+        ctx.args_insert(count, RedisString::create(std::ptr::null_mut(), "__TIME__"));
+        let now = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap();
+        ctx.args_insert(
+            count + 1,
+            RedisString::create(std::ptr::null_mut(), &format!("{}", now.as_millis())),
+        );
+    }
+}
+
+//////////////////////////////////////////////////////
+
+redis_module! {
+    name: "command_filter",
+    version: 1,
+    data_types: [],
+    commands: [],
+    filters:[
+        [filter, 0],
+    ]
+}

src/commandfilter/mod.rs

@@ -0,0 +1,65 @@
+use crate::raw;
+use crate::RedisString;
+use crate::Status;
+use std::os::raw::c_int;
+use std::ptr;
+
+pub struct CommandFilterContext {
+    pub ctx: *mut raw::RedisModuleCommandFilterCtx,
+}
+
+impl CommandFilterContext {
+    pub fn new(ctx: *mut raw::RedisModuleCommandFilterCtx) -> Self {
+        CommandFilterContext { ctx }
+    }
+
+    pub fn args_count(&self) -> usize {
+        unsafe { raw::RedisModule_CommandFilterArgsCount.unwrap()(self.ctx) as usize }
+    }
+
+    pub fn args_get(&self, pos: usize) -> Option<RedisString> {
+        let arg = unsafe {
+            raw::RedisModule_CommandFilterArgGet.unwrap()(self.ctx, pos as c_int)
+                as *mut raw::RedisModuleString
+        };
+        if arg.is_null() {
+            None
+        } else {
+            Some(RedisString::new(ptr::null_mut(), arg))
+        }
+    }
+
+    pub fn args_insert(&self, pos: usize, arg: RedisString) -> Status {
+        // retain arg since RedisModule_CommandFilterArgInsert going to release it too
+        raw::string_retain_string(std::ptr::null_mut(), arg.inner);
+        let status = unsafe {
+            raw::RedisModule_CommandFilterArgInsert.unwrap()(self.ctx, pos as c_int, arg.inner)
+                .into()
+        };
+
+        // If the string wasn't inserted we have to release it ourself
+        if status == Status::Err {
+            unsafe { raw::RedisModule_FreeString.unwrap()(std::ptr::null_mut(), arg.inner) };
+        }
+        status
+    }
+
+    pub fn args_replace(&self, pos: usize, arg: RedisString) -> Status {
+        // retain arg since RedisModule_CommandFilterArgReplace going to release it too
+        raw::string_retain_string(std::ptr::null_mut(), arg.inner);
+        let status = unsafe {
+            raw::RedisModule_CommandFilterArgReplace.unwrap()(self.ctx, pos as c_int, arg.inner)
+                .into()
+        };
+
+        // If the string wasn't replaced we have to release it ourself
+        if status == Status::Err {
+            unsafe { raw::RedisModule_FreeString.unwrap()(std::ptr::null_mut(), arg.inner) };
+        }
+        status
+    }
+
+    pub fn args_delete(&self, pos: usize) -> Status {
+        unsafe { raw::RedisModule_CommandFilterArgDelete.unwrap()(self.ctx, pos as c_int).into() }
+    }
+}

src/lib.rs

@@ -17,19 +17,22 @@ mod redismodule;
 pub mod redisraw;
 pub mod redisvalue;
 
+#[cfg(feature = "experimental-api")]
+mod commandfilter;
 mod context;
 pub mod key;
 pub mod logging;
 mod macros;
 
+#[cfg(feature = "experimental-api")]
+pub use crate::commandfilter::CommandFilterContext;
 #[cfg(feature = "experimental-api")]
 pub use crate::context::blocked::BlockedClient;
 #[cfg(feature = "experimental-api")]
 pub use crate::context::thread_safe::{DetachedFromClient, ThreadSafeContext};
+pub use crate::context::Context;
 #[cfg(feature = "experimental-api")]
 pub use crate::raw::NotifyEvent;
-
-pub use crate::context::Context;
 pub use crate::raw::Status;
 pub use crate::redismodule::*;
 

src/macros.rs

@@ -82,6 +82,31 @@ macro_rules! redis_event_handler {
     }};
 }
 
+#[cfg(feature = "experimental-api")]
+#[macro_export]
+macro_rules! redis_commnad_filter {
+    ($ctx:expr,
+     $filter_handler:expr,
+     $filter_flags:expr) => {{
+        /////////////////////
+        extern "C" fn __do_filter(ctx: *mut $crate::raw::RedisModuleCommandFilterCtx) {
+            let context = $crate::CommandFilterContext::new(ctx);
+            $filter_handler(&context);
+        }
+        /////////////////////
+        if unsafe {
+            $crate::raw::RedisModule_RegisterCommandFilter.unwrap()(
+                $ctx,
+                Some(__do_filter),
+                $filter_flags as c_int,
+            )
+        } == std::ptr::null_mut()
+        {
+            return $crate::raw::Status::Err as c_int;
+        }
+    }};
+}
+
 #[macro_export]
 macro_rules! redis_module {
     (
@@ -102,6 +127,12 @@ macro_rules! redis_module {
                 $keystep:expr
               ]),* $(,)*
         ] $(,)*
+        $(filters: [
+            $([
+                $filter_handler:expr,
+                $filter_flags:expr
+              ]),* $(,)*
+        ] $(,)*)?
         $(event_handlers: [
             $([
                 $(@$event_type:ident) +:
@@ -162,6 +193,12 @@ macro_rules! redis_module {
                 redis_command!(ctx, $name, $command, $flags, $firstkey, $lastkey, $keystep);
             )*
 
+            $(
+                $(
+                    redis_commnad_filter!(ctx, $filter_handler, $filter_flags);
+                )*
+            )?
+
             $(
                 $(
                     redis_event_handler!(ctx, $(raw::NotifyEvent::$event_type |)+ raw::NotifyEvent::empty(), $event_handler);

src/redismodule.rs

@@ -50,7 +50,7 @@ where
     }
 
     #[inline]
-   fn next_i64(&mut self) -> Result<i64, RedisError> {
+    fn next_i64(&mut self) -> Result<i64, RedisError> {
         self.next()
             .map_or(Err(RedisError::WrongArity), |v| v.parse_integer())
     }

src/redisvalue.rs

@@ -129,10 +129,10 @@ mod tests {
 
     #[test]
     fn from_vec() {
-        let v : Vec<u8> = vec![0,3,5,21,255];
+        let v: Vec<u8> = vec![0, 3, 5, 21, 255];
         assert_eq!(
             RedisValue::from(v),
-            RedisValue::StringBuffer(vec![0,3,5,21,255])
+            RedisValue::StringBuffer(vec![0, 3, 5, 21, 255])
         );
     }
 

tests/integration.rs

@@ -48,3 +48,28 @@ fn test_keys_pos() -> Result<()> {
 
     Ok(())
 }
+
+#[cfg(feature = "experimental-api")]
+#[test]
+fn test_command_filter() -> Result<()> {
+    let _guards = vec![start_redis_server_with_module("command_filter", 6481)
+        .with_context(|| "failed to start redis server")?];
+    let mut con =
+        get_redis_connection(6481).with_context(|| "failed to connect to redis server")?;
+
+    let res: i32 = redis::cmd("HSET")
+        .arg(&["mykey", "first", "Don"])
+        .query(&mut con)
+        .with_context(|| "failed to run HSET")?;
+    assert_eq!(res, 2);
+
+    let res: Vec<String> = redis::cmd("HGETALL")
+        .arg(&["mykey"])
+        .query(&mut con)
+        .with_context(|| "failed to run HSET")?;
+
+    assert_eq!(res.len(), 4);
+    assert_eq!(res[0..3], ["first", "Don", "__TIME__"]);
+
+    Ok(())
+}