fluencelabs/redis
1
0
Fork 0
mirror of https://github.com/fluencelabs/redis synced 2025-04-05 01:01:04 +00:00
Code Issues Projects Releases Wiki Activity

RDMF: redisAssert -> serverAssert.

Browse Source
This commit is contained in:
antirez 2015-07-26 15:29:53 +02:00
parent 14ff572482
commit 2d9e3eb107
24 changed files with 209 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/aof.c
View File

@ -204,7 +204,7 @@ void aof_background_fsync(int fd) {
/* Called when the user switches from "appendonly yes" to "appendonly no" /* Called when the user switches from "appendonly yes" to "appendonly no"
* at runtime using the CONFIG command. */ * at runtime using the CONFIG command. */
void stopAppendOnly(void) { void stopAppendOnly(void) {
redisAssert(server.aof_state != REDIS_AOF_OFF); serverAssert(server.aof_state != REDIS_AOF_OFF);
flushAppendOnlyFile(1); flushAppendOnlyFile(1);
aof_fsync(server.aof_fd); aof_fsync(server.aof_fd);
close(server.aof_fd); close(server.aof_fd);
@ -235,7 +235,7 @@ void stopAppendOnly(void) {
int startAppendOnly(void) { int startAppendOnly(void) {
server.aof_last_fsync = server.unixtime; server.aof_last_fsync = server.unixtime;
server.aof_fd = open(server.aof_filename,O_WRONLY|O_APPEND|O_CREAT,0644); server.aof_fd = open(server.aof_filename,O_WRONLY|O_APPEND|O_CREAT,0644);
redisAssert(server.aof_state == REDIS_AOF_OFF); serverAssert(server.aof_state == REDIS_AOF_OFF);
if (server.aof_fd == -1) { if (server.aof_fd == -1) {
serverLog(REDIS_WARNING,"Redis needs to enable the AOF but can't open the append only file: %s",strerror(errno)); serverLog(REDIS_WARNING,"Redis needs to enable the AOF but can't open the append only file: %s",strerror(errno));
return REDIS_ERR; return REDIS_ERR;
@ -685,9 +685,9 @@ int loadAppendOnlyFile(char *filename) {
cmd->proc(fakeClient); cmd->proc(fakeClient);
/* The fake client should not have a reply */ /* The fake client should not have a reply */
redisAssert(fakeClient->bufpos == 0 && listLength(fakeClient->reply) == 0); serverAssert(fakeClient->bufpos == 0 && listLength(fakeClient->reply) == 0);
/* The fake client should never get blocked */ /* The fake client should never get blocked */
redisAssert((fakeClient->flags & REDIS_BLOCKED) == 0); serverAssert((fakeClient->flags & REDIS_BLOCKED) == 0);
/* Clean up. Command code may have changed argv/argc so we use the /* Clean up. Command code may have changed argv/argc so we use the
* argv/argc of the client instead of the local variables. */ * argv/argc of the client instead of the local variables. */
@ -860,12 +860,12 @@ int rewriteSortedSetObject(rio *r, robj *key, robj *o) {
double score; double score;
eptr = ziplistIndex(zl,0); eptr = ziplistIndex(zl,0);
redisAssert(eptr != NULL); serverAssert(eptr != NULL);
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
redisAssert(sptr != NULL); serverAssert(sptr != NULL);
while (eptr != NULL) { while (eptr != NULL) {
redisAssert(ziplistGet(eptr,&vstr,&vlen,&vll)); serverAssert(ziplistGet(eptr,&vstr,&vlen,&vll));
score = zzlGetScore(sptr); score = zzlGetScore(sptr);
if (count == 0) { if (count == 0) {

2
src/blocked.c
View File

@ -112,7 +112,7 @@ void processUnblockedClients(void) {
while (listLength(server.unblocked_clients)) { while (listLength(server.unblocked_clients)) {
ln = listFirst(server.unblocked_clients); ln = listFirst(server.unblocked_clients);
redisAssert(ln != NULL); serverAssert(ln != NULL);
c = ln->value; c = ln->value;
listDelNode(server.unblocked_clients,ln); listDelNode(server.unblocked_clients,ln);
c->flags &= ~REDIS_UNBLOCKED; c->flags &= ~REDIS_UNBLOCKED;

46
src/cluster.c
View File

@ -176,7 +176,7 @@ int clusterLoadConfig(char *filename) {
p = strchr(s,','); p = strchr(s,',');
if (p) *p = '\0'; if (p) *p = '\0';
if (!strcasecmp(s,"myself")) { if (!strcasecmp(s,"myself")) {
redisAssert(server.cluster->myself == NULL); serverAssert(server.cluster->myself == NULL);
myself = server.cluster->myself = n; myself = server.cluster->myself = n;
n->flags |= REDIS_NODE_MYSELF; n->flags |= REDIS_NODE_MYSELF;
} else if (!strcasecmp(s,"master")) { } else if (!strcasecmp(s,"master")) {
@ -230,7 +230,7 @@ int clusterLoadConfig(char *filename) {
clusterNode *cn; clusterNode *cn;
p = strchr(argv[j],'-'); p = strchr(argv[j],'-');
redisAssert(p != NULL); serverAssert(p != NULL);
*p = '\0'; *p = '\0';
direction = p[1]; /* Either '>' or '<' */ direction = p[1]; /* Either '>' or '<' */
slot = atoi(argv[j]+1); slot = atoi(argv[j]+1);
@ -833,7 +833,7 @@ void freeClusterNode(clusterNode *n) {
/* Unlink from the set of nodes. */ /* Unlink from the set of nodes. */
nodename = sdsnewlen(n->name, REDIS_CLUSTER_NAMELEN); nodename = sdsnewlen(n->name, REDIS_CLUSTER_NAMELEN);
redisAssert(dictDelete(server.cluster->nodes,nodename) == DICT_OK); serverAssert(dictDelete(server.cluster->nodes,nodename) == DICT_OK);
sdsfree(nodename); sdsfree(nodename);
/* Release link and associated data structures. */ /* Release link and associated data structures. */
@ -915,7 +915,7 @@ void clusterRenameNode(clusterNode *node, char *newname) {
node->name, newname); node->name, newname);
retval = dictDelete(server.cluster->nodes, s); retval = dictDelete(server.cluster->nodes, s);
sdsfree(s); sdsfree(s);
redisAssert(retval == DICT_OK); serverAssert(retval == DICT_OK);
memcpy(node->name, newname, REDIS_CLUSTER_NAMELEN); memcpy(node->name, newname, REDIS_CLUSTER_NAMELEN);
clusterAddNode(node); clusterAddNode(node);
} }
@ -1183,7 +1183,7 @@ void markNodeAsFailingIfNeeded(clusterNode *node) {
void clearNodeFailureIfNeeded(clusterNode *node) { void clearNodeFailureIfNeeded(clusterNode *node) {
mstime_t now = mstime(); mstime_t now = mstime();
redisAssert(nodeFailed(node)); serverAssert(nodeFailed(node));
/* For slaves we always clear the FAIL flag if we can contact the /* For slaves we always clear the FAIL flag if we can contact the
* node again. */ * node again. */
@ -2571,7 +2571,7 @@ int clusterGetSlaveRank(void) {
int j, rank = 0; int j, rank = 0;
clusterNode *master; clusterNode *master;
redisAssert(nodeIsSlave(myself)); serverAssert(nodeIsSlave(myself));
master = myself->slaveof; master = myself->slaveof;
if (master == NULL) return 0; /* Never called by slaves without master. */ if (master == NULL) return 0; /* Never called by slaves without master. */
@ -3360,7 +3360,7 @@ int clusterDelSlot(int slot) {
clusterNode *n = server.cluster->slots[slot]; clusterNode *n = server.cluster->slots[slot];
if (!n) return REDIS_ERR; if (!n) return REDIS_ERR;
redisAssert(clusterNodeClearSlotBit(n,slot) == 1); serverAssert(clusterNodeClearSlotBit(n,slot) == 1);
server.cluster->slots[slot] = NULL; server.cluster->slots[slot] = NULL;
return REDIS_OK; return REDIS_OK;
} }
@ -3567,8 +3567,8 @@ int verifyClusterConfigWithData(void) {
/* Set the specified node 'n' as master for this node. /* Set the specified node 'n' as master for this node.
* If this node is currently a master, it is turned into a slave. */ * If this node is currently a master, it is turned into a slave. */
void clusterSetMaster(clusterNode *n) { void clusterSetMaster(clusterNode *n) {
redisAssert(n != myself); serverAssert(n != myself);
redisAssert(myself->numslots == 0); serverAssert(myself->numslots == 0);
if (nodeIsMaster(myself)) { if (nodeIsMaster(myself)) {
myself->flags &= ~REDIS_NODE_MASTER; myself->flags &= ~REDIS_NODE_MASTER;
@ -3894,7 +3894,7 @@ void clusterCommand(client *c) {
retval = del ? clusterDelSlot(j) : retval = del ? clusterDelSlot(j) :
clusterAddSlot(myself,j); clusterAddSlot(myself,j);
redisAssertWithInfo(c,NULL,retval == REDIS_OK); serverAssertWithInfo(c,NULL,retval == REDIS_OK);
} }
} }
zfree(slots); zfree(slots);
@ -4315,8 +4315,8 @@ void createDumpPayload(rio *payload, robj *o) {
/* Serialize the object in a RDB-like format. It consist of an object type /* Serialize the object in a RDB-like format. It consist of an object type
* byte followed by the serialized object. This is understood by RESTORE. */ * byte followed by the serialized object. This is understood by RESTORE. */
rioInitWithBuffer(payload,sdsempty()); rioInitWithBuffer(payload,sdsempty());
redisAssert(rdbSaveObjectType(payload,o)); serverAssert(rdbSaveObjectType(payload,o));
redisAssert(rdbSaveObject(payload,o)); serverAssert(rdbSaveObject(payload,o));
/* Write the footer, this is how it looks like: /* Write the footer, this is how it looks like:
* ----------------+---------------------+---------------+ * ----------------+---------------------+---------------+
@ -4610,9 +4610,9 @@ try_again:
/* Send the SELECT command if the current DB is not already selected. */ /* Send the SELECT command if the current DB is not already selected. */
int select = cs->last_dbid != dbid; /* Should we emit SELECT? */ int select = cs->last_dbid != dbid; /* Should we emit SELECT? */
if (select) { if (select) {
redisAssertWithInfo(c,NULL,rioWriteBulkCount(&cmd,'*',2)); serverAssertWithInfo(c,NULL,rioWriteBulkCount(&cmd,'*',2));
redisAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,"SELECT",6)); serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,"SELECT",6));
redisAssertWithInfo(c,NULL,rioWriteBulkLongLong(&cmd,dbid)); serverAssertWithInfo(c,NULL,rioWriteBulkLongLong(&cmd,dbid));
} }
/* Create RESTORE payload and generate the protocol to call the command. */ /* Create RESTORE payload and generate the protocol to call the command. */
@ -4621,28 +4621,28 @@ try_again:
ttl = expireat-mstime(); ttl = expireat-mstime();
if (ttl < 1) ttl = 1; if (ttl < 1) ttl = 1;
} }
redisAssertWithInfo(c,NULL,rioWriteBulkCount(&cmd,'*',replace ? 5 : 4)); serverAssertWithInfo(c,NULL,rioWriteBulkCount(&cmd,'*',replace ? 5 : 4));
if (server.cluster_enabled) if (server.cluster_enabled)
redisAssertWithInfo(c,NULL, serverAssertWithInfo(c,NULL,
rioWriteBulkString(&cmd,"RESTORE-ASKING",14)); rioWriteBulkString(&cmd,"RESTORE-ASKING",14));
else else
redisAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,"RESTORE",7)); serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,"RESTORE",7));
redisAssertWithInfo(c,NULL,sdsEncodedObject(c->argv[3])); serverAssertWithInfo(c,NULL,sdsEncodedObject(c->argv[3]));
redisAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,c->argv[3]->ptr, serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,c->argv[3]->ptr,
sdslen(c->argv[3]->ptr))); sdslen(c->argv[3]->ptr)));
redisAssertWithInfo(c,NULL,rioWriteBulkLongLong(&cmd,ttl)); serverAssertWithInfo(c,NULL,rioWriteBulkLongLong(&cmd,ttl));
/* Emit the payload argument, that is the serialized object using /* Emit the payload argument, that is the serialized object using
* the DUMP format. */ * the DUMP format. */
createDumpPayload(&payload,o); createDumpPayload(&payload,o);
redisAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,payload.io.buffer.ptr, serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,payload.io.buffer.ptr,
sdslen(payload.io.buffer.ptr))); sdslen(payload.io.buffer.ptr)));
sdsfree(payload.io.buffer.ptr); sdsfree(payload.io.buffer.ptr);
/* Add the REPLACE option to the RESTORE command if it was specified /* Add the REPLACE option to the RESTORE command if it was specified
* as a MIGRATE option. */ * as a MIGRATE option. */
if (replace) if (replace)
redisAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,"REPLACE",7)); serverAssertWithInfo(c,NULL,rioWriteBulkString(&cmd,"REPLACE",7));
/* Transfer the query to the other node in 64K chunks. */ /* Transfer the query to the other node in 64K chunks. */
errno = 0; errno = 0;

8
src/config.c
View File

@ -474,7 +474,7 @@ void loadServerConfigFromString(char *config) {
/* If the target command name is the empty string we just /* If the target command name is the empty string we just
* remove it from the command table. */ * remove it from the command table. */
retval = dictDelete(server.commands, argv[1]); retval = dictDelete(server.commands, argv[1]);
redisAssert(retval == DICT_OK); serverAssert(retval == DICT_OK);
/* Otherwise we re-add the command under a different name. */ /* Otherwise we re-add the command under a different name. */
if (sdslen(argv[2]) != 0) { if (sdslen(argv[2]) != 0) {
@ -703,8 +703,8 @@ void configSetCommand(client *c) {
robj *o; robj *o;
long long ll; long long ll;
int err; int err;
redisAssertWithInfo(c,c->argv[2],sdsEncodedObject(c->argv[2])); serverAssertWithInfo(c,c->argv[2],sdsEncodedObject(c->argv[2]));
redisAssertWithInfo(c,c->argv[3],sdsEncodedObject(c->argv[3])); serverAssertWithInfo(c,c->argv[3],sdsEncodedObject(c->argv[3]));
o = c->argv[3]; o = c->argv[3];
if (0) { /* this starts the config_set macros else-if chain. */ if (0) { /* this starts the config_set macros else-if chain. */
@ -1030,7 +1030,7 @@ void configGetCommand(client *c) {
char *pattern = o->ptr; char *pattern = o->ptr;
char buf[128]; char buf[128];
int matches = 0; int matches = 0;
redisAssertWithInfo(c,o,sdsEncodedObject(o)); serverAssertWithInfo(c,o,sdsEncodedObject(o));
/* String values */ /* String values */
config_get_string_field("dbfilename",server.rdb_filename); config_get_string_field("dbfilename",server.rdb_filename);

20
src/db.c
View File

@ -119,7 +119,7 @@ void dbAdd(redisDb *db, robj *key, robj *val) {
sds copy = sdsdup(key->ptr); sds copy = sdsdup(key->ptr);
int retval = dictAdd(db->dict, copy, val); int retval = dictAdd(db->dict, copy, val);
redisAssertWithInfo(NULL,key,retval == REDIS_OK); serverAssertWithInfo(NULL,key,retval == REDIS_OK);
if (val->type == OBJ_LIST) signalListAsReady(db, key); if (val->type == OBJ_LIST) signalListAsReady(db, key);
if (server.cluster_enabled) slotToKeyAdd(key); if (server.cluster_enabled) slotToKeyAdd(key);
} }
@ -132,7 +132,7 @@ void dbAdd(redisDb *db, robj *key, robj *val) {
void dbOverwrite(redisDb *db, robj *key, robj *val) { void dbOverwrite(redisDb *db, robj *key, robj *val) {
dictEntry *de = dictFind(db->dict,key->ptr); dictEntry *de = dictFind(db->dict,key->ptr);
redisAssertWithInfo(NULL,key,de != NULL); serverAssertWithInfo(NULL,key,de != NULL);
dictReplace(db->dict, key->ptr, val); dictReplace(db->dict, key->ptr, val);
} }
@ -224,7 +224,7 @@ int dbDelete(redisDb *db, robj *key) {
* using an sdscat() call to append some data, or anything else. * using an sdscat() call to append some data, or anything else.
*/ */
robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) { robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) {
redisAssert(o->type == OBJ_STRING); serverAssert(o->type == OBJ_STRING);
if (o->refcount != 1 || o->encoding != OBJ_ENCODING_RAW) { if (o->refcount != 1 || o->encoding != OBJ_ENCODING_RAW) {
robj *decoded = getDecodedObject(o); robj *decoded = getDecodedObject(o);
o = createRawStringObject(decoded->ptr, sdslen(decoded->ptr)); o = createRawStringObject(decoded->ptr, sdslen(decoded->ptr));
@ -460,7 +460,7 @@ void scanGenericCommand(client *c, robj *o, unsigned long cursor) {
/* Object must be NULL (to iterate keys names), or the type of the object /* Object must be NULL (to iterate keys names), or the type of the object
* must be Set, Sorted Set, or Hash. */ * must be Set, Sorted Set, or Hash. */
redisAssert(o == NULL || o->type == OBJ_SET || o->type == OBJ_HASH || serverAssert(o == NULL || o->type == OBJ_SET || o->type == OBJ_HASH ||
o->type == OBJ_ZSET); o->type == OBJ_ZSET);
/* Set i to the first option argument. The previous one is the cursor. */ /* Set i to the first option argument. The previous one is the cursor. */
@ -579,7 +579,7 @@ void scanGenericCommand(client *c, robj *o, unsigned long cursor) {
char buf[REDIS_LONGSTR_SIZE]; char buf[REDIS_LONGSTR_SIZE];
int len; int len;
redisAssert(kobj->encoding == OBJ_ENCODING_INT); serverAssert(kobj->encoding == OBJ_ENCODING_INT);
len = ll2string(buf,sizeof(buf),(long)kobj->ptr); len = ll2string(buf,sizeof(buf),(long)kobj->ptr);
if (!stringmatchlen(pat, patlen, buf, len, 0)) filter = 1; if (!stringmatchlen(pat, patlen, buf, len, 0)) filter = 1;
} }
@ -799,7 +799,7 @@ void moveCommand(client *c) {
int removeExpire(redisDb *db, robj *key) { int removeExpire(redisDb *db, robj *key) {
/* An expire may only be removed if there is a corresponding entry in the /* An expire may only be removed if there is a corresponding entry in the
* main dict. Otherwise, the key will never be freed. */ * main dict. Otherwise, the key will never be freed. */
redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL); serverAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
return dictDelete(db->expires,key->ptr) == DICT_OK; return dictDelete(db->expires,key->ptr) == DICT_OK;
} }
@ -808,7 +808,7 @@ void setExpire(redisDb *db, robj *key, long long when) {
/* Reuse the sds from the main dict in the expire dict */ /* Reuse the sds from the main dict in the expire dict */
kde = dictFind(db->dict,key->ptr); kde = dictFind(db->dict,key->ptr);
redisAssertWithInfo(NULL,key,kde != NULL); serverAssertWithInfo(NULL,key,kde != NULL);
de = dictReplaceRaw(db->expires,dictGetKey(kde)); de = dictReplaceRaw(db->expires,dictGetKey(kde));
dictSetSignedIntegerVal(de,when); dictSetSignedIntegerVal(de,when);
} }
@ -824,7 +824,7 @@ long long getExpire(redisDb *db, robj *key) {
/* The entry was found in the expire dict, this means it should also /* The entry was found in the expire dict, this means it should also
* be present in the main dict (safety check). */ * be present in the main dict (safety check). */
redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL); serverAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
return dictGetSignedIntegerVal(de); return dictGetSignedIntegerVal(de);
} }
@ -924,7 +924,7 @@ void expireGenericCommand(client *c, long long basetime, int unit) {
if (when <= mstime() && !server.loading && !server.masterhost) { if (when <= mstime() && !server.loading && !server.masterhost) {
robj *aux; robj *aux;
redisAssertWithInfo(c,key,dbDelete(c->db,key)); serverAssertWithInfo(c,key,dbDelete(c->db,key));
server.dirty++; server.dirty++;
/* Replicate/AOF this as an explicit DEL. */ /* Replicate/AOF this as an explicit DEL. */
@ -1025,7 +1025,7 @@ int *getKeysUsingCommandTable(struct redisCommand *cmd,robj **argv, int argc, in
if (last < 0) last = argc+last; if (last < 0) last = argc+last;
keys = zmalloc(sizeof(int)*((last - cmd->firstkey)+1)); keys = zmalloc(sizeof(int)*((last - cmd->firstkey)+1));
for (j = cmd->firstkey; j <= last; j += cmd->keystep) { for (j = cmd->firstkey; j <= last; j += cmd->keystep) {
redisAssert(j < argc); serverAssert(j < argc);
keys[i++] = j; keys[i++] = j;
} }
*numkeys = i; *numkeys = i;

22
src/debug.c
View File

@ -181,12 +181,12 @@ void computeDatasetDigest(unsigned char *final) {
double score; double score;
eptr = ziplistIndex(zl,0); eptr = ziplistIndex(zl,0);
redisAssert(eptr != NULL); serverAssert(eptr != NULL);
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
redisAssert(sptr != NULL); serverAssert(sptr != NULL);
while (eptr != NULL) { while (eptr != NULL) {
redisAssert(ziplistGet(eptr,&vstr,&vlen,&vll)); serverAssert(ziplistGet(eptr,&vstr,&vlen,&vll));
score = zzlGetScore(sptr); score = zzlGetScore(sptr);
memset(eledigest,0,20); memset(eledigest,0,20);
@ -267,7 +267,7 @@ void debugCommand(client *c) {
addReply(c,shared.ok); addReply(c,shared.ok);
} else if (!strcasecmp(c->argv[1]->ptr,"assert")) { } else if (!strcasecmp(c->argv[1]->ptr,"assert")) {
if (c->argc >= 3) c->argv[2] = tryObjectEncoding(c->argv[2]); if (c->argc >= 3) c->argv[2] = tryObjectEncoding(c->argv[2]);
redisAssertWithInfo(c,c->argv[0],1 == 2); serverAssertWithInfo(c,c->argv[0],1 == 2);
} else if (!strcasecmp(c->argv[1]->ptr,"reload")) { } else if (!strcasecmp(c->argv[1]->ptr,"reload")) {
if (rdbSave(server.rdb_filename) != REDIS_OK) { if (rdbSave(server.rdb_filename) != REDIS_OK) {
addReply(c,shared.err); addReply(c,shared.err);
@ -470,7 +470,7 @@ void debugCommand(client *c) {
/* =========================== Crash handling ============================== */ /* =========================== Crash handling ============================== */
void _redisAssert(char *estr, char *file, int line) { void _serverAssert(char *estr, char *file, int line) {
bugReportStart(); bugReportStart();
serverLog(REDIS_WARNING,"=== ASSERTION FAILED ==="); serverLog(REDIS_WARNING,"=== ASSERTION FAILED ===");
serverLog(REDIS_WARNING,"==> %s:%d '%s' is not true",file,line,estr); serverLog(REDIS_WARNING,"==> %s:%d '%s' is not true",file,line,estr);
@ -483,7 +483,7 @@ void _redisAssert(char *estr, char *file, int line) {
*((char*)-1) = 'x'; *((char*)-1) = 'x';
} }
void _redisAssertPrintClientInfo(client *c) { void _serverAssertPrintClientInfo(client *c) {
int j; int j;
bugReportStart(); bugReportStart();
@ -531,16 +531,16 @@ void serverLogObjectDebugInfo(robj *o) {
} }
} }
void _redisAssertPrintObject(robj *o) { void _serverAssertPrintObject(robj *o) {
bugReportStart(); bugReportStart();
serverLog(REDIS_WARNING,"=== ASSERTION FAILED OBJECT CONTEXT ==="); serverLog(REDIS_WARNING,"=== ASSERTION FAILED OBJECT CONTEXT ===");
serverLogObjectDebugInfo(o); serverLogObjectDebugInfo(o);
} }
void _redisAssertWithInfo(client *c, robj *o, char *estr, char *file, int line) { void _serverAssertWithInfo(client *c, robj *o, char *estr, char *file, int line) {
if (c) _redisAssertPrintClientInfo(c); if (c) _serverAssertPrintClientInfo(c);
if (o) _redisAssertPrintObject(o); if (o) _serverAssertPrintObject(o);
_redisAssert(estr,file,line); _serverAssert(estr,file,line);
} }
void _redisPanic(char *msg, char *file, int line) { void _redisPanic(char *msg, char *file, int line) {

4
src/hyperloglog.c
View File

@ -877,7 +877,7 @@ promote: /* Promote to dense representation. */
* is propagated to slaves / AOF, so if there is a sparse -> dense * is propagated to slaves / AOF, so if there is a sparse -> dense
* convertion, it will be performed in all the slaves as well. */ * convertion, it will be performed in all the slaves as well. */
int dense_retval = hllDenseAdd(hdr->registers, ele, elesize); int dense_retval = hllDenseAdd(hdr->registers, ele, elesize);
redisAssert(dense_retval == 1); serverAssert(dense_retval == 1);
return dense_retval; return dense_retval;
} }
@ -1108,7 +1108,7 @@ robj *createHLLObject(void) {
p += 2; p += 2;
aux -= xzero; aux -= xzero;
} }
redisAssert((p-(uint8_t*)s) == sparselen); serverAssert((p-(uint8_t*)s) == sparselen);
/* Create the actual object. */ /* Create the actual object. */
o = createObject(OBJ_STRING,s); o = createObject(OBJ_STRING,s);

2
src/multi.c
View File

@ -244,7 +244,7 @@ void unwatchAllKeys(client *c) {
* from the list */ * from the list */
wk = listNodeValue(ln); wk = listNodeValue(ln);
clients = dictFetchValue(wk->db->watched_keys, wk->key); clients = dictFetchValue(wk->db->watched_keys, wk->key);
redisAssertWithInfo(c,NULL,clients != NULL); serverAssertWithInfo(c,NULL,clients != NULL);
listDelNode(clients,listSearchKey(clients,c)); listDelNode(clients,listSearchKey(clients,c));
/* Kill the entry at all if this was the only client */ /* Kill the entry at all if this was the only client */
if (listLength(clients) == 0) if (listLength(clients) == 0)

28
src/networking.c
View File

@ -44,7 +44,7 @@ size_t sdsZmallocSize(sds s) {
/* Return the amount of memory used by the sds string at object->ptr /* Return the amount of memory used by the sds string at object->ptr
* for a string object. */ * for a string object. */
size_t getStringObjectSdsUsedMemory(robj *o) { size_t getStringObjectSdsUsedMemory(robj *o) {
redisAssertWithInfo(NULL,o,o->type == OBJ_STRING); serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
switch(o->encoding) { switch(o->encoding) {
case OBJ_ENCODING_RAW: return sdsZmallocSize(o->ptr); case OBJ_ENCODING_RAW: return sdsZmallocSize(o->ptr);
case OBJ_ENCODING_EMBSTR: return zmalloc_size(o)-sizeof(robj); case OBJ_ENCODING_EMBSTR: return zmalloc_size(o)-sizeof(robj);
@ -186,7 +186,7 @@ int prepareClientToWrite(client *c) {
robj *dupLastObjectIfNeeded(list *reply) { robj *dupLastObjectIfNeeded(list *reply) {
robj *new, *cur; robj *new, *cur;
listNode *ln; listNode *ln;
redisAssert(listLength(reply) > 0); serverAssert(listLength(reply) > 0);
ln = listLast(reply); ln = listLast(reply);
cur = listNodeValue(ln); cur = listNodeValue(ln);
if (cur->refcount > 1) { if (cur->refcount > 1) {
@ -748,7 +748,7 @@ void freeClient(client *c) {
/* Remove from the list of clients */ /* Remove from the list of clients */
if (c->fd != -1) { if (c->fd != -1) {
ln = listSearchKey(server.clients,c); ln = listSearchKey(server.clients,c);
redisAssert(ln != NULL); serverAssert(ln != NULL);
listDelNode(server.clients,ln); listDelNode(server.clients,ln);
} }
@ -756,7 +756,7 @@ void freeClient(client *c) {
* remove it from the list of unblocked clients. */ * remove it from the list of unblocked clients. */
if (c->flags & REDIS_UNBLOCKED) { if (c->flags & REDIS_UNBLOCKED) {
ln = listSearchKey(server.unblocked_clients,c); ln = listSearchKey(server.unblocked_clients,c);
redisAssert(ln != NULL); serverAssert(ln != NULL);
listDelNode(server.unblocked_clients,ln); listDelNode(server.unblocked_clients,ln);
} }
@ -769,7 +769,7 @@ void freeClient(client *c) {
} }
list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves; list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves;
ln = listSearchKey(l,c); ln = listSearchKey(l,c);
redisAssert(ln != NULL); serverAssert(ln != NULL);
listDelNode(l,ln); listDelNode(l,ln);
/* We need to remember the time when we started to have zero /* We need to remember the time when we started to have zero
* attached slaves, as after some time we'll free the replication * attached slaves, as after some time we'll free the replication
@ -787,7 +787,7 @@ void freeClient(client *c) {
* from the queue. */ * from the queue. */
if (c->flags & REDIS_CLOSE_ASAP) { if (c->flags & REDIS_CLOSE_ASAP) {
ln = listSearchKey(server.clients_to_close,c); ln = listSearchKey(server.clients_to_close,c);
redisAssert(ln != NULL); serverAssert(ln != NULL);
listDelNode(server.clients_to_close,ln); listDelNode(server.clients_to_close,ln);
} }
@ -1000,7 +1000,7 @@ int processMultibulkBuffer(client *c) {
if (c->multibulklen == 0) { if (c->multibulklen == 0) {
/* The client should have been reset */ /* The client should have been reset */
redisAssertWithInfo(c,NULL,c->argc == 0); serverAssertWithInfo(c,NULL,c->argc == 0);
/* Multi bulk length cannot be read without a \r\n */ /* Multi bulk length cannot be read without a \r\n */
newline = strchr(c->querybuf,'\r'); newline = strchr(c->querybuf,'\r');
@ -1018,7 +1018,7 @@ int processMultibulkBuffer(client *c) {
/* We know for sure there is a whole line since newline != NULL, /* We know for sure there is a whole line since newline != NULL,
* so go ahead and find out the multi bulk length. */ * so go ahead and find out the multi bulk length. */
redisAssertWithInfo(c,NULL,c->querybuf[0] == '*'); serverAssertWithInfo(c,NULL,c->querybuf[0] == '*');
ok = string2ll(c->querybuf+1,newline-(c->querybuf+1),&ll); ok = string2ll(c->querybuf+1,newline-(c->querybuf+1),&ll);
if (!ok || ll > 1024*1024) { if (!ok || ll > 1024*1024) {
addReplyError(c,"Protocol error: invalid multibulk length"); addReplyError(c,"Protocol error: invalid multibulk length");
@ -1039,7 +1039,7 @@ int processMultibulkBuffer(client *c) {
c->argv = zmalloc(sizeof(robj*)*c->multibulklen); c->argv = zmalloc(sizeof(robj*)*c->multibulklen);
} }
redisAssertWithInfo(c,NULL,c->multibulklen > 0); serverAssertWithInfo(c,NULL,c->multibulklen > 0);
while(c->multibulklen) { while(c->multibulklen) {
/* Read bulk length if unknown */ /* Read bulk length if unknown */
if (c->bulklen == -1) { if (c->bulklen == -1) {
@ -1523,7 +1523,7 @@ void rewriteClientCommandVector(client *c, int argc, ...) {
c->argv = argv; c->argv = argv;
c->argc = argc; c->argc = argc;
c->cmd = lookupCommandOrOriginal(c->argv[0]->ptr); c->cmd = lookupCommandOrOriginal(c->argv[0]->ptr);
redisAssertWithInfo(c,NULL,c->cmd != NULL); serverAssertWithInfo(c,NULL,c->cmd != NULL);
va_end(ap); va_end(ap);
} }
@ -1534,7 +1534,7 @@ void replaceClientCommandVector(client *c, int argc, robj **argv) {
c->argv = argv; c->argv = argv;
c->argc = argc; c->argc = argc;
c->cmd = lookupCommandOrOriginal(c->argv[0]->ptr); c->cmd = lookupCommandOrOriginal(c->argv[0]->ptr);
redisAssertWithInfo(c,NULL,c->cmd != NULL); serverAssertWithInfo(c,NULL,c->cmd != NULL);
} }
/* Rewrite a single item in the command vector. /* Rewrite a single item in the command vector.
@ -1542,7 +1542,7 @@ void replaceClientCommandVector(client *c, int argc, robj **argv) {
void rewriteClientCommandArgument(client *c, int i, robj *newval) { void rewriteClientCommandArgument(client *c, int i, robj *newval) {
robj *oldval; robj *oldval;
redisAssertWithInfo(c,NULL,i < c->argc); serverAssertWithInfo(c,NULL,i < c->argc);
oldval = c->argv[i]; oldval = c->argv[i];
c->argv[i] = newval; c->argv[i] = newval;
incrRefCount(newval); incrRefCount(newval);
@ -1551,7 +1551,7 @@ void rewriteClientCommandArgument(client *c, int i, robj *newval) {
/* If this is the command name make sure to fix c->cmd. */ /* If this is the command name make sure to fix c->cmd. */
if (i == 0) { if (i == 0) {
c->cmd = lookupCommandOrOriginal(c->argv[0]->ptr); c->cmd = lookupCommandOrOriginal(c->argv[0]->ptr);
redisAssertWithInfo(c,NULL,c->cmd != NULL); serverAssertWithInfo(c,NULL,c->cmd != NULL);
} }
} }
@ -1654,7 +1654,7 @@ int checkClientOutputBufferLimits(client *c) {
* called from contexts where the client can't be freed safely, i.e. from the * called from contexts where the client can't be freed safely, i.e. from the
* lower level functions pushing data inside the client output buffers. */ * lower level functions pushing data inside the client output buffers. */
void asyncCloseClientOnOutputBufferLimitReached(client *c) { void asyncCloseClientOnOutputBufferLimitReached(client *c) {
redisAssert(c->reply_bytes < SIZE_MAX-(1024*64)); serverAssert(c->reply_bytes < SIZE_MAX-(1024*64));
if (c->reply_bytes == 0 || c->flags & REDIS_CLOSE_ASAP) return; if (c->reply_bytes == 0 || c->flags & REDIS_CLOSE_ASAP) return;
if (checkClientOutputBufferLimits(c)) { if (checkClientOutputBufferLimits(c)) {
sds client = catClientInfoString(sdsempty(),c); sds client = catClientInfoString(sdsempty(),c);

16
src/object.c
View File

@ -163,7 +163,7 @@ robj *createStringObjectFromLongDouble(long double value, int humanfriendly) {
robj *dupStringObject(robj *o) { robj *dupStringObject(robj *o) {
robj *d; robj *d;
redisAssert(o->type == OBJ_STRING); serverAssert(o->type == OBJ_STRING);
switch(o->encoding) { switch(o->encoding) {
case OBJ_ENCODING_RAW: case OBJ_ENCODING_RAW:
@ -348,7 +348,7 @@ int checkType(client *c, robj *o, int type) {
} }
int isObjectRepresentableAsLongLong(robj *o, long long *llval) { int isObjectRepresentableAsLongLong(robj *o, long long *llval) {
redisAssertWithInfo(NULL,o,o->type == OBJ_STRING); serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
if (o->encoding == OBJ_ENCODING_INT) { if (o->encoding == OBJ_ENCODING_INT) {
if (llval) *llval = (long) o->ptr; if (llval) *llval = (long) o->ptr;
return REDIS_OK; return REDIS_OK;
@ -367,7 +367,7 @@ robj *tryObjectEncoding(robj *o) {
* in this function. Other types use encoded memory efficient * in this function. Other types use encoded memory efficient
* representations but are handled by the commands implementing * representations but are handled by the commands implementing
* the type. */ * the type. */
redisAssertWithInfo(NULL,o,o->type == OBJ_STRING); serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
/* We try some specialized encoding only for objects that are /* We try some specialized encoding only for objects that are
* RAW or EMBSTR encoded, in other words objects that are still * RAW or EMBSTR encoded, in other words objects that are still
@ -469,7 +469,7 @@ robj *getDecodedObject(robj *o) {
#define REDIS_COMPARE_COLL (1<<1) #define REDIS_COMPARE_COLL (1<<1)
int compareStringObjectsWithFlags(robj *a, robj *b, int flags) { int compareStringObjectsWithFlags(robj *a, robj *b, int flags) {
redisAssertWithInfo(NULL,a,a->type == OBJ_STRING && b->type == OBJ_STRING); serverAssertWithInfo(NULL,a,a->type == OBJ_STRING && b->type == OBJ_STRING);
char bufa[128], bufb[128], *astr, *bstr; char bufa[128], bufb[128], *astr, *bstr;
size_t alen, blen, minlen; size_t alen, blen, minlen;
@ -526,7 +526,7 @@ int equalStringObjects(robj *a, robj *b) {
} }
size_t stringObjectLen(robj *o) { size_t stringObjectLen(robj *o) {
redisAssertWithInfo(NULL,o,o->type == OBJ_STRING); serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
if (sdsEncodedObject(o)) { if (sdsEncodedObject(o)) {
return sdslen(o->ptr); return sdslen(o->ptr);
} else { } else {
@ -541,7 +541,7 @@ int getDoubleFromObject(robj *o, double *target) {
if (o == NULL) { if (o == NULL) {
value = 0; value = 0;
} else { } else {
redisAssertWithInfo(NULL,o,o->type == OBJ_STRING); serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
if (sdsEncodedObject(o)) { if (sdsEncodedObject(o)) {
errno = 0; errno = 0;
value = strtod(o->ptr, &eptr); value = strtod(o->ptr, &eptr);
@ -583,7 +583,7 @@ int getLongDoubleFromObject(robj *o, long double *target) {
if (o == NULL) { if (o == NULL) {
value = 0; value = 0;
} else { } else {
redisAssertWithInfo(NULL,o,o->type == OBJ_STRING); serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
if (sdsEncodedObject(o)) { if (sdsEncodedObject(o)) {
errno = 0; errno = 0;
value = strtold(o->ptr, &eptr); value = strtold(o->ptr, &eptr);
@ -621,7 +621,7 @@ int getLongLongFromObject(robj *o, long long *target) {
if (o == NULL) { if (o == NULL) {
value = 0; value = 0;
} else { } else {
redisAssertWithInfo(NULL,o,o->type == OBJ_STRING); serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
if (sdsEncodedObject(o)) { if (sdsEncodedObject(o)) {
errno = 0; errno = 0;
value = strtoll(o->ptr, &eptr, 10); value = strtoll(o->ptr, &eptr, 10);

4
src/pubsub.c
View File

@ -98,10 +98,10 @@ int pubsubUnsubscribeChannel(client *c, robj *channel, int notify) {
retval = 1; retval = 1;
/* Remove the client from the channel -> clients list hash table */ /* Remove the client from the channel -> clients list hash table */
de = dictFind(server.pubsub_channels,channel); de = dictFind(server.pubsub_channels,channel);
redisAssertWithInfo(c,NULL,de != NULL); serverAssertWithInfo(c,NULL,de != NULL);
clients = dictGetVal(de); clients = dictGetVal(de);
ln = listSearchKey(clients,c); ln = listSearchKey(clients,c);
redisAssertWithInfo(c,NULL,ln != NULL); serverAssertWithInfo(c,NULL,ln != NULL);
listDelNode(clients,ln); listDelNode(clients,ln);
if (listLength(clients) == 0) { if (listLength(clients) == 0) {
/* Free the list and associated hash entry at all if this was /* Free the list and associated hash entry at all if this was

12
src/rdb.c
View File

@ -357,7 +357,7 @@ ssize_t rdbSaveLongLongAsStringObject(rio *rdb, long long value) {
} else { } else {
/* Encode as string */ /* Encode as string */
enclen = ll2string((char*)buf,32,value); enclen = ll2string((char*)buf,32,value);
redisAssert(enclen < 32); serverAssert(enclen < 32);
if ((n = rdbSaveLen(rdb,enclen)) == -1) return -1; if ((n = rdbSaveLen(rdb,enclen)) == -1) return -1;
nwritten += n; nwritten += n;
if ((n = rdbWriteRaw(rdb,buf,enclen)) == -1) return -1; if ((n = rdbWriteRaw(rdb,buf,enclen)) == -1) return -1;
@ -373,7 +373,7 @@ int rdbSaveStringObject(rio *rdb, robj *obj) {
if (obj->encoding == OBJ_ENCODING_INT) { if (obj->encoding == OBJ_ENCODING_INT) {
return rdbSaveLongLongAsStringObject(rdb,(long)obj->ptr); return rdbSaveLongLongAsStringObject(rdb,(long)obj->ptr);
} else { } else {
redisAssertWithInfo(NULL,obj,sdsEncodedObject(obj)); serverAssertWithInfo(NULL,obj,sdsEncodedObject(obj));
return rdbSaveRawString(rdb,obj->ptr,sdslen(obj->ptr)); return rdbSaveRawString(rdb,obj->ptr,sdslen(obj->ptr));
} }
} }
@ -666,7 +666,7 @@ ssize_t rdbSaveObject(rio *rdb, robj *o) {
* we could switch to a faster solution. */ * we could switch to a faster solution. */
size_t rdbSavedObjectLen(robj *o) { size_t rdbSavedObjectLen(robj *o) {
ssize_t len = rdbSaveObject(NULL,o); ssize_t len = rdbSaveObject(NULL,o);
redisAssertWithInfo(NULL,o,len != -1); serverAssertWithInfo(NULL,o,len != -1);
return len; return len;
} }
@ -1051,10 +1051,10 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
/* Load raw strings */ /* Load raw strings */
field = rdbLoadStringObject(rdb); field = rdbLoadStringObject(rdb);
if (field == NULL) return NULL; if (field == NULL) return NULL;
redisAssert(sdsEncodedObject(field)); serverAssert(sdsEncodedObject(field));
value = rdbLoadStringObject(rdb); value = rdbLoadStringObject(rdb);
if (value == NULL) return NULL; if (value == NULL) return NULL;
redisAssert(sdsEncodedObject(value)); serverAssert(sdsEncodedObject(value));
/* Add pair to ziplist */ /* Add pair to ziplist */
o->ptr = ziplistPush(o->ptr, field->ptr, sdslen(field->ptr), ZIPLIST_TAIL); o->ptr = ziplistPush(o->ptr, field->ptr, sdslen(field->ptr), ZIPLIST_TAIL);
@ -1094,7 +1094,7 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
} }
/* All pairs should be read by now */ /* All pairs should be read by now */
redisAssert(len == 0); serverAssert(len == 0);
} else if (rdbtype == REDIS_RDB_TYPE_LIST_QUICKLIST) { } else if (rdbtype == REDIS_RDB_TYPE_LIST_QUICKLIST) {
if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL; if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL;
o = createQuicklistObject(); o = createQuicklistObject();

4
src/redisassert.h
View File

@ -40,8 +40,8 @@
#include <unistd.h> /* for _exit() */ #include <unistd.h> /* for _exit() */
#define assert(_e) ((_e)?(void)0 : (_redisAssert(#_e,__FILE__,__LINE__),_exit(1))) #define assert(_e) ((_e)?(void)0 : (_serverAssert(#_e,__FILE__,__LINE__),_exit(1)))
void _redisAssert(char *estr, char *file, int line); void _serverAssert(char *estr, char *file, int line);
#endif #endif

20
src/replication.c
View File

@ -69,7 +69,7 @@ char *replicationGetSlaveName(client *c) {
/* ---------------------------------- MASTER -------------------------------- */ /* ---------------------------------- MASTER -------------------------------- */
void createReplicationBacklog(void) { void createReplicationBacklog(void) {
redisAssert(server.repl_backlog == NULL); serverAssert(server.repl_backlog == NULL);
server.repl_backlog = zmalloc(server.repl_backlog_size); server.repl_backlog = zmalloc(server.repl_backlog_size);
server.repl_backlog_histlen = 0; server.repl_backlog_histlen = 0;
server.repl_backlog_idx = 0; server.repl_backlog_idx = 0;
@ -113,7 +113,7 @@ void resizeReplicationBacklog(long long newsize) {
} }
void freeReplicationBacklog(void) { void freeReplicationBacklog(void) {
redisAssert(listLength(server.slaves) == 0); serverAssert(listLength(server.slaves) == 0);
zfree(server.repl_backlog); zfree(server.repl_backlog);
server.repl_backlog = NULL; server.repl_backlog = NULL;
} }
@ -175,7 +175,7 @@ void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {
if (server.repl_backlog == NULL && listLength(slaves) == 0) return; if (server.repl_backlog == NULL && listLength(slaves) == 0) return;
/* We can't have slaves attached and no backlog. */ /* We can't have slaves attached and no backlog. */
redisAssert(!(listLength(slaves) != 0 && server.repl_backlog == NULL)); serverAssert(!(listLength(slaves) != 0 && server.repl_backlog == NULL));
/* Send SELECT command to every slave if needed. */ /* Send SELECT command to every slave if needed. */
if (server.slaveseldb != dictid) { if (server.slaveseldb != dictid) {
@ -821,7 +821,7 @@ void updateSlavesWaitingBgsave(int bgsaveerr, int type) {
/* Abort the async download of the bulk dataset while SYNC-ing with master */ /* Abort the async download of the bulk dataset while SYNC-ing with master */
void replicationAbortSyncTransfer(void) { void replicationAbortSyncTransfer(void) {
redisAssert(server.repl_state == REDIS_REPL_TRANSFER); serverAssert(server.repl_state == REDIS_REPL_TRANSFER);
aeDeleteFileEvent(server.el,server.repl_transfer_s,AE_READABLE); aeDeleteFileEvent(server.el,server.repl_transfer_s,AE_READABLE);
close(server.repl_transfer_s); close(server.repl_transfer_s);
@ -1411,7 +1411,7 @@ int connectWithMaster(void) {
void undoConnectWithMaster(void) { void undoConnectWithMaster(void) {
int fd = server.repl_transfer_s; int fd = server.repl_transfer_s;
redisAssert(server.repl_state == REDIS_REPL_CONNECTING || serverAssert(server.repl_state == REDIS_REPL_CONNECTING ||
server.repl_state == REDIS_REPL_RECEIVE_PONG); server.repl_state == REDIS_REPL_RECEIVE_PONG);
aeDeleteFileEvent(server.el,fd,AE_READABLE|AE_WRITABLE); aeDeleteFileEvent(server.el,fd,AE_READABLE|AE_WRITABLE);
close(fd); close(fd);
@ -1603,13 +1603,13 @@ void replicationSendAck(void) {
void replicationCacheMaster(client *c) { void replicationCacheMaster(client *c) {
listNode *ln; listNode *ln;
redisAssert(server.master != NULL && server.cached_master == NULL); serverAssert(server.master != NULL && server.cached_master == NULL);
serverLog(REDIS_NOTICE,"Caching the disconnected master state."); serverLog(REDIS_NOTICE,"Caching the disconnected master state.");
/* Remove from the list of clients, we don't want this client to be /* Remove from the list of clients, we don't want this client to be
* listed by CLIENT LIST or processed in any way by batch operations. */ * listed by CLIENT LIST or processed in any way by batch operations. */
ln = listSearchKey(server.clients,c); ln = listSearchKey(server.clients,c);
redisAssert(ln != NULL); serverAssert(ln != NULL);
listDelNode(server.clients,ln); listDelNode(server.clients,ln);
/* Save the master. Server.master will be set to null later by /* Save the master. Server.master will be set to null later by
@ -1774,14 +1774,14 @@ void replicationScriptCacheAdd(sds sha1) {
sds oldest = listNodeValue(ln); sds oldest = listNodeValue(ln);
retval = dictDelete(server.repl_scriptcache_dict,oldest); retval = dictDelete(server.repl_scriptcache_dict,oldest);
redisAssert(retval == DICT_OK); serverAssert(retval == DICT_OK);
listDelNode(server.repl_scriptcache_fifo,ln); listDelNode(server.repl_scriptcache_fifo,ln);
} }
/* Add current. */ /* Add current. */
retval = dictAdd(server.repl_scriptcache_dict,key,NULL); retval = dictAdd(server.repl_scriptcache_dict,key,NULL);
listAddNodeHead(server.repl_scriptcache_fifo,key); listAddNodeHead(server.repl_scriptcache_fifo,key);
redisAssert(retval == DICT_OK); serverAssert(retval == DICT_OK);
} }
/* Returns non-zero if the specified entry exists inside the cache, that is, /* Returns non-zero if the specified entry exists inside the cache, that is,
@ -1880,7 +1880,7 @@ void waitCommand(client *c) {
* instead. */ * instead. */
void unblockClientWaitingReplicas(client *c) { void unblockClientWaitingReplicas(client *c) {
listNode *ln = listSearchKey(server.clients_waiting_acks,c); listNode *ln = listSearchKey(server.clients_waiting_acks,c);
redisAssert(ln != NULL); serverAssert(ln != NULL);
listDelNode(server.clients_waiting_acks,ln); listDelNode(server.clients_waiting_acks,ln);
} }

2
src/rio.c
View File

@ -299,7 +299,7 @@ void rioGenericUpdateChecksum(rio *r, const void *buf, size_t len) {
* disk I/O concentrated in very little time. When we fsync in an explicit * disk I/O concentrated in very little time. When we fsync in an explicit
* way instead the I/O pressure is more distributed across time. */ * way instead the I/O pressure is more distributed across time. */
void rioSetAutoSync(rio *r, off_t bytes) { void rioSetAutoSync(rio *r, off_t bytes) {
redisAssert(r->read == rioFileIO.read); serverAssert(r->read == rioFileIO.read);
r->io.file.autosync = bytes; r->io.file.autosync = bytes;
} }

6
src/scripting.c
View File

@ -914,7 +914,7 @@ int luaCreateFunction(client *c, lua_State *lua, char *funcname, robj *body) {
{ {
int retval = dictAdd(server.lua_scripts, int retval = dictAdd(server.lua_scripts,
sdsnewlen(funcname+2,40),body); sdsnewlen(funcname+2,40),body);
redisAssertWithInfo(c,NULL,retval == DICT_OK); serverAssertWithInfo(c,NULL,retval == DICT_OK);
incrRefCount(body); incrRefCount(body);
} }
return REDIS_OK; return REDIS_OK;
@ -996,7 +996,7 @@ void evalGenericCommand(client *c, int evalsha) {
} }
/* Now the following is guaranteed to return non nil */ /* Now the following is guaranteed to return non nil */
lua_getglobal(lua, funcname); lua_getglobal(lua, funcname);
redisAssert(!lua_isnil(lua,-1)); serverAssert(!lua_isnil(lua,-1));
} }
/* Populate the argv and keys table accordingly to the arguments that /* Populate the argv and keys table accordingly to the arguments that
@ -1081,7 +1081,7 @@ void evalGenericCommand(client *c, int evalsha) {
robj *script = dictFetchValue(server.lua_scripts,c->argv[1]->ptr); robj *script = dictFetchValue(server.lua_scripts,c->argv[1]->ptr);
replicationScriptCacheAdd(c->argv[1]->ptr); replicationScriptCacheAdd(c->argv[1]->ptr);
redisAssertWithInfo(c,NULL,script != NULL); serverAssertWithInfo(c,NULL,script != NULL);
rewriteClientCommandArgument(c,0, rewriteClientCommandArgument(c,0,
resetRefCount(createStringObject("EVAL",4))); resetRefCount(createStringObject("EVAL",4)));
rewriteClientCommandArgument(c,1,script); rewriteClientCommandArgument(c,1,script);

32
src/sentinel.c
View File

@ -454,7 +454,7 @@ void initSentinel(void) {
struct redisCommand *cmd = sentinelcmds+j; struct redisCommand *cmd = sentinelcmds+j;
retval = dictAdd(server.commands, sdsnew(cmd->name), cmd); retval = dictAdd(server.commands, sdsnew(cmd->name), cmd);
redisAssert(retval == DICT_OK); serverAssert(retval == DICT_OK);
} }
/* Initialize various data structures. */ /* Initialize various data structures. */
@ -705,7 +705,7 @@ void sentinelScheduleScriptExecution(char *path, ...) {
sentinelReleaseScriptJob(sj); sentinelReleaseScriptJob(sj);
break; break;
} }
redisAssert(listLength(sentinel.scripts_queue) <= serverAssert(listLength(sentinel.scripts_queue) <=
SENTINEL_SCRIPT_MAX_QUEUE); SENTINEL_SCRIPT_MAX_QUEUE);
} }
} }
@ -973,7 +973,7 @@ void instanceLinkCloseConnection(instanceLink *link, redisAsyncContext *c) {
* replies for an instance that no longer exists. */ * replies for an instance that no longer exists. */
instanceLink *releaseInstanceLink(instanceLink *link, sentinelRedisInstance *ri) instanceLink *releaseInstanceLink(instanceLink *link, sentinelRedisInstance *ri)
{ {
redisAssert(link->refcount > 0); serverAssert(link->refcount > 0);
link->refcount--; link->refcount--;
if (link->refcount != 0) { if (link->refcount != 0) {
if (ri && ri->link->cc) { if (ri && ri->link->cc) {
@ -1016,7 +1016,7 @@ instanceLink *releaseInstanceLink(instanceLink *link, sentinelRedisInstance *ri)
* different master and sharing was performed. Otherwise REDIS_ERR * different master and sharing was performed. Otherwise REDIS_ERR
* is returned. */ * is returned. */
int sentinelTryConnectionSharing(sentinelRedisInstance *ri) { int sentinelTryConnectionSharing(sentinelRedisInstance *ri) {
redisAssert(ri->flags & SRI_SENTINEL); serverAssert(ri->flags & SRI_SENTINEL);
dictIterator *di; dictIterator *di;
dictEntry *de; dictEntry *de;
@ -1052,7 +1052,7 @@ int sentinelTryConnectionSharing(sentinelRedisInstance *ri) {
* *
* Return the number of updated Sentinel addresses. */ * Return the number of updated Sentinel addresses. */
int sentinelUpdateSentinelAddressInAllMasters(sentinelRedisInstance *ri) { int sentinelUpdateSentinelAddressInAllMasters(sentinelRedisInstance *ri) {
redisAssert(ri->flags & SRI_SENTINEL); serverAssert(ri->flags & SRI_SENTINEL);
dictIterator *di; dictIterator *di;
dictEntry *de; dictEntry *de;
int reconfigured = 0; int reconfigured = 0;
@ -1140,8 +1140,8 @@ sentinelRedisInstance *createSentinelRedisInstance(char *name, int flags, char *
dict *table = NULL; dict *table = NULL;
char slavename[REDIS_PEER_ID_LEN], *sdsname; char slavename[REDIS_PEER_ID_LEN], *sdsname;
redisAssert(flags & (SRI_MASTER|SRI_SLAVE|SRI_SENTINEL)); serverAssert(flags & (SRI_MASTER|SRI_SLAVE|SRI_SENTINEL));
redisAssert((flags & SRI_MASTER) || master != NULL); serverAssert((flags & SRI_MASTER) || master != NULL);
/* Check address validity. */ /* Check address validity. */
addr = createSentinelAddr(hostname,port); addr = createSentinelAddr(hostname,port);
@ -1262,7 +1262,7 @@ sentinelRedisInstance *sentinelRedisInstanceLookupSlave(
sentinelRedisInstance *slave; sentinelRedisInstance *slave;
char buf[REDIS_PEER_ID_LEN]; char buf[REDIS_PEER_ID_LEN];
redisAssert(ri->flags & SRI_MASTER); serverAssert(ri->flags & SRI_MASTER);
anetFormatAddr(buf,sizeof(buf),ip,port); anetFormatAddr(buf,sizeof(buf),ip,port);
key = sdsnew(buf); key = sdsnew(buf);
slave = dictFetchValue(ri->slaves,key); slave = dictFetchValue(ri->slaves,key);
@ -1320,7 +1320,7 @@ sentinelRedisInstance *getSentinelRedisInstanceByAddrAndRunID(dict *instances, c
dictEntry *de; dictEntry *de;
sentinelRedisInstance *instance = NULL; sentinelRedisInstance *instance = NULL;
redisAssert(ip || runid); /* User must pass at least one search param. */ serverAssert(ip || runid); /* User must pass at least one search param. */
di = dictGetIterator(instances); di = dictGetIterator(instances);
while((de = dictNext(di)) != NULL) { while((de = dictNext(di)) != NULL) {
sentinelRedisInstance *ri = dictGetVal(de); sentinelRedisInstance *ri = dictGetVal(de);
@ -1388,7 +1388,7 @@ void sentinelDelFlagsToDictOfRedisInstances(dict *instances, int flags) {
#define SENTINEL_RESET_NO_SENTINELS (1<<0) #define SENTINEL_RESET_NO_SENTINELS (1<<0)
void sentinelResetMaster(sentinelRedisInstance *ri, int flags) { void sentinelResetMaster(sentinelRedisInstance *ri, int flags) {
redisAssert(ri->flags & SRI_MASTER); serverAssert(ri->flags & SRI_MASTER);
dictRelease(ri->slaves); dictRelease(ri->slaves);
ri->slaves = dictCreate(&instancesDictType,NULL); ri->slaves = dictCreate(&instancesDictType,NULL);
if (!(flags & SENTINEL_RESET_NO_SENTINELS)) { if (!(flags & SENTINEL_RESET_NO_SENTINELS)) {
@ -3606,7 +3606,7 @@ int sentinelLeaderIncr(dict *counters, char *runid) {
return oldval+1; return oldval+1;
} else { } else {
de = dictAddRaw(counters,runid); de = dictAddRaw(counters,runid);
redisAssert(de != NULL); serverAssert(de != NULL);
dictSetUnsignedIntegerVal(de,1); dictSetUnsignedIntegerVal(de,1);
return 1; return 1;
} }
@ -3628,7 +3628,7 @@ char *sentinelGetLeader(sentinelRedisInstance *master, uint64_t epoch) {
uint64_t leader_epoch; uint64_t leader_epoch;
uint64_t max_votes = 0; uint64_t max_votes = 0;
redisAssert(master->flags & (SRI_O_DOWN|SRI_FAILOVER_IN_PROGRESS)); serverAssert(master->flags & (SRI_O_DOWN|SRI_FAILOVER_IN_PROGRESS));
counters = dictCreate(&leaderVotesDictType,NULL); counters = dictCreate(&leaderVotesDictType,NULL);
voters = dictSize(master->sentinels)+1; /* All the other sentinels and me. */ voters = dictSize(master->sentinels)+1; /* All the other sentinels and me. */
@ -3751,7 +3751,7 @@ int sentinelSendSlaveOf(sentinelRedisInstance *ri, char *host, int port) {
/* Setup the master state to start a failover. */ /* Setup the master state to start a failover. */
void sentinelStartFailover(sentinelRedisInstance *master) { void sentinelStartFailover(sentinelRedisInstance *master) {
redisAssert(master->flags & SRI_MASTER); serverAssert(master->flags & SRI_MASTER);
master->failover_state = SENTINEL_FAILOVER_STATE_WAIT_START; master->failover_state = SENTINEL_FAILOVER_STATE_WAIT_START;
master->flags |= SRI_FAILOVER_IN_PROGRESS; master->flags |= SRI_FAILOVER_IN_PROGRESS;
@ -4137,7 +4137,7 @@ void sentinelFailoverSwitchToPromotedSlave(sentinelRedisInstance *master) {
} }
void sentinelFailoverStateMachine(sentinelRedisInstance *ri) { void sentinelFailoverStateMachine(sentinelRedisInstance *ri) {
redisAssert(ri->flags & SRI_MASTER); serverAssert(ri->flags & SRI_MASTER);
if (!(ri->flags & SRI_FAILOVER_IN_PROGRESS)) return; if (!(ri->flags & SRI_FAILOVER_IN_PROGRESS)) return;
@ -4166,8 +4166,8 @@ void sentinelFailoverStateMachine(sentinelRedisInstance *ri) {
* the slave -> master switch. Otherwise the failover can't be aborted and * the slave -> master switch. Otherwise the failover can't be aborted and
* will reach its end (possibly by timeout). */ * will reach its end (possibly by timeout). */
void sentinelAbortFailover(sentinelRedisInstance *ri) { void sentinelAbortFailover(sentinelRedisInstance *ri) {
redisAssert(ri->flags & SRI_FAILOVER_IN_PROGRESS); serverAssert(ri->flags & SRI_FAILOVER_IN_PROGRESS);
redisAssert(ri->failover_state <= SENTINEL_FAILOVER_STATE_WAIT_PROMOTION); serverAssert(ri->failover_state <= SENTINEL_FAILOVER_STATE_WAIT_PROMOTION);
ri->flags &= ~(SRI_FAILOVER_IN_PROGRESS|SRI_FORCE_FAILOVER); ri->flags &= ~(SRI_FAILOVER_IN_PROGRESS|SRI_FORCE_FAILOVER);
ri->failover_state = SENTINEL_FAILOVER_STATE_NONE; ri->failover_state = SENTINEL_FAILOVER_STATE_NONE;

2
src/server.c
View File

@ -1938,7 +1938,7 @@ void populateCommandTable(void) {
/* Populate an additional dictionary that will be unaffected /* Populate an additional dictionary that will be unaffected
* by rename-command statements in redis.conf. */ * by rename-command statements in redis.conf. */
retval2 = dictAdd(server.orig_commands, sdsnew(c->name), c); retval2 = dictAdd(server.orig_commands, sdsnew(c->name), c);
redisAssert(retval1 == DICT_OK && retval2 == DICT_OK); serverAssert(retval1 == DICT_OK && retval2 == DICT_OK);
} }
} }

8
src/server.h
View File

@ -412,8 +412,8 @@ typedef long long mstime_t; /* millisecond time type. */
#define run_with_period(_ms_) if ((_ms_ <= 1000/server.hz) || !(server.cronloops%((_ms_)/(1000/server.hz)))) #define run_with_period(_ms_) if ((_ms_ <= 1000/server.hz) || !(server.cronloops%((_ms_)/(1000/server.hz))))
/* We can print the stacktrace, so our assert is defined this way: */ /* We can print the stacktrace, so our assert is defined this way: */
#define redisAssertWithInfo(_c,_o,_e) ((_e)?(void)0 : (_redisAssertWithInfo(_c,_o,#_e,__FILE__,__LINE__),_exit(1))) #define serverAssertWithInfo(_c,_o,_e) ((_e)?(void)0 : (_serverAssertWithInfo(_c,_o,#_e,__FILE__,__LINE__),_exit(1)))
#define redisAssert(_e) ((_e)?(void)0 : (_redisAssert(#_e,__FILE__,__LINE__),_exit(1))) #define serverAssert(_e) ((_e)?(void)0 : (_serverAssert(#_e,__FILE__,__LINE__),_exit(1)))
#define redisPanic(_e) _redisPanic(#_e,__FILE__,__LINE__),_exit(1) #define redisPanic(_e) _redisPanic(#_e,__FILE__,__LINE__),_exit(1)
/*----------------------------------------------------------------------------- /*-----------------------------------------------------------------------------
@ -1581,8 +1581,8 @@ void *realloc(void *ptr, size_t size) __attribute__ ((deprecated));
#endif #endif
/* Debugging stuff */ /* Debugging stuff */
void _redisAssertWithInfo(client *c, robj *o, char *estr, char *file, int line); void _serverAssertWithInfo(client *c, robj *o, char *estr, char *file, int line);
void _redisAssert(char *estr, char *file, int line); void _serverAssert(char *estr, char *file, int line);
void _redisPanic(char *msg, char *file, int line); void _redisPanic(char *msg, char *file, int line);
void bugReportStart(void); void bugReportStart(void);
void serverLogObjectDebugInfo(robj *o); void serverLogObjectDebugInfo(robj *o);

10
src/sort.c
View File

@ -416,7 +416,7 @@ void sortCommand(client *c) {
} }
while(rangelen--) { while(rangelen--) {
redisAssertWithInfo(c,sortval,ln != NULL); serverAssertWithInfo(c,sortval,ln != NULL);
ele = ln->obj; ele = ln->obj;
vector[j].obj = ele; vector[j].obj = ele;
vector[j].u.score = 0; vector[j].u.score = 0;
@ -442,7 +442,7 @@ void sortCommand(client *c) {
} else { } else {
redisPanic("Unknown type"); redisPanic("Unknown type");
} }
redisAssertWithInfo(c,sortval,j == vectorlen); serverAssertWithInfo(c,sortval,j == vectorlen);
/* Now it's time to load the right scores in the sorting vector */ /* Now it's time to load the right scores in the sorting vector */
if (dontsort == 0) { if (dontsort == 0) {
@ -475,7 +475,7 @@ void sortCommand(client *c) {
* far. We can just cast it */ * far. We can just cast it */
vector[j].u.score = (long)byval->ptr; vector[j].u.score = (long)byval->ptr;
} else { } else {
redisAssertWithInfo(c,sortval,1 != 1); serverAssertWithInfo(c,sortval,1 != 1);
} }
} }
@ -526,7 +526,7 @@ void sortCommand(client *c) {
} }
} else { } else {
/* Always fails */ /* Always fails */
redisAssertWithInfo(c,sortval,sop->type == REDIS_SORT_GET); serverAssertWithInfo(c,sortval,sop->type == REDIS_SORT_GET);
} }
} }
} }
@ -557,7 +557,7 @@ void sortCommand(client *c) {
decrRefCount(val); decrRefCount(val);
} else { } else {
/* Always fails */ /* Always fails */
redisAssertWithInfo(c,sortval,sop->type == REDIS_SORT_GET); serverAssertWithInfo(c,sortval,sop->type == REDIS_SORT_GET);
} }
} }
} }

30
src/t_hash.c
View File

@ -70,7 +70,7 @@ int hashTypeGetFromZiplist(robj *o, robj *field,
unsigned char *zl, *fptr = NULL, *vptr = NULL; unsigned char *zl, *fptr = NULL, *vptr = NULL;
int ret; int ret;
redisAssert(o->encoding == OBJ_ENCODING_ZIPLIST); serverAssert(o->encoding == OBJ_ENCODING_ZIPLIST);
field = getDecodedObject(field); field = getDecodedObject(field);
@ -81,7 +81,7 @@ int hashTypeGetFromZiplist(robj *o, robj *field,
if (fptr != NULL) { if (fptr != NULL) {
/* Grab pointer to the value (fptr points to the field) */ /* Grab pointer to the value (fptr points to the field) */
vptr = ziplistNext(zl, fptr); vptr = ziplistNext(zl, fptr);
redisAssert(vptr != NULL); serverAssert(vptr != NULL);
} }
} }
@ -89,7 +89,7 @@ int hashTypeGetFromZiplist(robj *o, robj *field,
if (vptr != NULL) { if (vptr != NULL) {
ret = ziplistGet(vptr, vstr, vlen, vll); ret = ziplistGet(vptr, vstr, vlen, vll);
redisAssert(ret); serverAssert(ret);
return 0; return 0;
} }
@ -101,7 +101,7 @@ int hashTypeGetFromZiplist(robj *o, robj *field,
int hashTypeGetFromHashTable(robj *o, robj *field, robj **value) { int hashTypeGetFromHashTable(robj *o, robj *field, robj **value) {
dictEntry *de; dictEntry *de;
redisAssert(o->encoding == OBJ_ENCODING_HT); serverAssert(o->encoding == OBJ_ENCODING_HT);
de = dictFind(o->ptr, field); de = dictFind(o->ptr, field);
if (de == NULL) return -1; if (de == NULL) return -1;
@ -205,7 +205,7 @@ int hashTypeSet(robj *o, robj *field, robj *value) {
if (fptr != NULL) { if (fptr != NULL) {
/* Grab pointer to the value (fptr points to the field) */ /* Grab pointer to the value (fptr points to the field) */
vptr = ziplistNext(zl, fptr); vptr = ziplistNext(zl, fptr);
redisAssert(vptr != NULL); serverAssert(vptr != NULL);
update = 1; update = 1;
/* Delete value */ /* Delete value */
@ -333,18 +333,18 @@ int hashTypeNext(hashTypeIterator *hi) {
if (fptr == NULL) { if (fptr == NULL) {
/* Initialize cursor */ /* Initialize cursor */
redisAssert(vptr == NULL); serverAssert(vptr == NULL);
fptr = ziplistIndex(zl, 0); fptr = ziplistIndex(zl, 0);
} else { } else {
/* Advance cursor */ /* Advance cursor */
redisAssert(vptr != NULL); serverAssert(vptr != NULL);
fptr = ziplistNext(zl, vptr); fptr = ziplistNext(zl, vptr);
} }
if (fptr == NULL) return REDIS_ERR; if (fptr == NULL) return REDIS_ERR;
/* Grab pointer to the value (fptr points to the field) */ /* Grab pointer to the value (fptr points to the field) */
vptr = ziplistNext(zl, fptr); vptr = ziplistNext(zl, fptr);
redisAssert(vptr != NULL); serverAssert(vptr != NULL);
/* fptr, vptr now point to the first or next pair */ /* fptr, vptr now point to the first or next pair */
hi->fptr = fptr; hi->fptr = fptr;
@ -366,21 +366,21 @@ void hashTypeCurrentFromZiplist(hashTypeIterator *hi, int what,
{ {
int ret; int ret;
redisAssert(hi->encoding == OBJ_ENCODING_ZIPLIST); serverAssert(hi->encoding == OBJ_ENCODING_ZIPLIST);
if (what & OBJ_HASH_KEY) { if (what & OBJ_HASH_KEY) {
ret = ziplistGet(hi->fptr, vstr, vlen, vll); ret = ziplistGet(hi->fptr, vstr, vlen, vll);
redisAssert(ret); serverAssert(ret);
} else { } else {
ret = ziplistGet(hi->vptr, vstr, vlen, vll); ret = ziplistGet(hi->vptr, vstr, vlen, vll);
redisAssert(ret); serverAssert(ret);
} }
} }
/* Get the field or value at iterator cursor, for an iterator on a hash value /* Get the field or value at iterator cursor, for an iterator on a hash value
* encoded as a ziplist. Prototype is similar to `hashTypeGetFromHashTable`. */ * encoded as a ziplist. Prototype is similar to `hashTypeGetFromHashTable`. */
void hashTypeCurrentFromHashTable(hashTypeIterator *hi, int what, robj **dst) { void hashTypeCurrentFromHashTable(hashTypeIterator *hi, int what, robj **dst) {
redisAssert(hi->encoding == OBJ_ENCODING_HT); serverAssert(hi->encoding == OBJ_ENCODING_HT);
if (what & OBJ_HASH_KEY) { if (what & OBJ_HASH_KEY) {
*dst = dictGetKey(hi->de); *dst = dictGetKey(hi->de);
@ -430,7 +430,7 @@ robj *hashTypeLookupWriteOrCreate(client *c, robj *key) {
} }
void hashTypeConvertZiplist(robj *o, int enc) { void hashTypeConvertZiplist(robj *o, int enc) {
redisAssert(o->encoding == OBJ_ENCODING_ZIPLIST); serverAssert(o->encoding == OBJ_ENCODING_ZIPLIST);
if (enc == OBJ_ENCODING_ZIPLIST) { if (enc == OBJ_ENCODING_ZIPLIST) {
/* Nothing to do... */ /* Nothing to do... */
@ -454,7 +454,7 @@ void hashTypeConvertZiplist(robj *o, int enc) {
if (ret != DICT_OK) { if (ret != DICT_OK) {
serverLogHexDump(REDIS_WARNING,"ziplist with dup elements dump", serverLogHexDump(REDIS_WARNING,"ziplist with dup elements dump",
o->ptr,ziplistBlobLen(o->ptr)); o->ptr,ziplistBlobLen(o->ptr));
redisAssert(ret == DICT_OK); serverAssert(ret == DICT_OK);
} }
} }
@ -768,7 +768,7 @@ void genericHgetallCommand(client *c, int flags) {
} }
hashTypeReleaseIterator(hi); hashTypeReleaseIterator(hi);
redisAssert(count == length); serverAssert(count == length);
} }
void hkeysCommand(client *c) { void hkeysCommand(client *c) {

20
src/t_list.c
View File

@ -111,7 +111,7 @@ void listTypeReleaseIterator(listTypeIterator *li) {
* entry is in fact an entry, 0 otherwise. */ * entry is in fact an entry, 0 otherwise. */
int listTypeNext(listTypeIterator *li, listTypeEntry *entry) { int listTypeNext(listTypeIterator *li, listTypeEntry *entry) {
/* Protect from converting when iterating */ /* Protect from converting when iterating */
redisAssert(li->subject->encoding == li->encoding); serverAssert(li->subject->encoding == li->encoding);
entry->li = li; entry->li = li;
if (li->encoding == OBJ_ENCODING_QUICKLIST) { if (li->encoding == OBJ_ENCODING_QUICKLIST) {
@ -159,7 +159,7 @@ void listTypeInsert(listTypeEntry *entry, robj *value, int where) {
/* Compare the given object with the entry at the current position. */ /* Compare the given object with the entry at the current position. */
int listTypeEqual(listTypeEntry *entry, robj *o) { int listTypeEqual(listTypeEntry *entry, robj *o) {
if (entry->li->encoding == OBJ_ENCODING_QUICKLIST) { if (entry->li->encoding == OBJ_ENCODING_QUICKLIST) {
redisAssertWithInfo(NULL,o,sdsEncodedObject(o)); serverAssertWithInfo(NULL,o,sdsEncodedObject(o));
return quicklistCompare(entry->entry.zi,o->ptr,sdslen(o->ptr)); return quicklistCompare(entry->entry.zi,o->ptr,sdslen(o->ptr));
} else { } else {
redisPanic("Unknown list encoding"); redisPanic("Unknown list encoding");
@ -177,8 +177,8 @@ void listTypeDelete(listTypeIterator *iter, listTypeEntry *entry) {
/* Create a quicklist from a single ziplist */ /* Create a quicklist from a single ziplist */
void listTypeConvert(robj *subject, int enc) { void listTypeConvert(robj *subject, int enc) {
redisAssertWithInfo(NULL,subject,subject->type==OBJ_LIST); serverAssertWithInfo(NULL,subject,subject->type==OBJ_LIST);
redisAssertWithInfo(NULL,subject,subject->encoding==OBJ_ENCODING_ZIPLIST); serverAssertWithInfo(NULL,subject,subject->encoding==OBJ_ENCODING_ZIPLIST);
if (enc == OBJ_ENCODING_QUICKLIST) { if (enc == OBJ_ENCODING_QUICKLIST) {
size_t zlen = server.list_max_ziplist_size; size_t zlen = server.list_max_ziplist_size;
@ -632,7 +632,7 @@ void blockForKeys(client *c, robj **keys, int numkeys, mstime_t timeout, robj *t
l = listCreate(); l = listCreate();
retval = dictAdd(c->db->blocking_keys,keys[j],l); retval = dictAdd(c->db->blocking_keys,keys[j],l);
incrRefCount(keys[j]); incrRefCount(keys[j]);
redisAssertWithInfo(c,keys[j],retval == DICT_OK); serverAssertWithInfo(c,keys[j],retval == DICT_OK);
} else { } else {
l = dictGetVal(de); l = dictGetVal(de);
} }
@ -648,7 +648,7 @@ void unblockClientWaitingData(client *c) {
dictIterator *di; dictIterator *di;
list *l; list *l;
redisAssertWithInfo(c,NULL,dictSize(c->bpop.keys) != 0); serverAssertWithInfo(c,NULL,dictSize(c->bpop.keys) != 0);
di = dictGetIterator(c->bpop.keys); di = dictGetIterator(c->bpop.keys);
/* The client may wait for multiple keys, so unblock it for every key. */ /* The client may wait for multiple keys, so unblock it for every key. */
while((de = dictNext(di)) != NULL) { while((de = dictNext(di)) != NULL) {
@ -656,7 +656,7 @@ void unblockClientWaitingData(client *c) {
/* Remove this client from the list of clients waiting for this key. */ /* Remove this client from the list of clients waiting for this key. */
l = dictFetchValue(c->db->blocking_keys,key); l = dictFetchValue(c->db->blocking_keys,key);
redisAssertWithInfo(c,key,l != NULL); serverAssertWithInfo(c,key,l != NULL);
listDelNode(l,listSearchKey(l,c)); listDelNode(l,listSearchKey(l,c));
/* If the list is empty we need to remove it to avoid wasting memory */ /* If the list is empty we need to remove it to avoid wasting memory */
if (listLength(l) == 0) if (listLength(l) == 0)
@ -699,7 +699,7 @@ void signalListAsReady(redisDb *db, robj *key) {
* to avoid adding it multiple times into a list with a simple O(1) * to avoid adding it multiple times into a list with a simple O(1)
* check. */ * check. */
incrRefCount(key); incrRefCount(key);
redisAssert(dictAdd(db->ready_keys,key,NULL) == DICT_OK); serverAssert(dictAdd(db->ready_keys,key,NULL) == DICT_OK);
} }
/* This is a helper function for handleClientsBlockedOnLists(). It's work /* This is a helper function for handleClientsBlockedOnLists(). It's work
@ -882,7 +882,7 @@ void blockingPopGenericCommand(client *c, int where) {
/* Non empty list, this is like a non normal [LR]POP. */ /* Non empty list, this is like a non normal [LR]POP. */
char *event = (where == REDIS_HEAD) ? "lpop" : "rpop"; char *event = (where == REDIS_HEAD) ? "lpop" : "rpop";
robj *value = listTypePop(o,where); robj *value = listTypePop(o,where);
redisAssert(value != NULL); serverAssert(value != NULL);
addReplyMultiBulkLen(c,2); addReplyMultiBulkLen(c,2);
addReplyBulk(c,c->argv[j]); addReplyBulk(c,c->argv[j]);
@ -950,7 +950,7 @@ void brpoplpushCommand(client *c) {
} else { } else {
/* The list exists and has elements, so /* The list exists and has elements, so
* the regular rpoplpushCommand is executed. */ * the regular rpoplpushCommand is executed. */
redisAssertWithInfo(c,key,listTypeLength(key) > 0); serverAssertWithInfo(c,key,listTypeLength(key) > 0);
rpoplpushCommand(c); rpoplpushCommand(c);
} }
} }

10
src/t_set.c
View File

@ -74,7 +74,7 @@ int setTypeAdd(robj *subject, robj *value) {
/* The set *was* an intset and this value is not integer /* The set *was* an intset and this value is not integer
* encodable, so dictAdd should always work. */ * encodable, so dictAdd should always work. */
redisAssertWithInfo(NULL,value, serverAssertWithInfo(NULL,value,
dictAdd(subject->ptr,value,NULL) == DICT_OK); dictAdd(subject->ptr,value,NULL) == DICT_OK);
incrRefCount(value); incrRefCount(value);
return 1; return 1;
@ -241,7 +241,7 @@ unsigned long setTypeSize(robj *subject) {
* set. */ * set. */
void setTypeConvert(robj *setobj, int enc) { void setTypeConvert(robj *setobj, int enc) {
setTypeIterator *si; setTypeIterator *si;
redisAssertWithInfo(NULL,setobj,setobj->type == OBJ_SET && serverAssertWithInfo(NULL,setobj,setobj->type == OBJ_SET &&
setobj->encoding == OBJ_ENCODING_INTSET); setobj->encoding == OBJ_ENCODING_INTSET);
if (enc == OBJ_ENCODING_HT) { if (enc == OBJ_ENCODING_HT) {
@ -256,7 +256,7 @@ void setTypeConvert(robj *setobj, int enc) {
si = setTypeInitIterator(setobj); si = setTypeInitIterator(setobj);
while (setTypeNext(si,&element,&intele) != -1) { while (setTypeNext(si,&element,&intele) != -1) {
element = createStringObjectFromLongLong(intele); element = createStringObjectFromLongLong(intele);
redisAssertWithInfo(NULL,element, serverAssertWithInfo(NULL,element,
dictAdd(d,element,NULL) == DICT_OK); dictAdd(d,element,NULL) == DICT_OK);
} }
setTypeReleaseIterator(si); setTypeReleaseIterator(si);
@ -696,10 +696,10 @@ void srandmemberWithCountCommand(client *c) {
} else { } else {
retval = dictAdd(d,dupStringObject(ele),NULL); retval = dictAdd(d,dupStringObject(ele),NULL);
} }
redisAssert(retval == DICT_OK); serverAssert(retval == DICT_OK);
} }
setTypeReleaseIterator(si); setTypeReleaseIterator(si);
redisAssert(dictSize(d) == size); serverAssert(dictSize(d) == size);
/* Remove random elements to reach the right count. */ /* Remove random elements to reach the right count. */
while(size > count) { while(size > count) {

96
src/t_zset.c
View File

@ -112,7 +112,7 @@ zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj) {
unsigned int rank[ZSKIPLIST_MAXLEVEL]; unsigned int rank[ZSKIPLIST_MAXLEVEL];
int i, level; int i, level;
redisAssert(!isnan(score)); serverAssert(!isnan(score));
x = zsl->header; x = zsl->header;
for (i = zsl->level-1; i >= 0; i--) { for (i = zsl->level-1; i >= 0; i--) {
/* store rank that is crossed to reach the insert position */ /* store rank that is crossed to reach the insert position */
@ -253,7 +253,7 @@ zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range) {
/* This is an inner range, so the next node cannot be NULL. */ /* This is an inner range, so the next node cannot be NULL. */
x = x->level[0].forward; x = x->level[0].forward;
redisAssert(x != NULL); serverAssert(x != NULL);
/* Check if score <= max. */ /* Check if score <= max. */
if (!zslValueLteMax(x->score,range)) return NULL; if (!zslValueLteMax(x->score,range)) return NULL;
@ -278,7 +278,7 @@ zskiplistNode *zslLastInRange(zskiplist *zsl, zrangespec *range) {
} }
/* This is an inner range, so this node cannot be NULL. */ /* This is an inner range, so this node cannot be NULL. */
redisAssert(x != NULL); serverAssert(x != NULL);
/* Check if score >= min. */ /* Check if score >= min. */
if (!zslValueGteMin(x->score,range)) return NULL; if (!zslValueGteMin(x->score,range)) return NULL;
@ -596,7 +596,7 @@ zskiplistNode *zslFirstInLexRange(zskiplist *zsl, zlexrangespec *range) {
/* This is an inner range, so the next node cannot be NULL. */ /* This is an inner range, so the next node cannot be NULL. */
x = x->level[0].forward; x = x->level[0].forward;
redisAssert(x != NULL); serverAssert(x != NULL);
/* Check if score <= max. */ /* Check if score <= max. */
if (!zslLexValueLteMax(x->obj,range)) return NULL; if (!zslLexValueLteMax(x->obj,range)) return NULL;
@ -621,7 +621,7 @@ zskiplistNode *zslLastInLexRange(zskiplist *zsl, zlexrangespec *range) {
} }
/* This is an inner range, so this node cannot be NULL. */ /* This is an inner range, so this node cannot be NULL. */
redisAssert(x != NULL); serverAssert(x != NULL);
/* Check if score >= min. */ /* Check if score >= min. */
if (!zslLexValueGteMin(x->obj,range)) return NULL; if (!zslLexValueGteMin(x->obj,range)) return NULL;
@ -639,8 +639,8 @@ double zzlGetScore(unsigned char *sptr) {
char buf[128]; char buf[128];
double score; double score;
redisAssert(sptr != NULL); serverAssert(sptr != NULL);
redisAssert(ziplistGet(sptr,&vstr,&vlen,&vlong)); serverAssert(ziplistGet(sptr,&vstr,&vlen,&vlong));
if (vstr) { if (vstr) {
memcpy(buf,vstr,vlen); memcpy(buf,vstr,vlen);
@ -661,8 +661,8 @@ robj *ziplistGetObject(unsigned char *sptr) {
unsigned int vlen; unsigned int vlen;
long long vlong; long long vlong;
redisAssert(sptr != NULL); serverAssert(sptr != NULL);
redisAssert(ziplistGet(sptr,&vstr,&vlen,&vlong)); serverAssert(ziplistGet(sptr,&vstr,&vlen,&vlong));
if (vstr) { if (vstr) {
return createStringObject((char*)vstr,vlen); return createStringObject((char*)vstr,vlen);
@ -679,7 +679,7 @@ int zzlCompareElements(unsigned char *eptr, unsigned char *cstr, unsigned int cl
unsigned char vbuf[32]; unsigned char vbuf[32];
int minlen, cmp; int minlen, cmp;
redisAssert(ziplistGet(eptr,&vstr,&vlen,&vlong)); serverAssert(ziplistGet(eptr,&vstr,&vlen,&vlong));
if (vstr == NULL) { if (vstr == NULL) {
/* Store string representation of long long in buf. */ /* Store string representation of long long in buf. */
vlen = ll2string((char*)vbuf,sizeof(vbuf),vlong); vlen = ll2string((char*)vbuf,sizeof(vbuf),vlong);
@ -700,12 +700,12 @@ unsigned int zzlLength(unsigned char *zl) {
* NULL when there is no next entry. */ * NULL when there is no next entry. */
void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) { void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) {
unsigned char *_eptr, *_sptr; unsigned char *_eptr, *_sptr;
redisAssert(*eptr != NULL && *sptr != NULL); serverAssert(*eptr != NULL && *sptr != NULL);
_eptr = ziplistNext(zl,*sptr); _eptr = ziplistNext(zl,*sptr);
if (_eptr != NULL) { if (_eptr != NULL) {
_sptr = ziplistNext(zl,_eptr); _sptr = ziplistNext(zl,_eptr);
redisAssert(_sptr != NULL); serverAssert(_sptr != NULL);
} else { } else {
/* No next entry. */ /* No next entry. */
_sptr = NULL; _sptr = NULL;
@ -719,12 +719,12 @@ void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) {
* set to NULL when there is no next entry. */ * set to NULL when there is no next entry. */
void zzlPrev(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) { void zzlPrev(unsigned char *zl, unsigned char **eptr, unsigned char **sptr) {
unsigned char *_eptr, *_sptr; unsigned char *_eptr, *_sptr;
redisAssert(*eptr != NULL && *sptr != NULL); serverAssert(*eptr != NULL && *sptr != NULL);
_sptr = ziplistPrev(zl,*eptr); _sptr = ziplistPrev(zl,*eptr);
if (_sptr != NULL) { if (_sptr != NULL) {
_eptr = ziplistPrev(zl,_sptr); _eptr = ziplistPrev(zl,_sptr);
redisAssert(_eptr != NULL); serverAssert(_eptr != NULL);
} else { } else {
/* No previous entry. */ /* No previous entry. */
_eptr = NULL; _eptr = NULL;
@ -752,7 +752,7 @@ int zzlIsInRange(unsigned char *zl, zrangespec *range) {
return 0; return 0;
p = ziplistIndex(zl,1); /* First score. */ p = ziplistIndex(zl,1); /* First score. */
redisAssert(p != NULL); serverAssert(p != NULL);
score = zzlGetScore(p); score = zzlGetScore(p);
if (!zslValueLteMax(score,range)) if (!zslValueLteMax(score,range))
return 0; return 0;
@ -771,7 +771,7 @@ unsigned char *zzlFirstInRange(unsigned char *zl, zrangespec *range) {
while (eptr != NULL) { while (eptr != NULL) {
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
redisAssert(sptr != NULL); serverAssert(sptr != NULL);
score = zzlGetScore(sptr); score = zzlGetScore(sptr);
if (zslValueGteMin(score,range)) { if (zslValueGteMin(score,range)) {
@ -799,7 +799,7 @@ unsigned char *zzlLastInRange(unsigned char *zl, zrangespec *range) {
while (eptr != NULL) { while (eptr != NULL) {
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
redisAssert(sptr != NULL); serverAssert(sptr != NULL);
score = zzlGetScore(sptr); score = zzlGetScore(sptr);
if (zslValueLteMax(score,range)) { if (zslValueLteMax(score,range)) {
@ -813,7 +813,7 @@ unsigned char *zzlLastInRange(unsigned char *zl, zrangespec *range) {
* When this returns NULL, we know there also is no element. */ * When this returns NULL, we know there also is no element. */
sptr = ziplistPrev(zl,eptr); sptr = ziplistPrev(zl,eptr);
if (sptr != NULL) if (sptr != NULL)
redisAssert((eptr = ziplistPrev(zl,sptr)) != NULL); serverAssert((eptr = ziplistPrev(zl,sptr)) != NULL);
else else
eptr = NULL; eptr = NULL;
} }
@ -852,7 +852,7 @@ int zzlIsInLexRange(unsigned char *zl, zlexrangespec *range) {
return 0; return 0;
p = ziplistIndex(zl,0); /* First element. */ p = ziplistIndex(zl,0); /* First element. */
redisAssert(p != NULL); serverAssert(p != NULL);
if (!zzlLexValueLteMax(p,range)) if (!zzlLexValueLteMax(p,range))
return 0; return 0;
@ -877,7 +877,7 @@ unsigned char *zzlFirstInLexRange(unsigned char *zl, zlexrangespec *range) {
/* Move to next element. */ /* Move to next element. */
sptr = ziplistNext(zl,eptr); /* This element score. Skip it. */ sptr = ziplistNext(zl,eptr); /* This element score. Skip it. */
redisAssert(sptr != NULL); serverAssert(sptr != NULL);
eptr = ziplistNext(zl,sptr); /* Next element. */ eptr = ziplistNext(zl,sptr); /* Next element. */
} }
@ -904,7 +904,7 @@ unsigned char *zzlLastInLexRange(unsigned char *zl, zlexrangespec *range) {
* When this returns NULL, we know there also is no element. */ * When this returns NULL, we know there also is no element. */
sptr = ziplistPrev(zl,eptr); sptr = ziplistPrev(zl,eptr);
if (sptr != NULL) if (sptr != NULL)
redisAssert((eptr = ziplistPrev(zl,sptr)) != NULL); serverAssert((eptr = ziplistPrev(zl,sptr)) != NULL);
else else
eptr = NULL; eptr = NULL;
} }
@ -918,7 +918,7 @@ unsigned char *zzlFind(unsigned char *zl, robj *ele, double *score) {
ele = getDecodedObject(ele); ele = getDecodedObject(ele);
while (eptr != NULL) { while (eptr != NULL) {
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
redisAssertWithInfo(NULL,ele,sptr != NULL); serverAssertWithInfo(NULL,ele,sptr != NULL);
if (ziplistCompare(eptr,ele->ptr,sdslen(ele->ptr))) { if (ziplistCompare(eptr,ele->ptr,sdslen(ele->ptr))) {
/* Matching element, pull out score. */ /* Matching element, pull out score. */
@ -952,7 +952,7 @@ unsigned char *zzlInsertAt(unsigned char *zl, unsigned char *eptr, robj *ele, do
int scorelen; int scorelen;
size_t offset; size_t offset;
redisAssertWithInfo(NULL,ele,sdsEncodedObject(ele)); serverAssertWithInfo(NULL,ele,sdsEncodedObject(ele));
scorelen = d2string(scorebuf,sizeof(scorebuf),score); scorelen = d2string(scorebuf,sizeof(scorebuf),score);
if (eptr == NULL) { if (eptr == NULL) {
zl = ziplistPush(zl,ele->ptr,sdslen(ele->ptr),ZIPLIST_TAIL); zl = ziplistPush(zl,ele->ptr,sdslen(ele->ptr),ZIPLIST_TAIL);
@ -964,7 +964,7 @@ unsigned char *zzlInsertAt(unsigned char *zl, unsigned char *eptr, robj *ele, do
eptr = zl+offset; eptr = zl+offset;
/* Insert score after the element. */ /* Insert score after the element. */
redisAssertWithInfo(NULL,ele,(sptr = ziplistNext(zl,eptr)) != NULL); serverAssertWithInfo(NULL,ele,(sptr = ziplistNext(zl,eptr)) != NULL);
zl = ziplistInsert(zl,sptr,(unsigned char*)scorebuf,scorelen); zl = ziplistInsert(zl,sptr,(unsigned char*)scorebuf,scorelen);
} }
@ -980,7 +980,7 @@ unsigned char *zzlInsert(unsigned char *zl, robj *ele, double score) {
ele = getDecodedObject(ele); ele = getDecodedObject(ele);
while (eptr != NULL) { while (eptr != NULL) {
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
redisAssertWithInfo(NULL,ele,sptr != NULL); serverAssertWithInfo(NULL,ele,sptr != NULL);
s = zzlGetScore(sptr); s = zzlGetScore(sptr);
if (s > score) { if (s > score) {
@ -1112,13 +1112,13 @@ void zsetConvert(robj *zobj, int encoding) {
zs->zsl = zslCreate(); zs->zsl = zslCreate();
eptr = ziplistIndex(zl,0); eptr = ziplistIndex(zl,0);
redisAssertWithInfo(NULL,zobj,eptr != NULL); serverAssertWithInfo(NULL,zobj,eptr != NULL);
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
redisAssertWithInfo(NULL,zobj,sptr != NULL); serverAssertWithInfo(NULL,zobj,sptr != NULL);
while (eptr != NULL) { while (eptr != NULL) {
score = zzlGetScore(sptr); score = zzlGetScore(sptr);
redisAssertWithInfo(NULL,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong)); serverAssertWithInfo(NULL,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong));
if (vstr == NULL) if (vstr == NULL)
ele = createStringObjectFromLongLong(vlong); ele = createStringObjectFromLongLong(vlong);
else else
@ -1126,7 +1126,7 @@ void zsetConvert(robj *zobj, int encoding) {
/* Has incremented refcount since it was just created. */ /* Has incremented refcount since it was just created. */
node = zslInsert(zs->zsl,score,ele); node = zslInsert(zs->zsl,score,ele);
redisAssertWithInfo(NULL,zobj,dictAdd(zs->dict,ele,&node->score) == DICT_OK); serverAssertWithInfo(NULL,zobj,dictAdd(zs->dict,ele,&node->score) == DICT_OK);
incrRefCount(ele); /* Added to dictionary. */ incrRefCount(ele); /* Added to dictionary. */
zzlNext(zl,&eptr,&sptr); zzlNext(zl,&eptr,&sptr);
} }
@ -1347,7 +1347,7 @@ void zaddGenericCommand(client *c, int flags) {
* delete the key object from the skiplist, since the * delete the key object from the skiplist, since the
* dictionary still has a reference to it. */ * dictionary still has a reference to it. */
if (score != curscore) { if (score != curscore) {
redisAssertWithInfo(c,curobj,zslDelete(zs->zsl,curscore,curobj)); serverAssertWithInfo(c,curobj,zslDelete(zs->zsl,curscore,curobj));
znode = zslInsert(zs->zsl,score,curobj); znode = zslInsert(zs->zsl,score,curobj);
incrRefCount(curobj); /* Re-inserted in skiplist. */ incrRefCount(curobj); /* Re-inserted in skiplist. */
dictGetVal(de) = &znode->score; /* Update score ptr. */ dictGetVal(de) = &znode->score; /* Update score ptr. */
@ -1358,7 +1358,7 @@ void zaddGenericCommand(client *c, int flags) {
} else if (!xx) { } else if (!xx) {
znode = zslInsert(zs->zsl,score,ele); znode = zslInsert(zs->zsl,score,ele);
incrRefCount(ele); /* Inserted in skiplist. */ incrRefCount(ele); /* Inserted in skiplist. */
redisAssertWithInfo(c,NULL,dictAdd(zs->dict,ele,&znode->score) == DICT_OK); serverAssertWithInfo(c,NULL,dictAdd(zs->dict,ele,&znode->score) == DICT_OK);
incrRefCount(ele); /* Added to dictionary. */ incrRefCount(ele); /* Added to dictionary. */
server.dirty++; server.dirty++;
added++; added++;
@ -1430,7 +1430,7 @@ void zremCommand(client *c) {
/* Delete from the skiplist */ /* Delete from the skiplist */
score = *(double*)dictGetVal(de); score = *(double*)dictGetVal(de);
redisAssertWithInfo(c,c->argv[j],zslDelete(zs->zsl,score,c->argv[j])); serverAssertWithInfo(c,c->argv[j],zslDelete(zs->zsl,score,c->argv[j]));
/* Delete from the hash table */ /* Delete from the hash table */
dictDelete(zs->dict,c->argv[j]); dictDelete(zs->dict,c->argv[j]);
@ -1654,7 +1654,7 @@ void zuiInitIterator(zsetopsrc *op) {
it->zl.eptr = ziplistIndex(it->zl.zl,0); it->zl.eptr = ziplistIndex(it->zl.zl,0);
if (it->zl.eptr != NULL) { if (it->zl.eptr != NULL) {
it->zl.sptr = ziplistNext(it->zl.zl,it->zl.eptr); it->zl.sptr = ziplistNext(it->zl.zl,it->zl.eptr);
redisAssert(it->zl.sptr != NULL); serverAssert(it->zl.sptr != NULL);
} }
} else if (op->encoding == OBJ_ENCODING_SKIPLIST) { } else if (op->encoding == OBJ_ENCODING_SKIPLIST) {
it->sl.zs = op->subject->ptr; it->sl.zs = op->subject->ptr;
@ -1762,7 +1762,7 @@ int zuiNext(zsetopsrc *op, zsetopval *val) {
/* No need to check both, but better be explicit. */ /* No need to check both, but better be explicit. */
if (it->zl.eptr == NULL || it->zl.sptr == NULL) if (it->zl.eptr == NULL || it->zl.sptr == NULL)
return 0; return 0;
redisAssert(ziplistGet(it->zl.eptr,&val->estr,&val->elen,&val->ell)); serverAssert(ziplistGet(it->zl.eptr,&val->estr,&val->elen,&val->ell));
val->score = zzlGetScore(it->zl.sptr); val->score = zzlGetScore(it->zl.sptr);
/* Move to next element. */ /* Move to next element. */
@ -2223,12 +2223,12 @@ void zrangeGenericCommand(client *c, int reverse) {
else else
eptr = ziplistIndex(zl,2*start); eptr = ziplistIndex(zl,2*start);
redisAssertWithInfo(c,zobj,eptr != NULL); serverAssertWithInfo(c,zobj,eptr != NULL);
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
while (rangelen--) { while (rangelen--) {
redisAssertWithInfo(c,zobj,eptr != NULL && sptr != NULL); serverAssertWithInfo(c,zobj,eptr != NULL && sptr != NULL);
redisAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong)); serverAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong));
if (vstr == NULL) if (vstr == NULL)
addReplyBulkLongLong(c,vlong); addReplyBulkLongLong(c,vlong);
else else
@ -2261,7 +2261,7 @@ void zrangeGenericCommand(client *c, int reverse) {
} }
while(rangelen--) { while(rangelen--) {
redisAssertWithInfo(c,zobj,ln != NULL); serverAssertWithInfo(c,zobj,ln != NULL);
ele = ln->obj; ele = ln->obj;
addReplyBulk(c,ele); addReplyBulk(c,ele);
if (withscores) if (withscores)
@ -2353,7 +2353,7 @@ void genericZrangebyscoreCommand(client *c, int reverse) {
} }
/* Get score pointer for the first element. */ /* Get score pointer for the first element. */
redisAssertWithInfo(c,zobj,eptr != NULL); serverAssertWithInfo(c,zobj,eptr != NULL);
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
/* We don't know in advance how many matching elements there are in the /* We don't know in advance how many matching elements there are in the
@ -2382,7 +2382,7 @@ void genericZrangebyscoreCommand(client *c, int reverse) {
} }
/* We know the element exists, so ziplistGet should always succeed */ /* We know the element exists, so ziplistGet should always succeed */
redisAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong)); serverAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong));
rangelen++; rangelen++;
if (vstr == NULL) { if (vstr == NULL) {
@ -2509,7 +2509,7 @@ void zcountCommand(client *c) {
/* First element is in range */ /* First element is in range */
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
score = zzlGetScore(sptr); score = zzlGetScore(sptr);
redisAssertWithInfo(c,zobj,zslValueLteMax(score,&range)); serverAssertWithInfo(c,zobj,zslValueLteMax(score,&range));
/* Iterate over elements in range */ /* Iterate over elements in range */
while (eptr) { while (eptr) {
@ -2589,7 +2589,7 @@ void zlexcountCommand(client *c) {
/* First element is in range */ /* First element is in range */
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
redisAssertWithInfo(c,zobj,zzlLexValueLteMax(eptr,&range)); serverAssertWithInfo(c,zobj,zzlLexValueLteMax(eptr,&range));
/* Iterate over elements in range */ /* Iterate over elements in range */
while (eptr) { while (eptr) {
@ -2705,7 +2705,7 @@ void genericZrangebylexCommand(client *c, int reverse) {
} }
/* Get score pointer for the first element. */ /* Get score pointer for the first element. */
redisAssertWithInfo(c,zobj,eptr != NULL); serverAssertWithInfo(c,zobj,eptr != NULL);
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
/* We don't know in advance how many matching elements there are in the /* We don't know in advance how many matching elements there are in the
@ -2733,7 +2733,7 @@ void genericZrangebylexCommand(client *c, int reverse) {
/* We know the element exists, so ziplistGet should always /* We know the element exists, so ziplistGet should always
* succeed. */ * succeed. */
redisAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong)); serverAssertWithInfo(c,zobj,ziplistGet(eptr,&vstr,&vlen,&vlong));
rangelen++; rangelen++;
if (vstr == NULL) { if (vstr == NULL) {
@ -2853,16 +2853,16 @@ void zrankGenericCommand(client *c, int reverse) {
checkType(c,zobj,OBJ_ZSET)) return; checkType(c,zobj,OBJ_ZSET)) return;
llen = zsetLength(zobj); llen = zsetLength(zobj);
redisAssertWithInfo(c,ele,sdsEncodedObject(ele)); serverAssertWithInfo(c,ele,sdsEncodedObject(ele));
if (zobj->encoding == OBJ_ENCODING_ZIPLIST) { if (zobj->encoding == OBJ_ENCODING_ZIPLIST) {
unsigned char *zl = zobj->ptr; unsigned char *zl = zobj->ptr;
unsigned char *eptr, *sptr; unsigned char *eptr, *sptr;
eptr = ziplistIndex(zl,0); eptr = ziplistIndex(zl,0);
redisAssertWithInfo(c,zobj,eptr != NULL); serverAssertWithInfo(c,zobj,eptr != NULL);
sptr = ziplistNext(zl,eptr); sptr = ziplistNext(zl,eptr);
redisAssertWithInfo(c,zobj,sptr != NULL); serverAssertWithInfo(c,zobj,sptr != NULL);
rank = 1; rank = 1;
while(eptr != NULL) { while(eptr != NULL) {
@ -2891,7 +2891,7 @@ void zrankGenericCommand(client *c, int reverse) {
if (de != NULL) { if (de != NULL) {
score = *(double*)dictGetVal(de); score = *(double*)dictGetVal(de);
rank = zslGetRank(zsl,score,ele); rank = zslGetRank(zsl,score,ele);
redisAssertWithInfo(c,ele,rank); /* Existing elements always have a rank. */ serverAssertWithInfo(c,ele,rank); /* Existing elements always have a rank. */
if (reverse) if (reverse)
addReplyLongLong(c,llen-rank); addReplyLongLong(c,llen-rank);
else else