Clean up native types; still crashes

Author: gavrie

examples/data_type.rs

@@ -15,7 +15,7 @@ impl Default for MyType {
     }
 }
 
-static MY_REDIS_TYPE: RedisType = RedisType::new();
+static MY_REDIS_TYPE: RedisType = RedisType::new("mytype123");
 
 fn alloc_set(ctx: &Context, args: Vec<String>) -> RedisResult {
     let mut args = args.into_iter().skip(1);
@@ -79,6 +79,13 @@ fn alloc_get(ctx: &Context, args: Vec<String>) -> RedisResult {
 const MODULE_NAME: &str = "alloc";
 const MODULE_VERSION: c_int = 1;
 
-redis_module!(MODULE_NAME, MODULE_VERSION, [
-    Command::new("alloc.set", alloc_set, "write"),
-]);
+redis_module!(
+    MODULE_NAME,
+    MODULE_VERSION,
+    [
+        &MY_REDIS_TYPE,
+    ],
+    [
+        Command::new("alloc.set", alloc_set, "write"),
+    ]
+);

examples/hello.rs

@@ -2,6 +2,7 @@
 extern crate redismodule;
 
 use redismodule::{Context, Command, RedisResult, RedisError, parse_integer};
+use redismodule::native_types::RedisType;
 
 fn hello_mul(_: &Context, args: Vec<String>) -> RedisResult {
     if args.len() < 2 {
@@ -27,9 +28,14 @@ fn hello_mul(_: &Context, args: Vec<String>) -> RedisResult {
 const MODULE_NAME: &str = "hello";
 const MODULE_VERSION: u32 = 1;
 
-redis_module!(MODULE_NAME, MODULE_VERSION, [
-    Command::new("hello.mul", hello_mul, "write"),
-]);
+redis_module!(
+    MODULE_NAME,
+    MODULE_VERSION,
+    [] as [RedisType; 0],
+    [
+        Command::new("hello.mul", hello_mul, "write"),
+    ]
+);
 
 //////////////////////////////////////////////////////
 

src/macros.rs

@@ -23,7 +23,7 @@ macro_rules! log_debug {
 
 #[macro_export]
 macro_rules! redis_module (
-    ($module_name:expr, $module_version:expr, $commands:expr) => (
+    ($module_name:expr, $module_version:expr, $data_types:expr, $commands:expr) => (
         use std::os::raw::c_int;
         use std::ffi::CString;
 
@@ -47,6 +47,12 @@ macro_rules! redis_module (
                     raw::REDISMODULE_APIVER_1 as c_int,
                 ) == raw::Status::Err as _ { return raw::Status::Err as _; }
 
+                for data_type in &$data_types {
+                    if data_type.create_data_type(ctx).is_err() {
+                        return raw::Status::Err as _;
+                    }
+                }
+
                 if true {
                     redismodule::alloc::use_redis_alloc();
                 } else {

src/native_types.rs

@@ -6,6 +6,7 @@ use std::os::raw::{c_int, c_void};
 use crate::raw;
 
 pub struct RedisType {
+    name: &'static str,
     pub raw_type: RefCell<*mut raw::RedisModuleType>,
 }
 
@@ -14,24 +15,24 @@ pub struct RedisType {
 unsafe impl Sync for RedisType {}
 
 impl RedisType {
-    pub const fn new() -> Self {
+    pub const fn new(name: &'static str) -> Self {
         RedisType {
+            name,
             raw_type: RefCell::new(ptr::null_mut()),
         }
     }
 
     pub fn create_data_type(
         &self,
         ctx: *mut raw::RedisModuleCtx,
-        name: &str,
     ) -> Result<(), &str> {
-        if name.len() != 9 {
+        if self.name.len() != 9 {
             let msg = "Redis requires the length of native type names to be exactly 9 characters";
-            redis_log(ctx, format!("{}, name is: '{}'", msg, name).as_str());
+            redis_log(ctx, format!("{}, name is: '{}'", msg, self.name).as_str());
             return Err(msg);
         }
 
-        let type_name = CString::new(name).unwrap();
+        let type_name = CString::new(self.name).unwrap();
 
         let mut type_methods = raw::RedisModuleTypeMethods {
             version: raw::REDISMODULE_TYPE_METHOD_VERSION as u64,
@@ -62,7 +63,7 @@ impl RedisType {
 
         *self.raw_type.borrow_mut() = redis_type;
 
-        redis_log(ctx, format!("Created new data type '{}'", name).as_str());
+        redis_log(ctx, format!("Created new data type '{}'", self.name).as_str());
 
         Ok(())
     }