src/scripting.c

   1 #include "redis.h"
   2 #include "sha1.h"
   3
   4 #include <lua.h>
   5 #include <lauxlib.h>
   6 #include <lualib.h>
   7
   8 char *redisProtocolToLuaType_Int(lua_State *lua, char *reply);
   9 char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply);
  10 char *redisProtocolToLuaType_Status(lua_State *lua, char *reply);
  11 char *redisProtocolToLuaType_Error(lua_State *lua, char *reply);
  12 char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply);
  13
  14 /* Take a Redis reply in the Redis protocol format and convert it into a
  15  * Lua type. Thanks to this function, and the introduction of not connected
  16  * clients, it is trvial to implement the redis() lua function.
  17  *
  18  * Basically we take the arguments, execute the Redis command in the context
  19  * of a non connected client, then take the generated reply and convert it
  20  * into a suitable Lua type. With this trick the scripting feature does not
  21  * need the introduction of a full Redis internals API. Basically the script
  22  * is like a normal client that bypasses all the slow I/O paths.
  23  *
  24  * Note: in this function we do not do any sanity check as the reply is
  25  * generated by Redis directly. This allows use to go faster.
  26  * The reply string can be altered during the parsing as it is discared
  27  * after the conversion is completed.
  28  *
  29  * Errors are returned as a table with a single 'err' field set to the
  30  * error string.
  31  */
  32
  33 char *redisProtocolToLuaType(lua_State *lua, char* reply) {
  34     char *p = reply;
  35
  36     switch(*p) {
  37     case ':':
  38         p = redisProtocolToLuaType_Int(lua,reply);
  39         break;
  40     case '$':
  41         p = redisProtocolToLuaType_Bulk(lua,reply);
  42         break;
  43     case '+':
  44         p = redisProtocolToLuaType_Status(lua,reply);
  45         break;
  46     case '-':
  47         p = redisProtocolToLuaType_Error(lua,reply);
  48         break;
  49     case '*':
  50         p = redisProtocolToLuaType_MultiBulk(lua,reply);
  51         break;
  52     }
  53     return p;
  54 }
  55
  56 char *redisProtocolToLuaType_Int(lua_State *lua, char *reply) {
  57     char *p = strchr(reply+1,'\r');
  58     long long value;
  59
  60     string2ll(reply+1,p-reply-1,&value);
  61     lua_pushnumber(lua,(lua_Number)value);
  62     return p+2;
  63 }
  64
  65 char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply) {
  66     char *p = strchr(reply+1,'\r');
  67     long long bulklen;
  68
  69     string2ll(reply+1,p-reply-1,&bulklen);
  70     if (bulklen == 0) {
  71         lua_pushnil(lua);
  72         return p+2;
  73     } else {
  74         lua_pushlstring(lua,p+2,bulklen);
  75         return p+2+bulklen+2;
  76     }
  77 }
  78
  79 char *redisProtocolToLuaType_Status(lua_State *lua, char *reply) {
  80     char *p = strchr(reply+1,'\r');
  81
  82     lua_pushlstring(lua,reply+1,p-reply-1);
  83     return p+2;
  84 }
  85
  86 char *redisProtocolToLuaType_Error(lua_State *lua, char *reply) {
  87     char *p = strchr(reply+1,'\r');
  88
  89     lua_newtable(lua);
  90     lua_pushstring(lua,"err");
  91     lua_pushlstring(lua,reply+1,p-reply-1);
  92     lua_settable(lua,-3);
  93     return p+2;
  94 }
  95
  96 char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply) {
  97     char *p = strchr(reply+1,'\r');
  98     long long mbulklen;
  99     int j = 0;
 100
 101     printf("--%s-- (%d)\n", reply,(int)(p-reply-1));
 102     string2ll(reply+1,p-reply-1,&mbulklen);
 103     p += 2;
 104     if (mbulklen == -1) {
 105         lua_pushnil(lua);
 106         return p;
 107     }
 108     printf("BL: %lld\n", mbulklen);
 109     lua_newtable(lua);
 110     for (j = 0; j < mbulklen; j++) {
 111         lua_pushnumber(lua,j);
 112         p = redisProtocolToLuaType(lua,p);
 113         lua_settable(lua,-3);
 114     }
 115     return p;
 116 }
 117
 118 int luaRedisCommand(lua_State *lua) {
 119     int j, argc = lua_gettop(lua);
 120     struct redisCommand *cmd;
 121     robj **argv;
 122     redisClient *c = server.lua_client;
 123     sds reply;
 124
 125     /* Build the arguments vector */
 126     argv = zmalloc(sizeof(robj*)*argc);
 127     for (j = 0; j < argc; j++)
 128         argv[j] = createStringObject((char*)lua_tostring(lua,j+1),
 129                                      lua_strlen(lua,j+1));
 130
 131     /* Command lookup */
 132     cmd = lookupCommand(argv[0]->ptr);
 133     if (!cmd || ((cmd->arity > 0 && cmd->arity != argc) ||
 134                    (argc < -cmd->arity)))
 135     {
 136         for (j = 0; j < argc; j++) decrRefCount(argv[j]);
 137         zfree(argv);
 138         lua_newtable(lua);
 139         lua_pushstring(lua,"err");
 140         if (cmd)
 141             lua_pushstring(lua,
 142                 "Wrong number of args calling Redis command From Lua script");
 143         else
 144             lua_pushstring(lua,"Unknown Redis command called from Lua script");
 145         lua_settable(lua,-3);
 146         return 1;
 147     }
 148
 149     /* Run the command in the context of a fake client */
 150     c->argv = argv;
 151     c->argc = argc;
 152     cmd->proc(c);
 153
 154     /* Convert the result of the Redis command into a suitable Lua type.
 155      * The first thing we need is to create a single string from the client
 156      * output buffers. */
 157     reply = sdsempty();
 158     if (c->bufpos) {
 159         reply = sdscatlen(reply,c->buf,c->bufpos);
 160         c->bufpos = 0;
 161     }
 162     while(listLength(c->reply)) {
 163         robj *o = listNodeValue(listFirst(c->reply));
 164
 165         sdscatlen(reply,o->ptr,sdslen(o->ptr));
 166         listDelNode(c->reply,listFirst(c->reply));
 167     }
 168     redisProtocolToLuaType(lua,reply);
 169     sdsfree(reply);
 170
 171     /* Clean up. Command code may have changed argv/argc so we use the
 172      * argv/argc of the client instead of the local variables. */
 173     for (j = 0; j < c->argc; j++)
 174         decrRefCount(c->argv[j]);
 175     zfree(c->argv);
 176
 177     return 1;
 178 }
 179
 180 void scriptingInit(void) {
 181     lua_State *lua = lua_open();
 182     luaL_openlibs(lua);
 183
 184     /* Register the 'r' command */
 185     lua_pushcfunction(lua,luaRedisCommand);
 186     lua_setglobal(lua,"redis");
 187
 188     /* Create the (non connected) client that we use to execute Redis commands
 189      * inside the Lua interpreter */
 190     server.lua_client = createClient(-1);
 191     server.lua_client->flags |= REDIS_LUA_CLIENT;
 192
 193     server.lua = lua;
 194 }
 195
 196 /* Hash the scripit into a SHA1 digest. We use this as Lua function name.
 197  * Digest should point to a 41 bytes buffer: 40 for SHA1 converted into an
 198  * hexadecimal number, plus 1 byte for null term. */
 199 void hashScript(char *digest, char *script, size_t len) {
 200     SHA1_CTX ctx;
 201     unsigned char hash[20];
 202     char *cset = "0123456789abcdef";
 203     int j;
 204
 205     SHA1Init(&ctx);
 206     SHA1Update(&ctx,(unsigned char*)script,len);
 207     SHA1Final(hash,&ctx);
 208
 209     for (j = 0; j < 20; j++) {
 210         digest[j*2] = cset[((hash[j]&0xF0)>>4)];
 211         digest[j*2+1] = cset[(hash[j]&0xF)];
 212     }
 213     digest[40] = '\0';
 214 }
 215
 216 void luaReplyToRedisReply(redisClient *c, lua_State *lua) {
 217     int t = lua_type(lua,1);
 218
 219     switch(t) {
 220     case LUA_TSTRING:
 221         addReplyBulkCBuffer(c,(char*)lua_tostring(lua,1),lua_strlen(lua,1));
 222         break;
 223     case LUA_TBOOLEAN:
 224         addReply(c,lua_toboolean(lua,1) ? shared.cone : shared.czero);
 225         break;
 226     case LUA_TNUMBER:
 227         addReplyLongLong(c,(long long)lua_tonumber(lua,1));
 228         break;
 229     case LUA_TTABLE:
 230         /* We need to check if it is an array or an error.
 231          * Error are returned as a single element table with 'err' field. */
 232         lua_pushstring(lua,"err");
 233         lua_gettable(lua,-2);
 234         t = lua_type(lua,-1);
 235         if (t == LUA_TSTRING) {
 236             addReplySds(c,sdscatprintf(sdsempty(),
 237                     "-%s\r\n",(char*)lua_tostring(lua,-1)));
 238             lua_pop(lua,1);
 239         } else {
 240             void *replylen = addDeferredMultiBulkLength(c);
 241             int j = 1, mbulklen = 0;
 242
 243             lua_pop(lua,1); /* Discard the 'err' field value we popped */
 244             while(1) {
 245                 lua_pushnumber(lua,j++);
 246                 lua_gettable(lua,-2);
 247                 t = lua_type(lua,-1);
 248                 if (t == LUA_TNIL) {
 249                     lua_pop(lua,1);
 250                     break;
 251                 } else if (t == LUA_TSTRING) {
 252                     size_t len;
 253                     char *s = (char*) lua_tolstring(lua,-1,&len);
 254
 255                     addReplyBulkCBuffer(c,s,len);
 256                     mbulklen++;
 257                 } else if (t == LUA_TNUMBER) {
 258                     addReplyLongLong(c,(long long)lua_tonumber(lua,-1));
 259                     mbulklen++;
 260                 }
 261                 lua_pop(lua,1);
 262             }
 263             setDeferredMultiBulkLength(c,replylen,mbulklen);
 264         }
 265         break;
 266     default:
 267         addReply(c,shared.nullbulk);
 268     }
 269     lua_pop(lua,1);
 270 }
 271
 272 /* Set an array of Redis String Objects as a Lua array (table) stored into a
 273  * global variable. */
 274 void luaSetGlobalArray(lua_State *lua, char *var, robj **elev, int elec) {
 275     int j;
 276
 277     lua_newtable(lua);
 278     for (j = 0; j < elec; j++) {
 279         lua_pushlstring(lua,(char*)elev[j]->ptr,sdslen(elev[j]->ptr));
 280         lua_rawseti(lua,-2,j+1);
 281     }
 282     lua_setglobal(lua,var);
 283 }
 284
 285 void evalCommand(redisClient *c) {
 286     lua_State *lua = server.lua;
 287     char funcname[43];
 288     long long numkeys;
 289
 290     /* Get the number of arguments that are keys */
 291     if (getLongLongFromObjectOrReply(c,c->argv[2],&numkeys,NULL) != REDIS_OK)
 292         return;
 293     if (numkeys > (c->argc - 3)) {
 294         addReplyError(c,"Number of keys can't be greater than number of args");
 295         return;
 296     }
 297
 298     /* We obtain the script SHA1, then check if this function is already
 299      * defined into the Lua state */
 300     funcname[0] = 'f';
 301     funcname[1] = '_';
 302     hashScript(funcname+2,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
 303     lua_getglobal(lua, funcname);
 304     if (lua_isnil(lua,1)) {
 305         /* Function not defined... let's define it. */
 306         sds funcdef = sdsempty();
 307
 308         lua_pop(lua,1); /* remove the nil from the stack */
 309         funcdef = sdscat(funcdef,"function ");
 310         funcdef = sdscatlen(funcdef,funcname,42);
 311         funcdef = sdscatlen(funcdef," ()\n",4);
 312         funcdef = sdscatlen(funcdef,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));
 313         funcdef = sdscatlen(funcdef,"\nend\n",5);
 314         printf("Defining:\n%s\n",funcdef);
 315
 316         if (luaL_loadbuffer(lua,funcdef,sdslen(funcdef),"func definition")) {
 317             addReplyErrorFormat(c,"Error compiling script (new function): %s\n",
 318                 lua_tostring(lua,-1));
 319             lua_pop(lua,1);
 320             sdsfree(funcdef);
 321             return;
 322         }
 323         sdsfree(funcdef);
 324         if (lua_pcall(lua,0,0,0)) {
 325             addReplyErrorFormat(c,"Error running script (new function): %s\n",
 326                 lua_tostring(lua,-1));
 327             lua_pop(lua,1);
 328             return;
 329         }
 330         lua_getglobal(lua, funcname);
 331     }
 332
 333     /* Populate the argv and keys table accordingly to the arguments that
 334      * EVAL received. */
 335     luaSetGlobalArray(lua,"KEYS",c->argv+3,numkeys);
 336     luaSetGlobalArray(lua,"ARGV",c->argv+3+numkeys,c->argc-3-numkeys);
 337
 338     /* At this point whatever this script was never seen before or if it was
 339      * already defined, we can call it. We have zero arguments and expect
 340      * a single return value. */
 341     if (lua_pcall(lua,0,1,0)) {
 342         addReplyErrorFormat(c,"Error running script (call to %s): %s\n",
 343             funcname, lua_tostring(lua,-1));
 344         lua_pop(lua,1);
 345         return;
 346     }
 347     luaReplyToRedisReply(c,lua);
 348 }