fluencelabs/redis
1
0
Fork 0
mirror of https://github.com/fluencelabs/redis synced 2025-06-20 20:46:31 +00:00
Code Issues Projects Releases Wiki Activity

Keyspace events: it is now possible to select subclasses of events.

Browse Source 
When keyspace events are enabled, the overhead is not sever but
noticeable, so this commit introduces the ability to select subclasses
of events in order to avoid to generate events the user is not
interested in.

The events can be selected using redis.conf or CONFIG SET / GET.
This commit is contained in:
antirez
2013-01-25 13:19:08 +01:00
parent 1c0c551776
commit fce016d31b
14 changed files with 237 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
src/notify.c
View File

@ -30,50 +30,97 @@
#include "redis.h"
/* This file implements keyspace events notification via Pub/Sub ad
* described at http://redis.io/topics/keyspace-events.
* described at http://redis.io/topics/keyspace-events. */
/* Turn a string representing notification classes into an integer
* representing notification classes flags xored.
*
* The API provided to the rest of the Redis core is a simple function:
* The function returns -1 if the input contains characters not mapping to
* any class. */
int keyspaceEventsStringToFlags(char *classes) {
char *p = classes;
int c, flags = 0;
while((c = *p++) != '\0') {
switch(c) {
case 'A': flags |= REDIS_NOTIFY_ALL; break;
case 'g': flags |= REDIS_NOTIFY_GENERIC; break;
case '$': flags |= REDIS_NOTIFY_STRING; break;
case 'l': flags |= REDIS_NOTIFY_LIST; break;
case 's': flags |= REDIS_NOTIFY_SET; break;
case 'h': flags |= REDIS_NOTIFY_HASH; break;
case 'z': flags |= REDIS_NOTIFY_ZSET; break;
case 'x': flags |= REDIS_NOTIFY_EXPIRED; break;
case 'e': flags |= REDIS_NOTIFY_EVICTED; break;
case 'K': flags |= REDIS_NOTIFY_KEYSPACE; break;
case 'E': flags |= REDIS_NOTIFY_KEYEVENT; break;
default: return -1;
}
}
return flags;
}
/* This function does exactly the revese of the function above: it gets
* as input an integer with the xored flags and returns a string representing
* the selected classes. The string returned is an sds string that needs to
* be released with sdsfree(). */
sds keyspaceEventsFlagsToString(int flags) {
sds res;
if ((flags & REDIS_NOTIFY_ALL) == REDIS_NOTIFY_ALL)
return sdsnew("A");
res = sdsempty();
if (flags & REDIS_NOTIFY_GENERIC) res = sdscatlen(res,"g",1);
if (flags & REDIS_NOTIFY_STRING) res = sdscatlen(res,"$",1);
if (flags & REDIS_NOTIFY_LIST) res = sdscatlen(res,"l",1);
if (flags & REDIS_NOTIFY_SET) res = sdscatlen(res,"s",1);
if (flags & REDIS_NOTIFY_HASH) res = sdscatlen(res,"h",1);
if (flags & REDIS_NOTIFY_ZSET) res = sdscatlen(res,"z",1);
if (flags & REDIS_NOTIFY_EXPIRED) res = sdscatlen(res,"x",1);
if (flags & REDIS_NOTIFY_EVICTED) res = sdscatlen(res,"e",1);
if (flags & REDIS_NOTIFY_KEYSPACE) res = sdscatlen(res,"K",1);
if (flags & REDIS_NOTIFY_KEYEVENT) res = sdscatlen(res,"E",1);
return res;
}
/* The API provided to the rest of the Redis core is a simple function:
*
* notifyKeyspaceEvent(char *event, robj *key, int dbid);
*
* 'event' is a C string representing the event name.
* 'key' is a Redis object representing the key name.
* 'dbid' is the database ID where the key lives.
*/
void notifyKeyspaceEvent(char *event, robj *key, int dbid) {
sds keyspace_chan, keyevent_chan;
int len;
* 'dbid' is the database ID where the key lives. */
void notifyKeyspaceEvent(int type, char *event, robj *key, int dbid) {
sds chan;
robj *chanobj;
int len = -1;
char buf[24];
robj *chan1, *chan2, *eventobj;
if (!server.notify_keyspace_events) return;
/* If notifications for this class of events are off, return ASAP. */
if (!(server.notify_keyspace_events & type)) return;
/* The prefix of the two channels is identical if not for
* 'keyspace' that is 'keyevent' in the event channel name, so
* we build a single prefix and overwrite 'event' with 'space'. */
keyspace_chan = sdsnewlen("__keyspace@",11);
len = ll2string(buf,sizeof(buf),dbid);
keyspace_chan = sdscatlen(keyspace_chan, buf, len);
keyspace_chan = sdscatlen(keyspace_chan, "__:", 3);
keyevent_chan = sdsdup(keyspace_chan); /* Dup the prefix. */
memcpy(keyevent_chan+5,"event",5); /* Fix it. */
/* __keyspace@<db>__:<key> <event> notifications. */
if (server.notify_keyspace_events & REDIS_NOTIFY_KEYSPACE) {
robj *eventobj;
eventobj = createStringObject(event,strlen(event));
chan = sdsnewlen("__keyspace@",11);
len = ll2string(buf,sizeof(buf),dbid);
chan = sdscatlen(chan, buf, len);
chan = sdscatlen(chan, "__:", 3);
eventobj = createStringObject(event,strlen(event));
chanobj = createObject(REDIS_STRING, chan);
pubsubPublishMessage(chanobj, eventobj);
decrRefCount(chanobj);
}
/* The keyspace channel name has a trailing key name, while
* the keyevent channel name has a trailing event name. */
keyspace_chan = sdscatsds(keyspace_chan, key->ptr);
keyevent_chan = sdscatsds(keyevent_chan, eventobj->ptr);
chan1 = createObject(REDIS_STRING, keyspace_chan);
chan2 = createObject(REDIS_STRING, keyevent_chan);
/* Finally publish the two notifications. */
pubsubPublishMessage(chan1, eventobj);
pubsubPublishMessage(chan2, key);
/* Release objects. */
decrRefCount(eventobj);
decrRefCount(chan1);
decrRefCount(chan2);
/* __keyevente@<db>__:<event> <key> notifications. */
if (server.notify_keyspace_events & REDIS_NOTIFY_KEYEVENT) {
chan = sdsnewlen("__keyevent@",11);
if (len == -1) len = ll2string(buf,sizeof(buf),dbid);
chan = sdscatlen(chan, buf, len);
chan = sdscatlen(chan, "__:", 3);
chanobj = createObject(REDIS_STRING, chan);
pubsubPublishMessage(chanobj, key);
decrRefCount(chanobj);
}
}