Add get_redis_version command (#184)

* WIP Add get_redis_command

* Fix test for test_helper example

* Fixes per code review by Gavrie

* Fixes per code review by Gavrie (addition)

* fix build and format

* Update Makefile - use a single cargo build command

Co-authored-by: Guy Korland <[email protected]>

* Update build.sh - use a single cargo build command

Co-authored-by: Guy Korland <[email protected]>

Co-authored-by: Rafi Einstein <[email protected]>
Co-authored-by: Guy Korland <[email protected]>

Author: 3 people

Cargo.toml

@@ -51,6 +51,11 @@ name = "events"
 crate-type = ["cdylib"]
 required-features = ["experimental-api"]
 
+[[example]]
+name = "test_helper"
+crate-type = ["cdylib"]
+required-features = ["test"]
+
 [[example]]
 name = "info"
 crate-type = ["cdylib"]
@@ -61,6 +66,7 @@ bitflags = "1.2"
 libc = "0.2"
 enum-primitive-derive = "^0.1"
 num-traits = "^0.2"
+regex = "1"
 strum_macros = "0.23"
 #failure = "0.1"
 backtrace = "0.3"

Makefile

@@ -64,7 +64,7 @@ RUST_SOEXT.freebsd=so
 RUST_SOEXT.macos=dylib
 
 build:
-	cargo build --features experimental-api --all --all-targets  $(CARGO_FLAGS)
+	cargo build --features experimental-api,test --all --all-targets  $(CARGO_FLAGS)
 	# cp $(TARGET_DIR)/librejson.$(RUST_SOEXT.$(OS)) $(TARGET)
 
 clean:

build.sh

@@ -1,3 +1,4 @@
 #!/usr/bin/env sh
-cargo build --features experimental-api --all --all-targets
+cargo build --features experimental-api,test --all --all-targets
+
 

examples/test_helper.rs

@@ -0,0 +1,42 @@
+#[macro_use]
+extern crate redis_module;
+
+use redis_module::{Context, RedisResult, RedisString};
+
+fn test_helper_version(ctx: &Context, _args: Vec<RedisString>) -> RedisResult {
+    let ver = ctx.get_redis_version()?;
+    let response: Vec<i64> = vec![ver.major.into(), ver.minor.into(), ver.patch.into()];
+
+    Ok(response.into())
+}
+
+#[cfg(feature = "test")]
+fn test_helper_version_rm_call(ctx: &Context, _args: Vec<RedisString>) -> RedisResult {
+    let ver = ctx.get_redis_version_rm_call()?;
+    let response: Vec<i64> = vec![ver.major.into(), ver.minor.into(), ver.patch.into()];
+
+    Ok(response.into())
+}
+
+//////////////////////////////////////////////////////
+
+#[cfg(not(feature = "test"))]
+redis_module! {
+    name: "test_helper",
+    version: 1,
+    data_types: [],
+    commands: [
+        ["test_helper.version", test_helper_version, "", 0, 0, 0],
+    ],
+}
+
+#[cfg(feature = "test")]
+redis_module! {
+    name: "test_helper",
+    version: 1,
+    data_types: [],
+    commands: [
+        ["test_helper.version", test_helper_version, "", 0, 0, 0],
+        ["test_helper._version_rm_call", test_helper_version_rm_call, "", 0, 0, 0],
+    ],
+}

src/context/mod.rs

@@ -3,8 +3,8 @@ use std::os::raw::{c_char, c_int, c_long, c_longlong};
 use std::ptr;
 
 use crate::key::{RedisKey, RedisKeyWritable};
-use crate::raw::ModuleOptions;
-use crate::{add_info_field_long_long, add_info_field_str, raw, Status};
+use crate::raw::{ModuleOptions, Version};
+use crate::{add_info_field_long_long, add_info_field_str, raw, utils, Status};
 use crate::{add_info_section, LogLevel};
 use crate::{RedisError, RedisResult, RedisString, RedisValue};
 
@@ -282,6 +282,45 @@ impl Context {
         raw::notify_keyspace_event(self.ctx, event_type, event, keyname)
     }
 
+    /// Returns the redis version either by calling RedisModule_GetServerVersion API,
+    /// Or if it is not available, by calling "info server" API and parsing the reply
+    pub fn get_redis_version(&self) -> Result<Version, RedisError> {
+        self.get_redis_version_internal(false)
+    }
+
+    /// Returns the redis version by calling "info server" API and parsing the reply
+    #[cfg(feature = "test")]
+    pub fn get_redis_version_rm_call(&self) -> Result<Version, RedisError> {
+        self.get_redis_version_internal(true)
+    }
+
+    #[allow(clippy::not_unsafe_ptr_arg_deref)]
+    fn get_redis_version_internal(&self, force_use_rm_call: bool) -> Result<Version, RedisError> {
+        match unsafe { raw::RedisModule_GetServerVersion } {
+            Some(api) if !force_use_rm_call => {
+                // Call existing API
+                Ok(Version::from(unsafe { api() }))
+            }
+            _ => {
+                // Call "info server"
+                if let Ok(RedisValue::SimpleString(s)) = self.call("info", &["server"]) {
+                    if let Some(ver) = utils::get_regexp_captures(
+                        s.as_str(),
+                        r"(?m)\bredis_version:([0-9]+)\.([0-9]+)\.([0-9]+)\b",
+                    ) {
+                        return Ok(Version {
+                            major: ver[0].parse::<c_int>().unwrap(),
+                            minor: ver[1].parse::<c_int>().unwrap(),
+                            patch: ver[2].parse::<c_int>().unwrap(),
+                        });
+                    }
+                }
+                Err(RedisError::Str(
+                    "Error getting redis_version from \"info server\" call",
+                ))
+            }
+        }
+    }
     pub fn set_module_options(&self, options: ModuleOptions) {
         unsafe { raw::RedisModule_SetModuleOptions.unwrap()(self.ctx, options.bits()) };
     }

src/lib.rs

@@ -21,6 +21,7 @@ mod context;
 pub mod key;
 pub mod logging;
 mod macros;
+mod utils;
 
 #[cfg(feature = "experimental-api")]
 pub use crate::context::blocked::BlockedClient;

src/raw.rs

@@ -643,6 +643,24 @@ pub fn get_keyspace_events() -> NotifyEvent {
     }
 }
 
+#[derive(Debug, PartialEq)]
+pub struct Version {
+    pub major: i32,
+    pub minor: i32,
+    pub patch: i32,
+}
+
+impl From<c_int> for Version {
+    fn from(ver: c_int) -> Self {
+        // Expected format: 0x00MMmmpp for Major, minor, patch
+        Version {
+            major: (ver & 0x00FF_0000) >> 16,
+            minor: (ver & 0x0000_FF00) >> 8,
+            patch: (ver & 0x0000_00FF),
+        }
+    }
+}
+
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub fn is_io_error(rdb: *mut RedisModuleIO) -> bool {
     unsafe { RedisModule_IsIOError.unwrap()(rdb) != 0 }

src/utils.rs

@@ -0,0 +1,19 @@
+use regex::Regex;
+
+/// Extracts regexp captures
+///
+/// Extract from `s` the captures defined in `reg_exp`
+pub fn get_regexp_captures<'a, 'b>(s: &'a str, reg_exp: &'b str) -> Option<Vec<&'a str>> {
+    Regex::new(reg_exp).map_or_else(
+        |_| None,
+        |re| {
+            let mut res: Vec<&str> = Vec::new();
+            re.captures_iter(s).for_each(|captures| {
+                for i in 1..captures.len() {
+                    res.push(captures.get(i).map_or_else(|| "", |m| m.as_str()));
+                }
+            });
+            Some(res)
+        },
+    )
+}

tests/integration.rs

@@ -1,16 +1,18 @@
-mod utils;
-
 use anyhow::Context;
 use anyhow::Result;
 use redis::RedisError;
+
 use utils::{get_redis_connection, start_redis_server_with_module};
 
+mod utils;
+
 #[test]
 fn test_hello() -> Result<()> {
-    let _guards = vec![start_redis_server_with_module("hello", 6479)
+    let port: u16 = 6479;
+    let _guards = vec![start_redis_server_with_module("hello", port)
         .with_context(|| "failed to start redis server")?];
     let mut con =
-        get_redis_connection(6479).with_context(|| "failed to connect to redis server")?;
+        get_redis_connection(port).with_context(|| "failed to connect to redis server")?;
 
     let res: Vec<i32> = redis::cmd("hello.mul")
         .arg(&[3, 4])
@@ -29,10 +31,11 @@ fn test_hello() -> Result<()> {
 
 #[test]
 fn test_keys_pos() -> Result<()> {
-    let _guards = vec![start_redis_server_with_module("keys_pos", 6480)
+    let port: u16 = 6480;
+    let _guards = vec![start_redis_server_with_module("keys_pos", port)
         .with_context(|| "failed to start redis server")?];
     let mut con =
-        get_redis_connection(6480).with_context(|| "failed to connect to redis server")?;
+        get_redis_connection(port).with_context(|| "failed to connect to redis server")?;
 
     let res: Vec<String> = redis::cmd("keys_pos")
         .arg(&["a", "1", "b", "2"])
@@ -43,23 +46,46 @@ fn test_keys_pos() -> Result<()> {
     let res: Result<Vec<String>, RedisError> =
         redis::cmd("keys_pos").arg(&["a", "1", "b"]).query(&mut con);
     if res.is_ok() {
-        return Err(anyhow::Error::msg("Shuold return an error"));
+        return Err(anyhow::Error::msg("Should return an error"));
     }
 
     Ok(())
 }
 
+#[test]
+fn test_test_helper_version() -> Result<()> {
+    let port: u16 = 6481;
+    let _guards = vec![start_redis_server_with_module("test_helper", port)
+        .with_context(|| "failed to start redis server")?];
+    let mut con =
+        get_redis_connection(port).with_context(|| "failed to connect to redis server")?;
+
+    let res: Vec<i64> = redis::cmd("test_helper.version")
+        .query(&mut con)
+        .with_context(|| "failed to run test_helper.version")?;
+    assert!(res[0] > 0);
+
+    // Test also an internal implementation that might not always be reached
+    let res2: Vec<i64> = redis::cmd("test_helper._version_rm_call")
+        .query(&mut con)
+        .with_context(|| "failed to run test_helper._version_rm_call")?;
+    assert_eq!(res, res2);
+
+    Ok(())
+}
+
 #[test]
 fn test_hello_info() -> Result<()> {
-    let _guards = vec![start_redis_server_with_module("hello", 6481)
+    let port: u16 = 6482;
+    let _guards = vec![start_redis_server_with_module("hello", port)
         .with_context(|| "failed to start redis server")?];
     let mut con =
-        get_redis_connection(6481).with_context(|| "failed to connect to redis server")?;
+        get_redis_connection(port).with_context(|| "failed to connect to redis server")?;
 
     let res: String = redis::cmd("INFO")
         .arg("HELLO")
         .query(&mut con)
-        .with_context(|| "failed to run hello.mul")?;
+        .with_context(|| "failed to run INFO HELLO")?;
     assert!(res.contains("hello_field:hello_value"));
 
     Ok(())
@@ -68,10 +94,11 @@ fn test_hello_info() -> Result<()> {
 #[allow(unused_must_use)]
 #[test]
 fn test_hello_err() -> Result<()> {
-    let _guards = vec![start_redis_server_with_module("hello", 6482)
+    let port: u16 = 6483;
+    let _guards = vec![start_redis_server_with_module("hello", port)
         .with_context(|| "failed to start redis server")?];
     let mut con =
-        get_redis_connection(6482).with_context(|| "failed to connect to redis server")?;
+        get_redis_connection(port).with_context(|| "failed to connect to redis server")?;
 
     // Make sure embedded nulls do not cause a crash
     redis::cmd("hello.err")

tests/utils.rs

@@ -69,7 +69,7 @@ pub fn start_redis_server_with_module(module_name: &str, port: u16) -> Result<Ch
 }
 
 // Get connection to Redis
-pub fn get_redis_connection(port: u64) -> Result<Connection> {
+pub fn get_redis_connection(port: u16) -> Result<Connection> {
     let client = redis::Client::open(format!("redis://127.0.0.1:{}/", port))?;
     loop {
         let res = client.get_connection();