Merge branch 'master' into gkorland-resp3-api

Cargo.toml

@@ -19,6 +19,10 @@ crate-type = ["cdylib"]
 name = "string"
 crate-type = ["cdylib"]
 
+[[example]]
+name = "configuration"
+crate-type = ["cdylib"]
+
 [[example]]
 name = "acl"
 crate-type = ["cdylib"]

examples/configuration.rs

@@ -0,0 +1,82 @@
+#[macro_use]
+extern crate redis_module;
+
+use std::sync::{
+    atomic::{AtomicBool, AtomicI64},
+    Mutex,
+};
+
+use lazy_static::lazy_static;
+use redis_module::{
+    configuration::{ConfigurationContext, ConfigurationFlags},
+    ConfigurationValue, Context, EnumConfigurationValue, RedisGILGuard, RedisResult, RedisString,
+    RedisValue,
+};
+
+enum_configuration! {
+    enum EnumConfiguration {
+        Val1 = 1,
+        Val2 = 2,
+    }
+}
+
+lazy_static! {
+    static ref NUM_OF_CONFIGURATION_CHANGES: RedisGILGuard<i64> = RedisGILGuard::default();
+    static ref CONFIGURATION_I64: RedisGILGuard<i64> = RedisGILGuard::default();
+    static ref CONFIGURATION_ATOMIC_I64: AtomicI64 = AtomicI64::new(1);
+    static ref CONFIGURATION_REDIS_STRING: RedisGILGuard<RedisString> =
+        RedisGILGuard::new(RedisString::create(None, "default"));
+    static ref CONFIGURATION_STRING: RedisGILGuard<String> = RedisGILGuard::new("default".into());
+    static ref CONFIGURATION_MUTEX_STRING: Mutex<String> = Mutex::new("default".into());
+    static ref CONFIGURATION_ATOMIC_BOOL: AtomicBool = AtomicBool::default();
+    static ref CONFIGURATION_BOOL: RedisGILGuard<bool> = RedisGILGuard::default();
+    static ref CONFIGURATION_ENUM: RedisGILGuard<EnumConfiguration> =
+        RedisGILGuard::new(EnumConfiguration::Val1);
+    static ref CONFIGURATION_MUTEX_ENUM: Mutex<EnumConfiguration> =
+        Mutex::new(EnumConfiguration::Val1);
+}
+
+fn on_configuration_changed<G, T: ConfigurationValue<G>>(
+    config_ctx: &ConfigurationContext,
+    _name: &str,
+    _val: &'static T,
+) {
+    let mut val = NUM_OF_CONFIGURATION_CHANGES.lock(config_ctx);
+    *val += 1
+}
+
+fn num_changes(ctx: &Context, _: Vec<RedisString>) -> RedisResult {
+    let val = NUM_OF_CONFIGURATION_CHANGES.lock(ctx);
+    Ok(RedisValue::Integer(*val))
+}
+
+//////////////////////////////////////////////////////
+
+redis_module! {
+    name: "configuration",
+    version: 1,
+    data_types: [],
+    commands: [
+        ["configuration.num_changes", num_changes, "", 0, 0, 0],
+    ],
+    configurations: [
+        i64: [
+            ["i64", &*CONFIGURATION_I64, 10, 0, 1000, ConfigurationFlags::DEFAULT, Some(Box::new(on_configuration_changed))],
+            ["atomic_i64", &*CONFIGURATION_ATOMIC_I64, 10, 0, 1000, ConfigurationFlags::DEFAULT, Some(Box::new(on_configuration_changed))],
+        ],
+        string: [
+            ["redis_string", &*CONFIGURATION_REDIS_STRING, "default", ConfigurationFlags::DEFAULT, Some(Box::new(on_configuration_changed))],
+            ["string", &*CONFIGURATION_STRING, "default", ConfigurationFlags::DEFAULT, Some(Box::new(on_configuration_changed::<String, _>))],
+            ["mutex_string", &*CONFIGURATION_MUTEX_STRING, "default", ConfigurationFlags::DEFAULT, Some(Box::new(on_configuration_changed::<String, _>))],
+        ],
+        bool: [
+            ["atomic_bool", &*CONFIGURATION_ATOMIC_BOOL, true, ConfigurationFlags::DEFAULT, Some(Box::new(on_configuration_changed))],
+            ["bool", &*CONFIGURATION_BOOL, true, ConfigurationFlags::DEFAULT, Some(Box::new(on_configuration_changed))],
+        ],
+        enum: [
+            ["enum", &*CONFIGURATION_ENUM, EnumConfiguration::Val1, ConfigurationFlags::DEFAULT, Some(Box::new(on_configuration_changed))],
+            ["enum_mutex", &*CONFIGURATION_MUTEX_ENUM, EnumConfiguration::Val1, ConfigurationFlags::DEFAULT, Some(Box::new(on_configuration_changed))],
+        ],
+        module_args_as_configuration: true,
+    ]
+}

examples/events.rs

@@ -4,6 +4,7 @@ extern crate redis_module;
 use redis_module::{
     Context, NotifyEvent, RedisError, RedisResult, RedisString, RedisValue, Status,
 };
+use std::ptr::NonNull;
 use std::sync::atomic::{AtomicI64, Ordering};
 
 static NUM_KEY_MISSES: AtomicI64 = AtomicI64::new(0);
@@ -25,7 +26,7 @@ fn event_send(ctx: &Context, args: Vec<RedisString>) -> RedisResult {
         return Err(RedisError::WrongArity);
     }
 
-    let key_name = RedisString::create(ctx.ctx, "mykey");
+    let key_name = RedisString::create(NonNull::new(ctx.ctx), "mykey");
     let status = ctx.notify_keyspace_event(NotifyEvent::GENERIC, "events.send", &key_name);
     match status {
         Status::Ok => Ok("Event sent".into()),

examples/threads.rs

@@ -31,7 +31,7 @@ struct StaticData {
 }
 
 lazy_static! {
-    static ref STATIC_DATA: RedisGILGuard<StaticData> = RedisGILGuard::default();
+    static ref STATIC_DATA: RedisGILGuard<StaticData> = RedisGILGuard::new(StaticData::default());
 }
 
 fn set_static_data(ctx: &Context, args: Vec<RedisString>) -> RedisResult {