#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);

void sha1hex(char *digest, char *script, size_t len);

char *redisProtocolToLuaType(lua_State *lua, char* reply) {

char *p = reply;

switch(*p) {

case ':':

p = redisProtocolToLuaType_Int(lua,reply);

break;

case '$':

p = redisProtocolToLuaType_Bulk(lua,reply);

break;

case '+':

p = redisProtocolToLuaType_Status(lua,reply);

break;

case '-':

p = redisProtocolToLuaType_Error(lua,reply);

break;

case '*':

p = redisProtocolToLuaType_MultiBulk(lua,reply);

break;

}

return p;

}

char *redisProtocolToLuaType_Int(lua_State *lua, char *reply) {

char *p = strchr(reply+1,'\r');

long long value;

string2ll(reply+1,p-reply-1,&value);

lua_pushnumber(lua,(lua_Number)value);

return p+2;

}

char *redisProtocolToLuaType_Bulk(lua_State *lua, char *reply) {

char *p = strchr(reply+1,'\r');

long long bulklen;

string2ll(reply+1,p-reply-1,&bulklen);

if (bulklen == -1) {

lua_pushboolean(lua,0);

return p+2;

} else {

lua_pushlstring(lua,p+2,bulklen);

return p+2+bulklen+2;

}

}

char *redisProtocolToLuaType_Status(lua_State *lua, char *reply) {

char *p = strchr(reply+1,'\r');

lua_newtable(lua);

lua_pushstring(lua,"ok");

lua_pushlstring(lua,reply+1,p-reply-1);

lua_settable(lua,-3);

return p+2;

}

char *redisProtocolToLuaType_Error(lua_State *lua, char *reply) {

char *p = strchr(reply+1,'\r');

lua_newtable(lua);

lua_pushstring(lua,"err");

lua_pushlstring(lua,reply+1,p-reply-1);

lua_settable(lua,-3);

return p+2;

}

char *redisProtocolToLuaType_MultiBulk(lua_State *lua, char *reply) {

char *p = strchr(reply+1,'\r');

long long mbulklen;

int j = 0;

string2ll(reply+1,p-reply-1,&mbulklen);

p += 2;

if (mbulklen == -1) {

lua_pushboolean(lua,0);

return p;

}

lua_newtable(lua);

for (j = 0; j < mbulklen; j++) {

lua_pushnumber(lua,j+1);

p = redisProtocolToLuaType(lua,p);

lua_settable(lua,-3);

}

return p;

}

void luaPushError(lua_State *lua, char *error) {

lua_newtable(lua);

lua_pushstring(lua,"err");

lua_pushstring(lua, error);

lua_settable(lua,-3);

}

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

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");

/* 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) */

}

int luaRedisGenericCommand(lua_State *lua, int raise_error) {

int j, argc = lua_gettop(lua);

struct redisCommand *cmd;

robj **argv;

// 指向伪客户端

redisClient *c = server.lua_client;

sds reply;

/* Require at least one argument */

// 参数检查

if (argc == 0) {

luaPushError(lua,

"Please specify at least one argument for redis.call()");

return 1;

}

/* Build the arguments vector */

// 构建参数数组

argv = zmalloc(sizeof(robj*)*argc);

for (j = 0; j < argc; j++) {

if (!lua_isstring(lua,j+1)) break;

argv[j] = createStringObject((char*)lua_tostring(lua,j+1),

lua_strlen(lua,j+1));

}

/* Check if one of the arguments passed by the Lua script

// 参数只能是字符串或者整数

if (j != argc) {

j--;

while (j >= 0) {

decrRefCount(argv[j]);

j--;

}

zfree(argv);

luaPushError(lua,

"Lua redis() command arguments must be strings or integers");

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)))

{

if (cmd)

luaPushError(lua,

"Wrong number of args calling Redis command From Lua script");

else

luaPushError(lua,"Unknown Redis command called from Lua script");

goto cleanup;

}

/* There are commands that are not allowed inside scripts. */

// 只能执行被允许在 Lua 脚本中执行的函数

if (cmd->flags & REDIS_CMD_NOSCRIPT) {

luaPushError(lua, "This Redis command is not allowed from scripts");

goto cleanup;

}

/* Write commands are forbidden against read-only slaves, or if a

if (cmd->flags & REDIS_CMD_WRITE) {

if (server.lua_random_dirty) {

// 不能在执行过随机命令之后执行写命令

luaPushError(lua,

"Write commands not allowed after non deterministic commands");

goto cleanup;

} else if (server.masterhost && server.repl_slave_ro &&

!(server.lua_caller->flags & REDIS_MASTER))

{

// 不能在附属节点执行

luaPushError(lua, shared.roslaveerr->ptr);

goto cleanup;

} else if (server.stop_writes_on_bgsave_err &&

server.saveparamslen > 0 &&

server.lastbgsave_status == REDIS_ERR)

{

// 不能在 Redis 已出错的环境下执行

luaPushError(lua, shared.bgsaveerr->ptr);

goto cleanup;

}

}

/* If we reached the memory limit configured via maxmemory, commands that

// 如果是第一次执行写操作，并且遭遇内存超过，那么退出

if (server.maxmemory && server.lua_write_dirty == 0 &&

(cmd->flags & REDIS_CMD_DENYOOM))

{

if (freeMemoryIfNeeded() == REDIS_ERR) {

luaPushError(lua, shared.oomerr->ptr);

goto cleanup;

}

}

// 如果是随机操作，设置 lua_random_dirty 状态

if (cmd->flags & REDIS_CMD_RANDOM) server.lua_random_dirty = 1;

// 如果是写操作，设置 lua_write_dirty 状态

if (cmd->flags & REDIS_CMD_WRITE) server.lua_write_dirty = 1;

/* Run the command */

// 执行命令

c->cmd = cmd;

call(c,REDIS_CALL_SLOWLOG | REDIS_CALL_STATS);

/* Convert the result of the Redis command into a suitable Lua type.

// 取出回复

reply = sdsempty();

if (c->bufpos) {

reply = sdscatlen(reply,c->buf,c->bufpos);

c->bufpos = 0;

}

while(listLength(c->reply)) {

robj *o = listNodeValue(listFirst(c->reply));

reply = sdscatlen(reply,o->ptr,sdslen(o->ptr));

listDelNode(c->reply,listFirst(c->reply));

}

if (raise_error && reply[0] != '-') raise_error = 0;

// 将回复转换为 Lua 值，并返回给 Lua 环境

redisProtocolToLuaType(lua,reply);

/* Sort the output array if needed, assuming it is a non-null multi bulk

// 看是否需要执行排序

if ((cmd->flags & REDIS_CMD_SORT_FOR_SCRIPT) &&

(reply[0] == '*' && reply[1] != '-')) {

luaSortArray(lua);

}

sdsfree(reply);

c->reply_bytes = 0;

cleanup:

/* Clean up. Command code may have changed argv/argc so we use the

for (j = 0; j < c->argc; j++)

decrRefCount(c->argv[j]);

zfree(c->argv);

if (raise_error) {

/* If we are here we should have an error in the stack, in the

lua_pushstring(lua,"err");

lua_gettable(lua,-2);

return lua_error(lua);

}

return 1;

}

int luaRedisCallCommand(lua_State *lua) {

return luaRedisGenericCommand(lua,1);

}

int luaRedisPCallCommand(lua_State *lua) {

return luaRedisGenericCommand(lua,0);

}

int luaRedisSha1hexCommand(lua_State *lua) {

int argc = lua_gettop(lua);

char digest[41];

size_t len;

char *s;

if (argc != 1) {

luaPushError(lua, "wrong number of arguments");

return 1;

}

s = (char*)lua_tolstring(lua,1,&len);

sha1hex(digest,s,len);

lua_pushstring(lua,digest);

return 1;

}

int luaRedisReturnSingleFieldTable(lua_State *lua, char *field) {

if (lua_gettop(lua) != 1 || lua_type(lua,-1) != LUA_TSTRING) {

luaPushError(lua, "wrong number or type of arguments");

return 1;

}

lua_newtable(lua);

lua_pushstring(lua, field);

lua_pushvalue(lua, -3);

lua_settable(lua, -3);

return 1;

}

int luaRedisErrorReplyCommand(lua_State *lua) {

return luaRedisReturnSingleFieldTable(lua,"err");

}

int luaRedisStatusReplyCommand(lua_State *lua) {

return luaRedisReturnSingleFieldTable(lua,"ok");

}

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);

REDIS_NOTUSED(lua);

// 计算已执行时间

elapsed = (ustime()/1000) - server.lua_time_start;

if (elapsed >= server.lua_time_limit && server.lua_timedout == 0) {

redisLog(REDIS_WARNING,"Lua slow script detected: still in execution after %lld milliseconds. You can try killing the script using the SCRIPT KILL command.",elapsed);

// 已超时

server.lua_timedout = 1;

/* Once the script timeouts we reenter the event loop to permit others

// 当脚本运行超时时，将正在执行的客户端从读事件中移除

// 并允许其他客户端执行 SCRIPT KILL 或者 SHUTDOWN NOSAVE

aeDeleteFileEvent(server.el, server.lua_caller->fd, AE_READABLE);

}

if (server.lua_timedout)

// 在脚本上下文中，启动文件事件处理（等待 SCRIPT KILL 或 SHUTDOWN NOSAVE）

aeProcessEvents(server.el, AE_FILE_EVENTS|AE_DONT_WAIT);

if (server.lua_kill) {

// 杀死脚本

redisLog(REDIS_WARNING,"Lua script killed by user with SCRIPT KILL.");

lua_pushstring(lua,"Script killed by user with SCRIPT KILL...");

lua_error(lua);

}

}

void luaLoadLib(lua_State *lua, const char *libname, lua_CFunction luafunc) {

lua_pushcfunction(lua, luafunc);

lua_pushstring(lua, libname);

lua_call(lua, 1, 0);

}

LUALIB_API int (luaopen_cjson) (lua_State *L);

LUALIB_API int (luaopen_struct) (lua_State *L);

LUALIB_API int (luaopen_cmsgpack) (lua_State *L);

void luaLoadLibraries(lua_State *lua) {

// 基础库

luaLoadLib(lua, "", luaopen_base);

// table 库

luaLoadLib(lua, LUA_TABLIBNAME, luaopen_table);

// 字符串库

luaLoadLib(lua, LUA_STRLIBNAME, luaopen_string);

// 数学库

luaLoadLib(lua, LUA_MATHLIBNAME, luaopen_math);

// debug 库

luaLoadLib(lua, LUA_DBLIBNAME, luaopen_debug);

// cjson 库

luaLoadLib(lua, "cjson", luaopen_cjson);

// struct 库

luaLoadLib(lua, "struct", luaopen_struct);

// cmsgpack 库

luaLoadLib(lua, "cmsgpack", luaopen_cmsgpack);

#if 0 /* Stuff that we don't load currently, for sandboxing concerns. */

luaLoadLib(lua, LUA_LOADLIBNAME, luaopen_package);

luaLoadLib(lua, LUA_OSLIBNAME, luaopen_os);

}

void luaRemoveUnsupportedFunctions(lua_State *lua) {

// 屏蔽 loadfile

lua_pushnil(lua);

lua_setglobal(lua,"loadfile");

}

void scriptingEnableGlobalsProtection(lua_State *lua) {

char *s[32];

sds code = sdsempty();

int j = 0;

/* strict.lua from: http://metalua.luaforge.net/src/lib/strict.lua.html.

s[j++]="local mt = {}\n";

s[j++]="setmetatable(_G, mt)\n";

s[j++]="mt.__newindex = function (t, n, v)\n";

s[j++]=" if debug.getinfo(2) then\n";

s[j++]=" local w = debug.getinfo(2, \"S\").what\n";

s[j++]=" if w ~= \"main\" and w ~= \"C\" then\n";

s[j++]=" error(\"Script attempted to create global variable '\"..tostring(n)..\"'\", 2)\n";

s[j++]=" end\n";

s[j++]=" end\n";

s[j++]=" rawset(t, n, v)\n";

s[j++]="end\n";

s[j++]="mt.__index = function (t, n)\n";

s[j++]=" if debug.getinfo(2) and debug.getinfo(2, \"S\").what ~= \"C\" then\n";

s[j++]=" error(\"Script attempted to access unexisting global variable '\"..tostring(n)..\"'\", 2)\n";

s[j++]=" end\n";

s[j++]=" return rawget(t, n)\n";

s[j++]="end\n";

s[j++]=NULL;

for (j = 0; s[j] != NULL; j++) code = sdscatlen(code,s[j],strlen(s[j]));

luaL_loadbuffer(lua,code,sdslen(code),"@enable_strict_lua");

lua_pcall(lua,0,0,0);

sdsfree(code);

}

void scriptingInit(void) {

// 创建一个新的 lua 环境

lua_State *lua = lua_open();

// 载入内置函数库

luaLoadLibraries(lua);

// 屏蔽所有不想暴露给脚本环境的函数（目前只有 loadfile）

luaRemoveUnsupportedFunctions(lua);

/* Initialize a dictionary we use to map SHAs to scripts.

server.lua_scripts = dictCreate(&shaScriptObjectDictType,NULL);

/* Register the redis commands table and fields */

// 创建 table ，并以给定名称将 C 函数注册到表格上

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 和 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. */

// 将 table 设置为 redis 全局变量

lua_setglobal(lua,"redis");

/* Replace math.random and math.randomseed with our implementations. */

// 将 math.random 和 math.randomseed 设置为 Redis 实现

// 用于生成确定性的随机数

// （对于同一个 seed ，生成的随机序列总是相同）

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 funciton that we use to sort the multi bulk output of non

{

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);

}

/* Create the (non connected) client that we use to execute Redis commands

if (server.lua_client == NULL) {

server.lua_client = createClient(-1);

server.lua_client->flags |= REDIS_LUA_CLIENT;

}

/* Lua beginners ofter don't use "local", this is likely to introduce

scriptingEnableGlobalsProtection(lua);

// 将 lua 环境赋值到服务器变量

server.lua = lua;

}

void scriptingRelease(void) {

// 释放记录脚本的字典

dictRelease(server.lua_scripts);

// 关闭 Lua 环境

lua_close(server.lua);

}

void scriptingReset(void) {

// 释放环境

scriptingRelease();

// 新键环境

scriptingInit();

}

void sha1hex(char *digest, char *script, size_t len) {

SHA1_CTX ctx;

unsigned char hash[20];

char *cset = "0123456789abcdef";

int j;

SHA1Init(&ctx);

SHA1Update(&ctx,(unsigned char*)script,len);

SHA1Final(hash,&ctx);

for (j = 0; j < 20; j++) {

digest[j*2] = cset[((hash[j]&0xF0)>>4)];

digest[j*2+1] = cset[(hash[j]&0xF)];

}

digest[40] = '\0';

}

void luaReplyToRedisReply(redisClient *c, lua_State *lua) {

int t = lua_type(lua,-1);

switch(t) {

case LUA_TSTRING:

addReplyBulkCBuffer(c,(char*)lua_tostring(lua,-1),lua_strlen(lua,-1));

break;

case LUA_TBOOLEAN:

addReply(c,lua_toboolean(lua,-1) ? shared.cone : shared.nullbulk);

break;

case LUA_TNUMBER:

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.

lua_pushstring(lua,"err");

lua_gettable(lua,-2);

t = lua_type(lua,-1);

if (t == LUA_TSTRING) {

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,1);

lua_pushstring(lua,"ok");

lua_gettable(lua,-2);

t = lua_type(lua,-1);

if (t == LUA_TSTRING) {

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);

int j = 1, mbulklen = 0;

lua_pop(lua,1); /* Discard the 'ok' field value we popped */

while(1) {

lua_pushnumber(lua,j++);

lua_gettable(lua,-2);

t = lua_type(lua,-1);

if (t == LUA_TNIL) {

lua_pop(lua,1);

break;

}

luaReplyToRedisReply(c, lua);

mbulklen++;

}

setDeferredMultiBulkLength(c,replylen,mbulklen);

}

break;

default:

addReply(c,shared.nullbulk);

}

lua_pop(lua,1);

}

void luaSetGlobalArray(lua_State *lua, char *var, robj **elev, int elec) {

int j;

lua_newtable(lua);

for (j = 0; j < elec; j++) {

lua_pushlstring(lua,(char*)elev[j]->ptr,sdslen(elev[j]->ptr));

lua_rawseti(lua,-2,j+1);

}

lua_setglobal(lua,var);

}

int luaCreateFunction(redisClient *c, lua_State *lua, char *funcname, robj *body) {

sds funcdef = sdsempty();

// 函数定义

funcdef = sdscat(funcdef,"function ");

funcdef = sdscatlen(funcdef,funcname,42);

funcdef = sdscatlen(funcdef,"() ",3);

funcdef = sdscatlen(funcdef,body->ptr,sdslen(body->ptr));

funcdef = sdscatlen(funcdef," end",4);

// 将函数定义载入到 Lua 中（并编译），但不执行该定义

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)) {

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

{

int retval = dictAdd(server.lua_scripts,

// SHA1 值，不包括前缀 f_

sdsnewlen(funcname+2,40),

// 代码体

body);

redisAssertWithInfo(c,NULL,retval == DICT_OK);

incrRefCount(body);

}

return REDIS_OK;

}

void evalGenericCommand(redisClient *c, int evalsha) {

lua_State *lua = server.lua;

char funcname[43];

long long numkeys;

int delhook = 0;

/* We want the same PRNG sequence at every call so that our PRNG is

redisSrand48(0);

/* We set this flag to zero to remember that so far no random command

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;

}

/* We obtain the script SHA1, then check if this function is already

// 组合出函数的名字，例如 f_282297a0228f48cd3fc6a55de6316f31422f5d17

funcname[0] = 'f';

funcname[1] = '_';

if (!evalsha) {

/* Hash the code if this is an EVAL call */

// 如果执行的是 EVAL 命令，那么计算脚本的 SHA1 校验和

sha1hex(funcname+2,c->argv[1]->ptr,sdslen(c->argv[1]->ptr));

} else {

// 如果执行的是 EVALSHA 命令，直接使用传入的 SHA1 值

/* 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';

}

/* 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

if (evalsha) {

// 如果执行的是 EVALSHA ，返回脚本未找到错误

addReply(c, shared.noscripterr);

return;

}

// 如果执行的是 EVAL ，那么创建并执行新函数，然后将代码添加到脚本字典中

if (luaCreateFunction(c,lua,funcname,c->argv[1]) == REDIS_ERR) return;

/* Now the following is guaranteed to return non nil */

lua_getglobal(lua, funcname);

redisAssert(!lua_isnil(lua,1));

}

/* Populate the argv and keys table accordingly to the arguments that

// 设置 KEYS 和 ARGV 全局变量到 Lua 环境

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 */

// 为 Lua 所属的（伪）客户端设置数据库

selectDb(server.lua_client,c->db->id);

/* Set an hook in order to be able to stop the script execution if it