#include "redis.h"
#include "sha1.h"
+#include "rand.h"
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
+#include <ctype.h>
+#include <math.h>
+
+char *redisProtocolToLuaType_Int(lua_State *lua, char *reply);
+char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply);
+char *redisProtocolToLuaType_Status(lua_State *lua, char *reply);
+char *redisProtocolToLuaType_Error(lua_State *lua, char *reply);
+char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply);
+int redis_math_random (lua_State *L);
+int redis_math_randomseed (lua_State *L);
+
+/* Take a Redis reply in the Redis protocol format and convert it into a
+ * Lua type. Thanks to this function, and the introduction of not connected
+ * clients, it is trvial to implement the redis() lua function.
+ *
+ * Basically we take the arguments, execute the Redis command in the context
+ * of a non connected client, then take the generated reply and convert it
+ * into a suitable Lua type. With this trick the scripting feature does not
+ * need the introduction of a full Redis internals API. Basically the script
+ * is like a normal client that bypasses all the slow I/O paths.
+ *
+ * Note: in this function we do not do any sanity check as the reply is
+ * generated by Redis directly. This allows use to go faster.
+ * The reply string can be altered during the parsing as it is discared
+ * after the conversion is completed.
+ *
+ * Errors are returned as a table with a single 'err' field set to the
+ * error string.
+ */
+
+char *redisProtocolToLuaType(lua_State *lua, char* reply) {
+ char *p = reply;
+
+ switch(*p) {
+ case ':':
+ p = redisProtocolToLuaType_Int(lua,reply);
+ break;
+ case '$':
+ p = redisProtocolToLuaType_Bulk(lua,reply);
+ break;
+ case '+':
+ p = redisProtocolToLuaType_Status(lua,reply);
+ break;
+ case '-':
+ p = redisProtocolToLuaType_Error(lua,reply);
+ break;
+ case '*':
+ p = redisProtocolToLuaType_MultiBulk(lua,reply);
+ break;
+ }
+ return p;
+}
+
+char *redisProtocolToLuaType_Int(lua_State *lua, char *reply) {
+ char *p = strchr(reply+1,'\r');
+ long long value;
+
+ string2ll(reply+1,p-reply-1,&value);
+ lua_pushnumber(lua,(lua_Number)value);
+ return p+2;
+}
+
+char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply) {
+ char *p = strchr(reply+1,'\r');
+ long long bulklen;
+
+ string2ll(reply+1,p-reply-1,&bulklen);
+ if (bulklen == -1) {
+ lua_pushboolean(lua,0);
+ return p+2;
+ } else {
+ lua_pushlstring(lua,p+2,bulklen);
+ return p+2+bulklen+2;
+ }
+}
+
+char *redisProtocolToLuaType_Status(lua_State *lua, char *reply) {
+ char *p = strchr(reply+1,'\r');
+
+ lua_newtable(lua);
+ lua_pushstring(lua,"ok");
+ lua_pushlstring(lua,reply+1,p-reply-1);
+ lua_settable(lua,-3);
+ return p+2;
+}
+
+char *redisProtocolToLuaType_Error(lua_State *lua, char *reply) {
+ char *p = strchr(reply+1,'\r');
+
+ lua_newtable(lua);
+ lua_pushstring(lua,"err");
+ lua_pushlstring(lua,reply+1,p-reply-1);
+ lua_settable(lua,-3);
+ return p+2;
+}
+
+char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply) {
+ char *p = strchr(reply+1,'\r');
+ long long mbulklen;
+ int j = 0;
+
+ string2ll(reply+1,p-reply-1,&mbulklen);
+ p += 2;
+ if (mbulklen == -1) {
+ lua_pushboolean(lua,0);
+ return p;
+ }
+ lua_newtable(lua);
+ for (j = 0; j < mbulklen; j++) {
+ lua_pushnumber(lua,j+1);
+ p = redisProtocolToLuaType(lua,p);
+ lua_settable(lua,-3);
+ }
+ return p;
+}
+
+void luaPushError(lua_State *lua, char *error) {
+ lua_newtable(lua);
+ lua_pushstring(lua,"err");
+ lua_pushstring(lua, error);
+ lua_settable(lua,-3);
+}
int luaRedisCommand(lua_State *lua) {
int j, argc = lua_gettop(lua);
redisClient *c = server.lua_client;
sds reply;
+ /* Build the arguments vector */
argv = zmalloc(sizeof(robj*)*argc);
- for (j = 0; j < argc; j++)
- argv[j] = createStringObject(lua_tostring(lua,j+1),lua_strlen(lua,j+1));
-
- /* Command lookup */
- cmd = lookupCommand(argv[0]->ptr);
- if (!cmd) {
+ for (j = 0; j < argc; j++) {
+ if (!lua_isstring(lua,j+1)) break;
+ argv[j] = createStringObject((char*)lua_tostring(lua,j+1),
+ lua_strlen(lua,j+1));
+ }
+
+ /* Check if one of the arguments passed by the Lua script
+ * is not a string or an integer (lua_isstring() return true for
+ * integers as well). */
+ if (j != argc) {
+ j--;
+ while (j >= 0) {
+ decrRefCount(argv[j]);
+ j--;
+ }
zfree(argv);
- lua_pushnil(lua);
- lua_pushstring(lua,"Unknown Redis command called from Lua script");
- return 2;
+ luaPushError(lua,
+ "Lua redis() command arguments must be strings or integers");
+ return 1;
}
- /* Run the command in the context of a fake client */
+
+ /* Setup our fake client for command execution */
c->argv = argv;
c->argc = argc;
+
+ /* Command lookup */
+ cmd = lookupCommand(argv[0]->ptr);
+ if (!cmd || ((cmd->arity > 0 && cmd->arity != argc) ||
+ (argc < -cmd->arity)))
+ {
+ if (cmd)
+ luaPushError(lua,
+ "Wrong number of args calling Redis command From Lua script");
+ else
+ luaPushError(lua,"Unknown Redis command called from Lua script");
+ goto cleanup;
+ }
+
+ if (cmd->flags & REDIS_CMD_NOSCRIPT) {
+ luaPushError(lua, "This Redis command is not allowed from scripts");
+ goto cleanup;
+ }
+
+ if (cmd->flags & REDIS_CMD_WRITE && server.lua_random_dirty) {
+ luaPushError(lua,
+ "Write commands not allowed after non deterministic commands");
+ goto cleanup;
+ }
+
+ if (cmd->flags & REDIS_CMD_RANDOM) server.lua_random_dirty = 1;
+
+ /* Run the command */
cmd->proc(c);
/* Convert the result of the Redis command into a suitable Lua type.
* output buffers. */
reply = sdsempty();
if (c->bufpos) {
- reply = sdscatlen(reply,c->bufpos,c->buf);
+ reply = sdscatlen(reply,c->buf,c->bufpos);
c->bufpos = 0;
}
while(listLength(c->reply)) {
robj *o = listNodeValue(listFirst(c->reply));
- sdscatlen(reply,o->ptr,sdslen(o->ptr));
+ reply = sdscatlen(reply,o->ptr,sdslen(o->ptr));
listDelNode(c->reply,listFirst(c->reply));
}
- lua_pushnumber(lua,1);
+ redisProtocolToLuaType(lua,reply);
+ sdsfree(reply);
+cleanup:
/* Clean up. Command code may have changed argv/argc so we use the
* argv/argc of the client instead of the local variables. */
for (j = 0; j < c->argc; j++)
return 1;
}
+int luaLogCommand(lua_State *lua) {
+ int j, argc = lua_gettop(lua);
+ int level;
+ sds log;
+
+ if (argc < 2) {
+ luaPushError(lua, "redis.log() requires two arguments or more.");
+ return 1;
+ } else if (!lua_isnumber(lua,-argc)) {
+ luaPushError(lua, "First argument must be a number (log level).");
+ return 1;
+ }
+ level = lua_tonumber(lua,-argc);
+ if (level < REDIS_DEBUG || level > REDIS_WARNING) {
+ luaPushError(lua, "Invalid debug level.");
+ return 1;
+ }
+
+ /* Glue together all the arguments */
+ log = sdsempty();
+ for (j = 1; j < argc; j++) {
+ size_t len;
+ char *s;
+
+ s = (char*)lua_tolstring(lua,(-argc)+j,&len);
+ if (s) {
+ if (j != 1) log = sdscatlen(log," ",1);
+ log = sdscatlen(log,s,len);
+ }
+ }
+ redisLogRaw(level,log);
+ sdsfree(log);
+ return 0;
+}
+
+void luaMaskCountHook(lua_State *lua, lua_Debug *ar) {
+ long long elapsed;
+ REDIS_NOTUSED(ar);
+
+ elapsed = (ustime()/1000) - server.lua_time_start;
+ if (elapsed >= server.lua_time_limit) {
+ redisLog(REDIS_NOTICE,"Lua script aborted for max execution time after %lld milliseconds of running time.",elapsed);
+ lua_pushstring(lua,"Script aborted for max execution time.");
+ lua_error(lua);
+ }
+}
+
+void luaLoadLib(lua_State *lua, const char *libname, lua_CFunction luafunc) {
+ lua_pushcfunction(lua, luafunc);
+ lua_pushstring(lua, libname);
+ lua_call(lua, 1, 0);
+}
+
+void luaLoadLibraries(lua_State *lua) {
+ luaLoadLib(lua, "", luaopen_base);
+ luaLoadLib(lua, LUA_TABLIBNAME, luaopen_table);
+ luaLoadLib(lua, LUA_STRLIBNAME, luaopen_string);
+ luaLoadLib(lua, LUA_MATHLIBNAME, luaopen_math);
+ luaLoadLib(lua, LUA_DBLIBNAME, luaopen_debug);
+
+#if 0 /* Stuff that we don't load currently, for sandboxing concerns. */
+ luaLoadLib(lua, LUA_LOADLIBNAME, luaopen_package);
+ luaLoadLib(lua, LUA_OSLIBNAME, luaopen_os);
+#endif
+}
+
void scriptingInit(void) {
lua_State *lua = lua_open();
- luaL_openlibs(lua);
+ luaLoadLibraries(lua);
+
+ /* Initialize a dictionary we use to map SHAs to scripts.
+ * This is useful for replication, as we need to replicate EVALSHA
+ * as EVAL, so we need to remember the associated script. */
+ server.lua_scripts = dictCreate(&dbDictType,NULL);
- /* Register the 'r' command */
+ /* Register the redis commands table and fields */
+ lua_newtable(lua);
+
+ /* redis.call */
+ lua_pushstring(lua,"call");
lua_pushcfunction(lua,luaRedisCommand);
- lua_setglobal(lua,"r");
+ lua_settable(lua,-3);
+
+ /* redis.log and log levels. */
+ lua_pushstring(lua,"log");
+ lua_pushcfunction(lua,luaLogCommand);
+ lua_settable(lua,-3);
+
+ lua_pushstring(lua,"LOG_DEBUG");
+ lua_pushnumber(lua,REDIS_DEBUG);
+ lua_settable(lua,-3);
+
+ lua_pushstring(lua,"LOG_VERBOSE");
+ lua_pushnumber(lua,REDIS_VERBOSE);
+ lua_settable(lua,-3);
+
+ lua_pushstring(lua,"LOG_NOTICE");
+ lua_pushnumber(lua,REDIS_NOTICE);
+ lua_settable(lua,-3);
+
+ lua_pushstring(lua,"LOG_WARNING");
+ lua_pushnumber(lua,REDIS_WARNING);
+ lua_settable(lua,-3);
+
+ /* Finally set the table as 'redis' global var. */
+ lua_setglobal(lua,"redis");
+
+ /* Replace math.random and math.randomseed with our implementations. */
+ lua_getglobal(lua,"math");
+
+ lua_pushstring(lua,"random");
+ lua_pushcfunction(lua,redis_math_random);
+ lua_settable(lua,-3);
+
+ lua_pushstring(lua,"randomseed");
+ lua_pushcfunction(lua,redis_math_randomseed);
+ lua_settable(lua,-3);
+
+ lua_setglobal(lua,"math");
/* Create the (non connected) client that we use to execute Redis commands
* inside the Lua interpreter */
server.lua_client = createClient(-1);
+ server.lua_client->flags |= REDIS_LUA_CLIENT;
server.lua = lua;
}
}
void luaReplyToRedisReply(redisClient *c, lua_State *lua) {
- int t = lua_type(lua,1);
+ int t = lua_type(lua,-1);
switch(t) {
case LUA_TSTRING:
- addReplyBulkCBuffer(c,(char*)lua_tostring(lua,1),lua_strlen(lua,1));
+ addReplyBulkCBuffer(c,(char*)lua_tostring(lua,-1),lua_strlen(lua,-1));
break;
case LUA_TBOOLEAN:
- addReply(c,lua_toboolean(lua,1) ? shared.cone : shared.czero);
+ addReply(c,lua_toboolean(lua,-1) ? shared.cone : shared.nullbulk);
break;
case LUA_TNUMBER:
- addReplyLongLong(c,(long long)lua_tonumber(lua,1));
+ addReplyLongLong(c,(long long)lua_tonumber(lua,-1));
+ break;
+ case LUA_TTABLE:
+ /* We need to check if it is an array, an error, or a status reply.
+ * Error are returned as a single element table with 'err' field.
+ * Status replies are returned as single elment table with 'ok' field */
+ lua_pushstring(lua,"err");
+ lua_gettable(lua,-2);
+ t = lua_type(lua,-1);
+ if (t == LUA_TSTRING) {
+ sds err = sdsnew(lua_tostring(lua,-1));
+ sdsmapchars(err,"\r\n"," ",2);
+ addReplySds(c,sdscatprintf(sdsempty(),"-%s\r\n",err));
+ sdsfree(err);
+ lua_pop(lua,2);
+ return;
+ }
+
+ lua_pop(lua,1);
+ lua_pushstring(lua,"ok");
+ lua_gettable(lua,-2);
+ t = lua_type(lua,-1);
+ if (t == LUA_TSTRING) {
+ sds ok = sdsnew(lua_tostring(lua,-1));
+ sdsmapchars(ok,"\r\n"," ",2);
+ addReplySds(c,sdscatprintf(sdsempty(),"+%s\r\n",ok));
+ sdsfree(ok);
+ lua_pop(lua,1);
+ } else {
+ void *replylen = addDeferredMultiBulkLength(c);
+ int j = 1, mbulklen = 0;
+
+ lua_pop(lua,1); /* Discard the 'ok' field value we popped */
+ while(1) {
+ lua_pushnumber(lua,j++);
+ lua_gettable(lua,-2);
+ t = lua_type(lua,-1);
+ if (t == LUA_TNIL) {
+ lua_pop(lua,1);
+ break;
+ }
+ luaReplyToRedisReply(c, lua);
+ mbulklen++;
+ }
+ setDeferredMultiBulkLength(c,replylen,mbulklen);
+ }
break;
default:
addReply(c,shared.nullbulk);
lua_pop(lua,1);
}
-void evalCommand(redisClient *c) {
+/* Set an array of Redis String Objects as a Lua array (table) stored into a
+ * global variable. */
+void luaSetGlobalArray(lua_State *lua, char *var, robj **elev, int elec) {
+ int j;
+
+ lua_newtable(lua);
+ for (j = 0; j < elec; j++) {
+ lua_pushlstring(lua,(char*)elev[j]->ptr,sdslen(elev[j]->ptr));
+ lua_rawseti(lua,-2,j+1);
+ }
+ lua_setglobal(lua,var);
+}
+
+void evalGenericCommand(redisClient *c, int evalsha) {
lua_State *lua = server.lua;
char funcname[43];
+ long long numkeys;
+
+ /* We want the same PRNG sequence at every call so that our PRNG is
+ * not affected by external state. */
+ redisSrand48(0);
+
+ /* We set this flag to zero to remember that so far no random command
+ * was called. This way we can allow the user to call commands like
+ * SRANDMEMBER or RANDOMKEY from Lua scripts as far as no write command
+ * is called (otherwise the replication and AOF would end with non
+ * deterministic sequences).
+ *
+ * Thanks to this flag we'll raise an error every time a write command
+ * is called after a random command was used. */
+ server.lua_random_dirty = 0;
+
+ /* Get the number of arguments that are keys */
+ if (getLongLongFromObjectOrReply(c,c->argv[2],&numkeys,NULL) != REDIS_OK)
+ return;
+ if (numkeys > (c->argc - 3)) {
+ addReplyError(c,"Number of keys can't be greater than number of args");
+ return;
+ }
/* We obtain the script SHA1, then check if this function is already
* defined into the Lua state */
funcname[0] = 'f';
funcname[1] = '_';
- hashScript(funcname+2,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
+ if (!evalsha) {
+ /* Hash the code if this is an EVAL call */
+ hashScript(funcname+2,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
+ } else {
+ /* We already have the SHA if it is a EVALSHA */
+ int j;
+ char *sha = c->argv[1]->ptr;
+
+ for (j = 0; j < 40; j++)
+ funcname[j+2] = tolower(sha[j]);
+ funcname[42] = '\0';
+ }
+
lua_getglobal(lua, funcname);
if (lua_isnil(lua,1)) {
- /* Function not defined... let's define it. */
- sds funcdef = sdsempty();
+ sds funcdef;
+
+ /* Function not defined... let's define it if we have the
+ * body of the funciton. If this is an EVALSHA call we can just
+ * return an error. */
+ if (evalsha) {
+ addReply(c, shared.noscripterr);
+ lua_pop(lua,1); /* remove the nil from the stack */
+ return;
+ }
+ funcdef = sdsempty();
lua_pop(lua,1); /* remove the nil from the stack */
funcdef = sdscat(funcdef,"function ");
funcdef = sdscatlen(funcdef," ()\n",4);
funcdef = sdscatlen(funcdef,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
funcdef = sdscatlen(funcdef,"\nend\n",5);
- printf("Defining:\n%s\n",funcdef);
+ /* printf("Defining:\n%s\n",funcdef); */
if (luaL_loadbuffer(lua,funcdef,sdslen(funcdef),"func definition")) {
addReplyErrorFormat(c,"Error compiling script (new function): %s\n",
lua_tostring(lua,-1));
lua_pop(lua,1);
+ sdsfree(funcdef);
return;
}
+ sdsfree(funcdef);
if (lua_pcall(lua,0,0,0)) {
addReplyErrorFormat(c,"Error running script (new function): %s\n",
lua_tostring(lua,-1));
return;
}
lua_getglobal(lua, funcname);
+
+ /* We also save a SHA1 -> Original script map in a dictionary
+ * so that we can replicate / write in the AOF all the
+ * EVALSHA commands as EVAL using the original script. */
+ {
+ int retval = dictAdd(server.lua_scripts,
+ sdsnewlen(funcname+2,40),c->argv[1]);
+ redisAssert(retval == DICT_OK);
+ incrRefCount(c->argv[1]);
+ }
}
+
+ /* Populate the argv and keys table accordingly to the arguments that
+ * EVAL received. */
+ luaSetGlobalArray(lua,"KEYS",c->argv+3,numkeys);
+ luaSetGlobalArray(lua,"ARGV",c->argv+3+numkeys,c->argc-3-numkeys);
+
+ /* Select the right DB in the context of the Lua client */
+ selectDb(server.lua_client,c->db->id);
+ /* Set an hook in order to be able to stop the script execution if it
+ * is running for too much time.
+ * We set the hook only if the time limit is enabled as the hook will
+ * make the Lua script execution slower. */
+ if (server.lua_time_limit > 0) {
+ lua_sethook(lua,luaMaskCountHook,LUA_MASKCOUNT,100000);
+ server.lua_time_start = ustime()/1000;
+ } else {
+ lua_sethook(lua,luaMaskCountHook,0,0);
+ }
+
/* At this point whatever this script was never seen before or if it was
* already defined, we can call it. We have zero arguments and expect
* a single return value. */
if (lua_pcall(lua,0,1,0)) {
+ selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */
addReplyErrorFormat(c,"Error running script (call to %s): %s\n",
funcname, lua_tostring(lua,-1));
lua_pop(lua,1);
+ lua_gc(lua,LUA_GCCOLLECT,0);
return;
}
+ selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */
luaReplyToRedisReply(c,lua);
+ lua_gc(lua,LUA_GCSTEP,1);
+
+ /* If we have slaves attached we want to replicate this command as
+ * EVAL instead of EVALSHA. We do this also in the AOF as currently there
+ * is no easy way to propagate a command in a different way in the AOF
+ * and in the replication link.
+ *
+ * IMPROVEMENT POSSIBLE:
+ * 1) Replicate this command as EVALSHA in the AOF.
+ * 2) Remember what slave already received a given script, and replicate
+ * the EVALSHA against this slaves when possible.
+ */
+ if (evalsha) {
+ robj *script = dictFetchValue(server.lua_scripts,c->argv[1]->ptr);
+
+ redisAssert(script != NULL);
+ rewriteClientCommandArgument(c,0,
+ resetRefCount(createStringObject("EVAL",4)));
+ rewriteClientCommandArgument(c,1,script);
+ }
+}
+
+void evalCommand(redisClient *c) {
+ evalGenericCommand(c,0);
+}
+
+void evalShaCommand(redisClient *c) {
+ if (sdslen(c->argv[1]->ptr) != 40) {
+ /* We know that a match is not possible if the provided SHA is
+ * not the right length. So we return an error ASAP, this way
+ * evalGenericCommand() can be implemented without string length
+ * sanity check */
+ addReply(c, shared.noscripterr);
+ return;
+ }
+ evalGenericCommand(c,1);
+}
+
+/* We replace math.random() with our implementation that is not affected
+ * by specific libc random() implementations and will output the same sequence
+ * (for the same seed) in every arch. */
+
+/* The following implementation is the one shipped with Lua itself but with
+ * rand() replaced by redisLrand48(). */
+int redis_math_random (lua_State *L) {
+ /* the `%' avoids the (rare) case of r==1, and is needed also because on
+ some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
+ lua_Number r = (lua_Number)(redisLrand48()%REDIS_LRAND48_MAX) /
+ (lua_Number)REDIS_LRAND48_MAX;
+ switch (lua_gettop(L)) { /* check number of arguments */
+ case 0: { /* no arguments */
+ lua_pushnumber(L, r); /* Number between 0 and 1 */
+ break;
+ }
+ case 1: { /* only upper limit */
+ int u = luaL_checkint(L, 1);
+ luaL_argcheck(L, 1<=u, 1, "interval is empty");
+ lua_pushnumber(L, floor(r*u)+1); /* int between 1 and `u' */
+ break;
+ }
+ case 2: { /* lower and upper limits */
+ int l = luaL_checkint(L, 1);
+ int u = luaL_checkint(L, 2);
+ luaL_argcheck(L, l<=u, 2, "interval is empty");
+ lua_pushnumber(L, floor(r*(u-l+1))+l); /* int between `l' and `u' */
+ break;
+ }
+ default: return luaL_error(L, "wrong number of arguments");
+ }
+ return 1;
+}
+
+int redis_math_randomseed (lua_State *L) {
+ redisSrand48(luaL_checkint(L, 1));
+ return 0;
}
projects / redis.git / blobdiff