Add support for running module unload code (#107)

* Can now run de-init code, similarly to how init code can be specified for a module.
* Added an example module to demonstrate the functionality.
* Also, fixed paths in macros, so that they can compile regardless of which identifiers
  the caller has brought into scope.

Author: slavak

Cargo.toml

@@ -36,6 +36,11 @@ required-features = ["experimental-api"]
 name = "data_type"
 crate-type = ["cdylib"]
 
+
+[[example]]
+name = "load_unload"
+crate-type = ["cdylib"]
+
 [dependencies]
 bitflags = "1.2"
 libc = "0.2"

examples/load_unload.rs

@@ -0,0 +1,48 @@
+#[macro_use]
+extern crate redis_module;
+
+use redis_module::{Context, LogLevel, RedisResult, raw};
+use std::os::raw::c_int;
+
+static mut GLOBAL_STATE: Option<String> = None;
+
+pub extern "C" fn init(ctx: *mut raw::RedisModuleCtx) -> c_int {
+    let ctx = Context::new(ctx);
+    let (before, after) = unsafe {
+        let before = GLOBAL_STATE.clone();
+        GLOBAL_STATE.replace("GLOBAL DATA".to_string());
+        let after = GLOBAL_STATE.clone();
+        (before, after)
+    };
+    ctx.log(LogLevel::Warning,
+            &format!("Update global state on LOAD. BEFORE: {:?}, AFTER: {:?}",
+                            before, after));
+
+    return raw::Status::Ok as c_int;
+}
+
+pub extern "C" fn deinit(ctx: *mut raw::RedisModuleCtx) -> c_int {
+    let ctx = Context::new(ctx);
+    let (before, after) = unsafe {
+        let before = GLOBAL_STATE.take();
+        let after = GLOBAL_STATE.clone();
+        (before, after)
+    };
+    ctx.log(LogLevel::Warning,
+            &format!("Update global state on UNLOAD. BEFORE: {:?}, AFTER: {:?}",
+                     before, after));
+
+    raw::Status::Ok as c_int
+}
+
+//////////////////////////////////////////////////////
+
+redis_module! {
+    name: "load_unload",
+    version: 1,
+    data_types: [],
+    init: init,
+    deinit: deinit,
+    commands: [],
+}
+

src/macros.rs

@@ -12,19 +12,20 @@ macro_rules! redis_command {
 
         /////////////////////
         extern "C" fn do_command(
-            ctx: *mut raw::RedisModuleCtx,
-            argv: *mut *mut raw::RedisModuleString,
+            ctx: *mut $crate::raw::RedisModuleCtx,
+            argv: *mut *mut $crate::raw::RedisModuleString,
             argc: c_int,
         ) -> c_int {
             let context = Context::new(ctx);
 
-            let args_decoded: Result<Vec<_>, RedisError> =
+            let args_decoded: Result<Vec<_>, $crate::RedisError> =
                 unsafe { slice::from_raw_parts(argv, argc as usize) }
                     .into_iter()
                     .map(|&arg| {
-                        RedisString::from_ptr(arg)
+                        $crate::RedisString::from_ptr(arg)
                             .map(|v| v.to_owned())
-                            .map_err(|_| RedisError::Str("UTF8 encoding error in handler args"))
+                            .map_err(|_|$crate::RedisError::Str(
+                                "UTF8 encoding error in handler args"))
                     })
                     .collect();
 
@@ -37,7 +38,7 @@ macro_rules! redis_command {
         /////////////////////
 
         if unsafe {
-            raw::RedisModule_CreateCommand.unwrap()(
+            $crate::raw::RedisModule_CreateCommand.unwrap()(
                 $ctx,
                 name.as_ptr(),
                 Some(do_command),
@@ -46,9 +47,9 @@ macro_rules! redis_command {
                 $lastkey,
                 $keystep,
             )
-        } == raw::Status::Err as c_int
+        } == $crate::raw::Status::Err as c_int
         {
-            return raw::Status::Err as c_int;
+            return $crate::raw::Status::Err as c_int;
         }
     }};
 }
@@ -62,6 +63,7 @@ macro_rules! redis_module {
             $($data_type:ident),* $(,)*
         ],
         $(init: $init_func:ident,)* $(,)*
+        $(deinit: $deinit_func:ident,)* $(,)*
         commands: [
             $([
                 $name:expr,
@@ -126,5 +128,19 @@ macro_rules! redis_module {
 
             raw::Status::Ok as c_int
         }
+
+        #[no_mangle]
+        #[allow(non_snake_case)]
+        pub extern "C" fn RedisModule_OnUnload(
+            ctx: *mut $crate::raw::RedisModuleCtx
+        ) -> std::os::raw::c_int {
+            $(
+                if $deinit_func(ctx) == raw::Status::Err as c_int {
+                    return $crate::raw::Status::Err as c_int;
+                }
+            )*
+
+            $crate::raw::Status::Ok as std::os::raw::c_int
+        }
     }
 }