Redis AOF 持久化 实现原理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

appendonly no      #是否开启AOF，默认no
appendfilename "appendonly.aof"     #aof文件

appendfsync   
#always 每条命令都刷盘
#everysec 每秒刷盘
#no 内核决定什么时候刷

no-appendfsync-on-rewrite no  #是否开启rdb类似方式rewrite镜像写
auto-aof-rewrite-percentage 100   #AOF文件是上一次重写的时候的1倍大小
auto-aof-rewrite-min-size 64mb    #并于AOF文件要大于64M

aof-load-truncated yes  #当数据恢复的时候，假如遇到数据损坏，是继续还是直接退出

aof-rewrite-incremental-fsync yes #当 aof rewrite 的时候开启32MB数据，刷一次盘

1
2
3
4
5
6
7

/* AOF states */

#define REDIS_AOF_OFF 0             /* AOF 关闭 */

#define REDIS_AOF_ON 1              /* AOF 开启 */

#define REDIS_AOF_WAIT_REWRITE 2    /* 在线修改 为 appendonly yes 的时候 正在rewrite */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 要刷到AOF文件的数据，string类型

server.aof_buf      

# rewrite 期间，执行的命令缓存 ，是一个链表

server.aof_rewrite_buf_blocks

#距上次rewrite之后 AOF 刷了多少数据，每次rewrite之后清空

server.aof_current_size

#上一次rewrite的时候，AOF数据大小

server.aof_rewrite_base_size

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

  /* Trigger an AOF rewrite if needed */
         if (server.rdb_child_pid == -1 &&
             server.aof_child_pid == -1 &&
             server.aof_rewrite_perc &&
             server.aof_current_size > server.aof_rewrite_min_size)
         {
            long long base = server.aof_rewrite_base_size ?
                            server.aof_rewrite_base_size : 1;
            long long growth = (server.aof_current_size*100/base) - 100;
            if (growth >= server.aof_rewrite_perc) {
                redisLog(REDIS_NOTICE,"Starting automatic rewriting of AOF on %lld%% growth",growth);
                rewriteAppendOnlyFileBackground();
            }
         }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void bgrewriteaofCommand(redisClient *c) {
    if (server.aof_child_pid != -1) {
        addReplyError(c,"Background append only file rewriting already in progress");
    } else if (server.rdb_child_pid != -1) {
        server.aof_rewrite_scheduled = 1;
        addReplyStatus(c,"Background append only file rewriting scheduled");
    } else if (rewriteAppendOnlyFileBackground() == REDIS_OK) {
        addReplyStatus(c,"Background append only file rewriting started");
    } else {
        addReply(c,shared.err);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

  } else if (!strcasecmp(c->argv[2]->ptr,"appendonly")) {
        int enable = yesnotoi(o->ptr);

        if (enable == -1) goto badfmt;
        if (enable == 0 && server.aof_state != REDIS_AOF_OFF) {
            stopAppendOnly();
        } else if (enable && server.aof_state == REDIS_AOF_OFF) {
            if (startAppendOnly() == REDIS_ERR) {
                addReplyError(c,
                    "Unable to turn on AOF. Check server logs.");
                return;
            }
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

/* Called when the user switches from "appendonly no" to "appendonly yes"
 * at runtime using the CONFIG command. */
int startAppendOnly(void) {
    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) {
        redisLog(REDIS_WARNING,"Redis needs to enable the AOF but can't open the append only file: %s",strerror(errno));
        return REDIS_ERR;
    }
    if (rewriteAppendOnlyFileBackground() == REDIS_ERR) {
        close(server.aof_fd);
        redisLog(REDIS_WARNING,"Redis needs to enable the AOF but can't trigger a background AOF rewrite operation. Check the above logs for more info about the error.");
        return REDIS_ERR;
    }
    /* We correctly switched on AOF, now wait for the rerwite to be complete
     * in order to append data on disk. */
    server.aof_state = REDIS_AOF_WAIT_REWRITE;
    return REDIS_OK;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

 /* AOF postponed flush: Try at every cron cycle if the slow fsync
     * completed. */
    if (server.aof_flush_postponed_start) flushAppendOnlyFile(0);

    /* AOF write errors: in this case we have a buffer to flush as well and
     * clear the AOF error in case of success to make the DB writable again,
     * however to try every second is enough in case of 'hz' is set to
     * an higher frequency. */
    run_with_period(1000) {
        if (server.aof_last_write_status == REDIS_ERR)
            flushAppendOnlyFile(0);
    }