渐进式解析 Redis 源码 - REDIS 客户端 & RESP 协议

2018-10-18 阅读量

几乎所有主流编程语言都提供了与 REDIS 服务端交互的 cli 平台，基于 TCP 构建的通讯协议 RESP…

本文我们从 redis-cli 原生客户端的角度进行剖析 Redis 客户端功能流程 以及 RESP 协议

另外，由于 redis-cli 使用了 linenoise库（ linenoise 是一个命令行编辑库，由 Redis 设计者 Antirez 发布的一个用于替代 readline 的工具库，广泛应用于 Redis、MongoDB、Android等），而其中有 tty 限制不能直接使用 gdb/cgdb 进行调试，建议使用打印调试数据至日志文件的方式。

当然，也可以通过固定 src/redis-cli.c: line 1445 变量值的方式跳过 linenoise 函数，再使用 gdb/cgdb 进行调试

redis-cli 功能流程

redis-cli 作为最直观的 Redis交互客户端，功能流程主要如下

初始化默认参数配置 config
终端输出判断
参数解析
- config 赋值
- 判断 help 相关参数打印 usage 信息
- 判断 version 相关参数打印 version 信息，版本号是根据 git 版本信息而来的
输出模式判断
- Latency 延迟监控模式 --latency
- Latency 延迟图形监控模式 --latency-dist
- 从库模式 --slave
- RDB 数据转换模式 --rdb
- 管道/批量操作模式 --pipe
- 查找占用大内存的 key 模式 --bigkeys
- 查找热点 key --hotkeys
- 统计模式 --stat
- 扫描执行模式 key --scan / --pattern
- LRU test 模式 --lru-test
- 测试延迟模式 --intrinsic-latency
- LUA 脚本模式 --eval
连接服务端
命令交互
- 命令识别初始化
- linenoise 命令行模式设置、命令提示回调函数、命令补全回调函数、历史命令加载以及命令保存
- 命令行内容读取
- 命令行解析
- 识别特殊命令 quit / exit / restart / connect / clear 处理
- 命令协议格式转换
- 命令执行器，执行指定命令
- 执行时间记录，时间大于 500毫秒则打印出来

redis-cli 参数详情如下，注释比较详细：

/* redis-cli.c: line 1199 */
static void usage(void) {
    sds version = cliVersion();
    fprintf(stderr,
"redis-cli %s\n"
"\n"
"Usage: redis-cli [OPTIONS] [cmd [arg [arg ...]]]\n"
"  -h <hostname>      Server hostname (default: 127.0.0.1).\n"
"  -p <port>          Server port (default: 6379).\n"
"  -s <socket>        Server socket (overrides hostname and port).\n"
"  -a <password>      Password to use when connecting to the server.\n"
"  -u <uri>           Server URI.\n"
// 重复执行
"  -r <repeat>        Execute specified command N times.\n"
// 重复执行间隔 秒
"  -i <interval>      When -r is used, waits <interval> seconds per command.\n"
"                     It is possible to specify sub-second times like -i 0.1.\n"
// 选择数据库
"  -n <db>            Database number.\n"
// 从标准输入（stdin）读取数据作为redis-cli的最后一个参数
// 比如 将字符串world作为set hello的值
// echo "world" | redis-cli -x set hello
"  -x                 Read last argument from STDIN.\n"
// 批量命令分隔符
"  -d <delimiter>     Multi-bulk delimiter in for raw formatting (default: \\n).\n"
// cluster 模式
"  -c                 Enable cluster mode (follow -ASK and -MOVED redirections).\n"
// 返回格式化后的结果
"  --raw              Use raw formatting for replies (default when STDOUT is\n"
"                     not a tty).\n"
// 返回结果原始的格式
"  --no-raw           Force formatted output even when STDOUT is not a tty.\n"
// 按照 csv格式 输出
"  --csv              Output in CSV format.\n"
// 统计模式
"  --stat             Print rolling stats about server: mem, clients, ...\n"
// 延迟监控，测试客户端到目标Redis的网络延迟（执行结果只有一条）
"  --latency          Enter a special mode continuously sampling latency.\n"
"                     If you use this mode in an interactive session it runs\n"
"                     forever displaying real-time stats. Otherwise if --raw or\n"
"                     --csv is specified, or if you redirect the output to a non\n"
"                     TTY, it samples the latency for 1 second (you can use\n"
"                     -i to change the interval), then produces a single output\n"
"                     and exits.\n"
// 分段延迟监控，以分时段的形式了解延迟信息（延时信息每15秒输出一次），可以通过-i参数控制间隔时间
"  --latency-history  Like --latency but tracking latency changes over time.\n"
"                     Default time interval is 15 sec. Change it using -i.\n"
// 图表延迟监控，使用统计图表的形式从控制台输出延迟统计信息
"  --latency-dist     Shows latency as a spectrum, requires xterm 256 colors.\n"
"                     Default time interval is 1 sec. Change it using -i.\n"
// 用于测试Redis置换策略的性能以及分析设置的maxmemory项是否合理，<keys>表示key的分布范围，比如 --lru-test 1000000，表示 100万 key 的执行情况
"  --lru-test <keys>  Simulate a cache workload with an 80-20 distribution.\n"
// 把当前客户端模拟成当前 Redis 节点的从节点，可以用来获取当前 Redis 节点的更新操作
"  --slave            Simulate a slave showing commands received from the master.\n"
// 请求 Redis 实例生成并发送 RDB 持久化文件，保存在本地，可使用它做持久化文件的定期备份
"  --rdb <filename>   Transfer an RDB dump from remote server to local file.\n"
// 将命令封装成 Redis 通信协议定义的数据格式，批量发送给 Redis 执行
"  --pipe             Transfer raw Redis protocol from stdin to server.\n"
// pipe 模式超时时间
"  --pipe-timeout <n> In --pipe mode, abort with error if after sending all data.\n"
"                     no reply is received within <n> seconds.\n"
"                     Default timeout: %d. Use 0 to wait forever.\n"
// 实际使用scan命令对Redis的键进行采样，从中找到内存占用比较大的键值，这些键可能是系统的瓶颈，为了方便用户使用所以添加了 --bigkeys 选项
"  --bigkeys          Sample Redis keys looking for big keys.\n"
// 实际使用scan命令遍历所有key，再通过OBJECT FREQ获取访问频率并排序，即可得到热点key，为了方便用户使用所以添加了 --hotkeys 选项
"  --hotkeys          Sample Redis keys looking for hot keys.\n"
"                     only works when maxmemory-policy is *lfu.\n"
// --scan 和 --pattern 配合使用，用于扫描指定模式的键，相当于使用scan命令
"  --scan             List all keys using the SCAN command.\n"
"  --pattern <pat>    Useful with --scan to specify a SCAN pattern.\n"
// 在server段进行判断一定时间内是否Redis有延迟
"  --intrinsic-latency <sec> Run a test to measure intrinsic system latency.\n"
"                     The test will run for the specified amount of seconds.\n"
// 执行脚本文件
"  --eval <file>      Send an EVAL command using the Lua script at <file>.\n"
// 启用 lua 脚本调试器  异步调试
"  --ldb              Used with --eval enable the Redis Lua debugger.\n"
// 启用 lua 脚本调试器  同步调试，会阻塞
"  --ldb-sync-mode    Like --ldb but uses the synchronous Lua debugger, in\n"
"                     this mode the server is blocked and script changes are\n"
"                     are not rolled back from the server memory.\n"
// 帮助说明
"  --help             Output this help and exit.\n"
"  --version          Output version and exit.\n"
"\n"
"Examples:\n"
"  cat /etc/passwd | redis-cli -x set mypasswd\n"
"  redis-cli get mypasswd\n"
"  redis-cli -r 100 lpush mylist x\n"
"  redis-cli -r 100 -i 1 info | grep used_memory_human:\n"
"  redis-cli --eval myscript.lua key1 key2 , arg1 arg2 arg3\n"
"  redis-cli --scan --pattern '*:12345*'\n"
"\n"
"  (Note: when using --eval the comma separates KEYS[] from ARGV[] items)\n"
"\n"
"When no command is given, redis-cli starts in interactive mode.\n"
"Type \"help\" in interactive mode for information on available commands\n"
"and settings.\n"
"\n",
        version, REDIS_CLI_DEFAULT_PIPE_TIMEOUT);
    sdsfree(version);
    exit(1);
}

RESP 协议

为了保证客户端与服务端 TCP 数据交互的一致性，同时也为了 Redis 的广泛推广，在 1.2 版本中引入了 RESP 协议（ REdis Serialization Protocol ），并最终在 Redis 2.0 版本成为 Redis 服务器通信的标准方式；这一协议的产生，使得各种编程语言可以极为方便的对 Redis 进行数据操作。

RESP 协议在保证 TCP 操作一致性的同时，还具备了 易实现、快速解析、可读性强 等特性，当然协议格式的特殊性中，保证了数据是二进制安全的。

Request

请求协议格式如下，命令本身也是作为参数的，比如 GET、SET 等，作为第一个参数

*[参数数量] CR LF
$[参数 1 长度] CR LF
 [参数 1 数据] CR LF
$[参数 2 长度] CR LF
 [参数 2 数据] CR LF
 ......
$[参数 N 长度] CR LF
 [参数 N 数据] CR LF

比如 SET foo tests，分解转换就是

*3
$3
SET
$3
foo
$5
tests

最终传输内容主体就是

1	*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$5\r\ntests\r\n

Response

响应协议内容一般根据不同数据类型分作多种情况进行返回，一般根据响应内容的第一个字节，确认返回类型：

"+" 为 单行/状态 回复（single line reply / status reply）
"-" 为 错误回复（error reply）
":" 为 整数回复（integer reply）
"$" 为 批量回复（bulk reply）
"*" 为 多条批量回复（multi bulk reply）

单行/状态回复

一般为 + 开头 \r\n 结尾的单行字符串，比如

[wettper@web-lovers redis-src]$ src/redis-cli 
127.0.0.1:6379> SET foo tests
OK
------------
实际返回解析前的内容：
+OK\r\n

错误回复

错误回复的响应内容跟单行比较相像，区别就是第一个字节的标识符为 -

[wettper@web-lovers redis-src]$ src/redis-cli 
[wettper@web-lovers redis-src]$ src/redis-cli 
127.0.0.1:6379> testcomm a b
(error) ERR unknown command `testcomm`, with args beginning with: `a`, `b`, 
------------
实际返回解析前的内容：
-ERR unknown command `testcomm`, with args beginning with: `a`, `b`,\r\n

整数回复

整数回复也比较简单，标识符为 :

[wettper@web-lovers redis-src]$ src/redis-cli 
127.0.0.1:6379> EXISTS foo
(integer) 1
------------
实际返回解析前的内容：
:1\r\n

返回整数结果的命令有这些：SETNX 、 DEL 、 EXISTS 、 INCR 、 INCRBY 、 DECR 、 DECRBY 、 DBSIZE 、 LASTSAVE 、 RENAMENX 、 MOVE 、 LLEN 、 SADD 、 SREM 、 SISMEMBER 、 SCARD 等

批量回复

即为多行字符串回复，字符串的最大长度为 512 MB ，协议模式为：$[字符串长度]\r\n[字符串内容]\r\n，当然我们平时也会碰到客户端提示 nil，这样的协议内容格式为：$-1\r\n

[wettper@web-lovers redis-src]$ src/redis-cli 
127.0.0.1:6379> GET foo
"abcdefghigklmnopqrstuvwxyz0123abcdefghigklmnopqrstuvwxyz0123abcdefghigklmnopqrstuvwxyz0123abcdefghigklmnopqrstuvwxyz0123abcdefghigklmnopqrstuvwxyz0123"
------------
实际返回解析前的内容：
$150\r\nabcdefghigklmnopqrstuvwxyz0123abcdefghigklmnopqrstuvwxyz0123abcdefghigklmnopqrstuvwxyz0123abcdefghigklmnopqrstuvwxyz0123abcdefghigklmnopqrstuvwxyz0123\r\n
127.0.0.1:6379> GET foo2
(nil)
------------
实际返回解析前的内容：
$-1\r\n

多条批量回复

很多类似 LRANGE、SMEMBERS 等的命令都会返回多个值，对应协议为：

返回多个数据（假如返回4个结果）：*[结果个数]\r\n$[结果1长度]\r\n[结果1内容]\r\n$[结果2长度]\r\n[结果2内容]\r\n$[结果3长度]\r\n[结果3内容]\r\n$[结果4长度]\r\n[结果4内容]\r\n
返回空表：*0\r\n

返回 nil（比如 BLPOP 命令）*-1\r\n

[wettper@web-lovers redis-src]$ src/redis-cli
127.0.0.1:6379> LPUSH foo2 a bc def higk lmnop qrstuv wxyz
(integer) 7
------------
实际返回解析前的内容：
:7\r\n
127.0.0.1:6379> LRANGE foo2 0 -1
1) "wxyz"
2) "qrstuv"
3) "lmnop"
4) "higk"
5) "def"
6) "bc"
7) "a"
------------
实际返回解析前的内容：
*7\r\n$4\r\nwxyz\r\n$6\r\nqrstuv\r\n$5\r\nlmnop\r\n$4\r\nhigk\r\n$3\r\ndef\r\n$2\r\nbc\r\n$1\r\na\r\n

源码解析

由于有些方法里的代码量比较大，我们这里按照典型的代码片段进行解析，同志们可以根据文章提示的代码位置和代码里面的关键词在源码中搜素，可能数据结构一些元素看不太懂什么意思，没关系，先混个脸熟，后面看完回头再看过来就明白了

主函数

/* redis-cli.c: line 3709 */
int main(int argc, char **argv) {
    int firstarg;
    // ....省略了一部分代码
    // 输出模式判断，用来响应数据的格式化
    if (!isatty(fileno(stdout)) && (getenv("FAKETTY") == NULL))
        // 非终端，比如 eval
        config.output = OUTPUT_RAW;
    else
        // 终端
        config.output = OUTPUT_STANDARD;
    config.mb_delim = sdsnew("\n");
    
    // 参数解析，包括：
    // 1. config 赋值
    // 2. 判断 help 相关参数打印 usage 信息
    // 3. 判断 version 相关参数打印 version 信息，版本号 是根据 git 版本信息 而来的
    firstarg = parseOptions(argc,argv);
    argc -= firstarg;
    argv += firstarg;
    /* Latency mode */
    // Latency 延迟监控模式
    if (config.latency_mode) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        latencyMode();
    }
    /* Latency distribution mode */
    // Latency 延迟图形监控模式
    if (config.latency_dist_mode) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        latencyDistMode();
    }
    /* Slave mode */
    // 从库模式
    if (config.slave_mode) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        slaveMode();
    }
    /* Get RDB mode. */
    // RDB 数据转换模式
    if (config.getrdb_mode) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        getRDB();
    }
    /* Pipe mode */
    // 管道/批量操作模式
    if (config.pipe_mode) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        pipeMode();
    }
    /* Find big keys */
    // 查找占用大内存的 key 模式
    if (config.bigkeys) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        findBigKeys();
    }
    /* Find hot keys */
    // 查找热点 key
    if (config.hotkeys) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        findHotKeys();
    }
    /* Stat mode */
    // 统计模式
    if (config.stat_mode) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        if (config.interval == 0) config.interval = 1000000;
        statMode();
    }
    /* Scan mode */
    // 扫描执行模式 key
    if (config.scan_mode) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        scanMode();
    }
    /* LRU test mode */
    // LRU test 模式
    if (config.lru_test_mode) {
        if (cliConnect(0) == REDIS_ERR) exit(1);
        LRUTestMode();
    }
    /* Intrinsic latency mode */
    if (config.intrinsic_latency_mode) intrinsicLatencyMode();
    /* Start interactive mode when no command is provided */
    // 普通交互模式
    if (argc == 0 && !config.eval) {
        /* Ignore SIGPIPE in interactive mode to force a reconnect */
        signal(SIGPIPE, SIG_IGN);
        /* Note that in repl mode we don't abort on connection error.
         * A new attempt will be performed for every command send. */
        // 连接 redis 服务端
        cliConnect(0);
        // 操作交互的具体逻辑
        repl();
    }
    /* Otherwise, we have some arguments to execute */
    if (cliConnect(0) != REDIS_OK) exit(1);
    // eval 脚本模式
    if (config.eval) {
        return evalMode(argc,argv);
    } else {
        return noninteractive(argc,convertToSds(argc,argv));
    }
}

普通操作交互模式主逻辑函数 repl()

/* redis-cli.c: line 1374 */
static void repl(void) {
    sds historyfile = NULL;
    int history = 0;
    char *line;
    int argc;
    sds *argv;
    /* Initialize the help and, if possible, use the COMMAND command in order
     * to retrieve missing entries. */
    // 命令提示信息初始化
    cliInitHelp();
    // 命令提示信息设置
    cliIntegrateHelp();
    config.interactive = 1;
    // 设置多行模式
    linenoiseSetMultiLine(1);
    // 设置信息自动补全回调函数，tab 效果
    linenoiseSetCompletionCallback(completionCallback);
    // 设置命令提示内容以及显示样式 回调函数
    linenoiseSetHintsCallback(hintsCallback);
    // 设置 提示内容清理 回调函数
    linenoiseSetFreeHintsCallback(freeHintsCallback);
    /* Only use history and load the rc file when stdin is a tty. */
    // tty 模式下，保留命令 到 历史命令文件中
    if (isatty(fileno(stdin))) {
        // 设置 历史命令文件
        historyfile = getDotfilePath(REDIS_CLI_HISTFILE_ENV,REDIS_CLI_HISTFILE_DEFAULT);
        //keep in-memory history always regardless if history file can be determined
        history = 1;
        if (historyfile != NULL) {
            // 加载 历史命令文件内容
            linenoiseHistoryLoad(historyfile);
        }
        cliLoadPreferences();
    }
    // 初始化前缀比如：127.0.0.1:6379> 
    cliRefreshPrompt();
    // 读取命令
    while((line = linenoise(context ? config.prompt : "not connected> ")) != NULL) {
        if (line[0] != '\0') {
            long repeat = 1;
            int skipargs = 0;
            char *endptr = NULL;
            // 命令解析，并按将参数分别存入 argc 中
            argv = cliSplitArgs(line,&argc);
            /* check if we have a repeat command option and
             * need to skip the first arg */
            // 初始 参数重复 变量，并且跳过 第一个 命令参数
            if (argv && argc > 0) {
                errno = 0;
                repeat = strtol(argv[0], &endptr, 10);
                if (argc > 1 && *endptr == '\0') {
                    if (errno == ERANGE || errno == EINVAL || repeat <= 0) {
                        fputs("Invalid redis-cli repeat command option value.\n", stdout);
                        sdsfreesplitres(argv, argc);
                        linenoiseFree(line);
                        continue;
                    }
                    skipargs = 1;
                } else {
                    repeat = 1;
                }
            }
            /* Won't save auth command in history file */
            if (!(argv && argc > 0 && !strcasecmp(argv[0+skipargs], "auth"))) {
                // 添加到 历史命令文件中
                if (history) linenoiseHistoryAdd(line);
                if (historyfile) linenoiseHistorySave(historyfile);
            }
            if (argv == NULL) {
                printf("Invalid argument(s)\n");
                linenoiseFree(line);
                continue;
            } else if (argc > 0) {
                // 退出命令
                if (strcasecmp(argv[0],"quit") == 0 ||
                    strcasecmp(argv[0],"exit") == 0)
                {
                    exit(0);
                } else if (argv[0][0] == ':') {
                    // 识别 : 开头命令，现在一般是提示信息设置命令 :set hints 或者 :set nohints
                    cliSetPreferences(argv,argc,1);
                    sdsfreesplitres(argv,argc);
                    linenoiseFree(line);
                    continue;
                } else if (strcasecmp(argv[0],"restart") == 0) {
                    // 重启，不过一般是有 lua 脚本执行
                    if (config.eval) {
                        config.eval_ldb = 1;
                        config.output = OUTPUT_RAW;
                        return; /* Return to evalMode to restart the session. */
                    } else {
                        printf("Use 'restart' only in Lua debugging mode.");
                    }
                } else if (argc == 3 && !strcasecmp(argv[0],"connect")) {
                    // 设置 ip port 重新连接
                    sdsfree(config.hostip);
                    config.hostip = sdsnew(argv[1]);
                    config.hostport = atoi(argv[2]);
                    cliRefreshPrompt();
                    cliConnect(1);
                } else if (argc == 1 && !strcasecmp(argv[0],"clear")) {
                    // 清屏
                    linenoiseClearScreen();
                } else {
                    // 执行逻辑主体
                    // 开始时间，后续用来计算执行时间
                    long long start_time = mstime(), elapsed;
                    // 处理命令请求
                    issueCommandRepeat(argc-skipargs, argv+skipargs, repeat);
                    /* If our debugging session ended, show the EVAL final
                     * reply. */
                    // eval 调试执行完毕
                    if (config.eval_ldb_end) {
                        config.eval_ldb_end = 0;
                        cliReadReply(0);
                        printf("\n(Lua debugging session ended%s)\n\n",
                            config.eval_ldb_sync ? "" :
                            " -- dataset changes rolled back");
                    }
                    // 计算执行时间，如果执行时间操作 500ms，则输出提示
                    elapsed = mstime()-start_time;
                    if (elapsed >= 500 &&
                        config.output == OUTPUT_STANDARD)
                    {
                        printf("(%.2fs)\n",(double)elapsed/1000);
                    }
                }
            }
            /* Free the argument vector */
            sdsfreesplitres(argv,argc);
        }
        /* linenoise() returns malloc-ed lines like readline() */
        linenoiseFree(line);
    }
    exit(0);
}

命令执行函数 issueCommandRepeat()，其中重要的是发送命令函数 cliSendCommand()

/* redis-cli.c: line 925 */
static int cliSendCommand(int argc, char **argv, long repeat) {
    char *command = argv[0];
    size_t *argvlen;
    int j, output_raw;
    // debugging 模式下 跳过 help
    if (!config.eval_ldb && /* In debugging mode, let's pass "help" to Redis. */
        (!strcasecmp(command,"help") || !strcasecmp(command,"?"))) {
        cliOutputHelp(--argc, ++argv);
        return REDIS_OK;
    }
    if (context == NULL) return REDIS_ERR;
    output_raw = 0;
    // 设置指定命令执行 多行输出
    if (!strcasecmp(command,"info") ||
        (argc >= 2 && !strcasecmp(command,"debug") &&
                       !strcasecmp(argv[1],"htstats")) ||
        (argc >= 2 && !strcasecmp(command,"memory") &&
                      (!strcasecmp(argv[1],"malloc-stats") ||
                       !strcasecmp(argv[1],"doctor"))) ||
        (argc == 2 && !strcasecmp(command,"cluster") &&
                      (!strcasecmp(argv[1],"nodes") ||
                       !strcasecmp(argv[1],"info"))) ||
        (argc == 2 && !strcasecmp(command,"client") &&
                       !strcasecmp(argv[1],"list")) ||
        (argc == 3 && !strcasecmp(command,"latency") &&
                       !strcasecmp(argv[1],"graph")) ||
        (argc == 2 && !strcasecmp(command,"latency") &&
                       !strcasecmp(argv[1],"doctor")))
    {
        output_raw = 1;
    }
    // 根据命令设置不同模式
    if (!strcasecmp(command,"shutdown")) config.shutdown = 1;
    if (!strcasecmp(command,"monitor")) config.monitor_mode = 1;
    if (!strcasecmp(command,"subscribe") ||
        !strcasecmp(command,"psubscribe")) config.pubsub_mode = 1;
    if (!strcasecmp(command,"sync") ||
        !strcasecmp(command,"psync")) config.slave_mode = 1;
    /* When the user manually calls SCRIPT DEBUG, setup the activation of
     * debugging mode on the next eval if needed. */
    // 脚本执行模式
    if (argc == 3 && !strcasecmp(argv[0],"script") &&
                     !strcasecmp(argv[1],"debug"))
    {
        if (!strcasecmp(argv[2],"yes") || !strcasecmp(argv[2],"sync")) {
            config.enable_ldb_on_eval = 1;
        } else {
            config.enable_ldb_on_eval = 0;
        }
    }
    /* Actually activate LDB on EVAL if needed. */
    if (!strcasecmp(command,"eval") && config.enable_ldb_on_eval) {
        config.eval_ldb = 1;
        config.output = OUTPUT_RAW;
    }
    /* Setup argument length */
    // 获取每个参数的长度，以便按照协议内容组装
    argvlen = zmalloc(argc*sizeof(size_t));
    for (j = 0; j < argc; j++)
        argvlen[j] = sdslen(argv[j]);
    while(repeat-- > 0) {
        // 组装请求协议，将请求协议内容放入 context->obuf 里，比如 *3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$5\r\ntests\r\n
        redisAppendCommandArgv(context,argc,(const char**)argv,argvlen);
        // 监控模式下的发送请求，cliReadReply 为发送请求并获取响应的函数
        while (config.monitor_mode) {
            if (cliReadReply(output_raw) != REDIS_OK) exit(1);
            fflush(stdout);
        }
        // 订阅模式， while 持续读取请求响应
        if (config.pubsub_mode) {
            if (config.output != OUTPUT_RAW)
                printf("Reading messages... (press Ctrl-C to quit)\n");
            while (1) {
                if (cliReadReply(output_raw) != REDIS_OK) exit(1);
            }
        }
        // 从库模式，同步数据
        if (config.slave_mode) {
            printf("Entering slave output mode...  (press Ctrl-C to quit)\n");
            slaveMode();
            config.slave_mode = 0;
            zfree(argvlen);
            return REDIS_ERR;  /* Error = slaveMode lost connection to master */
        }
        // 普通情况下的，发送请求并获取响应内容
        if (cliReadReply(output_raw) != REDIS_OK) {
            zfree(argvlen);
            return REDIS_ERR;
        } else {
            /* Store database number when SELECT was successfully executed. */
            // 假设 是 select dbnum 命令，则存储 dbnum，并将 命令提示前缀更新，加上 dbnum 信息。如果是 auth 命令，则成功后直接执行以下 select dbnum
            if (!strcasecmp(command,"select") && argc == 2 && config.last_cmd_type != REDIS_REPLY_ERROR) {
                config.dbnum = atoi(argv[1]);
                cliRefreshPrompt();
            } else if (!strcasecmp(command,"auth") && argc == 2) {
                cliSelect();
            }
        }
        if (config.interval) usleep(config.interval);
        fflush(stdout); /* Make it grep friendly */
    }
    zfree(argvlen);
    return REDIS_OK;
}

按照协议格式发送内容给服务端，并获取响应，cliReadReply()

/* redis-cli.c: line 845 */
static int cliReadReply(int output_raw_strings) {
    void *_reply;
    redisReply *reply;
    sds out = NULL;
    int output = 1;
    // 发送请求，逻辑比较简单
    // 1. 初始化响应数据结构
    // 2. 连接句柄中写入 请求协议
    // 3. 读取服务端响应（包装好的协议内容）
    // 4. 将响应的协议内容解析，存入 reply 响应数据结构
    if (redisGetReply(context,&_reply) != REDIS_OK) {
        if (config.shutdown) {
            redisFree(context);
            context = NULL;
            return REDIS_OK;
        }
        if (config.interactive) {
            /* Filter cases where we should reconnect */
            if (context->err == REDIS_ERR_IO &&
                (errno == ECONNRESET || errno == EPIPE))
                return REDIS_ERR;
            if (context->err == REDIS_ERR_EOF)
                return REDIS_ERR;
        }
        cliPrintContextError();
        exit(1);
        return REDIS_ERR; /* avoid compiler warning */
    }
    // 响应数据结构
    reply = (redisReply*)_reply;
    config.last_cmd_type = reply->type;
    /* Check if we need to connect to a different node and reissue the
     * request. */
    // 集群模式
    if (config.cluster_mode && reply->type == REDIS_REPLY_ERROR &&
        (!strncmp(reply->str,"MOVED",5) || !strcmp(reply->str,"ASK")))
    {
        // 集群存在 数据在其他slot 的情况，这里会提示数据存于目的服务器的 host:port，从而修改后续请求的地址变量 以及 命令提示前缀
        char *p = reply->str, *s;
        int slot;
        output = 0;
        /* Comments show the position of the pointer as:
         *
         * [S] for pointer 's'
         * [P] for pointer 'p'
         */
        s = strchr(p,' ');      /* MOVED[S]3999 127.0.0.1:6381 */
        p = strchr(s+1,' ');    /* MOVED[S]3999[P]127.0.0.1:6381 */
        *p = '\0';
        slot = atoi(s+1);
        s = strrchr(p+1,':');    /* MOVED 3999[P]127.0.0.1[S]6381 */
        *s = '\0';
        sdsfree(config.hostip);
        config.hostip = sdsnew(p+1);
        config.hostport = atoi(s+1);
        if (config.interactive)
            printf("-> Redirected to slot [%d] located at %s:%d\n",
                slot, config.hostip, config.hostport);
        config.cluster_reissue_command = 1;
        cliRefreshPrompt();
    }
    // 不同的输出模式，会对应不同的数据格式化方法，便于数据输出的接收
    if (output) {
        if (output_raw_strings) {
            out = cliFormatReplyRaw(reply);
        } else {
            if (config.output == OUTPUT_RAW) {
                out = cliFormatReplyRaw(reply);
                out = sdscat(out,"\n");
            } else if (config.output == OUTPUT_STANDARD) {
                out = cliFormatReplyTTY(reply,"");
            } else if (config.output == OUTPUT_CSV) {
                out = cliFormatReplyCSV(reply);
                out = sdscat(out,"\n");
            }
        }
        fwrite(out,sdslen(out),1,stdout);
        sdsfree(out);
    }
    freeReplyObject(reply);
    return REDIS_OK;
}

本文作者： wettper
本文链接： http://www.web-lovers.com/redis-source-cli.html
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 3.0 许可协议。转载请注明出处！