Go Redis module

go-rm will let you write redis module in golang.

Modules

redismodule
- rxhash

Demo

# Ensure you installed the newest redis
# for example by using brew you can
# brew reinstall redis --HEAD

# Build redis module
go build -v -buildmode=c-shared github.com/redismodule/rxhash/cmd/rxhash

# Start redis-server and load our module with debug log
redis-server --loadmodule rxhash --loglevel debug

Connect to out redis-server

# Test hgetset
redis-cli hset a a 1
#> (integer) 1
redis-cli hgetset a a 2
#> "1"
redis-cli hget a a
#> "2"
# Return nil if field not exists
redis-cli hgetset a b 2
#> (nil)
redis-cli hgetset a b 3
#> "2"

Wow, it works, now you can distribute this redis module to you friends. :P

How to write a module

Implement a redis module is as easy as you write a cli app in go, this is all you need to implement above command.

package main

import "github.com/wenerme/go-rm/rm"

func main() {
    // In case someone try to run this
    rm.Run()
}

func init() {
    rm.Mod = CreateMyMod()
}
func CreateMyMod() *rm.Module {
    mod := rm.NewMod()
    mod.Name = "hashex"
    mod.Version = 1
    mod.Commands = []rm.Command{CreateCommand_HGETSET()}
    return mod
}
func CreateCommand_HGETSET() rm.Command {
	return rm.Command{
		Usage: "HGETSET key field value",
		Desc: `Sets the 'field' in Hash 'key' to 'value' and returns the previous value, if any.
Reply: String, the previous value or NULL if 'field' didn't exist. `,
		Name:   "hgetset",
		Flags:  "write fast deny-oom",
		FirstKey:1, LastKey:1, KeyStep:1,
		Action: func(cmd rm.CmdContext) int {
			ctx, args := cmd.Ctx, cmd.Args
			if len(cmd.Args) != 4 {
				return ctx.WrongArity()
			}
			ctx.AutoMemory()
			key, ok := openHashKey(ctx, args[1])
			if !ok {
				return rm.ERR
			}
			// get the current value of the hash element
			var val rm.String;
			key.HashGet(rm.HASH_NONE, cmd.Args[2], (*uintptr)(&val))
			// set the element to the new value
			key.HashSet(rm.HASH_NONE, cmd.Args[2], cmd.Args[3])
			if val.IsNull() {
				ctx.ReplyWithNull()
			} else {
				ctx.ReplyWithString(val)
			}
			return rm.OK
		},
	}
}
// open the key and make sure it is indeed a Hash and not empty
func openHashKey(ctx rm.Ctx, k rm.String) (rm.Key, bool) {
	key := ctx.OpenKey(k, rm.READ | rm.WRITE)
	if key.KeyType() != rm.KEYTYPE_EMPTY && key.KeyType() != rm.KEYTYPE_HASH {
		ctx.ReplyWithError(rm.ERRORMSG_WRONGTYPE)
		return rm.Key(0), false
	}
	return key, true
}

Fantasy

A module management module, supplies
- mod.search
  - Search module from repository(github?)
  - Repository structure like this
```
/namespace
    /module-name
        /bin
            /darwin_amd64
                module-name.so
                module-name.sha
            /linux_amd64
        module-name.go     
```
- mod.get
  - Download module to ~/.redismodule
  - Because module is write in go, so we can build for almost any platform
  - We can use tag/commit to version the binary, so we can download the old version too
- mod.install
  - Install downloaded module by calling redis command
- ...
A cluster management module
- Easy to create/manage/monitor redis3 cluster
A json data type to demonstration how to add new data type in redis.
- json.fmt key template
- json.path key path [pretty]
- json.get key [pretty]
- json.set key value
  - this will validate the json format

Pitfall

C can not call Go function, so every callback is pre-generated
- 200 commands at most
- 5 data type at most
- limits are easy to change, just need a proper max value
Go can not call var_args, function call is pre-generated
- HashSet/HashGet can accept 20 args at most
- limits are easy to change, just need a proper max value
Don't know what happens when unload a golang shared module
- Single module
- Multi module
  - Is there runtime are shared ?
Module write in go can not report it's memory usage to redis, max memory limits is useless
If a module write in go also include a third party write in other language, the memory usage is unknown
Module can only accept command, seems there is no way to call redis initiative.

TODO

Find a proper limits for data types and var_args