Refactor into modules

Author: gavrie

examples/data_type.rs

@@ -7,11 +7,11 @@ use libc::c_int;
 extern crate redismodule;
 
 use redismodule::error::Error;
-use redismodule::Command;
+use redismodule::CommandOld;
 use redismodule::raw;
-use redismodule::Redis;
+use redismodule::Context;
 use redismodule::raw::module_init;
-use redismodule::types::RedisType;
+use redismodule::native_types::RedisType;
 
 const MODULE_NAME: &str = "alloc";
 const MODULE_VERSION: c_int = 1;
@@ -25,15 +25,15 @@ static MY_TYPE: RedisType = RedisType::new();
 
 struct AllocSetCommand;
 
-impl Command for AllocSetCommand {
+impl CommandOld for AllocSetCommand {
     fn name() -> &'static str { "alloc.set" }
 
     fn external_command() -> raw::CommandFunc { AllocSetCommand_Redis }
 
     fn str_flags() -> &'static str { "write" }
 
     // Run the command.
-    fn run(r: Redis, args: &[&str]) -> Result<(), Error> {
+    fn run(r: Context, args: &[&str]) -> Result<(), Error> {
         if args.len() != 3 {
             // FIXME: Use RedisModule_WrongArity instead. Return an ArityError here and
             // in the low-level implementation call RM_WrongArity.
@@ -102,15 +102,15 @@ pub extern "C" fn AllocSetCommand_Redis(
 
 struct AllocGetCommand;
 
-impl Command for AllocGetCommand {
+impl CommandOld for AllocGetCommand {
     fn name() -> &'static str { "alloc.get" }
 
     fn external_command() -> raw::CommandFunc { AllocGetCommand_Redis }
 
     fn str_flags() -> &'static str { "" }
 
     // Run the command.
-    fn run(r: Redis, args: &[&str]) -> Result<(), Error> {
+    fn run(r: Context, args: &[&str]) -> Result<(), Error> {
         if args.len() != 2 {
             // FIXME: Use RedisModule_WrongArity instead. Return an ArityError here and
             // in the low-level implementation call RM_WrongArity.
@@ -155,15 +155,15 @@ pub extern "C" fn AllocGetCommand_Redis(
 
 struct AllocDelCommand;
 
-impl Command for AllocDelCommand {
+impl CommandOld for AllocDelCommand {
     fn name() -> &'static str { "alloc.del" }
 
     fn external_command() -> raw::CommandFunc { AllocDelCommand_Redis }
 
     fn str_flags() -> &'static str { "write" }
 
     // Run the command.
-    fn run(r: Redis, args: &[&str]) -> Result<(), Error> {
+    fn run(r: Context, args: &[&str]) -> Result<(), Error> {
         if args.len() != 2 {
             // FIXME: Use RedisModule_WrongArity instead?
             return Err(Error::generic(format!(
@@ -195,8 +195,10 @@ pub extern "C" fn AllocDelCommand_Redis(
 fn module_on_load(ctx: *mut raw::RedisModuleCtx) -> Result<(), &'static str> {
     module_init(ctx, MODULE_NAME, MODULE_VERSION)?;
 
-// TODO: Call this from inside module_init
-    redismodule::use_redis_alloc();
+    // TODO: Call this from inside module_init
+    if true {
+        redismodule::alloc::use_redis_alloc();
+    }
 
     MY_TYPE.create_data_type(ctx, "mytype123")?;
 

examples/hello.rs

@@ -5,9 +5,9 @@ use libc::c_int;
 extern crate redismodule;
 
 use redismodule::error::Error;
-use redismodule::Command;
+use redismodule::CommandOld;
 use redismodule::raw;
-use redismodule::Redis;
+use redismodule::Context;
 use redismodule::raw::module_init;
 
 const MODULE_NAME: &str = "hello";
@@ -18,15 +18,15 @@ const MODULE_VERSION: c_int = 1;
 
 struct HelloMulCommand;
 
-impl Command for HelloMulCommand {
+impl CommandOld for HelloMulCommand {
     fn name() -> &'static str { "hello.mul" }
 
     fn external_command() -> raw::CommandFunc { HelloMulCommand_Redis }
 
     fn str_flags() -> &'static str { "write" }
 
     // Run the command.
-    fn run(r: Redis, args: &[&str]) -> Result<(), Error> {
+    fn run(r: Context, args: &[&str]) -> Result<(), Error> {
         if args.len() != 3 {
             return Err(Error::generic(format!(
                 "Usage: {} <m1> <m2>", Self::name()
@@ -59,15 +59,15 @@ pub extern "C" fn HelloMulCommand_Redis(
 
 struct HelloAddCommand;
 
-impl Command for HelloAddCommand {
+impl CommandOld for HelloAddCommand {
     fn name() -> &'static str { "hello.add" }
 
     fn external_command() -> raw::CommandFunc { HelloAddCommand_Redis }
 
     fn str_flags() -> &'static str { "write" }
 
     // Run the command.
-    fn run(r: Redis, args: &[&str]) -> Result<(), Error> {
+    fn run(r: Context, args: &[&str]) -> Result<(), Error> {
         if args.len() != 3 {
             // FIXME: Use RedisModule_WrongArity instead?
             return Err(Error::generic(format!(

src/alloc.rs

@@ -0,0 +1,32 @@
+use std::os::raw::c_void;
+use std::alloc::{System, GlobalAlloc, Layout};
+use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering::SeqCst};
+
+use crate::raw;
+
+pub struct RedisAlloc;
+
+static USE_REDIS_ALLOC: AtomicBool = ATOMIC_BOOL_INIT;
+
+unsafe impl GlobalAlloc for RedisAlloc {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let use_redis = USE_REDIS_ALLOC.load(SeqCst);
+        if use_redis {
+            return raw::RedisModule_Alloc.unwrap()(layout.size()) as *mut u8;
+        }
+        System.alloc(layout)
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let use_redis = USE_REDIS_ALLOC.load(SeqCst);
+        if use_redis {
+            return raw::RedisModule_Free.unwrap()(ptr as *mut c_void);
+        }
+        System.dealloc(ptr, layout);
+    }
+}
+
+pub fn use_redis_alloc() {
+    eprintln!("Using Redis allocator");
+    USE_REDIS_ALLOC.store(true, SeqCst);
+}

src/command.rs

@@ -0,0 +1,77 @@
+use std::ffi::CString;
+use std::os::raw::c_int;
+
+use crate::raw;
+use crate::error::Error;
+use crate::context::Context;
+use crate::parse_args;
+
+
+/*
+pub struct Command<F> where F: Fn(&Context, Vec<String>) -> RedisResult {
+    pub name: &'static str,
+    pub handler: F,
+    pub flags: &'static str,
+}
+*/
+
+type CommandFuncPtr = extern "C" fn(
+    *mut raw::RedisModuleCtx,
+    *mut *mut raw::RedisModuleString,
+    c_int,
+) -> c_int;
+
+
+pub trait CommandOld {
+    // Should return the name of the command to be registered.
+    fn name() -> &'static str;
+
+    fn external_command() -> CommandFuncPtr;
+
+    // Should return any flags to be registered with the name as a string
+    // separated list. See the Redis module API documentation for a complete
+    // list of the ones that are available.
+    fn str_flags() -> &'static str;
+
+    // Run the command.
+    fn run(r: Context, args: &[&str]) -> Result<(), Error>;
+
+    /// Provides a basic wrapper for a command's implementation that parses
+    /// arguments to Rust data types and handles the OK/ERR reply back to Redis.
+    fn execute(
+        ctx: *mut raw::RedisModuleCtx,
+        argv: *mut *mut raw::RedisModuleString,
+        argc: c_int,
+    ) -> raw::Status {
+        let args = parse_args(argv, argc).unwrap();
+        let str_args: Vec<&str> = args.iter().map(|s| s.as_str()).collect();
+
+        let r = Context::new(ctx);
+
+        match Self::run(r, str_args.as_slice()) {
+            Ok(_) => raw::Status::Ok,
+            Err(e) => {
+                let message = format!("Redis error: {}", e.to_string());
+                let message = CString::new(message).unwrap();
+
+                raw::reply_with_error(
+                    ctx,
+                    message.as_ptr(),
+                );
+
+                raw::Status::Err
+            }
+        }
+    }
+
+    fn create(ctx: *mut raw::RedisModuleCtx) -> Result<(), &'static str> {
+        raw::create_command(
+            ctx,
+            Self::name(),
+            Self::external_command(),
+            Self::str_flags(),
+            0, 0, 0,
+        )
+    }
+}
+

src/context.rs

@@ -0,0 +1,107 @@
+use std::os::raw::{c_long, c_longlong};
+use std::ffi::CString;
+
+use crate::raw;
+use crate::error::Error;
+use crate::{RedisString, LogLevel, Reply};
+use crate::key::{RedisKey,RedisKeyWritable};
+
+/// Redis is a structure that's designed to give us a high-level interface to
+/// the Redis module API by abstracting away the raw C FFI calls.
+pub struct Context {
+    ctx: *mut raw::RedisModuleCtx,
+}
+
+impl Context {
+    pub fn new(ctx: *mut raw::RedisModuleCtx) -> Self {
+        Self {ctx}
+    }
+
+    /// Coerces a Redis string as an integer.
+    ///
+    /// Redis is pretty dumb about data types. It nominally supports strings
+    /// versus integers, but an integer set in the store will continue to look
+    /// like a string (i.e. "1234") until some other operation like INCR forces
+    /// its coercion.
+    ///
+    /// This method coerces a Redis string that looks like an integer into an
+    /// integer response. All other types of replies are passed through
+    /// unmodified.
+    pub fn coerce_integer(
+        &self,
+        reply_res: Result<Reply, Error>,
+    ) -> Result<Reply, Error> {
+        match reply_res {
+            Ok(Reply::String(s)) => match s.parse::<i64>() {
+                Ok(n) => Ok(Reply::Integer(n)),
+                _ => Ok(Reply::String(s)),
+            },
+            _ => reply_res,
+        }
+    }
+
+    pub fn create_string(&self, s: &str) -> RedisString {
+        RedisString::create(self.ctx, s)
+    }
+
+    pub fn log(&self, level: LogLevel, message: &str) {
+        let level = CString::new(format!("{:?}", level).to_lowercase()).unwrap();
+        let fmt = CString::new(message).unwrap();
+        raw::log(
+            self.ctx,
+            level.as_ptr(),
+            fmt.as_ptr(),
+        );
+    }
+
+    pub fn log_debug(&self, message: &str) {
+        // Note that we log our debug messages as notice level in Redis. This
+        // is so that they'll show up with default configuration. Our debug
+        // logging will get compiled out in a release build so this won't
+        // result in undue noise in production.
+        self.log(LogLevel::Notice, message);
+    }
+
+    /// Opens a Redis key for read access.
+    pub fn open_key(&self, key: &str) -> RedisKey {
+        RedisKey::open(self.ctx, key)
+    }
+
+    /// Opens a Redis key for read and write access.
+    pub fn open_key_writable(&self, key: &str) -> RedisKeyWritable {
+        RedisKeyWritable::open(self.ctx, key)
+    }
+
+    /// Tells Redis that we're about to reply with an (Redis) array.
+    ///
+    /// Used by invoking once with the expected length and then calling any
+    /// combination of the other reply_* methods exactly that number of times.
+    pub fn reply_array(&self, len: i64) -> Result<(), Error> {
+        handle_status(
+            raw::reply_with_array(self.ctx, len as c_long),
+            "Could not reply with long",
+        )
+    }
+
+    pub fn reply_integer(&self, integer: i64) -> Result<(), Error> {
+        handle_status(
+            raw::reply_with_long_long(self.ctx, integer as c_longlong),
+            "Could not reply with longlong",
+        )
+    }
+
+    pub fn reply_string(&self, message: &str) -> Result<(), Error> {
+        let redis_str = self.create_string(message);
+        handle_status(
+            raw::reply_with_string(self.ctx, redis_str.str_inner),
+            "Could not reply with string",
+        )
+    }
+}
+
+fn handle_status(status: raw::Status, message: &str) -> Result<(), Error> {
+    match status {
+        raw::Status::Ok => Ok(()),
+        raw::Status::Err => Err(error!(message)),
+    }
+}