gvsafronov/futriix
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

More rebranding (#606)

Browse Source 
More rebranding of

* Log messages (#252)
* The DENIED error reply
* Internal function names and comments, mainly Lua API

---------

Signed-off-by: Viktor Söderqvist <viktor.soderqvist@est.tech>
This commit is contained in:
Viktor Söderqvist 2024-06-06 16:40:55 -07:00 committed by GitHub
parent 278ce0cae0
commit ad5fd5b95c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
20 changed files with 219 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cluster_legacy.c
View File

@ -561,7 +561,7 @@ int clusterLoadConfig(char *filename) {
clusterAddNode(master);
}
/* shard_id can be absent if we are loading a nodes.conf generated
* by an older version of Redis; we should follow the primary's
* by an older version; we should follow the primary's
* shard_id in this case */
if (auxFieldHandlers[af_shard_id].isPresent(n) == 0) {
memcpy(n->shard_id, master->shard_id, CLUSTER_NAMELEN);

2
src/debug.c
View File

@ -925,7 +925,7 @@ void debugCommand(client *c) {
addReply(c, shared.ok);
} else if (!strcasecmp(c->argv[1]->ptr, "stringmatch-test") && c->argc == 2) {
stringmatchlen_fuzz_test();
addReplyStatus(c, "Apparently Redis did not crash: test passed");
addReplyStatus(c, "Apparently the server did not crash: test passed");
} else if (!strcasecmp(c->argv[1]->ptr, "set-disable-deny-scripts") && c->argc == 3) {
server.script_disable_deny_script = atoi(c->argv[2]->ptr);
addReply(c, shared.ok);

116
src/eval.c
View File

@ -99,7 +99,7 @@ struct ldbState {
int bp[LDB_BREAKPOINTS_MAX]; /* An array of breakpoints line numbers. */
int bpcount; /* Number of valid entries inside bp. */
int step; /* Stop at next line regardless of breakpoints. */
int luabp; /* Stop at next line because redis.breakpoint() was called. */
int luabp; /* Stop at next line because server.breakpoint() was called. */
sds *src; /* Lua script source code split by line. */
int lines; /* Number of lines in 'src'. */
int currentline; /* Current line number. */
@ -114,7 +114,7 @@ struct ldbState {
/* Perform the SHA1 of the input string. We use this both for hashing script
* bodies in order to obtain the Lua function name, and in the implementation
* of redis.sha1().
* of server.sha1().
*
* 'digest' should point to a 41 bytes buffer: 40 for SHA1 converted into an
* hexadecimal number, plus 1 byte for null term. */
@ -135,12 +135,12 @@ void sha1hex(char *digest, char *script, size_t len) {
digest[40] = '\0';
}
/* redis.breakpoint()
/* server.breakpoint()
*
* Allows to stop execution during a debugging session from within
* the Lua code implementation, like if a breakpoint was set in the code
* immediately after the function. */
int luaRedisBreakpointCommand(lua_State *lua) {
int luaServerBreakpointCommand(lua_State *lua) {
if (ldb.active) {
ldb.luabp = 1;
lua_pushboolean(lua, 1);
@ -150,12 +150,12 @@ int luaRedisBreakpointCommand(lua_State *lua) {
return 1;
}
/* redis.debug()
/* server.debug()
*
* Log a string message into the output console.
* Can take multiple arguments that will be separated by commas.
* Nothing is returned to the caller. */
int luaRedisDebugCommand(lua_State *lua) {
int luaServerDebugCommand(lua_State *lua) {
if (!ldb.active) return 0;
int argc = lua_gettop(lua);
sds log = sdscatprintf(sdsempty(), "<debug> line %d: ", ldb.currentline);
@ -167,14 +167,14 @@ int luaRedisDebugCommand(lua_State *lua) {
return 0;
}
/* redis.replicate_commands()
/* server.replicate_commands()
*
* DEPRECATED: Now do nothing and always return true.
* Turn on single commands replication if the script never called
* a write command so far, and returns true. Otherwise if the script
* already started to write, returns false and stick to whole scripts
* replication, which is our default. */
int luaRedisReplicateCommandsCommand(lua_State *lua) {
int luaServerReplicateCommandsCommand(lua_State *lua) {
lua_pushboolean(lua, 1);
return 1;
}
@ -205,27 +205,27 @@ void scriptingInit(int setup) {
lctx.lua_scripts_lru_list = listCreate();
lctx.lua_scripts_mem = 0;
luaRegisterRedisAPI(lua);
luaRegisterServerAPI(lua);
/* register debug commands */
lua_getglobal(lua, "redis");
lua_getglobal(lua, "server");
/* redis.breakpoint */
/* server.breakpoint */
lua_pushstring(lua, "breakpoint");
lua_pushcfunction(lua, luaRedisBreakpointCommand);
lua_pushcfunction(lua, luaServerBreakpointCommand);
lua_settable(lua, -3);
/* redis.debug */
/* server.debug */
lua_pushstring(lua, "debug");
lua_pushcfunction(lua, luaRedisDebugCommand);
lua_pushcfunction(lua, luaServerDebugCommand);
lua_settable(lua, -3);
/* redis.replicate_commands */
/* server.replicate_commands */
lua_pushstring(lua, "replicate_commands");
lua_pushcfunction(lua, luaRedisReplicateCommandsCommand);
lua_pushcfunction(lua, luaServerReplicateCommandsCommand);
lua_settable(lua, -3);
lua_setglobal(lua, "redis");
lua_setglobal(lua, "server");
/* 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
@ -1204,50 +1204,50 @@ void ldbLogStackValue(lua_State *lua, char *prefix) {
ldbLogWithMaxLen(s);
}
char *ldbRedisProtocolToHuman_Int(sds *o, char *reply);
char *ldbRedisProtocolToHuman_Bulk(sds *o, char *reply);
char *ldbRedisProtocolToHuman_Status(sds *o, char *reply);
char *ldbRedisProtocolToHuman_MultiBulk(sds *o, char *reply);
char *ldbRedisProtocolToHuman_Set(sds *o, char *reply);
char *ldbRedisProtocolToHuman_Map(sds *o, char *reply);
char *ldbRedisProtocolToHuman_Null(sds *o, char *reply);
char *ldbRedisProtocolToHuman_Bool(sds *o, char *reply);
char *ldbRedisProtocolToHuman_Double(sds *o, char *reply);
char *ldbRespToHuman_Int(sds *o, char *reply);
char *ldbRespToHuman_Bulk(sds *o, char *reply);
char *ldbRespToHuman_Status(sds *o, char *reply);
char *ldbRespToHuman_MultiBulk(sds *o, char *reply);
char *ldbRespToHuman_Set(sds *o, char *reply);
char *ldbRespToHuman_Map(sds *o, char *reply);
char *ldbRespToHuman_Null(sds *o, char *reply);
char *ldbRespToHuman_Bool(sds *o, char *reply);
char *ldbRespToHuman_Double(sds *o, char *reply);
/* Get RESP from 'reply' and appends it in human readable form to
* the passed SDS string 'o'.
*
* Note that the SDS string is passed by reference (pointer of pointer to
* char*) so that we can return a modified pointer, as for SDS semantics. */
char *ldbRedisProtocolToHuman(sds *o, char *reply) {
char *ldbRespToHuman(sds *o, char *reply) {
char *p = reply;
/* clang-format off */
switch(*p) {
case ':': p = ldbRedisProtocolToHuman_Int(o,reply); break;
case '$': p = ldbRedisProtocolToHuman_Bulk(o,reply); break;
case '+': p = ldbRedisProtocolToHuman_Status(o,reply); break;
case '-': p = ldbRedisProtocolToHuman_Status(o,reply); break;
case '*': p = ldbRedisProtocolToHuman_MultiBulk(o,reply); break;
case '~': p = ldbRedisProtocolToHuman_Set(o,reply); break;
case '%': p = ldbRedisProtocolToHuman_Map(o,reply); break;
case '_': p = ldbRedisProtocolToHuman_Null(o,reply); break;
case '#': p = ldbRedisProtocolToHuman_Bool(o,reply); break;
case ',': p = ldbRedisProtocolToHuman_Double(o,reply); break;
case ':': p = ldbRespToHuman_Int(o,reply); break;
case '$': p = ldbRespToHuman_Bulk(o,reply); break;
case '+': p = ldbRespToHuman_Status(o,reply); break;
case '-': p = ldbRespToHuman_Status(o,reply); break;
case '*': p = ldbRespToHuman_MultiBulk(o,reply); break;
case '~': p = ldbRespToHuman_Set(o,reply); break;
case '%': p = ldbRespToHuman_Map(o,reply); break;
case '_': p = ldbRespToHuman_Null(o,reply); break;
case '#': p = ldbRespToHuman_Bool(o,reply); break;
case ',': p = ldbRespToHuman_Double(o,reply); break;
}
/* clang-format on */
return p;
}
/* The following functions are helpers for ldbRedisProtocolToHuman(), each
/* The following functions are helpers for ldbRespToHuman(), each
* take care of a given RESP return type. */
char *ldbRedisProtocolToHuman_Int(sds *o, char *reply) {
char *ldbRespToHuman_Int(sds *o, char *reply) {
char *p = strchr(reply + 1, '\r');
*o = sdscatlen(*o, reply + 1, p - reply - 1);
return p + 2;
}
char *ldbRedisProtocolToHuman_Bulk(sds *o, char *reply) {
char *ldbRespToHuman_Bulk(sds *o, char *reply) {
char *p = strchr(reply + 1, '\r');
long long bulklen;
@ -1261,14 +1261,14 @@ char *ldbRedisProtocolToHuman_Bulk(sds *o, char *reply) {
}
}
char *ldbRedisProtocolToHuman_Status(sds *o, char *reply) {
char *ldbRespToHuman_Status(sds *o, char *reply) {
char *p = strchr(reply + 1, '\r');
*o = sdscatrepr(*o, reply, p - reply);
return p + 2;
}
char *ldbRedisProtocolToHuman_MultiBulk(sds *o, char *reply) {
char *ldbRespToHuman_MultiBulk(sds *o, char *reply) {
char *p = strchr(reply + 1, '\r');
long long mbulklen;
int j = 0;
@ -1281,14 +1281,14 @@ char *ldbRedisProtocolToHuman_MultiBulk(sds *o, char *reply) {
}
*o = sdscatlen(*o, "[", 1);
for (j = 0; j < mbulklen; j++) {
p = ldbRedisProtocolToHuman(o, p);
p = ldbRespToHuman(o, p);
if (j != mbulklen - 1) *o = sdscatlen(*o, ",", 1);
}
*o = sdscatlen(*o, "]", 1);
return p;
}
char *ldbRedisProtocolToHuman_Set(sds *o, char *reply) {
char *ldbRespToHuman_Set(sds *o, char *reply) {
char *p = strchr(reply + 1, '\r');
long long mbulklen;
int j = 0;
@ -1297,14 +1297,14 @@ char *ldbRedisProtocolToHuman_Set(sds *o, char *reply) {
p += 2;
*o = sdscatlen(*o, "~(", 2);
for (j = 0; j < mbulklen; j++) {
p = ldbRedisProtocolToHuman(o, p);
p = ldbRespToHuman(o, p);
if (j != mbulklen - 1) *o = sdscatlen(*o, ",", 1);
}
*o = sdscatlen(*o, ")", 1);
return p;
}
char *ldbRedisProtocolToHuman_Map(sds *o, char *reply) {
char *ldbRespToHuman_Map(sds *o, char *reply) {
char *p = strchr(reply + 1, '\r');
long long mbulklen;
int j = 0;
@ -1313,22 +1313,22 @@ char *ldbRedisProtocolToHuman_Map(sds *o, char *reply) {
p += 2;
*o = sdscatlen(*o, "{", 1);
for (j = 0; j < mbulklen; j++) {
p = ldbRedisProtocolToHuman(o, p);
p = ldbRespToHuman(o, p);
*o = sdscatlen(*o, " => ", 4);
p = ldbRedisProtocolToHuman(o, p);
p = ldbRespToHuman(o, p);
if (j != mbulklen - 1) *o = sdscatlen(*o, ",", 1);
}
*o = sdscatlen(*o, "}", 1);
return p;
}
char *ldbRedisProtocolToHuman_Null(sds *o, char *reply) {
char *ldbRespToHuman_Null(sds *o, char *reply) {
char *p = strchr(reply + 1, '\r');
*o = sdscatlen(*o, "(null)", 6);
return p + 2;
}
char *ldbRedisProtocolToHuman_Bool(sds *o, char *reply) {
char *ldbRespToHuman_Bool(sds *o, char *reply) {
char *p = strchr(reply + 1, '\r');
if (reply[1] == 't')
*o = sdscatlen(*o, "#true", 5);
@ -1337,7 +1337,7 @@ char *ldbRedisProtocolToHuman_Bool(sds *o, char *reply) {
return p + 2;
}
char *ldbRedisProtocolToHuman_Double(sds *o, char *reply) {
char *ldbRespToHuman_Double(sds *o, char *reply) {
char *p = strchr(reply + 1, '\r');
*o = sdscatlen(*o, "(double) ", 9);
*o = sdscatlen(*o, reply + 1, p - reply - 1);
@ -1347,9 +1347,9 @@ char *ldbRedisProtocolToHuman_Double(sds *o, char *reply) {
/* Log a RESP reply as debugger output, in a human readable format.
* If the resulting string is longer than 'len' plus a few more chars
* used as prefix, it gets truncated. */
void ldbLogRedisReply(char *reply) {
void ldbLogRespReply(char *reply) {
sds log = sdsnew("<reply> ");
ldbRedisProtocolToHuman(&log, reply);
ldbRespToHuman(&log, reply);
ldbLogWithMaxLen(log);
}
@ -1487,10 +1487,10 @@ void ldbEval(lua_State *lua, sds *argv, int argc) {
}
/* Implement the debugger "server" command. We use a trick in order to make
* the implementation very simple: we just call the Lua redis.call() command
* the implementation very simple: we just call the Lua server.call() command
* implementation, with ldb.step enabled, so as a side effect the command
* and its reply are logged. */
void ldbRedis(lua_State *lua, sds *argv, int argc) {
void ldbServer(lua_State *lua, sds *argv, int argc) {
int j;
if (!lua_checkstack(lua, argc + 1)) {
@ -1500,7 +1500,7 @@ void ldbRedis(lua_State *lua, sds *argv, int argc) {
* given by the user (without the first argument) and we also push the 'server' global table and
* 'server.call' function so:
* (1 (server table)) + (1 (server.call function)) + (argc - 1 (all arguments without the first)) = argc + 1*/
ldbLogRedisReply("max lua stack reached");
ldbLogRespReply("max lua stack reached");
return;
}
@ -1592,7 +1592,7 @@ int ldbRepl(lua_State *lua) {
/* Execute the command. */
if (!strcasecmp(argv[0], "h") || !strcasecmp(argv[0], "help")) {
ldbLog(sdsnew("Redis Lua debugger help:"));
ldbLog(sdsnew("Lua debugger help:"));
ldbLog(sdsnew("[h]elp Show this help."));
ldbLog(sdsnew("[s]tep Run current line and stop again."));
ldbLog(sdsnew("[n]ext Alias for step."));
@ -1650,7 +1650,7 @@ int ldbRepl(lua_State *lua) {
/* [r]redis or [v]alkey calls a command. We accept "server" too, but
* not "s" because that's "step". Neither can we use [c]all because
* "c" is continue. */
ldbRedis(lua, argv, argc);
ldbServer(lua, argv, argc);
ldbSendLogs();
} else if ((!strcasecmp(argv[0], "p") || !strcasecmp(argv[0], "print"))) {
if (argc == 2)

28
src/function_lua.c
View File

@ -274,7 +274,7 @@ static int luaRegisterFunctionReadNamedArgs(lua_State *lua, registerFunctionArgs
luaFunctionCtx *lua_f_ctx = NULL;
uint64_t flags = 0;
if (!lua_istable(lua, 1)) {
err = "calling redis.register_function with a single argument is only applicable to Lua table (representing "
err = "calling server.register_function with a single argument is only applicable to Lua table (representing "
"named arguments).";
goto error;
}
@ -284,23 +284,23 @@ static int luaRegisterFunctionReadNamedArgs(lua_State *lua, registerFunctionArgs
while (lua_next(lua, -2)) {
/* Stack now: table, key, value */
if (!lua_isstring(lua, -2)) {
err = "named argument key given to redis.register_function is not a string";
err = "named argument key given to server.register_function is not a string";
goto error;
}
const char *key = lua_tostring(lua, -2);
if (!strcasecmp(key, "function_name")) {
if (!(name = luaGetStringSds(lua, -1))) {
err = "function_name argument given to redis.register_function must be a string";
err = "function_name argument given to server.register_function must be a string";
goto error;
}
} else if (!strcasecmp(key, "description")) {
if (!(desc = luaGetStringSds(lua, -1))) {
err = "description argument given to redis.register_function must be a string";
err = "description argument given to server.register_function must be a string";
goto error;
}
} else if (!strcasecmp(key, "callback")) {
if (!lua_isfunction(lua, -1)) {
err = "callback argument given to redis.register_function must be a function";
err = "callback argument given to server.register_function must be a function";
goto error;
}
int lua_function_ref = luaL_ref(lua, LUA_REGISTRYINDEX);
@ -310,7 +310,7 @@ static int luaRegisterFunctionReadNamedArgs(lua_State *lua, registerFunctionArgs
continue; /* value was already popped, so no need to pop it out. */
} else if (!strcasecmp(key, "flags")) {
if (!lua_istable(lua, -1)) {
err = "flags argument to redis.register_function must be a table representing function flags";
err = "flags argument to server.register_function must be a table representing function flags";
goto error;
}
if (luaRegisterFunctionReadFlags(lua, &flags) != C_OK) {
@ -319,19 +319,19 @@ static int luaRegisterFunctionReadNamedArgs(lua_State *lua, registerFunctionArgs
}
} else {
/* unknown argument was given, raise an error */
err = "unknown argument given to redis.register_function";
err = "unknown argument given to server.register_function";
goto error;
}
lua_pop(lua, 1); /* pop the value to continue the iteration */
}
if (!name) {
err = "redis.register_function must get a function name argument";
err = "server.register_function must get a function name argument";
goto error;
}
if (!lua_f_ctx) {
err = "redis.register_function must get a callback argument";
err = "server.register_function must get a callback argument";
goto error;
}
@ -355,12 +355,12 @@ static int luaRegisterFunctionReadPositionalArgs(lua_State *lua, registerFunctio
sds name = NULL;
luaFunctionCtx *lua_f_ctx = NULL;
if (!(name = luaGetStringSds(lua, 1))) {
err = "first argument to redis.register_function must be a string";
err = "first argument to server.register_function must be a string";
goto error;
}
if (!lua_isfunction(lua, 2)) {
err = "second argument to redis.register_function must be a function";
err = "second argument to server.register_function must be a function";
goto error;
}
@ -382,7 +382,7 @@ error:
static int luaRegisterFunctionReadArgs(lua_State *lua, registerFunctionArgs *register_f_args) {
int argc = lua_gettop(lua);
if (argc < 1 || argc > 2) {
luaPushError(lua, "wrong number of arguments to redis.register_function");
luaPushError(lua, "wrong number of arguments to server.register_function");
return C_ERR;
}
@ -398,7 +398,7 @@ static int luaRegisterFunction(lua_State *lua) {
loadCtx *load_ctx = luaGetFromRegistry(lua, REGISTRY_LOAD_CTX_NAME);
if (!load_ctx) {
luaPushError(lua, "redis.register_function can only be called on FUNCTION LOAD command");
luaPushError(lua, "server.register_function can only be called on FUNCTION LOAD command");
return luaError(lua);
}
@ -423,7 +423,7 @@ int luaEngineInitEngine(void) {
luaEngineCtx *lua_engine_ctx = zmalloc(sizeof(*lua_engine_ctx));
lua_engine_ctx->lua = lua_open();
luaRegisterRedisAPI(lua_engine_ctx->lua);
luaRegisterServerAPI(lua_engine_ctx->lua);
/* Register the library commands table and fields and store it to registry */
lua_newtable(lua_engine_ctx->lua); /* load library globals */

10
src/networking.c
View File

@ -1291,19 +1291,19 @@ void clientAcceptHandler(connection *conn) {
* user what to do to fix it if needed. */
if (server.protected_mode && DefaultUser->flags & USER_FLAG_NOPASS) {
if (connIsLocal(conn) != 1) {
char *err = "-DENIED Redis is running in protected mode because protected "
char *err = "-DENIED Running in protected mode because protected "
"mode is enabled and no password is set for the default user. "
"In this mode connections are only accepted from the loopback interface. "
"If you want to connect from external computers to Redis you "
"If you want to connect from external computers, you "
"may adopt one of the following solutions: "
"1) Just disable protected mode sending the command "
"'CONFIG SET protected-mode no' from the loopback interface "
"by connecting to Redis from the same host the server is "
"running, however MAKE SURE Redis is not publicly accessible "
"by connecting from the same host the server is "
"running, however MAKE SURE it's not publicly accessible "
"from internet if you do so. Use CONFIG REWRITE to make this "
"change permanent. "
"2) Alternatively you can just disable the protected mode by "
"editing the Redis configuration file, and setting the protected "
"editing the configuration file, and setting the protected "
"mode option to 'no', and then restarting the server. "
"3) If you started the server manually just for testing, restart "
"it with the '--protected-mode no' option. "

2
src/rdb.c
View File

@ -3081,7 +3081,7 @@ int rdbLoadRioWithLoadingCtx(rio *rdb, int rdbflags, rdbSaveInfo *rsi, rdbLoadin
} else if (!strcasecmp(auxkey->ptr, "redis-ver")) {
serverLog(LL_NOTICE, "Loading RDB produced by Redis version %s", (char *)auxval->ptr);
} else if (!strcasecmp(auxkey->ptr, "valkey-ver")) {
serverLog(LL_NOTICE, "Loading RDB produced by valkey version %s", (char *)auxval->ptr);
serverLog(LL_NOTICE, "Loading RDB produced by Valkey version %s", (char *)auxval->ptr);
} else if (!strcasecmp(auxkey->ptr, "ctime")) {
time_t age = time(NULL) - strtol(auxval->ptr, NULL, 10);
if (age < 0) age = 0;

86
src/script_lua.c
View File

@ -224,7 +224,7 @@ static void redisProtocolToLuaType_Int(void *ctx, long long val, const char *pro
if (!lua_checkstack(lua, 1)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_pushnumber(lua, (lua_Number)val);
}
@ -240,7 +240,7 @@ static void redisProtocolToLuaType_NullBulkString(void *ctx, const char *proto,
if (!lua_checkstack(lua, 1)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_pushboolean(lua, 0);
}
@ -255,7 +255,7 @@ static void redisProtocolToLuaType_NullArray(void *ctx, const char *proto, size_
if (!lua_checkstack(lua, 1)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_pushboolean(lua, 0);
}
@ -273,7 +273,7 @@ redisProtocolToLuaType_BulkString(void *ctx, const char *str, size_t len, const
if (!lua_checkstack(lua, 1)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_pushlstring(lua, str, len);
}
@ -289,7 +289,7 @@ static void redisProtocolToLuaType_Status(void *ctx, const char *str, size_t len
if (!lua_checkstack(lua, 3)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_newtable(lua);
lua_pushstring(lua, "ok");
@ -308,7 +308,7 @@ static void redisProtocolToLuaType_Error(void *ctx, const char *str, size_t len,
if (!lua_checkstack(lua, 3)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
sds err_msg = sdscatlen(sdsnew("-"), str, len);
luaPushErrorBuff(lua, err_msg);
@ -326,7 +326,7 @@ static void redisProtocolToLuaType_Map(struct ReplyParser *parser, void *ctx, si
if (!lua_checkstack(lua, 3)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_newtable(lua);
lua_pushstring(lua, "map");
@ -348,7 +348,7 @@ static void redisProtocolToLuaType_Set(struct ReplyParser *parser, void *ctx, si
if (!lua_checkstack(lua, 3)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_newtable(lua);
lua_pushstring(lua, "set");
@ -362,7 +362,7 @@ static void redisProtocolToLuaType_Set(struct ReplyParser *parser, void *ctx, si
* to push elements to the stack. On failure, exit with panic.
* Notice that here we need to check the stack again because the recursive
* call to redisProtocolToLuaType might have use the room allocated in the stack*/
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_pushboolean(lua, 1);
lua_settable(lua, -3);
@ -379,7 +379,7 @@ static void redisProtocolToLuaType_Array(struct ReplyParser *parser, void *ctx,
if (!lua_checkstack(lua, 2)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_newtable(lua);
}
@ -422,7 +422,7 @@ static void redisProtocolToLuaType_VerbatimString(void *ctx,
if (!lua_checkstack(lua, 5)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_newtable(lua);
lua_pushstring(lua, "verbatim_string");
@ -448,7 +448,7 @@ redisProtocolToLuaType_BigNumber(void *ctx, const char *str, size_t len, const c
if (!lua_checkstack(lua, 3)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_newtable(lua);
lua_pushstring(lua, "big_number");
@ -467,7 +467,7 @@ static void redisProtocolToLuaType_Null(void *ctx, const char *proto, size_t pro
if (!lua_checkstack(lua, 1)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_pushnil(lua);
}
@ -483,7 +483,7 @@ static void redisProtocolToLuaType_Bool(void *ctx, int val, const char *proto, s
if (!lua_checkstack(lua, 1)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_pushboolean(lua, val);
}
@ -499,7 +499,7 @@ static void redisProtocolToLuaType_Double(void *ctx, double d, const char *proto
if (!lua_checkstack(lua, 3)) {
/* Increase the Lua stack if needed, to make sure there is enough room
* to push elements to the stack. On failure, exit with panic. */
serverPanic("lua stack limit reach when parsing redis.call reply");
serverPanic("lua stack limit reach when parsing server.call reply");
}
lua_newtable(lua);
lua_pushstring(lua, "double");
@ -508,7 +508,7 @@ static void redisProtocolToLuaType_Double(void *ctx, double d, const char *proto
}
/* This function is used in order to push an error on the Lua stack in the
* format used by redis.pcall to return errors, which is a lua table
* format used by server.pcall to return errors, which is a lua table
* with an "err" field set to the error string including the error code.
* Note that this table is never a valid reply by proper commands,
* since the returned tables are otherwise always indexed by integers, never by strings.
@ -527,7 +527,7 @@ void luaPushErrorBuff(lua_State *lua, sds err_buffer) {
/* There are two possible formats for the received `error` string:
* 1) "-CODE msg": in this case we remove the leading '-' since we don't store it as part of the lua error format.
* 2) "msg": in this case we prepend a generic 'ERR' code since all error statuses need some error code.
* We support format (1) so this function can reuse the error messages used in other places in redis.
* We support format (1) so this function can reuse the error messages used in other places.
* We support format (2) so it'll be easy to pass descriptive errors to this function without worrying about format.
*/
if (err_buffer[0] == '-') {
@ -565,7 +565,7 @@ void luaPushError(lua_State *lua, const char *error) {
}
/* In case the error set into the Lua stack by luaPushError() was generated
* by the non-error-trapping version of redis.pcall(), which is redis.call(),
* by the non-error-trapping version of server.pcall(), which is server.call(),
* this function will raise the Lua error so that the execution of the
* script will be halted. */
int luaError(lua_State *lua) {
@ -759,7 +759,7 @@ static void luaReplyToRedisReply(client *c, client *script_client, lua_State *lu
}
/* ---------------------------------------------------------------------------
* Lua redis.* functions implementations.
* Lua server.* functions implementations.
* ------------------------------------------------------------------------- */
void freeLuaRedisArgv(robj **argv, int argc, int argv_len);
@ -946,7 +946,7 @@ static int luaRedisGenericCommand(lua_State *lua, int raise_error) {
redisProtocolToLuaType(lua, reply);
/* If the debugger is active, log the reply from the server. */
if (ldbIsEnabled()) ldbLogRedisReply(reply);
if (ldbIsEnabled()) ldbLogRespReply(reply);
if (reply != c->buf) sdsfree(reply);
c->reply_bytes = 0;
@ -998,17 +998,17 @@ static int luaRedisPcall(lua_State *lua) {
return lua_gettop(lua);
}
/* redis.call() */
/* server.call() */
static int luaRedisCallCommand(lua_State *lua) {
return luaRedisGenericCommand(lua, 1);
}
/* redis.pcall() */
/* server.pcall() */
static int luaRedisPCallCommand(lua_State *lua) {
return luaRedisGenericCommand(lua, 0);
}
/* This adds redis.sha1hex(string) to Lua scripts using the same hashing
/* This adds server.sha1hex(string) to Lua scripts using the same hashing
* function used for sha1ing lua scripts. */
static int luaRedisSha1hexCommand(lua_State *lua) {
int argc = lua_gettop(lua);
@ -1031,8 +1031,8 @@ static int luaRedisSha1hexCommand(lua_State *lua) {
* passed as argument. This helper function is handy when returning
* a RESP error or status reply from Lua:
*
* return redis.error_reply("ERR Some Error")
* return redis.status_reply("ERR Some Error")
* return server.error_reply("ERR Some Error")
* return server.status_reply("ERR Some Error")
*/
static int luaRedisReturnSingleFieldTable(lua_State *lua, char *field) {
if (lua_gettop(lua) != 1 || lua_type(lua, -1) != LUA_TSTRING) {
@ -1047,7 +1047,7 @@ static int luaRedisReturnSingleFieldTable(lua_State *lua, char *field) {
return 1;
}
/* redis.error_reply() */
/* server.error_reply() */
static int luaRedisErrorReplyCommand(lua_State *lua) {
if (lua_gettop(lua) != 1 || lua_type(lua, -1) != LUA_TSTRING) {
luaPushError(lua, "wrong number or type of arguments");
@ -1066,12 +1066,12 @@ static int luaRedisErrorReplyCommand(lua_State *lua) {
return 1;
}
/* redis.status_reply() */
/* server.status_reply() */
static int luaRedisStatusReplyCommand(lua_State *lua) {
return luaRedisReturnSingleFieldTable(lua, "ok");
}
/* redis.set_repl()
/* server.set_repl()
*
* Set the propagation of write commands executed in the context of the
* script to on/off for AOF and slaves. */
@ -1082,7 +1082,7 @@ static int luaRedisSetReplCommand(lua_State *lua) {
serverAssert(rctx); /* Only supported inside script invocation */
if (argc != 1) {
luaPushError(lua, "redis.set_repl() requires one argument.");
luaPushError(lua, "server.set_repl() requires one argument.");
return luaError(lua);
}
@ -1096,7 +1096,7 @@ static int luaRedisSetReplCommand(lua_State *lua) {
return 0;
}
/* redis.acl_check_cmd()
/* server.acl_check_cmd()
*
* Checks ACL permissions for given command for the current user. */
static int luaRedisAclCheckCmdPermissionsCommand(lua_State *lua) {
@ -1132,14 +1132,14 @@ static int luaRedisAclCheckCmdPermissionsCommand(lua_State *lua) {
}
/* redis.log() */
/* server.log() */
static 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.");
luaPushError(lua, "server.log() requires two arguments or more.");
return luaError(lua);
} else if (!lua_isnumber(lua, -argc)) {
luaPushError(lua, "First argument must be a number (log level).");
@ -1169,14 +1169,14 @@ static int luaLogCommand(lua_State *lua) {
return 0;
}
/* redis.setresp() */
/* server.setresp() */
static int luaSetResp(lua_State *lua) {
scriptRunCtx *rctx = luaGetFromRegistry(lua, REGISTRY_RUN_CTX_NAME);
serverAssert(rctx); /* Only supported inside script invocation */
int argc = lua_gettop(lua);
if (argc != 1) {
luaPushError(lua, "redis.setresp() requires one argument.");
luaPushError(lua, "server.setresp() requires one argument.");
return luaError(lua);
}
@ -1378,7 +1378,7 @@ void luaRegisterVersion(lua_State *lua) {
}
void luaRegisterLogFunction(lua_State *lua) {
/* redis.log and log levels. */
/* server.log and log levels. */
lua_pushstring(lua, "log");
lua_pushcfunction(lua, luaLogCommand);
lua_settable(lua, -3);
@ -1400,7 +1400,7 @@ void luaRegisterLogFunction(lua_State *lua) {
lua_settable(lua, -3);
}
void luaRegisterRedisAPI(lua_State *lua) {
void luaRegisterServerAPI(lua_State *lua) {
lua_pushvalue(lua, LUA_GLOBALSINDEX);
luaSetAllowListProtection(lua);
lua_pop(lua, 1);
@ -1413,12 +1413,12 @@ void luaRegisterRedisAPI(lua_State *lua) {
/* Register the commands table and fields */
lua_newtable(lua);
/* redis.call */
/* server.call */
lua_pushstring(lua, "call");
lua_pushcfunction(lua, luaRedisCallCommand);
lua_settable(lua, -3);
/* redis.pcall */
/* server.pcall */
lua_pushstring(lua, "pcall");
lua_pushcfunction(lua, luaRedisPCallCommand);
lua_settable(lua, -3);
@ -1427,17 +1427,17 @@ void luaRegisterRedisAPI(lua_State *lua) {
luaRegisterVersion(lua);
/* redis.setresp */
/* server.setresp */
lua_pushstring(lua, "setresp");
lua_pushcfunction(lua, luaSetResp);
lua_settable(lua, -3);
/* redis.sha1hex */
/* server.sha1hex */
lua_pushstring(lua, "sha1hex");
lua_pushcfunction(lua, luaRedisSha1hexCommand);
lua_settable(lua, -3);
/* redis.error_reply and redis.status_reply */
/* server.error_reply and server.status_reply */
lua_pushstring(lua, "error_reply");
lua_pushcfunction(lua, luaRedisErrorReplyCommand);
lua_settable(lua, -3);
@ -1445,7 +1445,7 @@ void luaRegisterRedisAPI(lua_State *lua) {
lua_pushcfunction(lua, luaRedisStatusReplyCommand);
lua_settable(lua, -3);
/* redis.set_repl and associated flags. */
/* server.set_repl and associated flags. */
lua_pushstring(lua, "set_repl");
lua_pushcfunction(lua, luaRedisSetReplCommand);
lua_settable(lua, -3);
@ -1470,7 +1470,7 @@ void luaRegisterRedisAPI(lua_State *lua) {
lua_pushnumber(lua, PROPAGATE_AOF | PROPAGATE_REPL);
lua_settable(lua, -3);
/* redis.acl_check_cmd */
/* server.acl_check_cmd */
lua_pushstring(lua, "acl_check_cmd");
lua_pushcfunction(lua, luaRedisAclCheckCmdPermissionsCommand);
lua_settable(lua, -3);

2
src/script_lua.h
View File

@ -66,7 +66,7 @@ typedef struct errorInfo {
int ignore_err_stats_update;
} errorInfo;
void luaRegisterRedisAPI(lua_State *lua);
void luaRegisterServerAPI(lua_State *lua);
sds luaGetStringSds(lua_State *lua, int index);
void luaRegisterGlobalProtectionFunction(lua_State *lua);
void luaSetErrorMetatable(lua_State *lua);

2
src/server.h
View File

@ -3465,7 +3465,7 @@ void freeLuaScriptsAsync(dict *lua_scripts, list *lua_scripts_lru_list, lua_Stat
void freeFunctionsAsync(functionsLibCtx *lib_ctx);
int ldbIsEnabled(void);
void ldbLog(sds entry);
void ldbLogRedisReply(char *reply);
void ldbLogRespReply(char *reply);
void sha1hex(char *digest, char *script, size_t len);
unsigned long evalMemory(void);
dict *evalScriptsDict(void);

4
tests/integration/replication-4.tcl
View File

@ -61,8 +61,8 @@ start_server {tags {"repl external:skip"}} {
# Load some functions to be used later
$master FUNCTION load replace {#!lua name=test
redis.register_function{function_name='f_default_flags', callback=function(keys, args) return redis.call('get',keys[1]) end, flags={}}
redis.register_function{function_name='f_no_writes', callback=function(keys, args) return redis.call('get',keys[1]) end, flags={'no-writes'}}
server.register_function{function_name='f_default_flags', callback=function(keys, args) return redis.call('get',keys[1]) end, flags={}}
server.register_function{function_name='f_no_writes', callback=function(keys, args) return redis.call('get',keys[1]) end, flags={'no-writes'}}
}
test {First server should have role slave after SLAVEOF} {

6
tests/integration/replication.tcl
View File

@ -574,12 +574,12 @@ foreach testType {Successful Aborted} {
# Set a function value on replica to check status during loading, on failure and after swapping db
$replica function load {#!lua name=test
redis.register_function('test', function() return 'hello1' end)
server.register_function('test', function() return 'hello1' end)
}
# Set a function value on master to check it reaches the replica when replication ends
$master function load {#!lua name=test
redis.register_function('test', function() return 'hello2' end)
server.register_function('test', function() return 'hello2' end)
}
# Remember the sync_full stat before the client kill.
@ -727,7 +727,7 @@ test {diskless loading short read} {
# Set a function value to check short read handling on functions
r function load {#!lua name=test
redis.register_function('test', function() return 'hello1' end)
server.register_function('test', function() return 'hello1' end)
}
for {set k 0} {$k < 3} {incr k} {

4
tests/integration/valkey-cli.tcl
View File

@ -451,7 +451,7 @@ if {!$::tls} { ;# fake_redis_node doesn't support TLS
set dir [lindex [r config get dir] 1]
assert_equal "OK" [r debug populate 100000 key 1000]
assert_equal "lib1" [r function load "#!lua name=lib1\nredis.register_function('func1', function() return 123 end)"]
assert_equal "lib1" [r function load "#!lua name=lib1\nserver.register_function('func1', function() return 123 end)"]
if {$functions_only} {
set args "--functions-rdb $dir/cli.rdb"
} else {
@ -464,7 +464,7 @@ if {!$::tls} { ;# fake_redis_node doesn't support TLS
file rename "$dir/cli.rdb" "$dir/dump.rdb"
assert_equal "OK" [r set should-not-exist 1]
assert_equal "should_not_exist_func" [r function load "#!lua name=should_not_exist_func\nredis.register_function('should_not_exist_func', function() return 456 end)"]
assert_equal "should_not_exist_func" [r function load "#!lua name=should_not_exist_func\nserver.register_function('should_not_exist_func', function() return 456 end)"]
assert_equal "OK" [r debug reload nosave]
assert_equal {} [r get should-not-exist]
assert_equal {{library_name lib1 engine LUA functions {{name func1 description {} flags {}}}}} [r function list]

2
tests/unit/aofrw.tcl
View File

@ -194,7 +194,7 @@ start_server {tags {"aofrw external:skip"} overrides {aof-use-rdb-preamble no}}
test "AOF rewrite functions" {
r flushall
r FUNCTION LOAD {#!lua name=test
redis.register_function('test', function() return 1 end)
server.register_function('test', function() return 1 end)
}
r bgrewriteaof
waitForBgrewriteaof r

4
tests/unit/cluster/cli.tcl
View File

@ -181,7 +181,7 @@ start_multiple_servers 5 [list overrides $base_conf] {
# upload a function to all the cluster
exec src/valkey-cli --cluster-yes --cluster call 127.0.0.1:[srv 0 port] \
FUNCTION LOAD {#!lua name=TEST
redis.register_function('test', function() return 'hello' end)
server.register_function('test', function() return 'hello' end)
}
# adding node to the cluster
@ -205,7 +205,7 @@ start_multiple_servers 5 [list overrides $base_conf] {
# add function to node 5
assert_equal {TEST} [$node5_rd FUNCTION LOAD {#!lua name=TEST
redis.register_function('test', function() return 'hello' end)
server.register_function('test', function() return 'hello' end)
}]
# make sure functions was added to node 5

6
tests/unit/cluster/scripting.tcl
View File

@ -17,7 +17,7 @@ start_cluster 1 0 {tags {external:skip cluster}} {
return 'OK'
end
redis.register_function('test_cross_slot', test_cross_slot)}
server.register_function('test_cross_slot', test_cross_slot)}
assert_error "ERR Script attempted to access keys that do not hash to the same slot*" {r FCALL test_cross_slot 0}
}
@ -45,7 +45,7 @@ start_cluster 1 0 {tags {external:skip cluster}} {
return 'OK'
end
redis.register_function{function_name='test_cross_slot', callback=test_cross_slot, flags={ 'allow-cross-slot-keys' }}}
server.register_function{function_name='test_cross_slot', callback=test_cross_slot, flags={ 'allow-cross-slot-keys' }}}
r FCALL test_cross_slot 0
# Retrieve data from different slot to verify data has been stored in the correct dictionary in cluster-enabled setup
@ -73,7 +73,7 @@ start_cluster 1 0 {tags {external:skip cluster}} {
test "Function no-cluster flag" {
R 0 function load {#!lua name=test
redis.register_function{function_name='f1', callback=function() return 'hello' end, flags={'no-cluster'}}
server.register_function{function_name='f1', callback=function() return 'hello' end, flags={'no-cluster'}}
}
catch {R 0 fcall f1 0} e
assert_match {*Can not run script on cluster, 'no-cluster' flag is set*} $e

154
tests/unit/functions.tcl
View File

@ -1,9 +1,9 @@
proc get_function_code {args} {
return [format "#!%s name=%s\nredis.register_function('%s', function(KEYS, ARGV)\n %s \nend)" [lindex $args 0] [lindex $args 1] [lindex $args 2] [lindex $args 3]]
return [format "#!%s name=%s\nserver.register_function('%s', function(KEYS, ARGV)\n %s \nend)" [lindex $args 0] [lindex $args 1] [lindex $args 2] [lindex $args 3]]
}
proc get_no_writes_function_code {args} {
return [format "#!%s name=%s\nredis.register_function{function_name='%s', callback=function(KEYS, ARGV)\n %s \nend, flags={'no-writes'}}" [lindex $args 0] [lindex $args 1] [lindex $args 2] [lindex $args 3]]
return [format "#!%s name=%s\nserver.register_function{function_name='%s', callback=function(KEYS, ARGV)\n %s \nend, flags={'no-writes'}}" [lindex $args 0] [lindex $args 1] [lindex $args 2] [lindex $args 3]]
}
start_server {tags {"scripting"}} {
@ -433,7 +433,7 @@ test {FUNCTION can processes create, delete and flush commands in AOF when doing
start_server {} {
r config set appendonly yes
waitForBgrewriteaof r
r FUNCTION LOAD "#!lua name=test\nredis.register_function('test', function() return 'hello' end)"
r FUNCTION LOAD "#!lua name=test\nserver.register_function('test', function() return 'hello' end)"
r config set slave-read-only yes
r slaveof 127.0.0.1 0
r debug loadaof
@ -447,7 +447,7 @@ test {FUNCTION can processes create, delete and flush commands in AOF when doing
r slaveof no one
assert_equal [r function list] {}
r FUNCTION LOAD "#!lua name=test\nredis.register_function('test', function() return 'hello' end)"
r FUNCTION LOAD "#!lua name=test\nserver.register_function('test', function() return 'hello' end)"
r FUNCTION FLUSH
r slaveof 127.0.0.1 0
@ -463,7 +463,7 @@ start_server {tags {"scripting"}} {
local function ping()
return redis.call('ping')
end
redis.register_function(
server.register_function(
'f1',
function(keys, args)
return ping()
@ -478,13 +478,13 @@ start_server {tags {"scripting"}} {
local function add1(a)
return a + 1
end
redis.register_function(
server.register_function(
'f1',
function(keys, args)
return add1(1)
end
)
redis.register_function(
server.register_function(
'f2',
function(keys, args)
return add1(2)
@ -502,19 +502,19 @@ start_server {tags {"scripting"}} {
local function add1(a)
return a + 2
end
redis.register_function(
server.register_function(
'f1',
function(keys, args)
return add1(1)
end
)
redis.register_function(
server.register_function(
'f2',
'not a function'
)
}
} e
assert_match {*second argument to redis.register_function must be a function*} $e
assert_match {*second argument to server.register_function must be a function*} $e
assert_equal [r fcall f1 0] {2}
assert_equal [r fcall f2 0] {3}
}
@ -522,7 +522,7 @@ start_server {tags {"scripting"}} {
test {LIBRARIES - test registration function name collision} {
catch {
r function load replace {#!lua name=lib2
redis.register_function(
server.register_function(
'f1',
function(keys, args)
return 1
@ -538,13 +538,13 @@ start_server {tags {"scripting"}} {
test {LIBRARIES - test registration function name collision on same library} {
catch {
r function load replace {#!lua name=lib2
redis.register_function(
server.register_function(
'f1',
function(keys, args)
return 1
end
)
redis.register_function(
server.register_function(
'f1',
function(keys, args)
return 1
@ -558,43 +558,43 @@ start_server {tags {"scripting"}} {
test {LIBRARIES - test registration with no argument} {
catch {
r function load replace {#!lua name=lib2
redis.register_function()
server.register_function()
}
} e
set _ $e
} {*wrong number of arguments to redis.register_function*}
} {*wrong number of arguments to server.register_function*}
test {LIBRARIES - test registration with only name} {
catch {
r function load replace {#!lua name=lib2
redis.register_function('f1')
server.register_function('f1')
}
} e
set _ $e
} {*calling redis.register_function with a single argument is only applicable to Lua table*}
} {*calling server.register_function with a single argument is only applicable to Lua table*}
test {LIBRARIES - test registration with to many arguments} {
catch {
r function load replace {#!lua name=lib2
redis.register_function('f1', function() return 1 end, {}, 'description', 'extra arg')
server.register_function('f1', function() return 1 end, {}, 'description', 'extra arg')
}
} e
set _ $e
} {*wrong number of arguments to redis.register_function*}
} {*wrong number of arguments to server.register_function*}
test {LIBRARIES - test registration with no string name} {
catch {
r function load replace {#!lua name=lib2
redis.register_function(nil, function() return 1 end)
server.register_function(nil, function() return 1 end)
}
} e
set _ $e
} {*first argument to redis.register_function must be a string*}
} {*first argument to server.register_function must be a string*}
test {LIBRARIES - test registration with wrong name format} {
catch {
r function load replace {#!lua name=lib2
redis.register_function('test\0test', function() return 1 end)
server.register_function('test\0test', function() return 1 end)
}
} e
set _ $e
@ -603,7 +603,7 @@ start_server {tags {"scripting"}} {
test {LIBRARIES - test registration with empty name} {
catch {
r function load replace {#!lua name=lib2
redis.register_function('', function() return 1 end)
server.register_function('', function() return 1 end)
}
} e
set _ $e
@ -703,10 +703,10 @@ start_server {tags {"scripting"}} {
test {LIBRARIES - register function inside a function} {
r function load {#!lua name=lib
redis.register_function(
server.register_function(
'f1',
function(keys, args)
redis.register_function(
server.register_function(
'f2',
function(key, args)
return 2
@ -751,7 +751,7 @@ start_server {tags {"scripting"}} {
test {LIBRARIES - named arguments} {
r function load {#!lua name=lib
redis.register_function{
server.register_function{
function_name='f1',
callback=function()
return 'hello'
@ -765,7 +765,7 @@ start_server {tags {"scripting"}} {
test {LIBRARIES - named arguments, bad function name} {
catch {
r function load replace {#!lua name=lib
redis.register_function{
server.register_function{
function_name=function() return 1 end,
callback=function()
return 'hello'
@ -775,12 +775,12 @@ start_server {tags {"scripting"}} {
}
} e
set _ $e
} {*function_name argument given to redis.register_function must be a string*}
} {*function_name argument given to server.register_function must be a string*}
test {LIBRARIES - named arguments, bad callback type} {
catch {
r function load replace {#!lua name=lib
redis.register_function{
server.register_function{
function_name='f1',
callback='bad',
description='some desc'
@ -788,12 +788,12 @@ start_server {tags {"scripting"}} {
}
} e
set _ $e
} {*callback argument given to redis.register_function must be a function*}
} {*callback argument given to server.register_function must be a function*}
test {LIBRARIES - named arguments, bad description} {
catch {
r function load replace {#!lua name=lib
redis.register_function{
server.register_function{
function_name='f1',
callback=function()
return 'hello'
@ -803,12 +803,12 @@ start_server {tags {"scripting"}} {
}
} e
set _ $e
} {*description argument given to redis.register_function must be a string*}
} {*description argument given to server.register_function must be a string*}
test {LIBRARIES - named arguments, unknown argument} {
catch {
r function load replace {#!lua name=lib
redis.register_function{
server.register_function{
function_name='f1',
callback=function()
return 'hello'
@ -819,12 +819,12 @@ start_server {tags {"scripting"}} {
}
} e
set _ $e
} {*unknown argument given to redis.register_function*}
} {*unknown argument given to server.register_function*}
test {LIBRARIES - named arguments, missing function name} {
catch {
r function load replace {#!lua name=lib
redis.register_function{
server.register_function{
callback=function()
return 'hello'
end,
@ -833,19 +833,19 @@ start_server {tags {"scripting"}} {
}
} e
set _ $e
} {*redis.register_function must get a function name argument*}
} {*server.register_function must get a function name argument*}
test {LIBRARIES - named arguments, missing callback} {
catch {
r function load replace {#!lua name=lib
redis.register_function{
server.register_function{
function_name='f1',
description='desc'
}
}
} e
set _ $e
} {*redis.register_function must get a callback argument*}
} {*server.register_function must get a callback argument*}
test {FUNCTION - test function restore with function name collision} {
r function flush
@ -853,19 +853,19 @@ start_server {tags {"scripting"}} {
local function add1(a)
return a + 1
end
redis.register_function(
server.register_function(
'f1',
function(keys, args)
return add1(1)
end
)
redis.register_function(
server.register_function(
'f2',
function(keys, args)
return add1(2)
end
)
redis.register_function(
server.register_function(
'f3',
function(keys, args)
return add1(3)
@ -877,7 +877,7 @@ start_server {tags {"scripting"}} {
# load a library with different name but with the same function name
r function load {#!lua name=lib1
redis.register_function(
server.register_function(
'f6',
function(keys, args)
return 7
@ -888,19 +888,19 @@ start_server {tags {"scripting"}} {
local function add1(a)
return a + 1
end
redis.register_function(
server.register_function(
'f4',
function(keys, args)
return add1(4)
end
)
redis.register_function(
server.register_function(
'f5',
function(keys, args)
return add1(5)
end
)
redis.register_function(
server.register_function(
'f3',
function(keys, args)
return add1(3)
@ -926,14 +926,14 @@ start_server {tags {"scripting"}} {
test {FUNCTION - test function list with code} {
r function flush
r function load {#!lua name=library1
redis.register_function('f6', function(keys, args) return 7 end)
server.register_function('f6', function(keys, args) return 7 end)
}
r function list withcode
} {{library_name library1 engine LUA functions {{name f6 description {} flags {}}} library_code {*redis.register_function('f6', function(keys, args) return 7 end)*}}}
} {{library_name library1 engine LUA functions {{name f6 description {} flags {}}} library_code {*server.register_function('f6', function(keys, args) return 7 end)*}}}
test {FUNCTION - test function list with pattern} {
r function load {#!lua name=lib1
redis.register_function('f7', function(keys, args) return 7 end)
server.register_function('f7', function(keys, args) return 7 end)
}
r function list libraryname library*
} {{library_name library1 engine LUA functions {{name f6 description {} flags {}}}}}
@ -961,14 +961,14 @@ start_server {tags {"scripting"}} {
test {FUNCTION - verify OOM on function load and function restore} {
r function flush
r function load replace {#!lua name=test
redis.register_function('f1', function() return 1 end)
server.register_function('f1', function() return 1 end)
}
set payload [r function dump]
r config set maxmemory 1
r function flush
catch {r function load replace {#!lua name=test
redis.register_function('f1', function() return 1 end)
server.register_function('f1', function() return 1 end)
}} e
assert_match {*command not allowed when used memory*} $e
@ -981,7 +981,7 @@ start_server {tags {"scripting"}} {
test {FUNCTION - verify allow-omm allows running any command} {
r FUNCTION load replace {#!lua name=f1
redis.register_function{
server.register_function{
function_name='f1',
callback=function() return redis.call('set', 'x', '1') end,
flags={'allow-oom'}
@ -1000,18 +1000,18 @@ start_server {tags {"scripting"}} {
start_server {tags {"scripting"}} {
test {FUNCTION - wrong flags type named arguments} {
catch {r function load replace {#!lua name=test
redis.register_function{
server.register_function{
function_name = 'f1',
callback = function() return 1 end,
flags = 'bad flags type'
}
}} e
set _ $e
} {*flags argument to redis.register_function must be a table representing function flags*}
} {*flags argument to server.register_function must be a table representing function flags*}
test {FUNCTION - wrong flag type} {
catch {r function load replace {#!lua name=test
redis.register_function{
server.register_function{
function_name = 'f1',
callback = function() return 1 end,
flags = {function() return 1 end}
@ -1022,7 +1022,7 @@ start_server {tags {"scripting"}} {
test {FUNCTION - unknown flag} {
catch {r function load replace {#!lua name=test
redis.register_function{
server.register_function{
function_name = 'f1',
callback = function() return 1 end,
flags = {'unknown'}
@ -1033,7 +1033,7 @@ start_server {tags {"scripting"}} {
test {FUNCTION - write script on fcall_ro} {
r function load replace {#!lua name=test
redis.register_function{
server.register_function{
function_name = 'f1',
callback = function() return redis.call('set', 'x', 1) end
}
@ -1044,7 +1044,7 @@ start_server {tags {"scripting"}} {
test {FUNCTION - write script with no-writes flag} {
r function load replace {#!lua name=test
redis.register_function{
server.register_function{
function_name = 'f1',
callback = function() return redis.call('set', 'x', 1) end,
flags = {'no-writes'}
@ -1056,7 +1056,7 @@ start_server {tags {"scripting"}} {
test {FUNCTION - deny oom} {
r FUNCTION load replace {#!lua name=test
redis.register_function('f1', function() return redis.call('set', 'x', '1') end)
server.register_function('f1', function() return redis.call('set', 'x', '1') end)
}
r config set maxmemory 1
@ -1069,7 +1069,7 @@ start_server {tags {"scripting"}} {
test {FUNCTION - deny oom on no-writes function} {
r FUNCTION load replace {#!lua name=test
redis.register_function{function_name='f1', callback=function() return 'hello' end, flags={'no-writes'}}
server.register_function{function_name='f1', callback=function() return 'hello' end, flags={'no-writes'}}
}
r config set maxmemory 1
@ -1082,10 +1082,10 @@ start_server {tags {"scripting"}} {
test {FUNCTION - allow stale} {
r FUNCTION load replace {#!lua name=test
redis.register_function{function_name='f1', callback=function() return 'hello' end, flags={'no-writes'}}
redis.register_function{function_name='f2', callback=function() return 'hello' end, flags={'allow-stale', 'no-writes'}}
redis.register_function{function_name='f3', callback=function() return redis.call('get', 'x') end, flags={'allow-stale', 'no-writes'}}
redis.register_function{function_name='f4', callback=function() return redis.call('info', 'server') end, flags={'allow-stale', 'no-writes'}}
server.register_function{function_name='f1', callback=function() return 'hello' end, flags={'no-writes'}}
server.register_function{function_name='f2', callback=function() return 'hello' end, flags={'allow-stale', 'no-writes'}}
server.register_function{function_name='f3', callback=function() return redis.call('get', 'x') end, flags={'allow-stale', 'no-writes'}}
server.register_function{function_name='f4', callback=function() return redis.call('info', 'server') end, flags={'allow-stale', 'no-writes'}}
}
r config set replica-serve-stale-data no
@ -1110,13 +1110,13 @@ start_server {tags {"scripting"}} {
r FUNCTION load replace {#!lua name=test
local version = redis.REDIS_VERSION_NUM
redis.register_function{function_name='get_version_v1', callback=function()
server.register_function{function_name='get_version_v1', callback=function()
return string.format('%s.%s.%s',
bit.band(bit.rshift(version, 16), 0x000000ff),
bit.band(bit.rshift(version, 8), 0x000000ff),
bit.band(version, 0x000000ff))
end}
redis.register_function{function_name='get_version_v2', callback=function() return redis.REDIS_VERSION end}
server.register_function{function_name='get_version_v2', callback=function() return redis.REDIS_VERSION end}
}
catch {[r fcall f1 0]} e
@ -1127,12 +1127,12 @@ start_server {tags {"scripting"}} {
r FUNCTION FLUSH
r FUNCTION load {#!lua name=test1
redis.register_function('f1', function() return 1 end)
redis.register_function('f2', function() return 1 end)
server.register_function('f1', function() return 1 end)
server.register_function('f2', function() return 1 end)
}
r FUNCTION load {#!lua name=test2
redis.register_function('f3', function() return 1 end)
server.register_function('f3', function() return 1 end)
}
r function stats
@ -1152,12 +1152,12 @@ start_server {tags {"scripting"}} {
r FUNCTION FLUSH
r FUNCTION load {#!lua name=test1
redis.register_function('f1', function() return 1 end)
redis.register_function('f2', function() return 1 end)
server.register_function('f1', function() return 1 end)
server.register_function('f2', function() return 1 end)
}
catch {r FUNCTION load {#!lua name=test1
redis.register_function('f3', function() return 1 end)
server.register_function('f3', function() return 1 end)
}} e
assert_match "*Library 'test1' already exists*" $e
@ -1172,35 +1172,35 @@ start_server {tags {"scripting"}} {
test {FUNCTION - function test empty engine} {
catch {r function load replace {#! name=test
redis.register_function('foo', function() return 1 end)
server.register_function('foo', function() return 1 end)
}} e
set _ $e
} {ERR Engine '' not found}
test {FUNCTION - function test unknown metadata value} {
catch {r function load replace {#!lua name=test foo=bar
redis.register_function('foo', function() return 1 end)
server.register_function('foo', function() return 1 end)
}} e
set _ $e
} {ERR Invalid metadata value given: foo=bar}
test {FUNCTION - function test no name} {
catch {r function load replace {#!lua
redis.register_function('foo', function() return 1 end)
server.register_function('foo', function() return 1 end)
}} e
set _ $e
} {ERR Library name was not given}
test {FUNCTION - function test multiple names} {
catch {r function load replace {#!lua name=foo name=bar
redis.register_function('foo', function() return 1 end)
server.register_function('foo', function() return 1 end)
}} e
set _ $e
} {ERR Invalid metadata value, name argument was given multiple times}
test {FUNCTION - function test name with quotes} {
r function load replace {#!lua name="foo"
redis.register_function('foo', function() return 1 end)
server.register_function('foo', function() return 1 end)
}
} {foo}
@ -1208,7 +1208,7 @@ start_server {tags {"scripting"}} {
r FUNCTION FLUSH
r FUNCTION load {#!lua name=test1
redis.register_function('f1', function()
server.register_function('f1', function()
mt = getmetatable(_G)
original_globals = mt.__index
original_globals['redis'] = function() return 1 end

2
tests/unit/introspection.tcl
View File

@ -311,7 +311,7 @@ start_server {tags {"introspection"}} {
test {MONITOR can log commands issued by functions} {
r function load replace {#!lua name=test
redis.register_function('test', function() return redis.call('set', 'foo', 'bar') end)
server.register_function('test', function() return redis.call('set', 'foo', 'bar') end)
}
set rd [valkey_deferring_client]
$rd monitor

2
tests/unit/moduleapi/misc.tcl
View File

@ -45,7 +45,7 @@ start_server {overrides {save {900 1}} tags {"modules"}} {
test {test RedisModule_ResetDataset do not reset functions} {
r function load {#!lua name=lib
redis.register_function('test', function() return 1 end)
server.register_function('test', function() return 1 end)
}
assert_equal [r function list] {{library_name lib engine LUA functions {{name test description {} flags {}}}}}
r test.flushall

2
tests/unit/pause.tcl
View File

@ -133,7 +133,7 @@ start_server {tags {"pause network"}} {
r set x y
# create a function for later
r FUNCTION load replace {#!lua name=f1
redis.register_function{
server.register_function{
function_name='f1',
callback=function() return "hello" end,
flags={'no-writes'}

2
tests/unit/scripting.tcl
View File

@ -1189,7 +1189,7 @@ start_server {tags {"scripting"}} {
set buf "*3\r\n\$4\r\neval\r\n\$33\r\nwhile 1 do redis.call('ping') end\r\n\$1\r\n0\r\n"
append buf "*1\r\n\$4\r\nping\r\n"
} else {
set buf "*4\r\n\$8\r\nfunction\r\n\$4\r\nload\r\n\$7\r\nreplace\r\n\$97\r\n#!lua name=test\nredis.register_function('test', function() while 1 do redis.call('ping') end end)\r\n"
set buf "*4\r\n\$8\r\nfunction\r\n\$4\r\nload\r\n\$7\r\nreplace\r\n\$99\r\n#!lua name=test\nserver.register_function('test', function() while 1 do server.call('ping') end end)\r\n"
append buf "*3\r\n\$5\r\nfcall\r\n\$4\r\ntest\r\n\$1\r\n0\r\n"
append buf "*1\r\n\$4\r\nping\r\n"
}