#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
+#include <ctype.h>
char *redisProtocolToLuaType_Int(lua_State *lua, char *reply);
char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply);
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);
lua_State *lua = lua_open();
luaL_openlibs(lua);
- /* Register the 'r' command */
+ /* 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 redis commands table and fields */
+ lua_newtable(lua);
+
+ /* redis.call */
+ lua_pushstring(lua,"call");
lua_pushcfunction(lua,luaRedisCommand);
+ 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");
/* Create the (non connected) client that we use to execute Redis commands
lua_gettable(lua,-2);
t = lua_type(lua,-1);
if (t == LUA_TSTRING) {
- addReplySds(c,sdscatprintf(sdsempty(),
- "-%s\r\n",(char*)lua_tostring(lua,-1)));
+ 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_gettable(lua,-2);
t = lua_type(lua,-1);
if (t == LUA_TSTRING) {
- addReplySds(c,sdscatprintf(sdsempty(),
- "+%s\r\n",(char*)lua_tostring(lua,-1)));
+ 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);
lua_setglobal(lua,var);
}
-void evalCommand(redisClient *c) {
+void evalGenericCommand(redisClient *c, int evalsha) {
lua_State *lua = server.lua;
char funcname[43];
long long numkeys;
* 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 ");
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
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);
}
projects / redis.git / blobdiff