#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
return 1;
}
+ /* 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)))
{
- for (j = 0; j < argc; j++) decrRefCount(argv[j]);
- zfree(argv);
if (cmd)
luaPushError(lua,
"Wrong number of args calling Redis command From Lua script");
else
luaPushError(lua,"Unknown Redis command called from Lua script");
- return 1;
+ goto cleanup;
}
- /* Run the command in the context of a fake client */
- c->argv = argv;
- c->argc = argc;
+ 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.
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++)
}
}
+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
/* 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);
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;
{
int retval = dictAdd(server.lua_scripts,
sdsnewlen(funcname+2,40),c->argv[1]);
- redisAssert(retval == DICT_OK);
+ redisAssertWithInfo(c,NULL,retval == DICT_OK);
incrRefCount(c->argv[1]);
}
}
if (evalsha) {
robj *script = dictFetchValue(server.lua_scripts,c->argv[1]->ptr);
- redisAssert(script != NULL);
+ redisAssertWithInfo(c,NULL,script != NULL);
rewriteClientCommandArgument(c,0,
resetRefCount(createStringObject("EVAL",4)));
rewriteClientCommandArgument(c,1,script);
}
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