mirror of
https://github.com/fluencelabs/redis
synced 2025-03-17 16:10:50 +00:00
commit
44f26aea0c
@ -46,7 +46,7 @@ void stopAppendOnly(void) {
|
||||
/* Called when the user switches from "appendonly no" to "appendonly yes"
|
||||
* at runtime using the CONFIG command. */
|
||||
int startAppendOnly(void) {
|
||||
server.aof_last_fsync = time(NULL);
|
||||
server.aof_last_fsync = server.unixtime;
|
||||
server.aof_fd = open(server.aof_filename,O_WRONLY|O_APPEND|O_CREAT,0644);
|
||||
redisAssert(server.aof_state == REDIS_AOF_OFF);
|
||||
if (server.aof_fd == -1) {
|
||||
|
26
src/db.c
26
src/db.c
@ -10,28 +10,6 @@ void SlotToKeyDel(robj *key);
|
||||
* C-level DB API
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
/* Important notes on lookup and disk store.
|
||||
*
|
||||
* When disk store is enabled on lookup we can have different cases.
|
||||
*
|
||||
* a) The key is in memory:
|
||||
* - If the key is not in IO_SAVEINPROG state we can access it.
|
||||
* As if it's just IO_SAVE this means we have the key in the IO queue
|
||||
* but can't be accessed by the IO thread (it requires to be
|
||||
* translated into an IO Job by the cache cron function.)
|
||||
* - If the key is in IO_SAVEINPROG we can't touch the key and have
|
||||
* to blocking wait completion of operations.
|
||||
* b) The key is not in memory:
|
||||
* - If it's marked as non existing on disk as well (negative cache)
|
||||
* we don't need to perform the disk access.
|
||||
* - if the key MAY EXIST, but is not in memory, and it is marked as IO_SAVE
|
||||
* then the key can only be a deleted one. As IO_SAVE keys are never
|
||||
* evicted (dirty state), so the only possibility is that key was deleted.
|
||||
* - if the key MAY EXIST we need to blocking load it.
|
||||
* We check that the key is not in IO_SAVEINPROG state before accessing
|
||||
* the disk object. If it is in this state, we wait.
|
||||
*/
|
||||
|
||||
robj *lookupKey(redisDb *db, robj *key) {
|
||||
dictEntry *de = dictFind(db->dict,key->ptr);
|
||||
if (de) {
|
||||
@ -161,8 +139,6 @@ int dbDelete(redisDb *db, robj *key) {
|
||||
}
|
||||
}
|
||||
|
||||
/* Empty the whole database.
|
||||
* If diskstore is enabled this function will just flush the in-memory cache. */
|
||||
long long emptyDb() {
|
||||
int j;
|
||||
long long removed = 0;
|
||||
@ -518,7 +494,7 @@ int expireIfNeeded(redisDb *db, robj *key) {
|
||||
* that is, 0 if we think the key should be still valid, 1 if
|
||||
* we think the key is expired at this time. */
|
||||
if (server.masterhost != NULL) {
|
||||
return time(NULL) > when;
|
||||
return mstime() > when;
|
||||
}
|
||||
|
||||
/* Return when this key has not expired */
|
||||
|
@ -52,7 +52,7 @@ redisClient *createClient(int fd) {
|
||||
c->bulklen = -1;
|
||||
c->sentlen = 0;
|
||||
c->flags = 0;
|
||||
c->ctime = c->lastinteraction = time(NULL);
|
||||
c->ctime = c->lastinteraction = server.unixtime;
|
||||
c->authenticated = 0;
|
||||
c->replstate = REDIS_REPL_NONE;
|
||||
c->reply = listCreate();
|
||||
@ -604,7 +604,7 @@ void freeClient(redisClient *c) {
|
||||
if (c->flags & REDIS_MASTER) {
|
||||
server.master = NULL;
|
||||
server.repl_state = REDIS_REPL_CONNECT;
|
||||
server.repl_down_since = time(NULL);
|
||||
server.repl_down_since = server.unixtime;
|
||||
/* Since we lost the connection with the master, we should also
|
||||
* close the connection with all our slaves if we have any, so
|
||||
* when we'll resync with the master the other slaves will sync again
|
||||
@ -732,7 +732,7 @@ void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (totwritten > 0) c->lastinteraction = time(NULL);
|
||||
if (totwritten > 0) c->lastinteraction = server.unixtime;
|
||||
if (c->bufpos == 0 && listLength(c->reply) == 0) {
|
||||
c->sentlen = 0;
|
||||
aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
|
||||
@ -1017,7 +1017,7 @@ void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
|
||||
}
|
||||
if (nread) {
|
||||
sdsIncrLen(c->querybuf,nread);
|
||||
c->lastinteraction = time(NULL);
|
||||
c->lastinteraction = server.unixtime;
|
||||
} else {
|
||||
server.current_client = NULL;
|
||||
return;
|
||||
@ -1058,7 +1058,6 @@ void getClientsMaxBuffers(unsigned long *longest_output_list,
|
||||
sds getClientInfoString(redisClient *client) {
|
||||
char ip[32], flags[16], events[3], *p;
|
||||
int port;
|
||||
time_t now = time(NULL);
|
||||
int emask;
|
||||
|
||||
anetPeerToString(client->fd,ip,&port);
|
||||
@ -1087,8 +1086,8 @@ sds getClientInfoString(redisClient *client) {
|
||||
return sdscatprintf(sdsempty(),
|
||||
"addr=%s:%d fd=%d age=%ld idle=%ld flags=%s db=%d sub=%d psub=%d qbuf=%lu qbuf-free=%lu obl=%lu oll=%lu omem=%lu events=%s cmd=%s",
|
||||
ip,port,client->fd,
|
||||
(long)(now - client->ctime),
|
||||
(long)(now - client->lastinteraction),
|
||||
(long)(server.unixtime - client->ctime),
|
||||
(long)(server.unixtime - client->lastinteraction),
|
||||
flags,
|
||||
client->db->id,
|
||||
(int) dictSize(client->pubsub_channels),
|
||||
|
@ -270,9 +270,7 @@ robj *tryObjectEncoding(robj *o) {
|
||||
|
||||
/* Ok, this object can be encoded...
|
||||
*
|
||||
* Can I use a shared object? Only if the object is inside a given
|
||||
* range and if the back end in use is in-memory. For disk store every
|
||||
* object in memory used as value should be independent.
|
||||
* Can I use a shared object? Only if the object is inside a given range
|
||||
*
|
||||
* Note that we also avoid using shared integers when maxmemory is used
|
||||
* because every object needs to have a private LRU field for the LRU
|
||||
|
16
src/redis.c
16
src/redis.c
@ -612,7 +612,7 @@ void activeExpireCycle(void) {
|
||||
}
|
||||
|
||||
void updateLRUClock(void) {
|
||||
server.lruclock = (time(NULL)/REDIS_LRU_CLOCK_RESOLUTION) &
|
||||
server.lruclock = (server.unixtime/REDIS_LRU_CLOCK_RESOLUTION) &
|
||||
REDIS_LRU_CLOCK_MAX;
|
||||
}
|
||||
|
||||
@ -821,15 +821,13 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
|
||||
updateDictResizePolicy();
|
||||
}
|
||||
} else {
|
||||
time_t now = time(NULL);
|
||||
|
||||
/* If there is not a background saving/rewrite in progress check if
|
||||
* we have to save/rewrite now */
|
||||
for (j = 0; j < server.saveparamslen; j++) {
|
||||
struct saveparam *sp = server.saveparams+j;
|
||||
|
||||
if (server.dirty >= sp->changes &&
|
||||
now-server.lastsave > sp->seconds) {
|
||||
server.unixtime-server.lastsave > sp->seconds) {
|
||||
redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
|
||||
sp->changes, sp->seconds);
|
||||
rdbSaveBackground(server.rdb_filename);
|
||||
@ -1683,7 +1681,7 @@ void bytesToHuman(char *s, unsigned long long n) {
|
||||
* on memory corruption problems. */
|
||||
sds genRedisInfoString(char *section) {
|
||||
sds info = sdsempty();
|
||||
time_t uptime = time(NULL)-server.stat_starttime;
|
||||
time_t uptime = server.unixtime-server.stat_starttime;
|
||||
int j, numcommands;
|
||||
struct rusage self_ru, c_ru;
|
||||
unsigned long lol, bib;
|
||||
@ -1822,7 +1820,7 @@ sds genRedisInfoString(char *section) {
|
||||
perc = ((double)server.loading_loaded_bytes /
|
||||
server.loading_total_bytes) * 100;
|
||||
|
||||
elapsed = time(NULL)-server.loading_start_time;
|
||||
elapsed = server.unixtime-server.loading_start_time;
|
||||
if (elapsed == 0) {
|
||||
eta = 1; /* A fake 1 second figure if we don't have
|
||||
enough info */
|
||||
@ -1893,7 +1891,7 @@ sds genRedisInfoString(char *section) {
|
||||
(server.repl_state == REDIS_REPL_CONNECTED) ?
|
||||
"up" : "down",
|
||||
server.master ?
|
||||
((int)(time(NULL)-server.master->lastinteraction)) : -1,
|
||||
((int)(server.unixtime-server.master->lastinteraction)) : -1,
|
||||
server.repl_state == REDIS_REPL_TRANSFER
|
||||
);
|
||||
|
||||
@ -1902,14 +1900,14 @@ sds genRedisInfoString(char *section) {
|
||||
"master_sync_left_bytes:%ld\r\n"
|
||||
"master_sync_last_io_seconds_ago:%d\r\n"
|
||||
,(long)server.repl_transfer_left,
|
||||
(int)(time(NULL)-server.repl_transfer_lastio)
|
||||
(int)(server.unixtime-server.repl_transfer_lastio)
|
||||
);
|
||||
}
|
||||
|
||||
if (server.repl_state != REDIS_REPL_CONNECTED) {
|
||||
info = sdscatprintf(info,
|
||||
"master_link_down_since_seconds:%ld\r\n",
|
||||
(long)time(NULL)-server.repl_down_since);
|
||||
(long)server.unixtime-server.repl_down_since);
|
||||
}
|
||||
}
|
||||
info = sdscatprintf(info,
|
||||
|
@ -817,7 +817,7 @@ extern dictType zsetDictType;
|
||||
extern dictType clusterNodesDictType;
|
||||
extern dictType dbDictType;
|
||||
extern double R_Zero, R_PosInf, R_NegInf, R_Nan;
|
||||
dictType hashDictType;
|
||||
extern dictType hashDictType;
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Functions prototypes
|
||||
|
@ -307,7 +307,7 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
|
||||
/* At this stage just a newline works as a PING in order to take
|
||||
* the connection live. So we refresh our last interaction
|
||||
* timestamp. */
|
||||
server.repl_transfer_lastio = time(NULL);
|
||||
server.repl_transfer_lastio = server.unixtime;
|
||||
return;
|
||||
} else if (buf[0] != '$') {
|
||||
redisLog(REDIS_WARNING,"Bad protocol from MASTER, the first byte is not '$', are you sure the host and port are right?");
|
||||
@ -330,7 +330,7 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
|
||||
replicationAbortSyncTransfer();
|
||||
return;
|
||||
}
|
||||
server.repl_transfer_lastio = time(NULL);
|
||||
server.repl_transfer_lastio = server.unixtime;
|
||||
if (write(server.repl_transfer_fd,buf,nread) != nread) {
|
||||
redisLog(REDIS_WARNING,"Write error or short write writing to the DB dump file needed for MASTER <-> SLAVE synchrnonization: %s", strerror(errno));
|
||||
goto error;
|
||||
@ -441,7 +441,7 @@ void syncWithMaster(aeEventLoop *el, int fd, void *privdata, int mask) {
|
||||
/* Prepare a suitable temp file for bulk transfer */
|
||||
while(maxtries--) {
|
||||
snprintf(tmpfile,256,
|
||||
"temp-%d.%ld.rdb",(int)time(NULL),(long int)getpid());
|
||||
"temp-%d.%ld.rdb",(int)server.unixtime,(long int)getpid());
|
||||
dfd = open(tmpfile,O_CREAT|O_WRONLY|O_EXCL,0644);
|
||||
if (dfd != -1) break;
|
||||
sleep(1);
|
||||
@ -462,7 +462,7 @@ void syncWithMaster(aeEventLoop *el, int fd, void *privdata, int mask) {
|
||||
server.repl_state = REDIS_REPL_TRANSFER;
|
||||
server.repl_transfer_left = -1;
|
||||
server.repl_transfer_fd = dfd;
|
||||
server.repl_transfer_lastio = time(NULL);
|
||||
server.repl_transfer_lastio = server.unixtime;
|
||||
server.repl_transfer_tmpfile = zstrdup(tmpfile);
|
||||
return;
|
||||
|
||||
@ -490,7 +490,7 @@ int connectWithMaster(void) {
|
||||
return REDIS_ERR;
|
||||
}
|
||||
|
||||
server.repl_transfer_lastio = time(NULL);
|
||||
server.repl_transfer_lastio = server.unixtime;
|
||||
server.repl_transfer_s = fd;
|
||||
server.repl_state = REDIS_REPL_CONNECTING;
|
||||
return REDIS_OK;
|
||||
|
@ -910,7 +910,7 @@ int getTimeoutFromObjectOrReply(redisClient *c, robj *object, time_t *timeout) {
|
||||
return REDIS_ERR;
|
||||
}
|
||||
|
||||
if (tval > 0) tval += time(NULL);
|
||||
if (tval > 0) tval += server.unixtime;
|
||||
*timeout = tval;
|
||||
|
||||
return REDIS_OK;
|
||||
|
Loading…
x
Reference in New Issue
Block a user