X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/48f0308ad327d3bf4a89c1fc1ca977b7ed6f0f96..cdd140aa67be01a994dbb001e050f3dd2b0578ee:/redis.c diff --git a/redis.c b/redis.c index 375a31f8..f5fb5e45 100644 --- a/redis.c +++ b/redis.c @@ -172,11 +172,8 @@ /* Sort operations */ #define REDIS_SORT_GET 0 -#define REDIS_SORT_DEL 1 -#define REDIS_SORT_INCR 2 -#define REDIS_SORT_DECR 3 -#define REDIS_SORT_ASC 4 -#define REDIS_SORT_DESC 5 +#define REDIS_SORT_ASC 1 +#define REDIS_SORT_DESC 2 #define REDIS_SORTKEY_MAX 1024 /* Log levels */ @@ -1036,7 +1033,7 @@ static void initServerConfig() { server.glueoutputbuf = 1; server.daemonize = 0; server.appendonly = 0; - server.appendfsync = APPENDFSYNC_EVERYSEC; + server.appendfsync = APPENDFSYNC_ALWAYS; server.lastfsync = time(NULL); server.appendfd = -1; server.appendseldb = -1; /* Make sure the first time will not match */ @@ -1101,10 +1098,10 @@ static void initServer() { server.stat_numcommands = 0; server.stat_numconnections = 0; server.stat_starttime = time(NULL); - aeCreateTimeEvent(server.el, 1000, serverCron, NULL, NULL); + aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL); if (server.appendonly) { - server.appendfd = open(server.appendfilename,O_WRONLY|O_APPEND|O_CREAT); + server.appendfd = open(server.appendfilename,O_WRONLY|O_APPEND|O_CREAT,0644); if (server.appendfd == -1) { redisLog(REDIS_WARNING, "Can't open the append-only file: %s", strerror(errno)); @@ -1255,11 +1252,11 @@ static void loadServerConfig(char *filename) { err = "argument must be 'yes' or 'no'"; goto loaderr; } } else if (!strcasecmp(argv[0],"appendfsync") && argc == 2) { - if (strcasecmp(argv[1],"no")) { + if (!strcasecmp(argv[1],"no")) { server.appendfsync = APPENDFSYNC_NO; - } else if (strcasecmp(argv[1],"always")) { + } else if (!strcasecmp(argv[1],"always")) { server.appendfsync = APPENDFSYNC_ALWAYS; - } else if (strcasecmp(argv[1],"everysec")) { + } else if (!strcasecmp(argv[1],"everysec")) { server.appendfsync = APPENDFSYNC_EVERYSEC; } else { err = "argument must be 'no', 'always' or 'everysec'"; @@ -1580,9 +1577,9 @@ static int processCommand(redisClient *c) { /* Exec the command */ dirty = server.dirty; cmd->proc(c); - if (server.appendonly != 0) + if (server.appendonly && server.dirty-dirty) feedAppendOnlyFile(cmd,c->db->id,c->argv,c->argc); - if (server.dirty-dirty != 0 && listLength(server.slaves)) + if (server.dirty-dirty && listLength(server.slaves)) replicationFeedSlaves(server.slaves,cmd,c->db->id,c->argv,c->argc); if (listLength(server.monitors)) replicationFeedSlaves(server.monitors,cmd,c->db->id,c->argv,c->argc); @@ -1666,63 +1663,6 @@ static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int di if (outv != static_outv) zfree(outv); } -/* TODO: translate EXPIREs into EXPIRETOs */ -static void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) { - sds buf = sdsempty(); - int j; - ssize_t nwritten; - time_t now; - - /* The DB this command was targetting is not the same as the last command - * we appendend. To issue a SELECT command is needed. */ - if (dictid != server.appendseldb) { - char seldb[64]; - - snprintf(seldb,sizeof(seldb),"%d",dictid); - buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%d\r\n%s\r\n", - strlen(seldb),seldb); - server.appendseldb = dictid; - } - /* Append the actual command */ - buf = sdscatprintf(buf,"*%d\r\n",argc); - for (j = 0; j < argc; j++) { - robj *o = argv[j]; - - if (o->encoding != REDIS_ENCODING_RAW) - o = getDecodedObject(o); - buf = sdscatprintf(buf,"$%d\r\n",sdslen(o->ptr)); - buf = sdscatlen(buf,o->ptr,sdslen(o->ptr)); - buf = sdscatlen(buf,"\r\n",2); - if (o != argv[j]) - decrRefCount(o); - } - /* We want to perform a single write. This should be guaranteed atomic - * at least if the filesystem we are writing is a real physical one. - * While this will save us against the server being killed I don't think - * there is much to do about the whole server stopping for power problems - * or alike */ - nwritten = write(server.appendfd,buf,sdslen(buf)); - if (nwritten != (unsigned)sdslen(buf)) { - /* Ooops, we are in troubles. The best thing to do for now is - * to simply exit instead to give the illusion that everything is - * working as expected. */ - if (nwritten == -1) { - redisLog(REDIS_WARNING,"Aborting on error writing to the append-only file: %s",strerror(errno)); - } else { - redisLog(REDIS_WARNING,"Aborting on short write while writing to the append-only file: %s",strerror(errno)); - } - abort(); - } - now = time(NULL); - if (server.appendfsync == APPENDFSYNC_ALWAYS || - (server.appendfsync == APPENDFSYNC_EVERYSEC && - now-server.lastfsync > 1)) - { - fsync(server.appendfd); /* Let's try to get this data on the disk */ - server.lastfsync = now; - } -} - static void processInputBuffer(redisClient *c) { again: if (c->bulklen == -1) { @@ -2811,7 +2751,7 @@ static int rdbLoad(char *filename) { eoferr: /* unexpected end of file is handled here with a fatal exit */ if (keyobj) decrRefCount(keyobj); - redisLog(REDIS_WARNING,"Short read or OOM loading DB. Unrecoverable error, exiting now."); + redisLog(REDIS_WARNING,"Short read or OOM loading DB. Unrecoverable error, aborting now."); exit(1); return REDIS_ERR; /* Just to avoid warning */ } @@ -3082,6 +3022,7 @@ static void typeCommand(redisClient *c) { case REDIS_STRING: type = "+string"; break; case REDIS_LIST: type = "+list"; break; case REDIS_SET: type = "+set"; break; + case REDIS_ZSET: type = "+zset"; break; default: type = "unknown"; break; } } @@ -4503,7 +4444,7 @@ static void sortCommand(redisClient *c) { int limit_start = 0, limit_count = -1, start, end; int j, dontsort = 0, vectorlen; int getop = 0; /* GET operation counter */ - robj *sortval, *sortby = NULL; + robj *sortval, *sortby = NULL, *storekey = NULL; redisSortObject *vector; /* Resulting vector to sort */ /* Lookup the key to sort. It must be of the right types */ @@ -4541,6 +4482,9 @@ static void sortCommand(redisClient *c) { limit_start = atoi(c->argv[j+1]->ptr); limit_count = atoi(c->argv[j+2]->ptr); j+=2; + } else if (!strcasecmp(c->argv[j]->ptr,"store") && leftargs >= 1) { + storekey = c->argv[j+1]; + j++; } else if (!strcasecmp(c->argv[j]->ptr,"by") && leftargs >= 1) { sortby = c->argv[j+1]; /* If the BY pattern does not contain '*', i.e. it is constant, @@ -4552,18 +4496,6 @@ static void sortCommand(redisClient *c) { REDIS_SORT_GET,c->argv[j+1])); getop++; j++; - } else if (!strcasecmp(c->argv[j]->ptr,"del") && leftargs >= 1) { - listAddNodeTail(operations,createSortOperation( - REDIS_SORT_DEL,c->argv[j+1])); - j++; - } else if (!strcasecmp(c->argv[j]->ptr,"incr") && leftargs >= 1) { - listAddNodeTail(operations,createSortOperation( - REDIS_SORT_INCR,c->argv[j+1])); - j++; - } else if (!strcasecmp(c->argv[j]->ptr,"get") && leftargs >= 1) { - listAddNodeTail(operations,createSortOperation( - REDIS_SORT_DECR,c->argv[j+1])); - j++; } else { decrRefCount(sortval); listRelease(operations); @@ -4670,32 +4602,70 @@ static void sortCommand(redisClient *c) { /* Send command output to the output buffer, performing the specified * GET/DEL/INCR/DECR operations if any. */ outputlen = getop ? getop*(end-start+1) : end-start+1; - addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen)); - for (j = start; j <= end; j++) { - listNode *ln; - if (!getop) { - addReplyBulkLen(c,vector[j].obj); - addReply(c,vector[j].obj); - addReply(c,shared.crlf); + if (storekey == NULL) { + /* STORE option not specified, sent the sorting result to client */ + addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen)); + for (j = start; j <= end; j++) { + listNode *ln; + if (!getop) { + addReplyBulkLen(c,vector[j].obj); + addReply(c,vector[j].obj); + addReply(c,shared.crlf); + } + listRewind(operations); + while((ln = listYield(operations))) { + redisSortOperation *sop = ln->value; + robj *val = lookupKeyByPattern(c->db,sop->pattern, + vector[j].obj); + + if (sop->type == REDIS_SORT_GET) { + if (!val || val->type != REDIS_STRING) { + addReply(c,shared.nullbulk); + } else { + addReplyBulkLen(c,val); + addReply(c,val); + addReply(c,shared.crlf); + } + } else { + assert(sop->type == REDIS_SORT_GET); /* always fails */ + } + } } - listRewind(operations); - while((ln = listYield(operations))) { - redisSortOperation *sop = ln->value; - robj *val = lookupKeyByPattern(c->db,sop->pattern, - vector[j].obj); - - if (sop->type == REDIS_SORT_GET) { - if (!val || val->type != REDIS_STRING) { - addReply(c,shared.nullbulk); + } else { + robj *listObject = createListObject(); + list *listPtr = (list*) listObject->ptr; + + /* STORE option specified, set the sorting result as a List object */ + for (j = start; j <= end; j++) { + listNode *ln; + if (!getop) { + listAddNodeTail(listPtr,vector[j].obj); + incrRefCount(vector[j].obj); + } + listRewind(operations); + while((ln = listYield(operations))) { + redisSortOperation *sop = ln->value; + robj *val = lookupKeyByPattern(c->db,sop->pattern, + vector[j].obj); + + if (sop->type == REDIS_SORT_GET) { + if (!val || val->type != REDIS_STRING) { + listAddNodeTail(listPtr,createStringObject("",0)); + } else { + listAddNodeTail(listPtr,val); + incrRefCount(val); + } } else { - addReplyBulkLen(c,val); - addReply(c,val); - addReply(c,shared.crlf); + assert(sop->type == REDIS_SORT_GET); /* always fails */ } - } else if (sop->type == REDIS_SORT_DEL) { - /* TODO */ } } + dictReplace(c->db->dict,storekey,listObject); + /* Note: we add 1 because the DB is dirty anyway since even if the + * SORT result is empty a new key is set and maybe the old content + * replaced. */ + server.dirty += 1+outputlen; + addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",outputlen)); } /* Cleanup */ @@ -5310,6 +5280,198 @@ static void freeMemoryIfNeeded(void) { } } +/* ============================== Append Only file ========================== */ + +static void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) { + sds buf = sdsempty(); + int j; + ssize_t nwritten; + time_t now; + robj *tmpargv[3]; + + /* The DB this command was targetting is not the same as the last command + * we appendend. To issue a SELECT command is needed. */ + if (dictid != server.appendseldb) { + char seldb[64]; + + snprintf(seldb,sizeof(seldb),"%d",dictid); + buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%d\r\n%s\r\n", + strlen(seldb),seldb); + server.appendseldb = dictid; + } + + /* "Fix" the argv vector if the command is EXPIRE. We want to translate + * EXPIREs into EXPIREATs calls */ + if (cmd->proc == expireCommand) { + long when; + + tmpargv[0] = createStringObject("EXPIREAT",8); + tmpargv[1] = argv[1]; + incrRefCount(argv[1]); + when = time(NULL)+strtol(argv[2]->ptr,NULL,10); + tmpargv[2] = createObject(REDIS_STRING, + sdscatprintf(sdsempty(),"%ld",when)); + argv = tmpargv; + } + + /* Append the actual command */ + buf = sdscatprintf(buf,"*%d\r\n",argc); + for (j = 0; j < argc; j++) { + robj *o = argv[j]; + + if (o->encoding != REDIS_ENCODING_RAW) + o = getDecodedObject(o); + buf = sdscatprintf(buf,"$%d\r\n",sdslen(o->ptr)); + buf = sdscatlen(buf,o->ptr,sdslen(o->ptr)); + buf = sdscatlen(buf,"\r\n",2); + if (o != argv[j]) + decrRefCount(o); + } + + /* Free the objects from the modified argv for EXPIREAT */ + if (cmd->proc == expireCommand) { + for (j = 0; j < 3; j++) + decrRefCount(argv[j]); + } + + /* We want to perform a single write. This should be guaranteed atomic + * at least if the filesystem we are writing is a real physical one. + * While this will save us against the server being killed I don't think + * there is much to do about the whole server stopping for power problems + * or alike */ + nwritten = write(server.appendfd,buf,sdslen(buf)); + if (nwritten != (signed)sdslen(buf)) { + /* Ooops, we are in troubles. The best thing to do for now is + * to simply exit instead to give the illusion that everything is + * working as expected. */ + if (nwritten == -1) { + redisLog(REDIS_WARNING,"Exiting on error writing to the append-only file: %s",strerror(errno)); + } else { + redisLog(REDIS_WARNING,"Exiting on short write while writing to the append-only file: %s",strerror(errno)); + } + exit(1); + } + now = time(NULL); + if (server.appendfsync == APPENDFSYNC_ALWAYS || + (server.appendfsync == APPENDFSYNC_EVERYSEC && + now-server.lastfsync > 1)) + { + fsync(server.appendfd); /* Let's try to get this data on the disk */ + server.lastfsync = now; + } +} + +/* In Redis commands are always executed in the context of a client, so in + * order to load the append only file we need to create a fake client. */ +static struct redisClient *createFakeClient(void) { + struct redisClient *c = zmalloc(sizeof(*c)); + + selectDb(c,0); + c->fd = -1; + c->querybuf = sdsempty(); + c->argc = 0; + c->argv = NULL; + c->flags = 0; + /* We set the fake client as a slave waiting for the synchronization + * so that Redis will not try to send replies to this client. */ + c->replstate = REDIS_REPL_WAIT_BGSAVE_START; + c->reply = listCreate(); + listSetFreeMethod(c->reply,decrRefCount); + listSetDupMethod(c->reply,dupClientReplyValue); + return c; +} + +static void freeFakeClient(struct redisClient *c) { + sdsfree(c->querybuf); + listRelease(c->reply); + zfree(c); +} + +/* Replay the append log file. On error REDIS_OK is returned. On non fatal + * error (the append only file is zero-length) REDIS_ERR is returned. On + * fatal error an error message is logged and the program exists. */ +int loadAppendOnlyFile(char *filename) { + struct redisClient *fakeClient; + FILE *fp = fopen(filename,"r"); + struct redis_stat sb; + + if (redis_fstat(fileno(fp),&sb) != -1 && sb.st_size == 0) + return REDIS_ERR; + + if (fp == NULL) { + redisLog(REDIS_WARNING,"Fatal error: can't open the append log file for reading: %s",strerror(errno)); + exit(1); + } + + fakeClient = createFakeClient(); + while(1) { + int argc, j; + unsigned long len; + robj **argv; + char buf[128]; + sds argsds; + struct redisCommand *cmd; + + if (fgets(buf,sizeof(buf),fp) == NULL) { + if (feof(fp)) + break; + else + goto readerr; + } + if (buf[0] != '*') goto fmterr; + argc = atoi(buf+1); + argv = zmalloc(sizeof(robj*)*argc); + for (j = 0; j < argc; j++) { + if (fgets(buf,sizeof(buf),fp) == NULL) goto readerr; + if (buf[0] != '$') goto fmterr; + len = strtol(buf+1,NULL,10); + argsds = sdsnewlen(NULL,len); + if (fread(argsds,len,1,fp) == 0) goto fmterr; + argv[j] = createObject(REDIS_STRING,argsds); + if (fread(buf,2,1,fp) == 0) goto fmterr; /* discard CRLF */ + } + + /* Command lookup */ + cmd = lookupCommand(argv[0]->ptr); + if (!cmd) { + redisLog(REDIS_WARNING,"Unknown command '%s' reading the append only file", argv[0]->ptr); + exit(1); + } + /* Try object sharing and encoding */ + if (server.shareobjects) { + int j; + for(j = 1; j < argc; j++) + argv[j] = tryObjectSharing(argv[j]); + } + if (cmd->flags & REDIS_CMD_BULK) + tryObjectEncoding(argv[argc-1]); + /* Run the command in the context of a fake client */ + fakeClient->argc = argc; + fakeClient->argv = argv; + cmd->proc(fakeClient); + /* Discard the reply objects list from the fake client */ + while(listLength(fakeClient->reply)) + listDelNode(fakeClient->reply,listFirst(fakeClient->reply)); + /* Clean up, ready for the next command */ + for (j = 0; j < argc; j++) decrRefCount(argv[j]); + zfree(argv); + } + fclose(fp); + freeFakeClient(fakeClient); + return REDIS_OK; + +readerr: + if (feof(fp)) { + redisLog(REDIS_WARNING,"Unexpected end of file reading the append only file"); + } else { + redisLog(REDIS_WARNING,"Unrecoverable error reading the append only file: %s", strerror(errno)); + } + exit(1); +fmterr: + redisLog(REDIS_WARNING,"Bad file format reading the append only file"); + exit(1); +} + /* ================================= Debugging ============================== */ static void debugCommand(redisClient *c) { @@ -5450,6 +5612,7 @@ static struct redisFunctionSym symsTable[] = { {"zremCommand",(unsigned long)zremCommand}, {"rdbSaveDoubleValue",(unsigned long)rdbSaveDoubleValue}, {"rdbLoadDoubleValue",(unsigned long)rdbLoadDoubleValue}, +{"feedAppendOnlyFile",(unsigned long)feedAppendOnlyFile}, {NULL,0} }; @@ -5641,8 +5804,13 @@ int main(int argc, char **argv) { #ifdef __linux__ linuxOvercommitMemoryWarning(); #endif - if (rdbLoad(server.dbfilename) == REDIS_OK) - redisLog(REDIS_NOTICE,"DB loaded from disk"); + if (server.appendonly) { + if (loadAppendOnlyFile(server.appendfilename) == REDIS_OK) + redisLog(REDIS_NOTICE,"DB loaded from append only file"); + } else { + if (rdbLoad(server.dbfilename) == REDIS_OK) + redisLog(REDIS_NOTICE,"DB loaded from disk"); + } if (aeCreateFileEvent(server.el, server.fd, AE_READABLE, acceptHandler, NULL, NULL) == AE_ERR) oom("creating file event"); redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port);