Implemented --latency in redis-cli

[redis.git] / src / scripting.c

diff --git a/src/scripting.c b/src/scripting.c
index 65cbed62dbd259c34596d2ee0ec17de86dbe64d1..794cba5e39580141512af8f1e05e95a7cce4fb8f 100644 (file)
--- a/src/scripting.c
+++ b/src/scripting.c
@@ -4,6 +4,7 @@
 #include <lua.h>
 #include <lauxlib.h>
 #include <lualib.h>
 #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);
 
 char *redisProtocolToLuaType_Int(lua_State *lua, char *reply);
 char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply);


@@ -68,7 +69,7 @@ char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply) {
 
     string2ll(reply+1,p-reply-1,&bulklen);
     if (bulklen == -1) {
 
     string2ll(reply+1,p-reply-1,&bulklen);
     if (bulklen == -1) {

-        lua_pushnil(lua);
+        lua_pushboolean(lua,0);

         return p+2;
     } else {
         lua_pushlstring(lua,p+2,bulklen);
         return p+2;
     } else {
         lua_pushlstring(lua,p+2,bulklen);


@@ -104,7 +105,7 @@ char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply) {
     string2ll(reply+1,p-reply-1,&mbulklen);
     p += 2;
     if (mbulklen == -1) {
     string2ll(reply+1,p-reply-1,&mbulklen);
     p += 2;
     if (mbulklen == -1) {

-        lua_pushnil(lua);
+        lua_pushboolean(lua,0);

         return p;
     }
     lua_newtable(lua);
         return p;
     }
     lua_newtable(lua);


@@ -199,12 +200,92 @@ int luaRedisCommand(lua_State *lua) {
     return 1;
 }
 
     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 scriptingInit(void) {
     lua_State *lua = lua_open();
     luaL_openlibs(lua);
 
 void scriptingInit(void) {
     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_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_setglobal(lua,"redis");
 
     /* Create the (non connected) client that we use to execute Redis commands


@@ -236,17 +317,17 @@ void hashScript(char *digest, char *script, size_t len) {
 }
 
 void luaReplyToRedisReply(redisClient *c, lua_State *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:
 
     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:
         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:
         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.
         break;
     case LUA_TTABLE:
         /* We need to check if it is an array, an error, or a status reply.


@@ -256,8 +337,10 @@ void luaReplyToRedisReply(redisClient *c, lua_State *lua) {
         lua_gettable(lua,-2);
         t = lua_type(lua,-1);
         if (t == LUA_TSTRING) {
         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_pop(lua,2);
             return;
         }


@@ -267,8 +350,10 @@ void luaReplyToRedisReply(redisClient *c, lua_State *lua) {
         lua_gettable(lua,-2);
         t = lua_type(lua,-1);
         if (t == LUA_TSTRING) {
         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_pop(lua,1);
         } else {
             void *replylen = addDeferredMultiBulkLength(c);


@@ -282,17 +367,9 @@ void luaReplyToRedisReply(redisClient *c, lua_State *lua) {
                 if (t == LUA_TNIL) {
                     lua_pop(lua,1);
                     break;
                 if (t == LUA_TNIL) {
                     lua_pop(lua,1);
                     break;

-                } else if (t == LUA_TSTRING) {
-                    size_t len;
-                    char *s = (char*) lua_tolstring(lua,-1,&len);
-
-                    addReplyBulkCBuffer(c,s,len);
-                    mbulklen++;
-                } else if (t == LUA_TNUMBER) {
-                    addReplyLongLong(c,(long long)lua_tonumber(lua,-1));
-                    mbulklen++;

                 }
                 }

-                lua_pop(lua,1);
+                luaReplyToRedisReply(c, lua);
+                mbulklen++;

             }
             setDeferredMultiBulkLength(c,replylen,mbulklen);
         }
             }
             setDeferredMultiBulkLength(c,replylen,mbulklen);
         }


@@ -316,7 +393,7 @@ void luaSetGlobalArray(lua_State *lua, char *var, robj **elev, int elec) {
     lua_setglobal(lua,var);
 }
 
     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;
     lua_State *lua = server.lua;
     char funcname[43];
     long long numkeys;


@@ -333,11 +410,32 @@ void evalCommand(redisClient *c) {
      * defined into the Lua state */
     funcname[0] = 'f';
     funcname[1] = '_';
      * 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)) {
     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 ");
 
         lua_pop(lua,1); /* remove the nil from the stack */
         funcdef = sdscat(funcdef,"function ");


@@ -362,21 +460,84 @@ void evalCommand(redisClient *c) {
             return;
         }
         lua_getglobal(lua, funcname);
             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);
     }
 
     /* 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)) {
     /* 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);
         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;
     }
         return;
     }

+    selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */

     luaReplyToRedisReply(c,lua);
     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);

 }
 }