redis源码分析 - lua环境的创建与分析
2017-04-23 19:00
543 查看
redis中 lua 环境的创建和初始化
redis 中,lua 环境的初始化,是从redis.c/initServer()函数中,调用
scriptingInit()函数开始的。
关于
scriptingInit()的描述
/* Initialize the scripting environment. * It is possible to call this function to reset the scripting environment * assuming that we call scriptingRelease() before. * See scriptingReset() for more information. */
也就是说,这个函数是初始化lua环境的,当然,如果调用了
scriptingRelease()在调用该函数,可以重置 lua 脚本环境。我们进入到函数中看一下代码。
void scriptingInit(void) { lua_State *lua = lua_open(); luaLoadLibraries(lua); luaRemoveUnsupportedFunctions(lua); /* 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(&shaScriptObjectDictType,NULL); /* Register the redis commands table and fields */ lua_newtable(lua); /* redis.call */ lua_pushstring(lua,"call"); lua_pushcfunction(lua,luaRedisCallCommand); lua_settable(lua,-3); /* redis.pcall */ lua_pushstring(lua,"pcall"); lua_pushcfunction(lua,luaRedisPCallCommand); 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); /* redis.sha1hex */ lua_pushstring(lua, "sha1hex"); lua_pushcfunction(lua, luaRedisSha1hexCommand); lua_settable(lua, -3); /* redis.error_reply and redis.status_reply */ lua_pushstring(lua, "error_reply"); lua_pushcfunction(lua, luaRedisErrorReplyCommand); lua_settable(lua, -3); lua_pushstring(lua, "status_reply"); lua_pushcfunction(lua, luaRedisStatusReplyCommand); lua_settable(lua, -3); /* 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"); /* Add a helper function that we use to sort the multi bulk output of non * deterministic commands, when containing 'false' elements. */ { char *compare_func = "function __redis__compare_helper(a,b)\n" " if a == false then a = '' end\n" " if b == false then b = '' end\n" " return a<b\n" "end\n"; luaL_loadbuffer(lua,compare_func,strlen(compare_func),"@cmp_func_def"); lua_pcall(lua,0,0,0); } /* Add a helper function we use for pcall error reporting. * Note that when the error is in the C function we want to report the * information about the caller, that's what makes sense from the point * of view of the user debugging a script. */ { char *errh_func = "local dbg = debug\n" "function __redis__err__handler(err)\n" " local i = dbg.getinfo(2,'nSl')\n" " if i and i.what == 'C' then\n" " i = dbg.getinfo(3,'nSl')\n" " end\n" " if i then\n" " return i.source .. ':' .. i.currentline .. ': ' .. err\n" " else\n" " return err\n" " end\n" "end\n"; luaL_loadbuffer(lua,errh_func,strlen(errh_func),"@err_handler_def"); lua_pcall(lua,0,0,0); } /* Create the (non connected) client that we use to execute Redis commands * inside the Lua interpreter. * Note: there is no need to create it again when this function is called * by scriptingReset(). */ if (server.lua_client == NULL) { server.lua_client = createClient(-1); server.lua_client->flags |= REDIS_LUA_CLIENT; } /* Lua beginners often don't use "local", this is likely to introduce * subtle bugs in their code. To prevent problems we protect accesses * to global variables. */ scriptingEnableGlobalsProtection(lua); server.lua = lua; }
1、 lua_open() 函数,创建一个lua环境
2、
luaLoadLibraries(lua),在新创建的lua环境中载入相应的库,同时删除库中不需要的函数,防止从外部引入不安全的代码
luaRemoveUnsupportedFunctions(lua),
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); luaLoadLib(lua, "cjson", luaopen_cjson); luaLoadLib(lua, "struct", luaopen_struct); luaLoadLib(lua, "cmsgpack", luaopen_cmsgpack); luaLoadLib(lua, "bit", luaopen_bit); #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 } /* Remove a functions that we don't want to expose to the Redis scripting * environment. */ void luaRemoveUnsupportedFunctions(lua_State *lua) { lua_pushnil(lua); //将空值入栈,此时栈顶元素为空值 lua_setglobal(lua,"loadfile"); //出栈,取出栈顶元素,即空值,并将其作为 loadfile 的值,也就相当于取消了 loadfile 这个函数的作用,置空了 }
3、
lua_newtable(lua)创建一张空表,并入栈
4、 将 c 中的luaRedisCallCommand 函数压入栈,作为表的函数;将 c 中的luaRedisPCallCommand 函数入栈,作为表的函数;将 c 中的luaLogCommand 函数入栈作为表的函数;将表复制为 redis,即创建 redis 全局 table。下面对其中一个注册函数进行解释
lua_newtable(lua); /* redis.call */ lua_pushstring(lua,"call"); lua_pushcfunction(lua,luaRedisCallCommand); lua_settable(lua,-3);
首先创建一个空表,入栈,此时栈顶元素为 table。然后将字符串 “call” 入栈,再将 c 函数 luaRedisCallCommand 函数入栈
lua_settable(lua, -3)
意思是 t[k]=v,t 为索引-3,栈中,-3 位元素 table,-1 为 luaRedisCallCommand,-2 为字符串call,v 表示栈顶元素,k表示栈顶元素的下一个元素,索引上面这个函数的意思就是
table["call"]=luaRedisCallCommand
就是将lua 中的call 函数注册为 c 中的 luaRedisCallCommand 函数,也可以记为
table.call=luaRedisCallCommand
后面代码意思都雷同,都是注册 c 函数到 lua 中。
注意:
lua_settable(lua_State *L, int index)会将栈顶两个元素弹出。
lua_setglobal(lua, "redis")
将表作为 redis的值,即创建的表为 redis 表,该表中包含以下函数:
redis.call 函数和 redis.pcall 函数,用于执行 redis 命令
redis.log 记录日志,日志级别对应为
redid.LOG_DEBUG,
redis.LOG_VERBOSE,
redis.LOG_NOTICE,
redis.LOG_WARNING
redis.sha1hex,计算 SHA1 校验和
redis.error_reply和
redis.status_reply函数,返回 redis 错误信息
5、 用 c 中自制的随机函数替换 Lua 中原有的随机函数
6、 创建排序辅助函数, Lua 环境使用这个辅助函数来对一部分 redis 命令的结果进行排序,从而消除这些命令的不确定性。
function __redis__compare_helper(a,b) if a == false then a = '' end if b == false then b = '' end return a<b end
7、 创建 redis.pcall 函数的错误报告辅助函数,这个函数可以提供更加详细发出错信息,比如能够在 c 函数的出错信息中提供调用者的信息
local dbg = debug; function __redis_err_handler(err) local i = dbg.getinfo (2, 'sS1') if i and i.what = 'C' then i = dgb.getinfo (3, 'nS1') end if i then return i.source .. ':' .. i.currentLine .. ':' .. err else return err end end
8、 对 lua 环境中的全局环境进行保护,防止用户在执行 lua 脚本的过程中,将额外的全局变量添加到 Lua 环境中
9、 将完成修改的 lua 环境保存到服务器状态的 lua 属性中。
创建排序辅助函数 __redis__compare_helper
在 redis 中产生不同输出的命令称为“带有不确定性的命令”,比如:SINTER
SUNION
SDIFF
SMEMBERS
HKEYS
HVALS
KEYS
比如对
SMEMBERS来说,在两个值相同,但是顺序不同的集合中,使用 SMEMBERS 得到的结果是不同的,输出的值的顺序不同。这样的输出就是不确定性,因为它本身不会排序。而 lua 中创建的这个辅助排序函数,可以用来消除这种不确定性。当 lua 执行完一个带有不确定性的命令时,程序会使用
__redis__compare_helper作为对比函数,自动调用 tables.sort 函数对命令进行一次排序,一次来保证相同的数据集总是产生相同的输出。
那,到底是什么一个代码流程呢,因为 redis.call 和 redis.pcall 在初始化的时候,已经使用 c 中的函数进行了注册,所以当调用 redis.call 或者 redis.pcall 的时候实际唤醒调用的是 c 函数 luaRedisCallCommand 或者 luaRedisPCallCommand
int luaRedisCallCommand(lua_State *lua) { return luaRedisGenericCommand(lua,1); } int luaRedisPCallCommand(lua_State *lua) { return luaRedisGenericCommand(lua,0); }
这两个函数,都是调用的
luaRedisGenericCommand函数,此时,在
luaGenericCommand函数中,在满足条件的情况下,调用
luaSortArray函数。
if ((cmd->flags & REDIS_CMD_SORT_FOR_SCRIPT) && (reply[0] == '*' && reply[1] != '-')) { luaSortArray(lua); }
满足上面条件的时候,才调用
luaSortArray这个函数,函数定义如下所示
/* Sort the array currently in the stack. We do this to make the output * of commands like KEYS or SMEMBERS something deterministic when called * from Lua (to play well with AOf/replication). * * The array is sorted using table.sort itself, and assuming all the * list elements are strings. */ void luaSortArray(lua_State *lua) { /* Initial Stack: array */ lua_getglobal(lua,"table"); lua_pushstring(lua,"sort"); lua_gettable(lua,-2); /* Stack: array, table, table.sort */ lua_pushvalue(lua,-3); /* Stack: array, table, table.sort, array */ if (lua_pcall(lua,1,0,0)) { /* Stack: array, table, error */ /* We are not interested in the error, we assume that the problem is * that there are 'false' elements inside the array, so we try * again with a slower function but able to handle this case, that * is: table.sort(table, __redis__compare_helper) */ lua_pop(lua,1); /* Stack: array, table */ lua_pushstring(lua,"sort"); /* Stack: array, table, sort */ lua_gettable(lua,-2); /* Stack: array, table, table.sort */ lua_pushvalue(lua,-3); /* Stack: array, table, table.sort, array */ lua_getglobal(lua,"__redis__compare_helper"); //table.sort(list [,compare]) /* Stack: array, table, table.sort, array, __redis__compare_helper */ lua_call(lua,2,0); } /* Stack: array (sorted), table */ lua_pop(lua,1); /* Stack: array (sorted) */ }
将 table.sort 中的 comp 参数作为
__redis_compare_helper辅助排序函数进行排序
lua 环境协作组件
lua 服务器创建了两个用于与 lua 环境进行写作的组件,分别是负责执行 lua 脚本的 redis 命令的伪客户端和保存 lua 脚本的lua_scripts字典。
typedef struct Server { ... /* Scripting */ lua_State *lua; /* The Lua interpreter. We use just one for all clients */ redisClient *lua_client; /* The "fake client" to query Redis from Lua */ redisClient *lua_caller; /* The client running EVAL right now, or NULL */ dict *lua_scripts; /* A dictionary of SHA1 -> Lua scripts */ mstime_t lua_time_limit; /* Script timeout in milliseconds */ mstime_t lua_time_start; /* Start time of script, milliseconds time */ int lua_write_dirty; /* True if a write command was called during the execution of the current script. */ int lua_random_dirty; /* True if a random command was called during the execution of the current script. */ int lua_timedout; /* True if we reached the time limit for script execution. */ int lua_kill; /* Kill the script if true. */ ... };
伪客户端
redis 命令执行必须有相应的客户端状态,redis服务器专门为 lua 环境创建了一个伪客户端,server 中的 lua_client 成员就是 lua 的伪客户端,当初始化 lua 环境时,对伪客户端初始化如下(scriptingInit()):/* Create the (non connected) client that we use to execute Redis commands * inside the Lua interpreter. * Note: there is no need to create it again when this function is called * by scriptingReset(). */ if (server.lua_client == NULL) { server.lua_client = createClient(-1); server.lua_client->flags |= REDIS_LUA_CLIENT; }
Lua 脚本使用 redis.call 或者 redis.pcall 执行 redis 命令的时候,步骤如下:
Lua 环境将 redis.call 或者 redis.pcall 想要执行的命令传给伪客户端
伪客户端将脚本想要执行的命令传给命令执行器 (call)
命令执行器执行命令后,将结果返回给伪客户端
伪客户端接收到结果并将结果返回给 lua 环境
lua 环境接收到结果之后,有将结果返回给 redis.call 或者 redis.pcall 函数
接收到结果的 redis.call 或者 redis.pcall 函数,将命令结果作为函数返回值返回给脚本中的调用者。
以上步骤摘自 《Redis 设计与实现》 黄健宏著,机械工业出版社,20.1.1节 伪客户端
使用客户端执行lua脚本
./redis-cli -h ${IP} -p ${PORT} -a ${PASSWORD} --eval <lua script>
lua_scripts 字典
另一个lua环境协作组件是lua_scripts字典。这个字典的值,是 lua 对应的脚本,键是 lua 脚本的 SHA1 校验和。这个可以在
scripting.c/luaCreateFunction()函数中查看
{ int retval = dictAdd(server.lua_scripts, sdsnewlen(funcname+2,40),body); //dict, key is sha1, value is script redisAssertWithInfo(c,NULL,retval == DICT_OK); incrRefCount(body); }
funcname 就是 lua 脚本的SHA1校验和,body 就是 lua 对应的脚本
EVAL 命令的实现
第一步:当客户端向服务器发送 EVAL 命令执行一段 lua 脚本的时候,服务器首先在 lua 环境中,为传入的脚本定义一个 lua 函数,函数名由 f_ 前缀加上脚本的 SHA1 校验和,而函数体即为脚本本身。
void evalGenericCommand(redisClient *c, int evalsha) { lua_State *lua = server.lua; char funcname[43]; long long numkeys; int delhook = 0, err; /* 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; server.lua_write_dirty = 0; /* Get the number of arguments that are keys */ if (getLongLongFromObjectOrReply(c,c->argv[2],&numkeys,NULL) != REDIS_OK) return; if (numkeys > (c->argc - 3)) { addReplyError(c,"Number of keys can't be greater than number of args"); return; } else if (numkeys < 0) { addReplyError(c,"Number of keys can't be negative"); return; } /* We obtain the script SHA1, then check if this function is already * defined into the Lua state */ funcname[0] = 'f'; funcname[1] = '_'; if (!evalsha) { /* Hash the code if this is an EVAL call */ sha1hex(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; /* Convert to lowercase. We don't use tolower since the function * managed to always show up in the profiler output consuming * a non trivial amount of time. */ for (j = 0; j < 40; j++) funcname[j+2] = (sha[j] >= 'A' && sha[j] <= 'Z') ? sha[j]+('a'-'A') : sha[j]; funcname[42] = '\0'; } /* Push the pcall error handler function on the stack. */ lua_getglobal(lua, "__redis__err__handler"); /* Try to lookup the Lua function */ lua_getglobal(lua, funcname); if (lua_isnil(lua,-1)) { lua_pop(lua,1); /* remove the nil from the stack */ /* Function not defined... let's define it if we have the * body of the function. If this is an EVALSHA call we can just * return an error. */ if (evalsha) { lua_pop(lua,1); /* remove the error handler from the stack. */ addReply(c, shared.noscripterr); return; } if (luaCreateFunction(c,lua,funcname,c->argv[1]) == REDIS_ERR) { lua_pop(lua,1); /* remove the error handler from the stack. */ /* The error is sent to the client by luaCreateFunction() * itself when it returns REDIS_ERR. */ return; } /* Now the following is guaranteed to return non nil */ lua_getglobal(lua, funcname); redisAssert(!lua_isnil(lua,-1)); } ... }
首先解析参数,可以查看 EVAL 命令的语法
EVAL script numkeys key [key ...] arg [arg ...]
在 lua 环境创建对应的 lua 函数,保存在变量 funcname 中,
funcname[0] = 'f'; funcname[1] = '_';
表示函数名以 f_ 作为前缀,使用 shahex1() 函数获取脚本的 SHA1 校验和,保存在 funcname 中,此时的 funcname 将作为 lua 环境中脚本对应的函数名。使用
luaCreateFunction函数在 lua 环境中创建该脚本的 lua 函数,同时将脚本即 lua 环境中对应的函数名加入到
lua_scripts字典中。
/* Define a lua function with the specified function name and body. * The function name musts be a 2 characters long string, since all the * functions we defined in the Lua context are in the form: * * f_<hex sha1 sum> * * On success REDIS_OK is returned, and nothing is left on the Lua stack. * On error REDIS_ERR is returned and an appropriate error is set in the * client context. */ int luaCreateFunction(redisClient *c, lua_State *lua, char *funcname, robj *body) { sds funcdef = sdsempty(); funcdef = sdscat(funcdef,"function "); //create lua function funcdef = sdscatlen(funcdef,funcname,42); funcdef = sdscatlen(funcdef,"() ",3); funcdef = sdscatlen(funcdef,body->ptr,sdslen(body->ptr)); funcdef = sdscatlen(funcdef,"\nend",4); if (luaL_loadbuffer(lua,funcdef,sdslen(funcdef),"@user_script")) { addReplyErrorFormat(c,"Error compiling script (new function): %s\n", lua_tostring(lua,-1)); lua_pop(lua,1); sdsfree(funcdef); return REDIS_ERR; } sdsfree(funcdef); if (lua_pcall(lua,0,0,0)) { //execute lua function addReplyErrorFormat(c,"Error running script (new function): %s\n", lua_tostring(lua,-1)); lua_pop(lua,1); return REDIS_ERR; } /* 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),body); //dict, key is sha1, value is script redisAssertWithInfo(c,NULL,retval == DICT_OK); incrRefCount(body); } return REDIS_OK; }
第二步:
执行脚本之前,服务器还需要做一些设置钩子和传入参数的准备工作
a、 将EVAL命令中传入的参数和脚本参数分为保存在 KEYS 和 ARGV 数组中,并作为全局变量保存在 lua 环境中
/* Populate the argv and keys table accordingly to the arguments that * EVAL received. */ luaSetGlobalArray(lua,"KEYS",c->argv+3,numkeys); // KEYS[1]=XX, KEYS[2]=XX luaSetGlobalArray(lua,"ARGV",c->argv+3+numkeys,c->argc-3-numkeys);
b、 为 lua 环境装载超时吃力钩子,当脚本运行时间超时时,客户端通过 SCRIPT KILL 命令可以停止脚本,也可以通过 SHUTDOWN 命令停止服务器。
c、 执行脚本
d、 移除钩子
e、 将执行脚本函数得到的结果保存到客户端状态的输出缓冲去,等待服务器将结果返回给客户端
if (err) { addReplyErrorFormat(c,"Error running script (call to %s): %s\n", funcname, lua_tostring(lua,-1)); lua_pop(lua,2); /* Consume the Lua reply and remove error handler. */ } else { /* On success convert the Lua return value into Redis protocol, and * send it to * the client. */ luaReplyToRedisReply(c,lua); /* Convert and consume the reply. */ lua_pop(lua,1); /* Remove the error handler. */ }
EVALSHA 命令
每一个被 EVAL 命令执行过的脚本,在 lua 环境中都会有一个与脚本对应的 lua 函数,函数的名字由 f_ 前缀和脚本的 SHA1 校验和组成。主要这个函数在 lua 环境中定义了,就会在lua_scripts中保存,那么使用 EVALSHA 命令,即使不知道脚本本身,也可以直接使用脚本的校验和来调用脚本对应的 lua 环境中的函数,这就是 EVALSHA 实现的原理
其他的脚本命令
这里主要讲下命令的作用SCRIPT FLUSH,用于清楚服务器中和 Lua 脚本有关的信息,这个命令会释放并重建
lua_scripts字典,关闭现有的 lua 环境并重新创建一个新的 lua 环境
SCRIPT EXISTS,根据输入的 SHA1 校验和,检查校验和对应的脚本是否存在于服务器中。(注意:该命令允许一次传入多个 SHA1 校验和)
SCRIPT LOAD,首先在 lua 环境中为脚本创建对应的 lua 函数,然后将脚本和 SHA1 校验和保存在
lua_scripts字典中
SCRIPT KILL,当服务器设置了参数
lua-time-limit时,每次在执行 lua 脚本之前,都会设置一个超时钩子,脚本运行时,一旦钩子发现脚本运行时间已经超时,钩子将定期检查是否有 SCRIPT KILL 或者 SHUTDOWN 命令到达。如果超时脚本未执行任何写操作,客户端可以通过 SCRIPT KILL 命令停止脚本,并向执行脚本的客户端返回一个错误信息。处理完之后,服务器将继续执行。如果脚本已经执行过写操作,那么客户端只能通过 SHUTDOWN 命令停止服务器,防止不合法的数据写入服务器中。
/* ---------------------------------------------------------------------------
* SCRIPT command for script environment introspection and control
* ------------------------------------------------------------------------- */
void scriptCommand(redisClient *c) {
if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"flush")) {
scriptingReset();
addReply(c,shared.ok);
replicationScriptCacheFlush();
server.dirty++; /* Propagating this command is a good idea. */
} else if (c->argc >= 2 && !strcasecmp(c->argv[1]->ptr,"exists")) {
int j;
addReplyMultiBulkLen(c, c->argc-2);
for (j = 2; j < c->argc; j++) {
if (dictFind(server.lua_scripts,c->argv[j]->ptr))
addReply(c,shared.cone);
else
addReply(c,shared.czero);
}
} else if (c->argc == 3 && !strcasecmp(c->argv[1]->ptr,"load")) {
char funcname[43];
sds sha;
funcname[0] = 'f'; funcname[1] = '_';sha1hex(funcname+2,c->argv[2]->ptr,sdslen(c->argv[2]->ptr));
sha = sdsnewlen(funcname+2,40);
if (dictFind(server.lua_scripts,sha) == NULL) {
if (luaCreateFunction(c,server.lua,funcname,c->argv[2])
== REDIS_ERR) {
sdsfree(sha);
return;
}
}
addReplyBulkCBuffer(c,funcname+2,40);
sdsfree(sha);
forceCommandPropagation(c,REDIS_PROPAGATE_REPL|REDIS_PROPAGATE_AOF);
} else if (c->argc == 2 && !strcasecmp(c->argv[1]->ptr,"kill")) {
if (server.lua_caller == NULL) {
addReplySds(c,sdsnew("-NOTBUSY No scripts in execution right now.\r\n"));
} else if (server.lua_write_dirty) {
addReplySds(c,sdsnew("-UNKILLABLE Sorry the script already executed write commands against the dataset. You can either wait the script termination or kill the server in a hard way using the SHUTDOWN NOSAVE command.\r\n"));
} else {
server.lua_kill = 1;
addReply(c,shared.ok);
}
} else {
addReplyError(c, "Unknown SCRIPT subcommand or wrong # of args.");
}
}
参考文献:
1. Redis 设计与实现,黄健宏著,机械工业出版社
2. redis 3.0.7 版本的源代码
3. lua manual 5.2
相关文章推荐
- redis客户端Jedis源码分析系列——连接池的创建过程
- Redis源码分析(二十八)--- object创建和释放redisObject对象
- Redis源码剖析和注释(二十)--- 网络连接库剖析(client的创建/释放、命令接收/回复、Redis通信协议分析等)
- Struts源码粗略分析一:准备开发环境
- lua源码分析2(局部函数的定义)
- 第二人生的源码分析(八十一)创建UI的显示板(Panel)
- 第二人生的源码分析(八十二)创建UI的浮动窗口(floater)
- 第二人生的源码分析(四十)创建多个工作线程
- 转载 linux 2.6线程创建源码分析
- Lua源码分析(1)
- lua源码分析(局部变量的定义)
- Lua 源码分析(一)
- GEF源码分析(三) 模拟GEF设计思路,解剖GEF2 附图:包含GEF的Editor创建时序图
- lua源码分析2(局部函数的定义)
- CCR源码分析-分析环境准备
- lua源码分析之性能分析1(赋值研究)
- 第二人生的源码分析(四十)创建多个工作线程
- Lua源码分析(3) -- 虚拟机
- 第二人生的源码分析(八十三)创建UI的菜单
- lua源码分析4(lua是怎么执行的)