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

Server replies now in the new format, test-redis.tcl and redis-cli modified accordingly

Browse Source
This commit is contained in:
antirez 2009-03-24 13:37:32 +01:00
parent 796d05f855
commit c937aa89b5
3 changed files with 252 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

165
redis-cli.c
View File

@ -40,11 +40,6 @@
#define REDIS_CMD_INLINE 1 #define REDIS_CMD_INLINE 1
#define REDIS_CMD_BULK 2 #define REDIS_CMD_BULK 2
#define REDIS_CMD_INTREPLY 4
#define REDIS_CMD_RETCODEREPLY 8
#define REDIS_CMD_BULKREPLY 16
#define REDIS_CMD_MULTIBULKREPLY 32
#define REDIS_CMD_SINGLELINEREPLY 64
#define REDIS_NOTUSED(V) ((void) V) #define REDIS_NOTUSED(V) ((void) V)
@ -60,54 +55,56 @@ struct redisCommand {
}; };
static struct redisCommand cmdTable[] = { static struct redisCommand cmdTable[] = {
{"get",2,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY}, {"get",2,REDIS_CMD_INLINE},
{"set",3,REDIS_CMD_BULK|REDIS_CMD_RETCODEREPLY}, {"set",3,REDIS_CMD_BULK},
{"setnx",3,REDIS_CMD_BULK|REDIS_CMD_INTREPLY}, {"setnx",3,REDIS_CMD_BULK},
{"del",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"del",2,REDIS_CMD_INLINE},
{"exists",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"exists",2,REDIS_CMD_INLINE},
{"incr",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"incr",2,REDIS_CMD_INLINE},
{"decr",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"decr",2,REDIS_CMD_INLINE},
{"rpush",3,REDIS_CMD_BULK|REDIS_CMD_RETCODEREPLY}, {"rpush",3,REDIS_CMD_BULK},
{"lpush",3,REDIS_CMD_BULK|REDIS_CMD_RETCODEREPLY}, {"lpush",3,REDIS_CMD_BULK},
{"rpop",2,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY}, {"rpop",2,REDIS_CMD_INLINE},
{"lpop",2,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY}, {"lpop",2,REDIS_CMD_INLINE},
{"llen",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"llen",2,REDIS_CMD_INLINE},
{"lindex",3,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY}, {"lindex",3,REDIS_CMD_INLINE},
{"lset",4,REDIS_CMD_BULK|REDIS_CMD_RETCODEREPLY}, {"lset",4,REDIS_CMD_BULK},
{"lrange",4,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY}, {"lrange",4,REDIS_CMD_INLINE},
{"ltrim",4,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"ltrim",4,REDIS_CMD_INLINE},
{"lrem",4,REDIS_CMD_BULK|REDIS_CMD_INTREPLY}, {"lrem",4,REDIS_CMD_BULK},
{"sadd",3,REDIS_CMD_BULK|REDIS_CMD_INTREPLY}, {"sadd",3,REDIS_CMD_BULK},
{"srem",3,REDIS_CMD_BULK|REDIS_CMD_INTREPLY}, {"srem",3,REDIS_CMD_BULK},
{"sismember",3,REDIS_CMD_BULK|REDIS_CMD_INTREPLY}, {"sismember",3,REDIS_CMD_BULK},
{"scard",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"scard",2,REDIS_CMD_INLINE},
{"sinter",-2,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY}, {"sinter",-2,REDIS_CMD_INLINE},
{"sinterstore",-3,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"sinterstore",-3,REDIS_CMD_INLINE},
{"smembers",2,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY}, {"smembers",2,REDIS_CMD_INLINE},
{"incrby",3,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"incrby",3,REDIS_CMD_INLINE},
{"decrby",3,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"decrby",3,REDIS_CMD_INLINE},
{"randomkey",1,REDIS_CMD_INLINE|REDIS_CMD_SINGLELINEREPLY}, {"randomkey",1,REDIS_CMD_INLINE},
{"select",2,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"select",2,REDIS_CMD_INLINE},
{"move",3,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"move",3,REDIS_CMD_INLINE},
{"rename",3,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"rename",3,REDIS_CMD_INLINE},
{"renamenx",3,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"renamenx",3,REDIS_CMD_INLINE},
{"keys",2,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY}, {"keys",2,REDIS_CMD_INLINE},
{"dbsize",1,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"dbsize",1,REDIS_CMD_INLINE},
{"ping",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"ping",1,REDIS_CMD_INLINE},
{"echo",2,REDIS_CMD_BULK|REDIS_CMD_BULKREPLY}, {"echo",2,REDIS_CMD_BULK},
{"save",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"save",1,REDIS_CMD_INLINE},
{"bgsave",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"bgsave",1,REDIS_CMD_INLINE},
{"shutdown",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"shutdown",1,REDIS_CMD_INLINE},
{"lastsave",1,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY}, {"lastsave",1,REDIS_CMD_INLINE},
{"type",2,REDIS_CMD_INLINE|REDIS_CMD_SINGLELINEREPLY}, {"type",2,REDIS_CMD_INLINE},
{"flushdb",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"flushdb",1,REDIS_CMD_INLINE},
{"flushall",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY}, {"flushall",1,REDIS_CMD_INLINE},
{"sort",-2,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY}, {"sort",-2,REDIS_CMD_INLINE},
{"info",1,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY}, {"info",1,REDIS_CMD_INLINE},
{"mget",-2,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY}, {"mget",-2,REDIS_CMD_INLINE},
{NULL,0,0} {NULL,0,0}
}; };
static int cliReadReply(int fd);
static struct redisCommand *lookupCommand(char *name) { static struct redisCommand *lookupCommand(char *name) {
int j = 0; int j = 0;
while(cmdTable[j].name != NULL) { while(cmdTable[j].name != NULL) {
@ -150,38 +147,26 @@ static sds cliReadLine(int fd) {
return sdstrim(line,"\r\n"); return sdstrim(line,"\r\n");
} }
static int cliReadInlineReply(int fd, int type) { static int cliReadSingleLineReply(int fd) {
sds reply = cliReadLine(fd); sds reply = cliReadLine(fd);
if (reply == NULL) return 1; if (reply == NULL) return 1;
printf("%s\n", reply); printf("%s\n", reply);
if (type == REDIS_CMD_SINGLELINEREPLY) return 0;
if (type == REDIS_CMD_INTREPLY) return atoi(reply) < 0;
if (type == REDIS_CMD_RETCODEREPLY) return reply[0] == '-';
return 0; return 0;
} }
static int cliReadBulkReply(int fd, int multibulk) { static int cliReadBulkReply(int fd) {
sds replylen = cliReadLine(fd); sds replylen = cliReadLine(fd);
char *reply, crlf[2]; char *reply, crlf[2];
int bulklen, error = 0; int bulklen;
if (replylen == NULL) return 1; if (replylen == NULL) return 1;
if (strcmp(replylen,"nil") == 0) {
sdsfree(replylen);
printf("(nil)\n");
return 0;
}
bulklen = atoi(replylen); bulklen = atoi(replylen);
if (multibulk && bulklen == -1) { if (bulklen == -1) {
sdsfree(replylen); sdsfree(replylen);
printf("(nil)"); printf("(nil)");
return 0; return 0;
} }
if (bulklen < 0) {
bulklen = -bulklen;
error = 1;
}
reply = zmalloc(bulklen); reply = zmalloc(bulklen);
anetRead(fd,reply,bulklen); anetRead(fd,reply,bulklen);
anetRead(fd,crlf,2); anetRead(fd,crlf,2);
@ -189,10 +174,10 @@ static int cliReadBulkReply(int fd, int multibulk) {
zfree(reply); zfree(reply);
return 1; return 1;
} }
if (!multibulk && isatty(fileno(stdout)) && reply[bulklen-1] != '\n') if (isatty(fileno(stdout)) && reply[bulklen-1] != '\n')
printf("\n"); printf("\n");
zfree(reply); zfree(reply);
return error; return 0;
} }
static int cliReadMultiBulkReply(int fd) { static int cliReadMultiBulkReply(int fd) {
@ -200,21 +185,45 @@ static int cliReadMultiBulkReply(int fd) {
int elements, c = 1; int elements, c = 1;
if (replylen == NULL) return 1; if (replylen == NULL) return 1;
if (strcmp(replylen,"nil") == 0) { elements = atoi(replylen);
if (elements == -1) {
sdsfree(replylen); sdsfree(replylen);
printf("(nil)\n"); printf("(nil)\n");
return 0; return 0;
} }
elements = atoi(replylen); if (elements == 0) {
printf("(empty list or set)\n");
}
while(elements--) { while(elements--) {
printf("%d. ", c); printf("%d. ", c);
if (cliReadBulkReply(fd,1)) return 1; if (cliReadReply(fd)) return 1;
printf("\n");
c++; c++;
} }
return 0; return 0;
} }
static int cliReadReply(int fd) {
char type;
if (anetRead(fd,&type,1) <= 0) exit(1);
switch(type) {
case '-':
printf("(error) ");
cliReadSingleLineReply(fd);
return 1;
case '+':
case ':':
return cliReadSingleLineReply(fd);
case '$':
return cliReadBulkReply(fd);
case '*':
return cliReadMultiBulkReply(fd);
default:
printf("protocol error, got '%c' as reply type byte\n", type);
return 1;
}
}
static int cliSendCommand(int argc, char **argv) { static int cliSendCommand(int argc, char **argv) {
struct redisCommand *rc = lookupCommand(argv[0]); struct redisCommand *rc = lookupCommand(argv[0]);
int fd, j, retval = 0; int fd, j, retval = 0;
@ -247,17 +256,7 @@ static int cliSendCommand(int argc, char **argv) {
cmd = sdscat(cmd,"\r\n"); cmd = sdscat(cmd,"\r\n");
} }
anetWrite(fd,cmd,sdslen(cmd)); anetWrite(fd,cmd,sdslen(cmd));
if (rc->flags & REDIS_CMD_INTREPLY) { retval = cliReadReply(fd);
retval = cliReadInlineReply(fd,REDIS_CMD_INTREPLY);
} else if (rc->flags & REDIS_CMD_RETCODEREPLY) {
retval = cliReadInlineReply(fd,REDIS_CMD_RETCODEREPLY);
} else if (rc->flags & REDIS_CMD_SINGLELINEREPLY) {
retval = cliReadInlineReply(fd,REDIS_CMD_SINGLELINEREPLY);
} else if (rc->flags & REDIS_CMD_BULKREPLY) {
retval = cliReadBulkReply(fd,0);
} else if (rc->flags & REDIS_CMD_MULTIBULKREPLY) {
retval = cliReadMultiBulkReply(fd);
}
if (retval) { if (retval) {
close(fd); close(fd);
return retval; return retval;

191
redis.c
View File

@ -214,10 +214,10 @@ typedef struct _redisSortOperation {
} redisSortOperation; } redisSortOperation;
struct sharedObjectsStruct { struct sharedObjectsStruct {
robj *crlf, *ok, *err, *zerobulk, *nil, *zero, *one, *pong, *space, robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *pong, *space,
*minus1, *minus2, *minus3, *minus4, *colon, *minus1, *nullbulk, *nullmultibulk,
*wrongtypeerr, *nokeyerr, *wrongtypeerrbulk, *nokeyerrbulk, *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
*syntaxerr, *syntaxerrbulk, *outofrangeerr, *plus,
*select0, *select1, *select2, *select3, *select4, *select0, *select1, *select2, *select3, *select4,
*select5, *select6, *select7, *select8, *select9; *select5, *select6, *select7, *select8, *select9;
} shared; } shared;
@ -660,29 +660,28 @@ static void createSharedObjects(void) {
shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n")); shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n")); shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n")); shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
shared.zerobulk = createObject(REDIS_STRING,sdsnew("0\r\n\r\n")); shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));
shared.nil = createObject(REDIS_STRING,sdsnew("nil\r\n")); shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));
shared.zero = createObject(REDIS_STRING,sdsnew("0\r\n")); shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
shared.one = createObject(REDIS_STRING,sdsnew("1\r\n")); shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));
shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));
/* no such key */ /* no such key */
shared.minus1 = createObject(REDIS_STRING,sdsnew("-1\r\n")); shared.minus1 = createObject(REDIS_STRING,sdsnew("-1\r\n"));
/* operation against key holding a value of the wrong type */
shared.minus2 = createObject(REDIS_STRING,sdsnew("-2\r\n"));
/* src and dest objects are the same */
shared.minus3 = createObject(REDIS_STRING,sdsnew("-3\r\n"));
/* out of range argument */
shared.minus4 = createObject(REDIS_STRING,sdsnew("-4\r\n"));
shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n")); shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));
shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew( shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
"-ERR Operation against a key holding the wrong kind of value\r\n")); "-ERR Operation against a key holding the wrong kind of value\r\n"));
shared.wrongtypeerrbulk = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%d\r\n%s",-sdslen(shared.wrongtypeerr->ptr)+2,shared.wrongtypeerr->ptr));
shared.nokeyerr = createObject(REDIS_STRING,sdsnew( shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
"-ERR no such key\r\n")); "-ERR no such key\r\n"));
shared.nokeyerrbulk = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%d\r\n%s",-sdslen(shared.nokeyerr->ptr)+2,shared.nokeyerr->ptr));
shared.syntaxerr = createObject(REDIS_STRING,sdsnew( shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
"-ERR syntax error\r\n")); "-ERR syntax error\r\n"));
shared.syntaxerrbulk = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%d\r\n%s",-sdslen(shared.syntaxerr->ptr)+2,shared.syntaxerr->ptr)); shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
"-ERR source and destination objects are the same\r\n"));
shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
"-ERR index out of range\r\n"));
shared.space = createObject(REDIS_STRING,sdsnew(" ")); shared.space = createObject(REDIS_STRING,sdsnew(" "));
shared.colon = createObject(REDIS_STRING,sdsnew(":"));
shared.plus = createObject(REDIS_STRING,sdsnew("+"));
shared.select0 = createStringObject("select 0\r\n",10); shared.select0 = createStringObject("select 0\r\n",10);
shared.select1 = createStringObject("select 1\r\n",10); shared.select1 = createStringObject("select 1\r\n",10);
shared.select2 = createStringObject("select 2\r\n",10); shared.select2 = createStringObject("select 2\r\n",10);
@ -1654,7 +1653,7 @@ static void pingCommand(redisClient *c) {
} }
static void echoCommand(redisClient *c) { static void echoCommand(redisClient *c) {
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n", addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
(int)sdslen(c->argv[1]->ptr))); (int)sdslen(c->argv[1]->ptr)));
addReply(c,c->argv[1]); addReply(c,c->argv[1]);
addReply(c,shared.crlf); addReply(c,shared.crlf);
@ -1671,7 +1670,7 @@ static void setGenericCommand(redisClient *c, int nx) {
dictReplace(c->dict,c->argv[1],c->argv[2]); dictReplace(c->dict,c->argv[1],c->argv[2]);
incrRefCount(c->argv[2]); incrRefCount(c->argv[2]);
} else { } else {
addReply(c,shared.zero); addReply(c,shared.czero);
return; return;
} }
} else { } else {
@ -1679,7 +1678,7 @@ static void setGenericCommand(redisClient *c, int nx) {
incrRefCount(c->argv[2]); incrRefCount(c->argv[2]);
} }
server.dirty++; server.dirty++;
addReply(c, nx ? shared.one : shared.ok); addReply(c, nx ? shared.cone : shared.ok);
} }
static void setCommand(redisClient *c) { static void setCommand(redisClient *c) {
@ -1695,14 +1694,14 @@ static void getCommand(redisClient *c) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.nil); addReply(c,shared.nullbulk);
} else { } else {
robj *o = dictGetEntryVal(de); robj *o = dictGetEntryVal(de);
if (o->type != REDIS_STRING) { if (o->type != REDIS_STRING) {
addReply(c,shared.wrongtypeerrbulk); addReply(c,shared.wrongtypeerr);
} else { } else {
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(o->ptr))); addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(o->ptr)));
addReply(c,o); addReply(c,o);
addReply(c,shared.crlf); addReply(c,shared.crlf);
} }
@ -1713,18 +1712,18 @@ static void mgetCommand(redisClient *c) {
dictEntry *de; dictEntry *de;
int j; int j;
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",c->argc-1)); addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->argc-1));
for (j = 1; j < c->argc; j++) { for (j = 1; j < c->argc; j++) {
de = dictFind(c->dict,c->argv[j]); de = dictFind(c->dict,c->argv[j]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.minus1); addReply(c,shared.nullbulk);
} else { } else {
robj *o = dictGetEntryVal(de); robj *o = dictGetEntryVal(de);
if (o->type != REDIS_STRING) { if (o->type != REDIS_STRING) {
addReply(c,shared.minus1); addReply(c,shared.nullbulk);
} else { } else {
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(o->ptr))); addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(o->ptr)));
addReply(c,o); addReply(c,o);
addReply(c,shared.crlf); addReply(c,shared.crlf);
} }
@ -1762,6 +1761,7 @@ static void incrDecrCommand(redisClient *c, int incr) {
incrRefCount(c->argv[1]); incrRefCount(c->argv[1]);
} }
server.dirty++; server.dirty++;
addReply(c,shared.colon);
addReply(c,o); addReply(c,o);
addReply(c,shared.crlf); addReply(c,shared.crlf);
} }
@ -1789,9 +1789,9 @@ static void decrbyCommand(redisClient *c) {
static void delCommand(redisClient *c) { static void delCommand(redisClient *c) {
if (dictDelete(c->dict,c->argv[1]) == DICT_OK) { if (dictDelete(c->dict,c->argv[1]) == DICT_OK) {
server.dirty++; server.dirty++;
addReply(c,shared.one); addReply(c,shared.cone);
} else { } else {
addReply(c,shared.zero); addReply(c,shared.czero);
} }
} }
@ -1800,9 +1800,9 @@ static void existsCommand(redisClient *c) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) if (de == NULL)
addReply(c,shared.zero); addReply(c,shared.czero);
else else
addReply(c,shared.one); addReply(c,shared.cone);
} }
static void selectCommand(redisClient *c) { static void selectCommand(redisClient *c) {
@ -1822,6 +1822,7 @@ static void randomkeyCommand(redisClient *c) {
if (de == NULL) { if (de == NULL) {
addReply(c,shared.crlf); addReply(c,shared.crlf);
} else { } else {
addReply(c,shared.plus);
addReply(c,dictGetEntryKey(de)); addReply(c,dictGetEntryKey(de));
addReply(c,shared.crlf); addReply(c,shared.crlf);
} }
@ -1852,18 +1853,18 @@ static void keysCommand(redisClient *c) {
} }
} }
dictReleaseIterator(di); dictReleaseIterator(di);
lenobj->ptr = sdscatprintf(sdsempty(),"%lu\r\n",keyslen+(numkeys ? (numkeys-1) : 0)); lenobj->ptr = sdscatprintf(sdsempty(),"$%lu\r\n",keyslen+(numkeys ? (numkeys-1) : 0));
addReply(c,shared.crlf); addReply(c,shared.crlf);
} }
static void dbsizeCommand(redisClient *c) { static void dbsizeCommand(redisClient *c) {
addReplySds(c, addReplySds(c,
sdscatprintf(sdsempty(),"%lu\r\n",dictGetHashTableUsed(c->dict))); sdscatprintf(sdsempty(),":%lu\r\n",dictGetHashTableUsed(c->dict)));
} }
static void lastsaveCommand(redisClient *c) { static void lastsaveCommand(redisClient *c) {
addReplySds(c, addReplySds(c,
sdscatprintf(sdsempty(),"%lu\r\n",server.lastsave)); sdscatprintf(sdsempty(),":%lu\r\n",server.lastsave));
} }
static void typeCommand(redisClient *c) { static void typeCommand(redisClient *c) {
@ -1872,14 +1873,14 @@ static void typeCommand(redisClient *c) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
type = "none"; type = "+none";
} else { } else {
robj *o = dictGetEntryVal(de); robj *o = dictGetEntryVal(de);
switch(o->type) { switch(o->type) {
case REDIS_STRING: type = "string"; break; case REDIS_STRING: type = "+string"; break;
case REDIS_LIST: type = "list"; break; case REDIS_LIST: type = "+list"; break;
case REDIS_SET: type = "set"; break; case REDIS_SET: type = "+set"; break;
default: type = "unknown"; break; default: type = "unknown"; break;
} }
} }
@ -1927,18 +1928,12 @@ static void renameGenericCommand(redisClient *c, int nx) {
/* To use the same key as src and dst is probably an error */ /* To use the same key as src and dst is probably an error */
if (sdscmp(c->argv[1]->ptr,c->argv[2]->ptr) == 0) { if (sdscmp(c->argv[1]->ptr,c->argv[2]->ptr) == 0) {
if (nx) addReply(c,shared.sameobjecterr);
addReply(c,shared.minus3);
else
addReplySds(c,sdsnew("-ERR src and dest key are the same\r\n"));
return; return;
} }
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
if (nx)
addReply(c,shared.minus1);
else
addReply(c,shared.nokeyerr); addReply(c,shared.nokeyerr);
return; return;
} }
@ -1947,7 +1942,7 @@ static void renameGenericCommand(redisClient *c, int nx) {
if (dictAdd(c->dict,c->argv[2],o) == DICT_ERR) { if (dictAdd(c->dict,c->argv[2],o) == DICT_ERR) {
if (nx) { if (nx) {
decrRefCount(o); decrRefCount(o);
addReply(c,shared.zero); addReply(c,shared.czero);
return; return;
} }
dictReplace(c->dict,c->argv[2],o); dictReplace(c->dict,c->argv[2],o);
@ -1956,7 +1951,7 @@ static void renameGenericCommand(redisClient *c, int nx) {
} }
dictDelete(c->dict,c->argv[1]); dictDelete(c->dict,c->argv[1]);
server.dirty++; server.dirty++;
addReply(c,nx ? shared.one : shared.ok); addReply(c,nx ? shared.cone : shared.ok);
} }
static void renameCommand(redisClient *c) { static void renameCommand(redisClient *c) {
@ -1977,7 +1972,7 @@ static void moveCommand(redisClient *c) {
src = c->dict; src = c->dict;
srcid = c->dictid; srcid = c->dictid;
if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) { if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) {
addReply(c,shared.minus4); addReply(c,shared.outofrangeerr);
return; return;
} }
dst = c->dict; dst = c->dict;
@ -1987,14 +1982,14 @@ static void moveCommand(redisClient *c) {
/* If the user is moving using as target the same /* If the user is moving using as target the same
* DB as the source DB it is probably an error. */ * DB as the source DB it is probably an error. */
if (src == dst) { if (src == dst) {
addReply(c,shared.minus3); addReply(c,shared.sameobjecterr);
return; return;
} }
/* Check if the element exists and get a reference */ /* Check if the element exists and get a reference */
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (!de) { if (!de) {
addReply(c,shared.zero); addReply(c,shared.czero);
return; return;
} }
@ -2002,7 +1997,7 @@ static void moveCommand(redisClient *c) {
key = dictGetEntryKey(de); key = dictGetEntryKey(de);
o = dictGetEntryVal(de); o = dictGetEntryVal(de);
if (dictAdd(dst,key,o) == DICT_ERR) { if (dictAdd(dst,key,o) == DICT_ERR) {
addReply(c,shared.zero); addReply(c,shared.czero);
return; return;
} }
incrRefCount(key); incrRefCount(key);
@ -2011,7 +2006,7 @@ static void moveCommand(redisClient *c) {
/* OK! key moved, free the entry in the source DB */ /* OK! key moved, free the entry in the source DB */
dictDelete(src,c->argv[1]); dictDelete(src,c->argv[1]);
server.dirty++; server.dirty++;
addReply(c,shared.one); addReply(c,shared.cone);
} }
/* =================================== Lists ================================ */ /* =================================== Lists ================================ */
@ -2064,15 +2059,15 @@ static void llenCommand(redisClient *c) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.zero); addReply(c,shared.czero);
return; return;
} else { } else {
robj *o = dictGetEntryVal(de); robj *o = dictGetEntryVal(de);
if (o->type != REDIS_LIST) { if (o->type != REDIS_LIST) {
addReply(c,shared.minus2); addReply(c,shared.wrongtypeerr);
} else { } else {
l = o->ptr; l = o->ptr;
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",listLength(l))); addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",listLength(l)));
} }
} }
} }
@ -2083,22 +2078,22 @@ static void lindexCommand(redisClient *c) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.nil); addReply(c,shared.nullbulk);
} else { } else {
robj *o = dictGetEntryVal(de); robj *o = dictGetEntryVal(de);
if (o->type != REDIS_LIST) { if (o->type != REDIS_LIST) {
addReply(c,shared.wrongtypeerrbulk); addReply(c,shared.wrongtypeerr);
} else { } else {
list *list = o->ptr; list *list = o->ptr;
listNode *ln; listNode *ln;
ln = listIndex(list, index); ln = listIndex(list, index);
if (ln == NULL) { if (ln == NULL) {
addReply(c,shared.nil); addReply(c,shared.nullbulk);
} else { } else {
robj *ele = listNodeValue(ln); robj *ele = listNodeValue(ln);
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(ele->ptr))); addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));
addReply(c,ele); addReply(c,ele);
addReply(c,shared.crlf); addReply(c,shared.crlf);
} }
@ -2124,7 +2119,7 @@ static void lsetCommand(redisClient *c) {
ln = listIndex(list, index); ln = listIndex(list, index);
if (ln == NULL) { if (ln == NULL) {
addReplySds(c,sdsnew("-ERR index out of range\r\n")); addReply(c,shared.outofrangeerr);
} else { } else {
robj *ele = listNodeValue(ln); robj *ele = listNodeValue(ln);
@ -2143,12 +2138,12 @@ static void popGenericCommand(redisClient *c, int where) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.nil); addReply(c,shared.nullbulk);
} else { } else {
robj *o = dictGetEntryVal(de); robj *o = dictGetEntryVal(de);
if (o->type != REDIS_LIST) { if (o->type != REDIS_LIST) {
addReply(c,shared.wrongtypeerrbulk); addReply(c,shared.wrongtypeerr);
} else { } else {
list *list = o->ptr; list *list = o->ptr;
listNode *ln; listNode *ln;
@ -2159,10 +2154,10 @@ static void popGenericCommand(redisClient *c, int where) {
ln = listLast(list); ln = listLast(list);
if (ln == NULL) { if (ln == NULL) {
addReply(c,shared.nil); addReply(c,shared.nullbulk);
} else { } else {
robj *ele = listNodeValue(ln); robj *ele = listNodeValue(ln);
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(ele->ptr))); addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));
addReply(c,ele); addReply(c,ele);
addReply(c,shared.crlf); addReply(c,shared.crlf);
listDelNode(list,ln); listDelNode(list,ln);
@ -2187,12 +2182,12 @@ static void lrangeCommand(redisClient *c) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.nil); addReply(c,shared.nullmultibulk);
} else { } else {
robj *o = dictGetEntryVal(de); robj *o = dictGetEntryVal(de);
if (o->type != REDIS_LIST) { if (o->type != REDIS_LIST) {
addReply(c,shared.wrongtypeerrbulk); addReply(c,shared.wrongtypeerr);
} else { } else {
list *list = o->ptr; list *list = o->ptr;
listNode *ln; listNode *ln;
@ -2209,7 +2204,7 @@ static void lrangeCommand(redisClient *c) {
/* indexes sanity checks */ /* indexes sanity checks */
if (start > end || start >= llen) { if (start > end || start >= llen) {
/* Out of range start or start > end result in empty list */ /* Out of range start or start > end result in empty list */
addReply(c,shared.zero); addReply(c,shared.emptymultibulk);
return; return;
} }
if (end >= llen) end = llen-1; if (end >= llen) end = llen-1;
@ -2217,10 +2212,10 @@ static void lrangeCommand(redisClient *c) {
/* Return the result in form of a multi-bulk reply */ /* Return the result in form of a multi-bulk reply */
ln = listIndex(list, start); ln = listIndex(list, start);
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",rangelen)); addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",rangelen));
for (j = 0; j < rangelen; j++) { for (j = 0; j < rangelen; j++) {
ele = listNodeValue(ln); ele = listNodeValue(ln);
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(ele->ptr))); addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));
addReply(c,ele); addReply(c,ele);
addReply(c,shared.crlf); addReply(c,shared.crlf);
ln = ln->next; ln = ln->next;
@ -2290,7 +2285,7 @@ static void lremCommand(redisClient *c) {
robj *o = dictGetEntryVal(de); robj *o = dictGetEntryVal(de);
if (o->type != REDIS_LIST) { if (o->type != REDIS_LIST) {
addReply(c,shared.minus2); addReply(c,shared.wrongtypeerr);
} else { } else {
list *list = o->ptr; list *list = o->ptr;
listNode *ln, *next; listNode *ln, *next;
@ -2314,7 +2309,7 @@ static void lremCommand(redisClient *c) {
} }
ln = next; ln = next;
} }
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",removed)); addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",removed));
} }
} }
} }
@ -2333,16 +2328,16 @@ static void saddCommand(redisClient *c) {
} else { } else {
set = dictGetEntryVal(de); set = dictGetEntryVal(de);
if (set->type != REDIS_SET) { if (set->type != REDIS_SET) {
addReply(c,shared.minus2); addReply(c,shared.wrongtypeerr);
return; return;
} }
} }
if (dictAdd(set->ptr,c->argv[2],NULL) == DICT_OK) { if (dictAdd(set->ptr,c->argv[2],NULL) == DICT_OK) {
incrRefCount(c->argv[2]); incrRefCount(c->argv[2]);
server.dirty++; server.dirty++;
addReply(c,shared.one); addReply(c,shared.cone);
} else { } else {
addReply(c,shared.zero); addReply(c,shared.czero);
} }
} }
@ -2351,20 +2346,20 @@ static void sremCommand(redisClient *c) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.zero); addReply(c,shared.czero);
} else { } else {
robj *set; robj *set;
set = dictGetEntryVal(de); set = dictGetEntryVal(de);
if (set->type != REDIS_SET) { if (set->type != REDIS_SET) {
addReply(c,shared.minus2); addReply(c,shared.wrongtypeerr);
return; return;
} }
if (dictDelete(set->ptr,c->argv[2]) == DICT_OK) { if (dictDelete(set->ptr,c->argv[2]) == DICT_OK) {
server.dirty++; server.dirty++;
addReply(c,shared.one); addReply(c,shared.cone);
} else { } else {
addReply(c,shared.zero); addReply(c,shared.czero);
} }
} }
} }
@ -2374,19 +2369,19 @@ static void sismemberCommand(redisClient *c) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.zero); addReply(c,shared.czero);
} else { } else {
robj *set; robj *set;
set = dictGetEntryVal(de); set = dictGetEntryVal(de);
if (set->type != REDIS_SET) { if (set->type != REDIS_SET) {
addReply(c,shared.minus2); addReply(c,shared.wrongtypeerr);
return; return;
} }
if (dictFind(set->ptr,c->argv[2])) if (dictFind(set->ptr,c->argv[2]))
addReply(c,shared.one); addReply(c,shared.cone);
else else
addReply(c,shared.zero); addReply(c,shared.czero);
} }
} }
@ -2396,15 +2391,15 @@ static void scardCommand(redisClient *c) {
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.zero); addReply(c,shared.czero);
return; return;
} else { } else {
robj *o = dictGetEntryVal(de); robj *o = dictGetEntryVal(de);
if (o->type != REDIS_SET) { if (o->type != REDIS_SET) {
addReply(c,shared.minus2); addReply(c,shared.wrongtypeerr);
} else { } else {
s = o->ptr; s = o->ptr;
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n", addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",
dictGetHashTableUsed(s))); dictGetHashTableUsed(s)));
} }
} }
@ -2431,13 +2426,13 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
de = dictFind(c->dict,setskeys[j]); de = dictFind(c->dict,setskeys[j]);
if (!de) { if (!de) {
zfree(dv); zfree(dv);
addReply(c,dstkey ? shared.nokeyerr : shared.nil); addReply(c,shared.nokeyerr);
return; return;
} }
setobj = dictGetEntryVal(de); setobj = dictGetEntryVal(de);
if (setobj->type != REDIS_SET) { if (setobj->type != REDIS_SET) {
zfree(dv); zfree(dv);
addReply(c,dstkey ? shared.wrongtypeerr : shared.wrongtypeerrbulk); addReply(c,shared.wrongtypeerr);
return; return;
} }
dv[j] = setobj->ptr; dv[j] = setobj->ptr;
@ -2479,7 +2474,7 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
continue; /* at least one set does not contain the member */ continue; /* at least one set does not contain the member */
ele = dictGetEntryKey(de); ele = dictGetEntryKey(de);
if (!dstkey) { if (!dstkey) {
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",sdslen(ele->ptr))); addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(ele->ptr)));
addReply(c,ele); addReply(c,ele);
addReply(c,shared.crlf); addReply(c,shared.crlf);
cardinality++; cardinality++;
@ -2491,7 +2486,7 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
dictReleaseIterator(di); dictReleaseIterator(di);
if (!dstkey) if (!dstkey)
lenobj->ptr = sdscatprintf(sdsempty(),"%d\r\n",cardinality); lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",cardinality);
else else
addReply(c,shared.ok); addReply(c,shared.ok);
zfree(dv); zfree(dv);
@ -2621,12 +2616,12 @@ static void sortCommand(redisClient *c) {
/* Lookup the key to sort. It must be of the right types */ /* Lookup the key to sort. It must be of the right types */
de = dictFind(c->dict,c->argv[1]); de = dictFind(c->dict,c->argv[1]);
if (de == NULL) { if (de == NULL) {
addReply(c,shared.nokeyerrbulk); addReply(c,shared.nokeyerr);
return; return;
} }
sortval = dictGetEntryVal(de); sortval = dictGetEntryVal(de);
if (sortval->type != REDIS_SET && sortval->type != REDIS_LIST) { if (sortval->type != REDIS_SET && sortval->type != REDIS_LIST) {
addReply(c,shared.wrongtypeerrbulk); addReply(c,shared.wrongtypeerr);
return; return;
} }
@ -2680,7 +2675,7 @@ static void sortCommand(redisClient *c) {
} else { } else {
decrRefCount(sortval); decrRefCount(sortval);
listRelease(operations); listRelease(operations);
addReply(c,shared.syntaxerrbulk); addReply(c,shared.syntaxerr);
return; return;
} }
j++; j++;
@ -2761,11 +2756,11 @@ static void sortCommand(redisClient *c) {
/* Send command output to the output buffer, performing the specified /* Send command output to the output buffer, performing the specified
* GET/DEL/INCR/DECR operations if any. */ * GET/DEL/INCR/DECR operations if any. */
outputlen = getop ? getop*(end-start+1) : end-start+1; outputlen = getop ? getop*(end-start+1) : end-start+1;
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",outputlen)); addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen));
for (j = start; j <= end; j++) { for (j = start; j <= end; j++) {
listNode *ln = operations->head; listNode *ln = operations->head;
if (!getop) { if (!getop) {
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n", addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
sdslen(vector[j].obj->ptr))); sdslen(vector[j].obj->ptr)));
addReply(c,vector[j].obj); addReply(c,vector[j].obj);
addReply(c,shared.crlf); addReply(c,shared.crlf);
@ -2779,7 +2774,7 @@ static void sortCommand(redisClient *c) {
if (!val || val->type != REDIS_STRING) { if (!val || val->type != REDIS_STRING) {
addReply(c,shared.minus1); addReply(c,shared.minus1);
} else { } else {
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n", addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
sdslen(val->ptr))); sdslen(val->ptr)));
addReply(c,val); addReply(c,val);
addReply(c,shared.crlf); addReply(c,shared.crlf);
@ -2827,7 +2822,7 @@ static void infoCommand(redisClient *c) {
uptime, uptime,
uptime/(3600*24) uptime/(3600*24)
); );
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",sdslen(info))); addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(info)));
addReplySds(c,info); addReplySds(c,info);
addReply(c,shared.crlf); addReply(c,shared.crlf);
} }
@ -2930,7 +2925,7 @@ static void syncCommand(redisClient *c) {
if (fd == -1 || fstat(fd,&sb) == -1) goto closeconn; if (fd == -1 || fstat(fd,&sb) == -1) goto closeconn;
len = sb.st_size; len = sb.st_size;
snprintf(sizebuf,32,"%d\r\n",len); snprintf(sizebuf,32,"$%d\r\n",len);
if (syncWrite(c->fd,sizebuf,strlen(sizebuf),5) == -1) goto closeconn; if (syncWrite(c->fd,sizebuf,strlen(sizebuf),5) == -1) goto closeconn;
while(len) { while(len) {
char buf[1024]; char buf[1024];
@ -2982,7 +2977,7 @@ static int syncWithMaster(void) {
strerror(errno)); strerror(errno));
return REDIS_ERR; return REDIS_ERR;
} }
dumpsize = atoi(buf); dumpsize = atoi(buf+1);
redisLog(REDIS_NOTICE,"Receiving %d bytes data dump from MASTER",dumpsize); redisLog(REDIS_NOTICE,"Receiving %d bytes data dump from MASTER",dumpsize);
/* Read the bulk write data on a temp file */ /* Read the bulk write data on a temp file */
snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random()); snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random());

149
test-redis.tcl
View File

@ -124,16 +124,16 @@ proc main {server port} {
puts -nonewline $fd "SET k1 4\r\nxyzk\r\nGET k1\r\nPING\r\n" puts -nonewline $fd "SET k1 4\r\nxyzk\r\nGET k1\r\nPING\r\n"
flush $fd flush $fd
set res {} set res {}
append res [string match +OK* [redis_read_retcode $fd]] append res [string match OK* [redis_read_reply $fd]]
append res [redis_bulk_read $fd] append res [redis_read_reply $fd]
append res [string match +PONG* [redis_read_retcode $fd]] append res [string match PONG* [redis_read_reply $fd]]
format $res format $res
} {1xyzk1} } {1xyzk1}
test {Non existing command} { test {Non existing command} {
puts -nonewline $fd "foo\r\n" puts -nonewline $fd "foo\r\n"
flush $fd flush $fd
string match -ERR* [redis_read_retcode $fd] string match ERR* [redis_read_reply $fd]
} {1} } {1}
test {Basic LPUSH, RPUSH, LLENGTH, LINDEX} { test {Basic LPUSH, RPUSH, LLENGTH, LINDEX} {
@ -181,19 +181,19 @@ proc main {server port} {
redis_del $fd mylist redis_del $fd mylist
redis_set $fd mylist foobar redis_set $fd mylist foobar
redis_llen $fd mylist redis_llen $fd mylist
} {-2} } {ERR*}
test {LINDEX against non-list value error} { test {LINDEX against non-list value error} {
redis_lindex $fd mylist 0 redis_lindex $fd mylist 0
} {*ERROR*} } {ERR*}
test {LPUSH against non-list value error} { test {LPUSH against non-list value error} {
redis_lpush $fd mylist 0 redis_lpush $fd mylist 0
} {-ERR*} } {ERR*}
test {RPUSH against non-list value error} { test {RPUSH against non-list value error} {
redis_rpush $fd mylist 0 redis_rpush $fd mylist 0
} {-ERR*} } {ERR*}
test {RENAME basic usage} { test {RENAME basic usage} {
redis_set $fd mykey hello redis_set $fd mykey hello
@ -236,11 +236,11 @@ proc main {server port} {
test {RENAME against non existing source key} { test {RENAME against non existing source key} {
redis_rename $fd nokey foobar redis_rename $fd nokey foobar
} {-ERR*} } {ERR*}
test {RENAME where source and dest key is the same} { test {RENAME where source and dest key is the same} {
redis_rename $fd mykey mykey redis_rename $fd mykey mykey
} {-ERR*} } {ERR*}
test {DEL all keys again (DB 0)} { test {DEL all keys again (DB 0)} {
foreach key [redis_keys $fd *] { foreach key [redis_keys $fd *] {
@ -309,7 +309,7 @@ proc main {server port} {
test {LPOP against non list value} { test {LPOP against non list value} {
redis_set $fd notalist foo redis_set $fd notalist foo
redis_lpop $fd notalist redis_lpop $fd notalist
} {*ERROR*against*} } {ERR*kind*}
test {Mass LPUSH/LPOP} { test {Mass LPUSH/LPOP} {
set sum 0 set sum 0
@ -363,16 +363,16 @@ proc main {server port} {
test {LSET out of range index} { test {LSET out of range index} {
redis_lset $fd mylist 10 foo redis_lset $fd mylist 10 foo
} {-ERR*range*} } {ERR*range*}
test {LSET against non existing key} { test {LSET against non existing key} {
redis_lset $fd nosuchkey 10 foo redis_lset $fd nosuchkey 10 foo
} {-ERR*key*} } {ERR*key*}
test {LSET against non list value} { test {LSET against non list value} {
redis_set $fd nolist foobar redis_set $fd nolist foobar
redis_lset $fd nolist 0 foo redis_lset $fd nolist 0 foo
} {-ERR*value*} } {ERR*value*}
test {SADD, SCARD, SISMEMBER, SMEMBERS basics} { test {SADD, SCARD, SISMEMBER, SMEMBERS basics} {
redis_sadd $fd myset foo redis_sadd $fd myset foo
@ -391,7 +391,7 @@ proc main {server port} {
test {SADD against non set} { test {SADD against non set} {
redis_sadd $fd mylist foo redis_sadd $fd mylist foo
} {-2} } {ERR*kind*}
test {SREM basics} { test {SREM basics} {
redis_sadd $fd myset ciao redis_sadd $fd myset ciao
@ -431,7 +431,7 @@ proc main {server port} {
redis_set $fd myemptykey {} redis_set $fd myemptykey {}
redis_set $fd mynormalkey {blablablba} redis_set $fd mynormalkey {blablablba}
redis_save $fd redis_save $fd
} {+OK} } {OK}
test {Create a random list} { test {Create a random list} {
set tosort {} set tosort {}
@ -606,221 +606,224 @@ proc redis_readnl {fd len} {
return $buf return $buf
} }
proc redis_bulk_read {fd {multi 0}} { proc redis_bulk_read {fd} {
set count [redis_read_integer $fd] set count [redis_read_line $fd]
if {$count eq {nil}} return {} if {$count == -1} return {}
if {$multi && $count == -1} return {} set buf [redis_readnl $fd $count]
set len [expr {abs($count)}]
set buf [redis_readnl $fd $len]
if {$count < 0} {return "***ERROR*** $buf"}
return $buf return $buf
} }
proc redis_multi_bulk_read fd { proc redis_multi_bulk_read fd {
set count [redis_read_integer $fd] set count [redis_read_line $fd]
if {$count eq {nil}} return {} if {$count == -1} return {}
if {$count < 0} {
set len [expr {abs($count)}]
set buf [redis_readnl $fd $len]
return "***ERROR*** $buf"
}
set l {} set l {}
for {set i 0} {$i < $count} {incr i} { for {set i 0} {$i < $count} {incr i} {
lappend l [redis_bulk_read $fd 1] lappend l [redis_read_reply $fd]
} }
return $l return $l
} }
proc redis_read_retcode fd { proc redis_read_line fd {
set retcode [string trim [gets $fd]] string trim [gets $fd]
# puts "S: $retcode"
return $retcode
} }
proc redis_read_integer fd { proc redis_read_reply fd {
string trim [gets $fd] set type [read $fd 1]
if {$type eq {:}} {
redis_read_line $fd
} elseif {$type eq {-}} {
redis_read_line $fd
} elseif {$type eq {+}} {
redis_read_line $fd
} elseif {$type eq {$}} {
redis_bulk_read $fd
} elseif {$type eq {*}} {
redis_multi_bulk_read $fd
} else {
error "Bad protocol: $type as initial reply byte"
}
} }
### Actual API ### ### Actual API ###
proc redis_set {fd key val} { proc redis_set {fd key val} {
redis_writenl $fd "set $key [string length $val]\r\n$val" redis_writenl $fd "set $key [string length $val]\r\n$val"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_setnx {fd key val} { proc redis_setnx {fd key val} {
redis_writenl $fd "setnx $key [string length $val]\r\n$val" redis_writenl $fd "setnx $key [string length $val]\r\n$val"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_get {fd key} { proc redis_get {fd key} {
redis_writenl $fd "get $key" redis_writenl $fd "get $key"
redis_bulk_read $fd redis_read_reply $fd
} }
proc redis_select {fd id} { proc redis_select {fd id} {
redis_writenl $fd "select $id" redis_writenl $fd "select $id"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_move {fd key id} { proc redis_move {fd key id} {
redis_writenl $fd "move $key $id" redis_writenl $fd "move $key $id"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_del {fd key} { proc redis_del {fd key} {
redis_writenl $fd "del $key" redis_writenl $fd "del $key"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_keys {fd pattern} { proc redis_keys {fd pattern} {
redis_writenl $fd "keys $pattern" redis_writenl $fd "keys $pattern"
split [redis_bulk_read $fd] split [redis_read_reply $fd]
} }
proc redis_dbsize {fd} { proc redis_dbsize {fd} {
redis_writenl $fd "dbsize" redis_writenl $fd "dbsize"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_incr {fd key} { proc redis_incr {fd key} {
redis_writenl $fd "incr $key" redis_writenl $fd "incr $key"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_decr {fd key} { proc redis_decr {fd key} {
redis_writenl $fd "decr $key" redis_writenl $fd "decr $key"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_exists {fd key} { proc redis_exists {fd key} {
redis_writenl $fd "exists $key" redis_writenl $fd "exists $key"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_lpush {fd key val} { proc redis_lpush {fd key val} {
redis_writenl $fd "lpush $key [string length $val]\r\n$val" redis_writenl $fd "lpush $key [string length $val]\r\n$val"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_rpush {fd key val} { proc redis_rpush {fd key val} {
redis_writenl $fd "rpush $key [string length $val]\r\n$val" redis_writenl $fd "rpush $key [string length $val]\r\n$val"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_llen {fd key} { proc redis_llen {fd key} {
redis_writenl $fd "llen $key" redis_writenl $fd "llen $key"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_scard {fd key} { proc redis_scard {fd key} {
redis_writenl $fd "scard $key" redis_writenl $fd "scard $key"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_lindex {fd key index} { proc redis_lindex {fd key index} {
redis_writenl $fd "lindex $key $index" redis_writenl $fd "lindex $key $index"
redis_bulk_read $fd redis_read_reply $fd
} }
proc redis_lrange {fd key first last} { proc redis_lrange {fd key first last} {
redis_writenl $fd "lrange $key $first $last" redis_writenl $fd "lrange $key $first $last"
redis_multi_bulk_read $fd redis_read_reply $fd
} }
proc redis_mget {fd args} { proc redis_mget {fd args} {
redis_writenl $fd "mget [join $args]" redis_writenl $fd "mget [join $args]"
redis_multi_bulk_read $fd redis_read_reply $fd
} }
proc redis_sort {fd key {params {}}} { proc redis_sort {fd key {params {}}} {
redis_writenl $fd "sort $key $params" redis_writenl $fd "sort $key $params"
redis_multi_bulk_read $fd redis_read_reply $fd
} }
proc redis_ltrim {fd key first last} { proc redis_ltrim {fd key first last} {
redis_writenl $fd "ltrim $key $first $last" redis_writenl $fd "ltrim $key $first $last"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_rename {fd key1 key2} { proc redis_rename {fd key1 key2} {
redis_writenl $fd "rename $key1 $key2" redis_writenl $fd "rename $key1 $key2"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_renamenx {fd key1 key2} { proc redis_renamenx {fd key1 key2} {
redis_writenl $fd "renamenx $key1 $key2" redis_writenl $fd "renamenx $key1 $key2"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_lpop {fd key} { proc redis_lpop {fd key} {
redis_writenl $fd "lpop $key" redis_writenl $fd "lpop $key"
redis_bulk_read $fd redis_read_reply $fd
} }
proc redis_rpop {fd key} { proc redis_rpop {fd key} {
redis_writenl $fd "rpop $key" redis_writenl $fd "rpop $key"
redis_bulk_read $fd redis_read_reply $fd
} }
proc redis_lset {fd key index val} { proc redis_lset {fd key index val} {
redis_writenl $fd "lset $key $index [string length $val]\r\n$val" redis_writenl $fd "lset $key $index [string length $val]\r\n$val"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_sadd {fd key val} { proc redis_sadd {fd key val} {
redis_writenl $fd "sadd $key [string length $val]\r\n$val" redis_writenl $fd "sadd $key [string length $val]\r\n$val"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_srem {fd key val} { proc redis_srem {fd key val} {
redis_writenl $fd "srem $key [string length $val]\r\n$val" redis_writenl $fd "srem $key [string length $val]\r\n$val"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_sismember {fd key val} { proc redis_sismember {fd key val} {
redis_writenl $fd "sismember $key [string length $val]\r\n$val" redis_writenl $fd "sismember $key [string length $val]\r\n$val"
redis_read_integer $fd redis_read_reply $fd
} }
proc redis_sinter {fd args} { proc redis_sinter {fd args} {
redis_writenl $fd "sinter [join $args]" redis_writenl $fd "sinter [join $args]"
redis_multi_bulk_read $fd redis_read_reply $fd
} }
proc redis_sinterstore {fd args} { proc redis_sinterstore {fd args} {
redis_writenl $fd "sinterstore [join $args]" redis_writenl $fd "sinterstore [join $args]"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_smembers {fd key} { proc redis_smembers {fd key} {
redis_writenl $fd "smembers $key" redis_writenl $fd "smembers $key"
redis_multi_bulk_read $fd redis_read_reply $fd
} }
proc redis_echo {fd str} { proc redis_echo {fd str} {
redis_writenl $fd "echo [string length $str]\r\n$str" redis_writenl $fd "echo [string length $str]\r\n$str"
redis_writenl $fd "smembers $key" redis_read_reply $fd
} }
proc redis_save {fd} { proc redis_save {fd} {
redis_writenl $fd "save" redis_writenl $fd "save"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_flushall {fd} { proc redis_flushall {fd} {
redis_writenl $fd "flushall" redis_writenl $fd "flushall"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_flushdb {fd} { proc redis_flushdb {fd} {
redis_writenl $fd "flushdb" redis_writenl $fd "flushdb"
redis_read_retcode $fd redis_read_reply $fd
} }
proc redis_lrem {fd key count val} { proc redis_lrem {fd key count val} {
redis_writenl $fd "lrem $key $count [string length $val]\r\n$val" redis_writenl $fd "lrem $key $count [string length $val]\r\n$val"
redis_read_integer $fd redis_read_reply $fd
} }
proc stress {} { proc stress {} {