src/scripting.c

   1 #include "redis.h"
   2 #include "sha1.h"
   3 #include "rand.h"
   4
   5 #include <lua.h>
   6 #include <lauxlib.h>
   7 #include <lualib.h>
   8 #include <ctype.h>
   9 #include <math.h>
  10
  11 char *redisProtocolToLuaType_Int(lua_State *lua, char *reply);
  12 char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply);
  13 char *redisProtocolToLuaType_Status(lua_State *lua, char *reply);
  14 char *redisProtocolToLuaType_Error(lua_State *lua, char *reply);
  15 char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply);
  16 int redis_math_random (lua_State *L);
  17 int redis_math_randomseed (lua_State *L);
  18
  19 /* Take a Redis reply in the Redis protocol format and convert it into a
  20  * Lua type. Thanks to this function, and the introduction of not connected
  21  * clients, it is trvial to implement the redis() lua function.
  22  *
  23  * Basically we take the arguments, execute the Redis command in the context
  24  * of a non connected client, then take the generated reply and convert it
  25  * into a suitable Lua type. With this trick the scripting feature does not
  26  * need the introduction of a full Redis internals API. Basically the script
  27  * is like a normal client that bypasses all the slow I/O paths.
  28  *
  29  * Note: in this function we do not do any sanity check as the reply is
  30  * generated by Redis directly. This allows use to go faster.
  31  * The reply string can be altered during the parsing as it is discared
  32  * after the conversion is completed.
  33  *
  34  * Errors are returned as a table with a single 'err' field set to the
  35  * error string.
  36  */
  37
  38 char *redisProtocolToLuaType(lua_State *lua, char* reply) {
  39     char *p = reply;
  40
  41     switch(*p) {
  42     case ':':
  43         p = redisProtocolToLuaType_Int(lua,reply);
  44         break;
  45     case '$':
  46         p = redisProtocolToLuaType_Bulk(lua,reply);
  47         break;
  48     case '+':
  49         p = redisProtocolToLuaType_Status(lua,reply);
  50         break;
  51     case '-':
  52         p = redisProtocolToLuaType_Error(lua,reply);
  53         break;
  54     case '*':
  55         p = redisProtocolToLuaType_MultiBulk(lua,reply);
  56         break;
  57     }
  58     return p;
  59 }
  60
  61 char *redisProtocolToLuaType_Int(lua_State *lua, char *reply) {
  62     char *p = strchr(reply+1,'\r');
  63     long long value;
  64
  65     string2ll(reply+1,p-reply-1,&value);
  66     lua_pushnumber(lua,(lua_Number)value);
  67     return p+2;
  68 }
  69
  70 char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply) {
  71     char *p = strchr(reply+1,'\r');
  72     long long bulklen;
  73
  74     string2ll(reply+1,p-reply-1,&bulklen);
  75     if (bulklen == -1) {
  76         lua_pushboolean(lua,0);
  77         return p+2;
  78     } else {
  79         lua_pushlstring(lua,p+2,bulklen);
  80         return p+2+bulklen+2;
  81     }
  82 }
  83
  84 char *redisProtocolToLuaType_Status(lua_State *lua, char *reply) {
  85     char *p = strchr(reply+1,'\r');
  86
  87     lua_newtable(lua);
  88     lua_pushstring(lua,"ok");
  89     lua_pushlstring(lua,reply+1,p-reply-1);
  90     lua_settable(lua,-3);
  91     return p+2;
  92 }
  93
  94 char *redisProtocolToLuaType_Error(lua_State *lua, char *reply) {
  95     char *p = strchr(reply+1,'\r');
  96
  97     lua_newtable(lua);
  98     lua_pushstring(lua,"err");
  99     lua_pushlstring(lua,reply+1,p-reply-1);
 100     lua_settable(lua,-3);
 101     return p+2;
 102 }
 103
 104 char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply) {
 105     char *p = strchr(reply+1,'\r');
 106     long long mbulklen;
 107     int j = 0;
 108
 109     string2ll(reply+1,p-reply-1,&mbulklen);
 110     p += 2;
 111     if (mbulklen == -1) {
 112         lua_pushboolean(lua,0);
 113         return p;
 114     }
 115     lua_newtable(lua);
 116     for (j = 0; j < mbulklen; j++) {
 117         lua_pushnumber(lua,j+1);
 118         p = redisProtocolToLuaType(lua,p);
 119         lua_settable(lua,-3);
 120     }
 121     return p;
 122 }
 123
 124 void luaPushError(lua_State *lua, char *error) {
 125     lua_newtable(lua);
 126     lua_pushstring(lua,"err");
 127     lua_pushstring(lua, error);
 128     lua_settable(lua,-3);
 129 }
 130
 131 int luaRedisCommand(lua_State *lua) {
 132     int j, argc = lua_gettop(lua);
 133     struct redisCommand *cmd;
 134     robj **argv;
 135     redisClient *c = server.lua_client;
 136     sds reply;
 137
 138     /* Build the arguments vector */
 139     argv = zmalloc(sizeof(robj*)*argc);
 140     for (j = 0; j < argc; j++) {
 141         if (!lua_isstring(lua,j+1)) break;
 142         argv[j] = createStringObject((char*)lua_tostring(lua,j+1),
 143                                      lua_strlen(lua,j+1));
 144     }
 145
 146     /* Check if one of the arguments passed by the Lua script
 147      * is not a string or an integer (lua_isstring() return true for
 148      * integers as well). */
 149     if (j != argc) {
 150         j--;
 151         while (j >= 0) {
 152             decrRefCount(argv[j]);
 153             j--;
 154         }
 155         zfree(argv);
 156         luaPushError(lua,
 157             "Lua redis() command arguments must be strings or integers");
 158         return 1;
 159     }
 160
 161     /* Command lookup */
 162     cmd = lookupCommand(argv[0]->ptr);
 163     if (!cmd || ((cmd->arity > 0 && cmd->arity != argc) ||
 164                    (argc < -cmd->arity)))
 165     {
 166         for (j = 0; j < argc; j++) decrRefCount(argv[j]);
 167         zfree(argv);
 168         if (cmd)
 169             luaPushError(lua,
 170                 "Wrong number of args calling Redis command From Lua script");
 171         else
 172             luaPushError(lua,"Unknown Redis command called from Lua script");
 173         return 1;
 174     }
 175
 176     /* Run the command in the context of a fake client */
 177     c->argv = argv;
 178     c->argc = argc;
 179     cmd->proc(c);
 180
 181     /* Convert the result of the Redis command into a suitable Lua type.
 182      * The first thing we need is to create a single string from the client
 183      * output buffers. */
 184     reply = sdsempty();
 185     if (c->bufpos) {
 186         reply = sdscatlen(reply,c->buf,c->bufpos);
 187         c->bufpos = 0;
 188     }
 189     while(listLength(c->reply)) {
 190         robj *o = listNodeValue(listFirst(c->reply));
 191
 192         reply = sdscatlen(reply,o->ptr,sdslen(o->ptr));
 193         listDelNode(c->reply,listFirst(c->reply));
 194     }
 195     redisProtocolToLuaType(lua,reply);
 196     sdsfree(reply);
 197
 198     /* Clean up. Command code may have changed argv/argc so we use the
 199      * argv/argc of the client instead of the local variables. */
 200     for (j = 0; j < c->argc; j++)
 201         decrRefCount(c->argv[j]);
 202     zfree(c->argv);
 203
 204     return 1;
 205 }
 206
 207 int luaLogCommand(lua_State *lua) {
 208     int j, argc = lua_gettop(lua);
 209     int level;
 210     sds log;
 211
 212     if (argc < 2) {
 213         luaPushError(lua, "redis.log() requires two arguments or more.");
 214         return 1;
 215     } else if (!lua_isnumber(lua,-argc)) {
 216         luaPushError(lua, "First argument must be a number (log level).");
 217         return 1;
 218     }
 219     level = lua_tonumber(lua,-argc);
 220     if (level < REDIS_DEBUG || level > REDIS_WARNING) {
 221         luaPushError(lua, "Invalid debug level.");
 222         return 1;
 223     }
 224
 225     /* Glue together all the arguments */
 226     log = sdsempty();
 227     for (j = 1; j < argc; j++) {
 228         size_t len;
 229         char *s;
 230
 231         s = (char*)lua_tolstring(lua,(-argc)+j,&len);
 232         if (s) {
 233             if (j != 1) log = sdscatlen(log," ",1);
 234             log = sdscatlen(log,s,len);
 235         }
 236     }
 237     redisLogRaw(level,log);
 238     sdsfree(log);
 239     return 0;
 240 }
 241
 242 void luaMaskCountHook(lua_State *lua, lua_Debug *ar) {
 243     long long elapsed;
 244     REDIS_NOTUSED(ar);
 245
 246     elapsed = (ustime()/1000) - server.lua_time_start;
 247     if (elapsed >= server.lua_time_limit) {
 248         redisLog(REDIS_NOTICE,"Lua script aborted for max execution time after %lld milliseconds of running time.",elapsed);
 249         lua_pushstring(lua,"Script aborted for max execution time.");
 250         lua_error(lua);
 251     }
 252 }
 253
 254 void scriptingInit(void) {
 255     lua_State *lua = lua_open();
 256     luaL_openlibs(lua);
 257
 258     /* Initialize a dictionary we use to map SHAs to scripts.
 259      * This is useful for replication, as we need to replicate EVALSHA
 260      * as EVAL, so we need to remember the associated script. */
 261     server.lua_scripts = dictCreate(&dbDictType,NULL);
 262
 263     /* Register the redis commands table and fields */
 264     lua_newtable(lua);
 265
 266     /* redis.call */
 267     lua_pushstring(lua,"call");
 268     lua_pushcfunction(lua,luaRedisCommand);
 269     lua_settable(lua,-3);
 270
 271     /* redis.log and log levels. */
 272     lua_pushstring(lua,"log");
 273     lua_pushcfunction(lua,luaLogCommand);
 274     lua_settable(lua,-3);
 275
 276     lua_pushstring(lua,"LOG_DEBUG");
 277     lua_pushnumber(lua,REDIS_DEBUG);
 278     lua_settable(lua,-3);
 279
 280     lua_pushstring(lua,"LOG_VERBOSE");
 281     lua_pushnumber(lua,REDIS_VERBOSE);
 282     lua_settable(lua,-3);
 283
 284     lua_pushstring(lua,"LOG_NOTICE");
 285     lua_pushnumber(lua,REDIS_NOTICE);
 286     lua_settable(lua,-3);
 287
 288     lua_pushstring(lua,"LOG_WARNING");
 289     lua_pushnumber(lua,REDIS_WARNING);
 290     lua_settable(lua,-3);
 291
 292     /* Finally set the table as 'redis' global var. */
 293     lua_setglobal(lua,"redis");
 294
 295     /* Replace math.random and math.randomseed with our implementations. */
 296     lua_getglobal(lua,"math");
 297
 298     lua_pushstring(lua,"random");
 299     lua_pushcfunction(lua,redis_math_random);
 300     lua_settable(lua,-3);
 301
 302     lua_pushstring(lua,"randomseed");
 303     lua_pushcfunction(lua,redis_math_randomseed);
 304     lua_settable(lua,-3);
 305
 306     lua_setglobal(lua,"math");
 307
 308     /* Create the (non connected) client that we use to execute Redis commands
 309      * inside the Lua interpreter */
 310     server.lua_client = createClient(-1);
 311     server.lua_client->flags |= REDIS_LUA_CLIENT;
 312
 313     server.lua = lua;
 314 }
 315
 316 /* Hash the scripit into a SHA1 digest. We use this as Lua function name.
 317  * Digest should point to a 41 bytes buffer: 40 for SHA1 converted into an
 318  * hexadecimal number, plus 1 byte for null term. */
 319 void hashScript(char *digest, char *script, size_t len) {
 320     SHA1_CTX ctx;
 321     unsigned char hash[20];
 322     char *cset = "0123456789abcdef";
 323     int j;
 324
 325     SHA1Init(&ctx);
 326     SHA1Update(&ctx,(unsigned char*)script,len);
 327     SHA1Final(hash,&ctx);
 328
 329     for (j = 0; j < 20; j++) {
 330         digest[j*2] = cset[((hash[j]&0xF0)>>4)];
 331         digest[j*2+1] = cset[(hash[j]&0xF)];
 332     }
 333     digest[40] = '\0';
 334 }
 335
 336 void luaReplyToRedisReply(redisClient *c, lua_State *lua) {
 337     int t = lua_type(lua,-1);
 338
 339     switch(t) {
 340     case LUA_TSTRING:
 341         addReplyBulkCBuffer(c,(char*)lua_tostring(lua,-1),lua_strlen(lua,-1));
 342         break;
 343     case LUA_TBOOLEAN:
 344         addReply(c,lua_toboolean(lua,-1) ? shared.cone : shared.nullbulk);
 345         break;
 346     case LUA_TNUMBER:
 347         addReplyLongLong(c,(long long)lua_tonumber(lua,-1));
 348         break;
 349     case LUA_TTABLE:
 350         /* We need to check if it is an array, an error, or a status reply.
 351          * Error are returned as a single element table with 'err' field.
 352          * Status replies are returned as single elment table with 'ok' field */
 353         lua_pushstring(lua,"err");
 354         lua_gettable(lua,-2);
 355         t = lua_type(lua,-1);
 356         if (t == LUA_TSTRING) {
 357             sds err = sdsnew(lua_tostring(lua,-1));
 358             sdsmapchars(err,"\r\n","  ",2);
 359             addReplySds(c,sdscatprintf(sdsempty(),"-%s\r\n",err));
 360             sdsfree(err);
 361             lua_pop(lua,2);
 362             return;
 363         }
 364
 365         lua_pop(lua,1);
 366         lua_pushstring(lua,"ok");
 367         lua_gettable(lua,-2);
 368         t = lua_type(lua,-1);
 369         if (t == LUA_TSTRING) {
 370             sds ok = sdsnew(lua_tostring(lua,-1));
 371             sdsmapchars(ok,"\r\n","  ",2);
 372             addReplySds(c,sdscatprintf(sdsempty(),"+%s\r\n",ok));
 373             sdsfree(ok);
 374             lua_pop(lua,1);
 375         } else {
 376             void *replylen = addDeferredMultiBulkLength(c);
 377             int j = 1, mbulklen = 0;
 378
 379             lua_pop(lua,1); /* Discard the 'ok' field value we popped */
 380             while(1) {
 381                 lua_pushnumber(lua,j++);
 382                 lua_gettable(lua,-2);
 383                 t = lua_type(lua,-1);
 384                 if (t == LUA_TNIL) {
 385                     lua_pop(lua,1);
 386                     break;
 387                 }
 388                 luaReplyToRedisReply(c, lua);
 389                 mbulklen++;
 390             }
 391             setDeferredMultiBulkLength(c,replylen,mbulklen);
 392         }
 393         break;
 394     default:
 395         addReply(c,shared.nullbulk);
 396     }
 397     lua_pop(lua,1);
 398 }
 399
 400 /* Set an array of Redis String Objects as a Lua array (table) stored into a
 401  * global variable. */
 402 void luaSetGlobalArray(lua_State *lua, char *var, robj **elev, int elec) {
 403     int j;
 404
 405     lua_newtable(lua);
 406     for (j = 0; j < elec; j++) {
 407         lua_pushlstring(lua,(char*)elev[j]->ptr,sdslen(elev[j]->ptr));
 408         lua_rawseti(lua,-2,j+1);
 409     }
 410     lua_setglobal(lua,var);
 411 }
 412
 413 void evalGenericCommand(redisClient *c, int evalsha) {
 414     lua_State *lua = server.lua;
 415     char funcname[43];
 416     long long numkeys;
 417
 418     /* We want the same PRNG sequence at every call so that our PRNG is
 419      * not affected by external state. */
 420     redisSrand48(0);
 421
 422     /* Get the number of arguments that are keys */
 423     if (getLongLongFromObjectOrReply(c,c->argv[2],&numkeys,NULL) != REDIS_OK)
 424         return;
 425     if (numkeys > (c->argc - 3)) {
 426         addReplyError(c,"Number of keys can't be greater than number of args");
 427         return;
 428     }
 429
 430     /* We obtain the script SHA1, then check if this function is already
 431      * defined into the Lua state */
 432     funcname[0] = 'f';
 433     funcname[1] = '_';
 434     if (!evalsha) {
 435         /* Hash the code if this is an EVAL call */
 436         hashScript(funcname+2,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
 437     } else {
 438         /* We already have the SHA if it is a EVALSHA */
 439         int j;
 440         char *sha = c->argv[1]->ptr;
 441
 442         for (j = 0; j < 40; j++)
 443             funcname[j+2] = tolower(sha[j]);
 444         funcname[42] = '\0';
 445     }
 446
 447     lua_getglobal(lua, funcname);
 448     if (lua_isnil(lua,1)) {
 449         sds funcdef;
 450
 451         /* Function not defined... let's define it if we have the
 452          * body of the funciton. If this is an EVALSHA call we can just
 453          * return an error. */
 454         if (evalsha) {
 455             addReply(c, shared.noscripterr);
 456             lua_pop(lua,1); /* remove the nil from the stack */
 457             return;
 458         }
 459         funcdef = sdsempty();
 460
 461         lua_pop(lua,1); /* remove the nil from the stack */
 462         funcdef = sdscat(funcdef,"function ");
 463         funcdef = sdscatlen(funcdef,funcname,42);
 464         funcdef = sdscatlen(funcdef," ()\n",4);
 465         funcdef = sdscatlen(funcdef,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
 466         funcdef = sdscatlen(funcdef,"\nend\n",5);
 467         /* printf("Defining:\n%s\n",funcdef); */
 468
 469         if (luaL_loadbuffer(lua,funcdef,sdslen(funcdef),"func definition")) {
 470             addReplyErrorFormat(c,"Error compiling script (new function): %s\n",
 471                 lua_tostring(lua,-1));
 472             lua_pop(lua,1);
 473             sdsfree(funcdef);
 474             return;
 475         }
 476         sdsfree(funcdef);
 477         if (lua_pcall(lua,0,0,0)) {
 478             addReplyErrorFormat(c,"Error running script (new function): %s\n",
 479                 lua_tostring(lua,-1));
 480             lua_pop(lua,1);
 481             return;
 482         }
 483         lua_getglobal(lua, funcname);
 484
 485         /* We also save a SHA1 -> Original script map in a dictionary
 486          * so that we can replicate / write in the AOF all the
 487          * EVALSHA commands as EVAL using the original script. */
 488         {
 489             int retval = dictAdd(server.lua_scripts,
 490                                  sdsnewlen(funcname+2,40),c->argv[1]);
 491             redisAssert(retval == DICT_OK);
 492             incrRefCount(c->argv[1]);
 493         }
 494     }
 495
 496     /* Populate the argv and keys table accordingly to the arguments that
 497      * EVAL received. */
 498     luaSetGlobalArray(lua,"KEYS",c->argv+3,numkeys);
 499     luaSetGlobalArray(lua,"ARGV",c->argv+3+numkeys,c->argc-3-numkeys);
 500
 501     /* Select the right DB in the context of the Lua client */
 502     selectDb(server.lua_client,c->db->id);
 503
 504     /* Set an hook in order to be able to stop the script execution if it
 505      * is running for too much time.
 506      * We set the hook only if the time limit is enabled as the hook will
 507      * make the Lua script execution slower. */
 508     if (server.lua_time_limit > 0) {
 509         lua_sethook(lua,luaMaskCountHook,LUA_MASKCOUNT,100000);
 510         server.lua_time_start = ustime()/1000;
 511     } else {
 512         lua_sethook(lua,luaMaskCountHook,0,0);
 513     }
 514
 515     /* At this point whatever this script was never seen before or if it was
 516      * already defined, we can call it. We have zero arguments and expect
 517      * a single return value. */
 518     if (lua_pcall(lua,0,1,0)) {
 519         selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */
 520         addReplyErrorFormat(c,"Error running script (call to %s): %s\n",
 521             funcname, lua_tostring(lua,-1));
 522         lua_pop(lua,1);
 523         lua_gc(lua,LUA_GCCOLLECT,0);
 524         return;
 525     }
 526     selectDb(c,server.lua_client->db->id); /* set DB ID from Lua client */
 527     luaReplyToRedisReply(c,lua);
 528     lua_gc(lua,LUA_GCSTEP,1);
 529
 530     /* If we have slaves attached we want to replicate this command as
 531      * EVAL instead of EVALSHA. We do this also in the AOF as currently there
 532      * is no easy way to propagate a command in a different way in the AOF
 533      * and in the replication link.
 534      *
 535      * IMPROVEMENT POSSIBLE:
 536      * 1) Replicate this command as EVALSHA in the AOF.
 537      * 2) Remember what slave already received a given script, and replicate
 538      *    the EVALSHA against this slaves when possible.
 539      */
 540     if (evalsha) {
 541         robj *script = dictFetchValue(server.lua_scripts,c->argv[1]->ptr);
 542
 543         redisAssert(script != NULL);
 544         rewriteClientCommandArgument(c,0,
 545             resetRefCount(createStringObject("EVAL",4)));
 546         rewriteClientCommandArgument(c,1,script);
 547     }
 548 }
 549
 550 void evalCommand(redisClient *c) {
 551     evalGenericCommand(c,0);
 552 }
 553
 554 void evalShaCommand(redisClient *c) {
 555     if (sdslen(c->argv[1]->ptr) != 40) {
 556         /* We know that a match is not possible if the provided SHA is
 557          * not the right length. So we return an error ASAP, this way
 558          * evalGenericCommand() can be implemented without string length
 559          * sanity check */
 560         addReply(c, shared.noscripterr);
 561         return;
 562     }
 563     evalGenericCommand(c,1);
 564 }
 565
 566 /* We replace math.random() with our implementation that is not affected
 567  * by specific libc random() implementations and will output the same sequence
 568  * (for the same seed) in every arch. */
 569
 570 /* The following implementation is the one shipped with Lua itself but with
 571  * rand() replaced by redisLrand48(). */
 572 int redis_math_random (lua_State *L) {
 573   /* the `%' avoids the (rare) case of r==1, and is needed also because on
 574      some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
 575   lua_Number r = (lua_Number)(redisLrand48()%REDIS_LRAND48_MAX) /
 576                                 (lua_Number)REDIS_LRAND48_MAX;
 577   switch (lua_gettop(L)) {  /* check number of arguments */
 578     case 0: {  /* no arguments */
 579       lua_pushnumber(L, r);  /* Number between 0 and 1 */
 580       break;
 581     }
 582     case 1: {  /* only upper limit */
 583       int u = luaL_checkint(L, 1);
 584       luaL_argcheck(L, 1<=u, 1, "interval is empty");
 585       lua_pushnumber(L, floor(r*u)+1);  /* int between 1 and `u' */
 586       break;
 587     }
 588     case 2: {  /* lower and upper limits */
 589       int l = luaL_checkint(L, 1);
 590       int u = luaL_checkint(L, 2);
 591       luaL_argcheck(L, l<=u, 2, "interval is empty");
 592       lua_pushnumber(L, floor(r*(u-l+1))+l);  /* int between `l' and `u' */
 593       break;
 594     }
 595     default: return luaL_error(L, "wrong number of arguments");
 596   }
 597   return 1;
 598 }
 599
 600 int redis_math_randomseed (lua_State *L) {
 601   redisSrand48(luaL_checkint(L, 1));
 602   return 0;
 603 }