Merge pull request #17 from threefoldtech/temp-cleanup

cleanup: flush temporary namespace when possible

Author: maxux

src/cache.c

@@ -255,6 +255,15 @@ static int zdbfs_cache_block_restore(zdbfs_t *fs, inocache_t *cache, blockcache_
     zdbfs_lowdebug("cache: block offloaded restored, %lu bytes read", block->blocksize);
     zdbfs_zdb_reply_free(reply);
 
+    // delete that block from temporary namespace
+    if(zdb_del(fs->tempctx, block->offid) != 0) {
+        zdbfs_debug("[-] cache: temporary: could not delete key: %u\n", block->offid);
+        return 0;
+    }
+
+    // ensure blockid is not set anymore
+    block->offid = 0;
+
     return 0;
 }
 
@@ -583,13 +592,51 @@ int zdbfs_cache_release(fuse_req_t req, inocache_t *cache) {
     return 1;
 }
 
+size_t zdbfs_cache_temp_cleanup(zdbfs_t *fs) {
+    zdb_nsinfo_t *temp;
+
+    if(!(temp = zdb_nsinfo(fs->tempctx, fs->opts->temp_ns)))
+        return 0;
+
+    if(temp->nextid > 32 && temp->entries == 1) {
+        zdbfs_lowdebug("cache: temporary namespace not empty and not in use: %lu", temp->nextid);
+
+        zdb_reply_t *reply;
+        redisReply *zreply;
+
+        zdbfs_lowdebug("cache: %s: backing up temporary namespace header", fs->opts->temp_ns);
+        if(!(reply = zdb_get(fs->tempctx, 0))) {
+            zdbfs_critical("cache: delegate: could not get header: %s", fs->tempctx->errstr);
+            return 1;
+        }
+
+        zdbfs_lowdebug("cache: %s: flushing temporary namespace", fs->opts->temp_ns);
+        zdb_flush(fs->tempctx);
+
+        zdbfs_lowdebug("cache: %s: restoring temporary namespace header", fs->opts->temp_ns);
+
+        if(!(zreply = redisCommand(fs->tempctx, "SET %b %b", NULL, 0, reply->value, reply->length))) {
+            zdbfs_critical("inode: temporary reset: %s", fs->tempctx->errstr);
+            return 1;
+        }
+
+        zdbfs_zdb_reply_free(reply);
+        freeReplyObject(zreply);
+    }
+
+    return 1;
+}
+
 size_t zdbfs_cache_sync(zdbfs_t *fs) {
     size_t cleared = 0;
 
     // runtime cache disabled
     if(!zdbfs_cache_enabled(fs))
         return 0;
 
+    // check if the temporary namespace needs to be reset
+    zdbfs_cache_temp_cleanup(fs);
+
     // checking each cache entries and check
     // if entry were added few time ago or more
     //

src/zdb.c

@@ -67,6 +67,28 @@ int zdb_nsnew(redisContext *remote, char *namespace) {
     return 0;
 }
 
+int zdb_flush(redisContext *remote) {
+    const char *argv[] = {"FLUSH"};
+    redisReply *reply;
+
+    zdbfs_debug("[+] zdb: flush: namespace: %p\n", remote);
+
+    if(!(reply = redisCommandArgv(remote, 1, argv, NULL))) {
+        zdbfs_critical("zdb: flush: %p: %s", remote, remote->errstr);
+        return 1;
+    }
+
+    if(strcmp(reply->str, "OK") != 0) {
+        zdbfs_error("zdb: flush: %p: %s", remote, reply->str);
+        freeReplyObject(reply);
+        return 1;
+    }
+
+    freeReplyObject(reply);
+
+    return 0;
+}
+
 int zdb_nsset(redisContext *remote, char *namespace, char *setting, char *value) {
     const char *argv[] = {"NSSET", namespace, setting, value};
     int argc = 4;
@@ -101,6 +123,30 @@ static size_t zdb_nsinfo_sizeval(char *buffer, char *entry) {
     return strtoumax(match, NULL, 10);
 }
 
+static size_t zdb_nsinfo_internal_id(char *buffer, char *entry) {
+    char *match;
+    char numbuf[64];
+
+    if(!(match = strstr(buffer, entry)))
+        return 0;
+
+    match += strlen(entry) + 2;
+
+    memset(numbuf, 0x00, sizeof(numbuf));
+    sprintf(numbuf, "0x");
+
+    // FIXME: loop ? better way ?
+    // convert 0xaabbccdd to 0xddccbbaa
+    memcpy(numbuf + 2, match + 8, 2);
+    memcpy(numbuf + 4, match + 6, 2);
+    memcpy(numbuf + 6, match + 4, 2);
+    memcpy(numbuf + 8, match + 2, 2);
+
+    // return strtoul(match, NULL, 0);
+    return strtoul(numbuf, NULL, 0);
+}
+
+
 static int zdb_locked(redisReply *reply) {
     if(reply->type != REDIS_REPLY_ERROR)
         return 0;
@@ -140,6 +186,7 @@ zdb_nsinfo_t *zdb_nsinfo(redisContext *remote, char *namespace) {
 
     nsinfo->entries = zdb_nsinfo_sizeval(reply->str, "entries");
     nsinfo->datasize = zdb_nsinfo_sizeval(reply->str, "data_size_bytes");
+    nsinfo->nextid = zdb_nsinfo_internal_id(reply->str, "next_internal_id");
 
     freeReplyObject(reply);
 

src/zdb.h

@@ -6,12 +6,14 @@
     typedef struct zdb_nsinfo_t {
         size_t entries;
         size_t datasize;
+        size_t nextid;
 
     } zdb_nsinfo_t;
 
     int zdbfs_zdb_connect(zdbfs_t *fs);
     void zdbfs_zdb_free(zdbfs_t *fs);
 
+    int zdb_flush(redisContext *remote);
     zdb_reply_t *zdb_get(redisContext *remote, uint32_t id);
     uint32_t zdb_set(redisContext *remote, uint32_t id, const void *buffer, size_t length);
     int zdb_del(redisContext *remote, uint32_t id);