This document discusses using the Rust programming language to write modules for Redis. It begins by introducing Rust and its advantages like safety and performance. It then explains how Redis modules currently use C and the challenges with that approach. Most of the document shows examples of translating simple C code to idiomatic Rust, highlighting Rust features like enums, generics, and error handling. It proposes using macros to generate boilerplate code for Redis modules in Rust. Finally, it briefly demonstrates a sample Redis module implemented in Rust and provides information on contributing to an open source project for Rust Redis modules.

1. PRESENTED BY
Writing Redis Modules in Rust
Gavrie Philipson
Redis Labs, Software Architect

2. PRESENTED BY
• Blazingly fast
• Memory-efficient
• Safe
What is Rust?

3. PRESENTED BY
• Friendly compiler
• Useful error messages
• Cargo
What is Rust?

4. PRESENTED BY
• Redis Modules run in the same memory space as Redis
• A bad memory access can crash the whole redis-server process
• Memory leaks will waste precious Redis memory
• We need safe memory access!
Why use Rust for writing Redis modules?

5. PRESENTED BY
• Redis is (mostly) single-threaded
• A slow module will slow down Redis
• We need performance!
• Rust’s safety does not mean reduced performance
• We can have nice things
Why use Rust for writing Redis modules?

6. PRESENTED BY
Why Rust: Writing safe code in C is Hard
1970 1976 1982 1988 1995 2001 2007 2013 2019
C
1972
• Features raw pointers, raw memory access, pointer arithmetic
• Memory management is handled explicitly by the developer
• No standard way to handle errors

7. PRESENTED BY
Why Rust: C++ looks great on paper, but…
1970 1976 1982 1988 1995 2001 2007 2013 2019
C++
1985
C
1972
• Enormously complex language
• Inscrutable error messages
• Includes all of unsafe C inside

8. PRESENTED BY
Why Rust: Strong type system, type inference, functional look
and feel
1970 1976 1982 1988 1995 2001 2007 2013 2019
TypeScript
2012
Scala
2004
Swift
2014
Kotlin
2011
Rust
2010
Go
2009
Java
1995
JS
1995
C++
1985
C
1972

9. PRESENTED BY
Show me the code already!

10. PRESENTED BY
typedef struct Person {
char *name;
int age;
} Person;
int main() {
Person person = { .name="Joe", .age=25 };
Person *somebody = &person;
printf("%s is %dn", somebody->name, somebody->age);
}
A simple program

11. PRESENTED BY
struct Person {
name: &'static str,
age: i32,
}
fn main() {
let person = Person { name: "Joe", age: 25 };
let somebody = &person;
println!("{} is {}", somebody.name, somebody.age);
}
Rust: The equivalent code

12. PRESENTED BY
struct Person {
name: &'static str,
age: i32,
}
fn main() {
let person = Person { name: "Joe", age: 25 };
person.age = 30; // Error: person is immutable
}
Rust: Immutable is the default

13. PRESENTED BY
struct Person {
name: &'static str,
age: i32,
}
fn main() {
let mut person = Person { name: "Joe", age: 25 };
person.age = 30;
}
Rust: Mutability must be specified explicitly

14. PRESENTED BY
struct Vec<T> {
buf: ...,
len: usize,
}
let mut languages: Vec<&str> = Vec::new();
languages.push("C");
languages.push("C++");
languages.push(“Rust");
Rust: Using generic containers

15. PRESENTED BY
• Code that modifies other code at compile time
• Can create new syntax in the language
let languages = vec!["C", "C++", "Rust"];
Rust: Avoiding the boilerplate: Macros!

16. PRESENTED BY
Rust: Sum types

17. PRESENTED BY
// Type-safe JSON Value
enum Value {
Null,
Bool(bool),
Number(f64),
String(String),
Array(Vec<Value>),
Object(Map<String, Value>),
}
Rust: Sum types

18. PRESENTED BY
let full_name = "John Doe";
let age_last_year = 42;
let john = json!({
"name": full_name,
"age": age_last_year + 1,
"phones": [
"+972-50-1234567",
"+972-3-7654321",
]
});
Rust: Sum types + Macros

19. PRESENTED BY
let val = match john {
Value::Null => "null",
Value::Bool(b) => format!("boolean: {}", b),
Value::Number(n) => format!("number: {}", n),
Value::String(_) => "string",
Value::Array(_) => "array",
Value::Object(_) => "object",
};
Rust: Pattern matching

20. PRESENTED BY
Enough of this, I want Redis modules in Rust!

21. PRESENTED BY
Existing Redis modules written in Rust:
• redis-cell by Brandur, 2016
• redismodule by Faineance, 2016
• redis-multi-map by Garrett Squire, 2018
Redis Modules: Creating a Rust API

22. PRESENTED BY
int hello_command(
RedisModuleCtx *ctx,
RedisModuleString **argv,
int argc
)
Redis Modules: C function defining a Redis command

23. PRESENTED BY
extern fn hello_command(
ctx: *mut RedisModuleCtx,
argv: *mut *mut RedisModuleString,
argc: c_int,
) -> c_int
Redis Modules: Rust equivalent using C FFI

24. PRESENTED BY
int hello_command(
RedisModuleCtx *ctx,
RedisModuleString **argv,
int argc
) {
if (argc != 2) return RedisModule_WrongArity(ctx);
return REDISMODULE_OK;
}
Redis Modules: C function defining a Redis command

25. PRESENTED BY
extern fn hello_command(
ctx: *mut RedisModuleCtx,
argv: *mut *mut RedisModuleString,
argc: c_int,
) -> c_int {
if argc != 2 { return RedisModule_WrongArity(ctx); }
REDISMODULE_OK
}
Redis Modules: Rust equivalent using C FFI

26. PRESENTED BY
extern fn hello_command(
ctx: *mut RedisModuleCtx,
argv: *mut *mut RedisModuleString,
argc: c_int,
) -> c_int {
if argc != 2 {
unsafe { return RedisModule_WrongArity(ctx); }
}
REDISMODULE_OK
}
Redis Modules: Rust equivalent using C FFI

27. PRESENTED BY
Nice, but this is just C in a Rust disguise

28. PRESENTED BY
let f = File::open("foo");
Rust: Error handling

29. PRESENTED BY
let f: Result<File, Error> = File::open("foo");
Rust: Error handling

30. PRESENTED BY
let f: Result<File, Error> = File::open("foo");
enum Result<T, E> {
Ok(T),
Err(E),
}
Rust: Error handling: The Result type

31. PRESENTED BY
let f: Result<File, Error> = File::open("foo");
enum Result<T, E> {
Ok(T),
Err(E),
}
match f {
Ok(file) => { file.bytes(); }
Err(err) => { println!("{}", err); }
}
Rust: Pattern matching on the Result

32. PRESENTED BY
extern fn hello_command(
ctx: *mut RedisModuleCtx,
argv: *mut *mut RedisModuleString,
argc: c_int,
) -> c_int
Redis Modules: The C equivalent again

33. PRESENTED BY
fn hello_command(
ctx: &Context,
args: Vec<String>,
) -> Result<RedisValue, RedisError>
Redis Modules: Idiomatic Rust function

34. PRESENTED BY
fn hello_command(
ctx: &Context,
args: Vec<String>,
) -> Result<RedisValue, RedisError> {
if args.len() != 2 {
return Err(RedisError::WrongArity);
}
Ok(RedisValue::None)
}
Idiomatic Rust binding

35. PRESENTED BY
• For each command, we need to:
• Implement it as a pure Rust function
• Write an extern C wrapper function that Redis can call
• Convert the arguments and return value
We need to write lots of boilerplate code :-(

36. PRESENTED BY
• We define a redis_command macro that generates the code for us:
redis_command!(ctx, "hello", hello_command, "");
Macros to the rescue!

37. PRESENTED BY
• We also define a redis_module macro that:
• Calls the necessary setup functions for a Redis module
• Sets up each Redis command by calling redis_command
Macros to the rescue!

38. PRESENTED BY
fn hello(ctx: &Context, args: Vec<String>) -> Result<…> {
let key = args.into_iter().skip(1).next_string()?;
let greeting = format!("Hello, {}!", key);
Ok(greeting.into())
}
redis_module! {
name: "hello",
version: 1,
commands: [["hello", hello, ""]],
}
A sample Redis module in Rust

39. PRESENTED BY
127.0.0.1:6379> MODULE LOAD libhello.so
OK
127.0.0.1:6379> HELLO
(error) ERR wrong number of arguments for 'HELLO' command
127.0.0.1:6379> HELLO world
"Hello, world!"
127.0.0.1:6379>
Running the module

40. PRESENTED BY
• https://github.com/RedisLabsModules/redismodule-rs/
• Still in early stages
• Contributions are more than welcome!
• Find me at gavrie@redislabs.com or @gavrieph
Check out the code

41. Thank you!

42. PRESENTED BY