add RESP3 new APIs

Cargo.toml

@@ -93,6 +93,10 @@ crate-type = ["cdylib"]
 name = "stream"
 crate-type = ["cdylib"]
 
+[[example]]
+name = "response"
+crate-type = ["cdylib"]
+
 [dependencies]
 bitflags = "1.2"
 libc = "0.2"

examples/call.rs

@@ -1,9 +1,9 @@
 #[macro_use]
 extern crate redis_module;
 
-use redis_module::raw::*;
 use redis_module::{
-    CallOptionsBuilder, CallReply, Context, RedisError, RedisResult, RedisString, RootCallReply,
+    CallOptionResp, CallOptionsBuilder, CallReply, CallResult, Context, RedisError, RedisResult,
+    RedisString,
 };
 
 fn call_test(ctx: &Context, _: Vec<RedisString>) -> RedisResult {
@@ -66,15 +66,48 @@ fn call_test(ctx: &Context, _: Vec<RedisString>) -> RedisResult {
     }
 
     let call_options = CallOptionsBuilder::new().script_mode().errors_as_replies();
-    let res: RootCallReply = ctx.call_ext::<&[&str; 0], _>("SHUTDOWN", &call_options.build(), &[]);
-    if res.get_type() != ReplyType::Error {
+    let res: CallResult = ctx.call_ext::<&[&str; 0], _>("SHUTDOWN", &call_options.build(), &[]);
+    if let Err(err) = res {
+        let error_msg = err.to_string().unwrap();
+        if !error_msg.contains("not allow") {
+            return Err(RedisError::String(format!(
+                "Failed to verify error messages, expected error message to contain 'not allow', error message: '{error_msg}'",
+            )));
+        }
+    } else {
         return Err(RedisError::Str("Failed to set script mode on call_ext"));
     }
-    let error_msg = res.get_string().unwrap();
-    if !error_msg.contains("not allow") {
-        return Err(RedisError::String(format!(
-            "Failed to verify error messages, expected error message to contain 'not allow', error message: '{error_msg}'",
-        )));
+
+    // test resp3 on call_ext
+    let call_options = CallOptionsBuilder::new()
+        .script_mode()
+        .resp_3(CallOptionResp::Resp3)
+        .errors_as_replies()
+        .build();
+    ctx.call_ext::<_, CallResult>("HSET", &call_options, &["x", "foo", "bar"])
+        .map_err(|e| -> RedisError { e.into() })?;
+    let res: CallReply = ctx
+        .call_ext::<_, CallResult>("HGETALL", &call_options, &["x"])
+        .map_err(|e| -> RedisError { e.into() })?;
+    if let CallReply::Map(map) = res {
+        let res = map.iter().fold(Vec::new(), |mut vec, (key, val)| {
+            if let CallReply::String(key) = key.unwrap() {
+                vec.push(key.to_string().unwrap());
+            }
+            if let CallReply::String(val) = val.unwrap() {
+                vec.push(val.to_string().unwrap());
+            }
+            vec
+        });
+        if res != vec!["foo".to_string(), "bar".to_string()] {
+            return Err(RedisError::String(
+                "Reply of hgetall does not match expected value".into(),
+            ));
+        }
+    } else {
+        return Err(RedisError::String(
+            "Did not get a set type on hgetall".into(),
+        ));
     }
 
     Ok("pass".into())

examples/response.rs

@@ -0,0 +1,72 @@
+#[macro_use]
+extern crate redis_module;
+
+use redis_module::{Context, NextArg, RedisError, RedisResult, RedisString, RedisValue};
+use std::collections::{HashMap, HashSet};
+
+fn map_mget(ctx: &Context, args: Vec<RedisString>) -> RedisResult {
+    if args.len() < 2 {
+        return Err(RedisError::WrongArity);
+    }
+
+    let mut args = args.into_iter().skip(1);
+    let key_name = args.next_arg()?;
+
+    let fields: Vec<RedisString> = args.collect();
+
+    let key = ctx.open_key(&key_name);
+    let values = key.hash_get_multi(&fields)?;
+    let res = match values {
+        None => RedisValue::Null,
+        Some(values) => {
+            let mut map: HashMap<RedisValue, RedisValue> = HashMap::with_capacity(fields.len());
+            for (field, value) in values.into_iter() {
+                map.insert(
+                    RedisValue::BulkRedisString(field),
+                    RedisValue::BulkRedisString(value),
+                );
+            }
+            RedisValue::Map(map)
+        }
+    };
+
+    Ok(res)
+}
+
+fn map_unique(ctx: &Context, args: Vec<RedisString>) -> RedisResult {
+    if args.len() < 2 {
+        return Err(RedisError::WrongArity);
+    }
+
+    let mut args = args.into_iter().skip(1);
+    let key_name = args.next_arg()?;
+
+    let fields: Vec<RedisString> = args.collect();
+
+    let key = ctx.open_key(&key_name);
+    let values = key.hash_get_multi(&fields)?;
+    let res = match values {
+        None => RedisValue::Null,
+        Some(values) => {
+            let mut set: HashSet<RedisValue> = HashSet::new();
+            for (_, value) in values.into_iter() {
+                set.insert(RedisValue::BulkRedisString(value));
+            }
+            RedisValue::Set(set)
+        }
+    };
+
+    Ok(res)
+}
+
+//////////////////////////////////////////////////////
+
+redis_module! {
+    name: "response",
+    version: 1,
+    data_types: [],
+    commands: [
+        ["map.mget", map_mget, "readonly", 1, 1, 1],
+        ["map.unique", map_unique, "readonly", 1, 1, 1],
+    ],
+}

examples/string.rs

@@ -40,7 +40,7 @@ redis_module! {
     version: 1,
     data_types: [],
     commands: [
-        ["string.set", string_set, "", 1, 1, 1],
-        ["string.get", string_get, "", 1, 1, 1],
+        ["string.set", string_set, "write fast deny-oom", 1, 1, 1],
+        ["string.get", string_get, "readonly", 1, 1, 1],
     ],
 }