2020-07-23 09:38:51 +00:00
|
|
|
/* This module is used to test the server keyspace events API.
|
|
|
|
|
*
|
|
|
|
|
* -----------------------------------------------------------------------------
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2020, Meir Shpilraien <meir at redislabs dot com>
|
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
|
*
|
|
|
|
|
* * Redistributions of source code must retain the above copyright notice,
|
|
|
|
|
* this list of conditions and the following disclaimer.
|
|
|
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
|
* * Neither the name of Redis nor the names of its contributors may be used
|
|
|
|
|
* to endorse or promote products derived from this software without
|
|
|
|
|
* specific prior written permission.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
|
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
*/
|
|
|
|
|
|
2022-08-02 15:00:11 +00:00
|
|
|
#define _BSD_SOURCE
|
2022-07-27 11:40:05 +00:00
|
|
|
#define _DEFAULT_SOURCE /* For usleep */
|
2020-07-23 09:38:51 +00:00
|
|
|
|
|
|
|
|
#include "redismodule.h"
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <string.h>
|
2022-07-27 11:40:05 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
|
|
ustime_t cached_time = 0;
|
2020-07-23 09:38:51 +00:00
|
|
|
|
2021-06-10 12:39:33 +00:00
|
|
|
/** stores all the keys on which we got 'loaded' keyspace notification **/
|
2020-07-23 09:38:51 +00:00
|
|
|
RedisModuleDict *loaded_event_log = NULL;
|
2021-04-19 18:33:26 +00:00
|
|
|
/** stores all the keys on which we got 'module' keyspace notification **/
|
|
|
|
|
RedisModuleDict *module_event_log = NULL;
|
2020-07-23 09:38:51 +00:00
|
|
|
|
2022-10-16 05:30:01 +00:00
|
|
|
/** Counts how many deleted KSN we got on keys with a prefix of "count_dels_" **/
|
|
|
|
|
static size_t dels = 0;
|
|
|
|
|
|
2020-12-06 11:14:18 +00:00
|
|
|
static int KeySpace_NotificationLoaded(RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key){
|
2020-07-23 09:38:51 +00:00
|
|
|
REDISMODULE_NOT_USED(ctx);
|
|
|
|
|
REDISMODULE_NOT_USED(type);
|
|
|
|
|
|
|
|
|
|
if(strcmp(event, "loaded") == 0){
|
|
|
|
|
const char* keyName = RedisModule_StringPtrLen(key, NULL);
|
|
|
|
|
int nokey;
|
|
|
|
|
RedisModule_DictGetC(loaded_event_log, (void*)keyName, strlen(keyName), &nokey);
|
|
|
|
|
if(nokey){
|
2020-08-09 03:11:47 +00:00
|
|
|
RedisModule_DictSetC(loaded_event_log, (void*)keyName, strlen(keyName), RedisModule_HoldString(ctx, key));
|
2020-07-23 09:38:51 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2020-12-06 11:14:18 +00:00
|
|
|
static int KeySpace_NotificationGeneric(RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key) {
|
|
|
|
|
REDISMODULE_NOT_USED(type);
|
2022-10-16 05:30:01 +00:00
|
|
|
const char *key_str = RedisModule_StringPtrLen(key, NULL);
|
|
|
|
|
if (strncmp(key_str, "count_dels_", 11) == 0 && strcmp(event, "del") == 0) {
|
|
|
|
|
if (RedisModule_GetContextFlags(ctx) & REDISMODULE_CTX_FLAGS_MASTER) {
|
|
|
|
|
dels++;
|
|
|
|
|
RedisModule_Replicate(ctx, "keyspace.incr_dels", "");
|
|
|
|
|
}
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
2022-07-27 11:40:05 +00:00
|
|
|
if (cached_time) {
|
|
|
|
|
RedisModule_Assert(cached_time == RedisModule_CachedMicroseconds());
|
|
|
|
|
usleep(1);
|
|
|
|
|
RedisModule_Assert(cached_time != RedisModule_Microseconds());
|
|
|
|
|
}
|
|
|
|
|
|
2020-12-06 11:14:18 +00:00
|
|
|
if (strcmp(event, "del") == 0) {
|
|
|
|
|
RedisModuleString *copykey = RedisModule_CreateStringPrintf(ctx, "%s_copy", RedisModule_StringPtrLen(key, NULL));
|
|
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "DEL", "s!", copykey);
|
|
|
|
|
RedisModule_FreeString(ctx, copykey);
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
|
|
|
|
|
int ctx_flags = RedisModule_GetContextFlags(ctx);
|
|
|
|
|
if (ctx_flags & REDISMODULE_CTX_FLAGS_LUA) {
|
|
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "INCR", "c", "lua");
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
}
|
|
|
|
|
if (ctx_flags & REDISMODULE_CTX_FLAGS_MULTI) {
|
|
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "INCR", "c", "multi");
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-25 10:05:06 +00:00
|
|
|
static int KeySpace_NotificationExpired(RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key) {
|
|
|
|
|
REDISMODULE_NOT_USED(type);
|
|
|
|
|
REDISMODULE_NOT_USED(event);
|
|
|
|
|
REDISMODULE_NOT_USED(key);
|
|
|
|
|
|
|
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "INCR", "c!", "testkeyspace:expired");
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
Fix replication inconsistency on modules that uses key space notifications (#10969)
Fix replication inconsistency on modules that uses key space notifications.
### The Problem
In general, key space notifications are invoked after the command logic was
executed (this is not always the case, we will discuss later about specific
command that do not follow this rules). For example, the `set x 1` will trigger
a `set` notification that will be invoked after the `set` logic was performed, so
if the notification logic will try to fetch `x`, it will see the new data that was written.
Consider the scenario on which the notification logic performs some write
commands. for example, the notification logic increase some counter,
`incr x{counter}`, indicating how many times `x` was changed.
The logical order by which the logic was executed is has follow:
```
set x 1
incr x{counter}
```
The issue is that the `set x 1` command is added to the replication buffer
at the end of the command invocation (specifically after the key space
notification logic was invoked and performed the `incr` command).
The replication/aof sees the commands in the wrong order:
```
incr x{counter}
set x 1
```
In this specific example the order is less important.
But if, for example, the notification would have deleted `x` then we would
end up with primary-replica inconsistency.
### The Solution
Put the command that cause the notification in its rightful place. In the
above example, the `set x 1` command logic was executed before the
notification logic, so it should be added to the replication buffer before
the commands that is invoked by the notification logic. To achieve this,
without a major code refactoring, we save a placeholder in the replication
buffer, when finishing invoking the command logic we check if the command
need to be replicated, and if it does, we use the placeholder to add it to the
replication buffer instead of appending it to the end.
To be efficient and not allocating memory on each command to save the
placeholder, the replication buffer array was modified to reuse memory
(instead of allocating it each time we want to replicate commands).
Also, to avoid saving a placeholder when not needed, we do it only for
WRITE or MAY_REPLICATE commands.
#### Additional Fixes
* Expire and Eviction notifications:
* Expire/Eviction logical order was to first perform the Expire/Eviction
and then the notification logic. The replication buffer got this in the
other way around (first notification effect and then the `del` command).
The PR fixes this issue.
* The notification effect and the `del` command was not wrap with
`multi-exec` (if needed). The PR also fix this issue.
* SPOP command:
* On spop, the `spop` notification was fired before the command logic
was executed. The change in this PR would have cause the replication
order to be change (first `spop` command and then notification `logic`)
although the logical order is first the notification logic and then the
`spop` logic. The right fix would have been to move the notification to
be fired after the command was executed (like all the other commands),
but this can be considered a breaking change. To overcome this, the PR
keeps the current behavior and changes the `spop` code to keep the right
logical order when pushing commands to the replication buffer. Another PR
will follow to fix the SPOP properly and match it to the other command (we
split it to 2 separate PR's so it will be easy to cherry-pick this PR to 7.0 if
we chose to).
#### Unhanded Known Limitations
* key miss event:
* On key miss event, if a module performed some write command on the
event (using `RM_Call`), the `dirty` counter would increase and the read
command that cause the key miss event would be replicated to the replication
and aof. This problem can also happened on a write command that open
some keys but eventually decides not to perform any action. We decided
not to handle this problem on this PR because the solution is complex
and will cause additional risks in case we will want to cherry-pick this PR.
We should decide if we want to handle it in future PR's. For now, modules
writers is advice not to perform any write commands on key miss event.
#### Testing
* We already have tests to cover cases where a notification is invoking write
commands that are also added to the replication buffer, the tests was modified
to verify that the replica gets the command in the correct logical order.
* Test was added to verify that `spop` behavior was kept unchanged.
* Test was added to verify key miss event behave as expected.
* Test was added to verify the changes do not break lazy expiration.
#### Additional Changes
* `propagateNow` function can accept a special dbid, -1, indicating not
to replicate `select`. We use this to replicate `multi/exec` on `propagatePendingCommands`
function. The side effect of this change is that now the `select` command
will appear inside the `multi/exec` block on the replication stream (instead of
outside of the `multi/exec` block). Tests was modified to match this new behavior.
2022-08-18 07:16:32 +00:00
|
|
|
/* This key miss notification handler is performing a write command inside the notification callback.
|
|
|
|
|
* Notice, it is discourage and currently wrong to perform a write command inside key miss event.
|
|
|
|
|
* It can cause read commands to be replicated to the replica/aof. This test is here temporary (for coverage and
|
|
|
|
|
* verification that it's not crashing). */
|
|
|
|
|
static int KeySpace_NotificationModuleKeyMiss(RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key) {
|
|
|
|
|
REDISMODULE_NOT_USED(type);
|
|
|
|
|
REDISMODULE_NOT_USED(event);
|
|
|
|
|
REDISMODULE_NOT_USED(key);
|
|
|
|
|
|
|
|
|
|
int flags = RedisModule_GetContextFlags(ctx);
|
|
|
|
|
if (!(flags & REDISMODULE_CTX_FLAGS_MASTER)) {
|
|
|
|
|
return REDISMODULE_OK; // ignore the event on replica
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "incr", "!c", "missed");
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
Module API to allow writes after key space notification hooks (#11199)
### Summary of API additions
* `RedisModule_AddPostNotificationJob` - new API to call inside a key space
notification (and on more locations in the future) and allow to add a post job as describe above.
* New module option, `REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS`,
allows to disable Redis protection of nested key-space notifications.
* `RedisModule_GetModuleOptionsAll` - gets the mask of all supported module options so a module
will be able to check if a given option is supported by the current running Redis instance.
### Background
The following PR is a proposal of handling write operations inside module key space notifications.
After a lot of discussions we came to a conclusion that module should not perform any write
operations on key space notification.
Some examples of issues that such write operation can cause are describe on the following links:
* Bad replication oreder - https://github.com/redis/redis/pull/10969
* Used after free - https://github.com/redis/redis/pull/10969#issuecomment-1223771006
* Used after free - https://github.com/redis/redis/pull/9406#issuecomment-1221684054
There are probably more issues that are yet to be discovered. The underline problem with writing
inside key space notification is that the notification runs synchronously, this means that the notification
code will be executed in the middle on Redis logic (commands logic, eviction, expire).
Redis **do not assume** that the data might change while running the logic and such changes
can crash Redis or cause unexpected behaviour.
The solution is to state that modules **should not** perform any write command inside key space
notification (we can chose whether or not we want to force it). To still cover the use-case where
module wants to perform a write operation as a reaction to key space notifications, we introduce
a new API , `RedisModule_AddPostNotificationJob`, that allows to register a callback that will be
called by Redis when the following conditions hold:
* It is safe to perform any write operation.
* The job will be called atomically along side the operation that triggers it (in our case, key
space notification).
Module can use this new API to safely perform any write operation and still achieve atomicity
between the notification and the write.
Although currently the API is supported on key space notifications, the API is written in a generic
way so that in the future we will be able to use it on other places (server events for example).
### Technical Details
Whenever a module uses `RedisModule_AddPostNotificationJob` the callback is added to a list
of callbacks (called `modulePostExecUnitJobs`) that need to be invoke after the current execution
unit ends (whether its a command, eviction, or active expire). In order to trigger those callback
atomically with the notification effect, we call those callbacks on `postExecutionUnitOperations`
(which was `propagatePendingCommands` before this PR). The new function fires the post jobs
and then calls `propagatePendingCommands`.
If the callback perform more operations that triggers more key space notifications. Those keys
space notifications might register more callbacks. Those callbacks will be added to the end
of `modulePostExecUnitJobs` list and will be invoke atomically after the current callback ends.
This raises a concerns of entering an infinite loops, we consider infinite loops as a logical bug
that need to be fixed in the module, an attempt to protect against infinite loops by halting the
execution could result in violation of the feature correctness and so **Redis will make no attempt
to protect the module from infinite loops**
In addition, currently key space notifications are not nested. Some modules might want to allow
nesting key-space notifications. To allow that and keep backward compatibility, we introduce a
new module option called `REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS`.
Setting this option will disable the Redis key-space notifications nesting protection and will
pass this responsibility to the module.
### Redis infrastructure
This PR promotes the existing `propagatePendingCommands` to an "Execution Unit" concept,
which is called after each atomic unit of execution,
Co-authored-by: Oran Agra <oran@redislabs.com>
Co-authored-by: Yossi Gottlieb <yossigo@gmail.com>
Co-authored-by: Madelyn Olson <34459052+madolson@users.noreply.github.com>
2022-11-24 17:00:04 +00:00
|
|
|
static int KeySpace_NotificationModuleString(RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key) {
|
|
|
|
|
REDISMODULE_NOT_USED(type);
|
|
|
|
|
REDISMODULE_NOT_USED(event);
|
|
|
|
|
RedisModuleKey *redis_key = RedisModule_OpenKey(ctx, key, REDISMODULE_READ);
|
|
|
|
|
|
|
|
|
|
size_t len = 0;
|
|
|
|
|
/* RedisModule_StringDMA could change the data format and cause the old robj to be freed.
|
|
|
|
|
* This code verifies that such format change will not cause any crashes.*/
|
|
|
|
|
char *data = RedisModule_StringDMA(redis_key, &len, REDISMODULE_READ);
|
|
|
|
|
int res = strncmp(data, "dummy", 5);
|
|
|
|
|
REDISMODULE_NOT_USED(res);
|
|
|
|
|
|
|
|
|
|
RedisModule_CloseKey(redis_key);
|
|
|
|
|
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void KeySpace_PostNotificationStringFreePD(void *pd) {
|
|
|
|
|
RedisModule_FreeString(NULL, pd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void KeySpace_PostNotificationString(RedisModuleCtx *ctx, void *pd) {
|
|
|
|
|
REDISMODULE_NOT_USED(ctx);
|
|
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "incr", "!s", pd);
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int KeySpace_NotificationModuleStringPostNotificationJob(RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key) {
|
|
|
|
|
REDISMODULE_NOT_USED(ctx);
|
|
|
|
|
REDISMODULE_NOT_USED(type);
|
|
|
|
|
REDISMODULE_NOT_USED(event);
|
|
|
|
|
|
|
|
|
|
const char *key_str = RedisModule_StringPtrLen(key, NULL);
|
|
|
|
|
|
|
|
|
|
if (strncmp(key_str, "string1_", 8) != 0) {
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
RedisModuleString *new_key = RedisModule_CreateStringPrintf(NULL, "string_changed{%s}", key_str);
|
|
|
|
|
RedisModule_AddPostNotificationJob(ctx, KeySpace_PostNotificationString, new_key, KeySpace_PostNotificationStringFreePD);
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-19 18:33:26 +00:00
|
|
|
static int KeySpace_NotificationModule(RedisModuleCtx *ctx, int type, const char *event, RedisModuleString *key) {
|
|
|
|
|
REDISMODULE_NOT_USED(ctx);
|
|
|
|
|
REDISMODULE_NOT_USED(type);
|
|
|
|
|
REDISMODULE_NOT_USED(event);
|
|
|
|
|
|
|
|
|
|
const char* keyName = RedisModule_StringPtrLen(key, NULL);
|
|
|
|
|
int nokey;
|
|
|
|
|
RedisModule_DictGetC(module_event_log, (void*)keyName, strlen(keyName), &nokey);
|
|
|
|
|
if(nokey){
|
|
|
|
|
RedisModule_DictSetC(module_event_log, (void*)keyName, strlen(keyName), RedisModule_HoldString(ctx, key));
|
|
|
|
|
}
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int cmdNotify(RedisModuleCtx *ctx, RedisModuleString **argv, int argc){
|
|
|
|
|
if(argc != 2){
|
|
|
|
|
return RedisModule_WrongArity(ctx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
RedisModule_NotifyKeyspaceEvent(ctx, REDISMODULE_NOTIFY_MODULE, "notify", argv[1]);
|
|
|
|
|
RedisModule_ReplyWithNull(ctx);
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int cmdIsModuleKeyNotified(RedisModuleCtx *ctx, RedisModuleString **argv, int argc){
|
|
|
|
|
if(argc != 2){
|
|
|
|
|
return RedisModule_WrongArity(ctx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* key = RedisModule_StringPtrLen(argv[1], NULL);
|
|
|
|
|
|
|
|
|
|
int nokey;
|
|
|
|
|
RedisModuleString* keyStr = RedisModule_DictGetC(module_event_log, (void*)key, strlen(key), &nokey);
|
|
|
|
|
|
|
|
|
|
RedisModule_ReplyWithArray(ctx, 2);
|
|
|
|
|
RedisModule_ReplyWithLongLong(ctx, !nokey);
|
|
|
|
|
if(nokey){
|
|
|
|
|
RedisModule_ReplyWithNull(ctx);
|
|
|
|
|
}else{
|
|
|
|
|
RedisModule_ReplyWithString(ctx, keyStr);
|
|
|
|
|
}
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-23 09:38:51 +00:00
|
|
|
static int cmdIsKeyLoaded(RedisModuleCtx *ctx, RedisModuleString **argv, int argc){
|
|
|
|
|
if(argc != 2){
|
|
|
|
|
return RedisModule_WrongArity(ctx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* key = RedisModule_StringPtrLen(argv[1], NULL);
|
|
|
|
|
|
|
|
|
|
int nokey;
|
2020-08-09 03:11:47 +00:00
|
|
|
RedisModuleString* keyStr = RedisModule_DictGetC(loaded_event_log, (void*)key, strlen(key), &nokey);
|
2020-07-23 09:38:51 +00:00
|
|
|
|
2020-08-09 03:11:47 +00:00
|
|
|
RedisModule_ReplyWithArray(ctx, 2);
|
2020-07-23 09:38:51 +00:00
|
|
|
RedisModule_ReplyWithLongLong(ctx, !nokey);
|
2020-08-09 03:11:47 +00:00
|
|
|
if(nokey){
|
|
|
|
|
RedisModule_ReplyWithNull(ctx);
|
|
|
|
|
}else{
|
|
|
|
|
RedisModule_ReplyWithString(ctx, keyStr);
|
|
|
|
|
}
|
2020-07-23 09:38:51 +00:00
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2020-12-06 11:14:18 +00:00
|
|
|
static int cmdDelKeyCopy(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
|
|
|
|
if (argc != 2)
|
|
|
|
|
return RedisModule_WrongArity(ctx);
|
|
|
|
|
|
2022-07-27 11:40:05 +00:00
|
|
|
cached_time = RedisModule_CachedMicroseconds();
|
|
|
|
|
|
2020-12-06 11:14:18 +00:00
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "DEL", "s!", argv[1]);
|
|
|
|
|
if (!rep) {
|
|
|
|
|
RedisModule_ReplyWithError(ctx, "NULL reply returned");
|
|
|
|
|
} else {
|
|
|
|
|
RedisModule_ReplyWithCallReply(ctx, rep);
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
}
|
2022-07-27 11:40:05 +00:00
|
|
|
cached_time = 0;
|
2020-12-06 11:14:18 +00:00
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Call INCR and propagate using RM_Call with `!`. */
|
|
|
|
|
static int cmdIncrCase1(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
|
|
|
|
if (argc != 2)
|
|
|
|
|
return RedisModule_WrongArity(ctx);
|
|
|
|
|
|
|
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "INCR", "s!", argv[1]);
|
|
|
|
|
if (!rep) {
|
|
|
|
|
RedisModule_ReplyWithError(ctx, "NULL reply returned");
|
|
|
|
|
} else {
|
|
|
|
|
RedisModule_ReplyWithCallReply(ctx, rep);
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
}
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Call INCR and propagate using RM_Replicate. */
|
|
|
|
|
static int cmdIncrCase2(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
|
|
|
|
if (argc != 2)
|
|
|
|
|
return RedisModule_WrongArity(ctx);
|
|
|
|
|
|
|
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "INCR", "s", argv[1]);
|
|
|
|
|
if (!rep) {
|
|
|
|
|
RedisModule_ReplyWithError(ctx, "NULL reply returned");
|
|
|
|
|
} else {
|
|
|
|
|
RedisModule_ReplyWithCallReply(ctx, rep);
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
}
|
|
|
|
|
RedisModule_Replicate(ctx, "INCR", "s", argv[1]);
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Call INCR and propagate using RM_ReplicateVerbatim. */
|
|
|
|
|
static int cmdIncrCase3(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
|
|
|
|
if (argc != 2)
|
|
|
|
|
return RedisModule_WrongArity(ctx);
|
|
|
|
|
|
|
|
|
|
RedisModuleCallReply* rep = RedisModule_Call(ctx, "INCR", "s", argv[1]);
|
|
|
|
|
if (!rep) {
|
|
|
|
|
RedisModule_ReplyWithError(ctx, "NULL reply returned");
|
|
|
|
|
} else {
|
|
|
|
|
RedisModule_ReplyWithCallReply(ctx, rep);
|
|
|
|
|
RedisModule_FreeCallReply(rep);
|
|
|
|
|
}
|
|
|
|
|
RedisModule_ReplicateVerbatim(ctx);
|
|
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-10-16 05:30:01 +00:00
|
|
|
static int cmdIncrDels(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
|
|
|
|
REDISMODULE_NOT_USED(argv);
|
|
|
|
|
REDISMODULE_NOT_USED(argc);
|
|
|
|
|
dels++;
|
|
|
|
|
return RedisModule_ReplyWithSimpleString(ctx, "OK");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int cmdGetDels(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
|
|
|
|
REDISMODULE_NOT_USED(argv);
|
|
|
|
|
REDISMODULE_NOT_USED(argc);
|
|
|
|
|
return RedisModule_ReplyWithLongLong(ctx, dels);
|
|
|
|
|
}
|
2020-12-06 11:14:18 +00:00
|
|
|
|
2020-07-23 09:38:51 +00:00
|
|
|
/* This function must be present on each Redis module. It is used in order to
|
|
|
|
|
* register the commands into the Redis server. */
|
|
|
|
|
int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
|
|
|
|
REDISMODULE_NOT_USED(argv);
|
|
|
|
|
REDISMODULE_NOT_USED(argc);
|
|
|
|
|
|
|
|
|
|
if (RedisModule_Init(ctx,"testkeyspace",1,REDISMODULE_APIVER_1) == REDISMODULE_ERR){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
loaded_event_log = RedisModule_CreateDict(ctx);
|
2021-04-19 18:33:26 +00:00
|
|
|
module_event_log = RedisModule_CreateDict(ctx);
|
2020-07-23 09:38:51 +00:00
|
|
|
|
2020-10-11 14:21:58 +00:00
|
|
|
int keySpaceAll = RedisModule_GetKeyspaceNotificationFlagsAll();
|
|
|
|
|
|
|
|
|
|
if (!(keySpaceAll & REDISMODULE_NOTIFY_LOADED)) {
|
|
|
|
|
// REDISMODULE_NOTIFY_LOADED event are not supported we can not start
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2020-12-06 11:14:18 +00:00
|
|
|
if(RedisModule_SubscribeToKeyspaceEvents(ctx, REDISMODULE_NOTIFY_LOADED, KeySpace_NotificationLoaded) != REDISMODULE_OK){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(RedisModule_SubscribeToKeyspaceEvents(ctx, REDISMODULE_NOTIFY_GENERIC, KeySpace_NotificationGeneric) != REDISMODULE_OK){
|
2020-07-23 09:38:51 +00:00
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-25 10:05:06 +00:00
|
|
|
if(RedisModule_SubscribeToKeyspaceEvents(ctx, REDISMODULE_NOTIFY_EXPIRED, KeySpace_NotificationExpired) != REDISMODULE_OK){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-19 18:33:26 +00:00
|
|
|
if(RedisModule_SubscribeToKeyspaceEvents(ctx, REDISMODULE_NOTIFY_MODULE, KeySpace_NotificationModule) != REDISMODULE_OK){
|
|
|
|
|
return REDISMODULE_ERR;
|
Fix replication inconsistency on modules that uses key space notifications (#10969)
Fix replication inconsistency on modules that uses key space notifications.
### The Problem
In general, key space notifications are invoked after the command logic was
executed (this is not always the case, we will discuss later about specific
command that do not follow this rules). For example, the `set x 1` will trigger
a `set` notification that will be invoked after the `set` logic was performed, so
if the notification logic will try to fetch `x`, it will see the new data that was written.
Consider the scenario on which the notification logic performs some write
commands. for example, the notification logic increase some counter,
`incr x{counter}`, indicating how many times `x` was changed.
The logical order by which the logic was executed is has follow:
```
set x 1
incr x{counter}
```
The issue is that the `set x 1` command is added to the replication buffer
at the end of the command invocation (specifically after the key space
notification logic was invoked and performed the `incr` command).
The replication/aof sees the commands in the wrong order:
```
incr x{counter}
set x 1
```
In this specific example the order is less important.
But if, for example, the notification would have deleted `x` then we would
end up with primary-replica inconsistency.
### The Solution
Put the command that cause the notification in its rightful place. In the
above example, the `set x 1` command logic was executed before the
notification logic, so it should be added to the replication buffer before
the commands that is invoked by the notification logic. To achieve this,
without a major code refactoring, we save a placeholder in the replication
buffer, when finishing invoking the command logic we check if the command
need to be replicated, and if it does, we use the placeholder to add it to the
replication buffer instead of appending it to the end.
To be efficient and not allocating memory on each command to save the
placeholder, the replication buffer array was modified to reuse memory
(instead of allocating it each time we want to replicate commands).
Also, to avoid saving a placeholder when not needed, we do it only for
WRITE or MAY_REPLICATE commands.
#### Additional Fixes
* Expire and Eviction notifications:
* Expire/Eviction logical order was to first perform the Expire/Eviction
and then the notification logic. The replication buffer got this in the
other way around (first notification effect and then the `del` command).
The PR fixes this issue.
* The notification effect and the `del` command was not wrap with
`multi-exec` (if needed). The PR also fix this issue.
* SPOP command:
* On spop, the `spop` notification was fired before the command logic
was executed. The change in this PR would have cause the replication
order to be change (first `spop` command and then notification `logic`)
although the logical order is first the notification logic and then the
`spop` logic. The right fix would have been to move the notification to
be fired after the command was executed (like all the other commands),
but this can be considered a breaking change. To overcome this, the PR
keeps the current behavior and changes the `spop` code to keep the right
logical order when pushing commands to the replication buffer. Another PR
will follow to fix the SPOP properly and match it to the other command (we
split it to 2 separate PR's so it will be easy to cherry-pick this PR to 7.0 if
we chose to).
#### Unhanded Known Limitations
* key miss event:
* On key miss event, if a module performed some write command on the
event (using `RM_Call`), the `dirty` counter would increase and the read
command that cause the key miss event would be replicated to the replication
and aof. This problem can also happened on a write command that open
some keys but eventually decides not to perform any action. We decided
not to handle this problem on this PR because the solution is complex
and will cause additional risks in case we will want to cherry-pick this PR.
We should decide if we want to handle it in future PR's. For now, modules
writers is advice not to perform any write commands on key miss event.
#### Testing
* We already have tests to cover cases where a notification is invoking write
commands that are also added to the replication buffer, the tests was modified
to verify that the replica gets the command in the correct logical order.
* Test was added to verify that `spop` behavior was kept unchanged.
* Test was added to verify key miss event behave as expected.
* Test was added to verify the changes do not break lazy expiration.
#### Additional Changes
* `propagateNow` function can accept a special dbid, -1, indicating not
to replicate `select`. We use this to replicate `multi/exec` on `propagatePendingCommands`
function. The side effect of this change is that now the `select` command
will appear inside the `multi/exec` block on the replication stream (instead of
outside of the `multi/exec` block). Tests was modified to match this new behavior.
2022-08-18 07:16:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(RedisModule_SubscribeToKeyspaceEvents(ctx, REDISMODULE_NOTIFY_KEY_MISS, KeySpace_NotificationModuleKeyMiss) != REDISMODULE_OK){
|
|
|
|
|
return REDISMODULE_ERR;
|
2021-04-19 18:33:26 +00:00
|
|
|
}
|
|
|
|
|
|
Module API to allow writes after key space notification hooks (#11199)
### Summary of API additions
* `RedisModule_AddPostNotificationJob` - new API to call inside a key space
notification (and on more locations in the future) and allow to add a post job as describe above.
* New module option, `REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS`,
allows to disable Redis protection of nested key-space notifications.
* `RedisModule_GetModuleOptionsAll` - gets the mask of all supported module options so a module
will be able to check if a given option is supported by the current running Redis instance.
### Background
The following PR is a proposal of handling write operations inside module key space notifications.
After a lot of discussions we came to a conclusion that module should not perform any write
operations on key space notification.
Some examples of issues that such write operation can cause are describe on the following links:
* Bad replication oreder - https://github.com/redis/redis/pull/10969
* Used after free - https://github.com/redis/redis/pull/10969#issuecomment-1223771006
* Used after free - https://github.com/redis/redis/pull/9406#issuecomment-1221684054
There are probably more issues that are yet to be discovered. The underline problem with writing
inside key space notification is that the notification runs synchronously, this means that the notification
code will be executed in the middle on Redis logic (commands logic, eviction, expire).
Redis **do not assume** that the data might change while running the logic and such changes
can crash Redis or cause unexpected behaviour.
The solution is to state that modules **should not** perform any write command inside key space
notification (we can chose whether or not we want to force it). To still cover the use-case where
module wants to perform a write operation as a reaction to key space notifications, we introduce
a new API , `RedisModule_AddPostNotificationJob`, that allows to register a callback that will be
called by Redis when the following conditions hold:
* It is safe to perform any write operation.
* The job will be called atomically along side the operation that triggers it (in our case, key
space notification).
Module can use this new API to safely perform any write operation and still achieve atomicity
between the notification and the write.
Although currently the API is supported on key space notifications, the API is written in a generic
way so that in the future we will be able to use it on other places (server events for example).
### Technical Details
Whenever a module uses `RedisModule_AddPostNotificationJob` the callback is added to a list
of callbacks (called `modulePostExecUnitJobs`) that need to be invoke after the current execution
unit ends (whether its a command, eviction, or active expire). In order to trigger those callback
atomically with the notification effect, we call those callbacks on `postExecutionUnitOperations`
(which was `propagatePendingCommands` before this PR). The new function fires the post jobs
and then calls `propagatePendingCommands`.
If the callback perform more operations that triggers more key space notifications. Those keys
space notifications might register more callbacks. Those callbacks will be added to the end
of `modulePostExecUnitJobs` list and will be invoke atomically after the current callback ends.
This raises a concerns of entering an infinite loops, we consider infinite loops as a logical bug
that need to be fixed in the module, an attempt to protect against infinite loops by halting the
execution could result in violation of the feature correctness and so **Redis will make no attempt
to protect the module from infinite loops**
In addition, currently key space notifications are not nested. Some modules might want to allow
nesting key-space notifications. To allow that and keep backward compatibility, we introduce a
new module option called `REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS`.
Setting this option will disable the Redis key-space notifications nesting protection and will
pass this responsibility to the module.
### Redis infrastructure
This PR promotes the existing `propagatePendingCommands` to an "Execution Unit" concept,
which is called after each atomic unit of execution,
Co-authored-by: Oran Agra <oran@redislabs.com>
Co-authored-by: Yossi Gottlieb <yossigo@gmail.com>
Co-authored-by: Madelyn Olson <34459052+madolson@users.noreply.github.com>
2022-11-24 17:00:04 +00:00
|
|
|
if(RedisModule_SubscribeToKeyspaceEvents(ctx, REDISMODULE_NOTIFY_STRING, KeySpace_NotificationModuleString) != REDISMODULE_OK){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(RedisModule_SubscribeToKeyspaceEvents(ctx, REDISMODULE_NOTIFY_STRING, KeySpace_NotificationModuleStringPostNotificationJob) != REDISMODULE_OK){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2021-04-19 18:33:26 +00:00
|
|
|
if (RedisModule_CreateCommand(ctx,"keyspace.notify", cmdNotify,"",0,0,0) == REDISMODULE_ERR){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (RedisModule_CreateCommand(ctx,"keyspace.is_module_key_notified", cmdIsModuleKeyNotified,"",0,0,0) == REDISMODULE_ERR){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-23 09:38:51 +00:00
|
|
|
if (RedisModule_CreateCommand(ctx,"keyspace.is_key_loaded", cmdIsKeyLoaded,"",0,0,0) == REDISMODULE_ERR){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2021-11-28 09:26:28 +00:00
|
|
|
if (RedisModule_CreateCommand(ctx, "keyspace.del_key_copy", cmdDelKeyCopy,
|
|
|
|
|
"write", 0, 0, 0) == REDISMODULE_ERR){
|
2020-12-06 11:14:18 +00:00
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2021-11-28 09:26:28 +00:00
|
|
|
if (RedisModule_CreateCommand(ctx, "keyspace.incr_case1", cmdIncrCase1,
|
|
|
|
|
"write", 0, 0, 0) == REDISMODULE_ERR){
|
2020-12-06 11:14:18 +00:00
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2021-11-28 09:26:28 +00:00
|
|
|
if (RedisModule_CreateCommand(ctx, "keyspace.incr_case2", cmdIncrCase2,
|
|
|
|
|
"write", 0, 0, 0) == REDISMODULE_ERR){
|
2020-12-06 11:14:18 +00:00
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2021-11-28 09:26:28 +00:00
|
|
|
if (RedisModule_CreateCommand(ctx, "keyspace.incr_case3", cmdIncrCase3,
|
|
|
|
|
"write", 0, 0, 0) == REDISMODULE_ERR){
|
2020-12-06 11:14:18 +00:00
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2022-10-16 05:30:01 +00:00
|
|
|
if (RedisModule_CreateCommand(ctx, "keyspace.incr_dels", cmdIncrDels,
|
|
|
|
|
"write", 0, 0, 0) == REDISMODULE_ERR){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (RedisModule_CreateCommand(ctx, "keyspace.get_dels", cmdGetDels,
|
|
|
|
|
"readonly", 0, 0, 0) == REDISMODULE_ERR){
|
|
|
|
|
return REDISMODULE_ERR;
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-23 09:38:51 +00:00
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int RedisModule_OnUnload(RedisModuleCtx *ctx) {
|
2020-08-09 03:11:47 +00:00
|
|
|
RedisModuleDictIter *iter = RedisModule_DictIteratorStartC(loaded_event_log, "^", NULL, 0);
|
|
|
|
|
char* key;
|
|
|
|
|
size_t keyLen;
|
|
|
|
|
RedisModuleString* val;
|
|
|
|
|
while((key = RedisModule_DictNextC(iter, &keyLen, (void**)&val))){
|
|
|
|
|
RedisModule_FreeString(ctx, val);
|
|
|
|
|
}
|
2020-07-23 09:38:51 +00:00
|
|
|
RedisModule_FreeDict(ctx, loaded_event_log);
|
2021-04-19 18:33:26 +00:00
|
|
|
RedisModule_DictIteratorStop(iter);
|
2020-07-23 09:38:51 +00:00
|
|
|
loaded_event_log = NULL;
|
2021-04-19 18:33:26 +00:00
|
|
|
|
|
|
|
|
iter = RedisModule_DictIteratorStartC(module_event_log, "^", NULL, 0);
|
|
|
|
|
while((key = RedisModule_DictNextC(iter, &keyLen, (void**)&val))){
|
|
|
|
|
RedisModule_FreeString(ctx, val);
|
|
|
|
|
}
|
|
|
|
|
RedisModule_FreeDict(ctx, module_event_log);
|
|
|
|
|
RedisModule_DictIteratorStop(iter);
|
|
|
|
|
module_event_log = NULL;
|
|
|
|
|
|
2020-07-23 09:38:51 +00:00
|
|
|
return REDISMODULE_OK;
|
|
|
|
|
}
|