客户端
原本以为这一章是针对客户端程序的一个编写,带着这种思维去阅读,然后发现其实是指代在 redisServer 中的客户端对象,也就是客户端在服务器上的一个实体映射.具体结构如下
typedef struct redisClient {
// 套接字描述符
int fd;
// 当前正在使用的数据库
redisDb *db;
// 当前正在使用的数据库的 id （号码）
int dictid;
// 客户端的名字
robj *name; /* As set by CLIENT SETNAME */
// 查询缓冲区
sds querybuf;
// 查询缓冲区长度峰值
size_t querybuf_peak; /* Recent (100ms or more) peak of querybuf size */
// 参数数量
int argc;
// 参数对象数组
robj **argv;
// 记录被客户端执行的命令
struct redisCommand *cmd, *lastcmd;
// 请求的类型：内联命令还是多条命令
int reqtype;
// 剩余未读取的命令内容数量
int multibulklen; /* number of multi bulk arguments left to read */
// 命令内容的长度
long bulklen; /* length of bulk argument in multi bulk request */
// 回复链表
list *reply;
// 回复链表中对象的总大小
unsigned long reply_bytes; /* Tot bytes of objects in reply list */
// 已发送字节，处理 short write 用
int sentlen; /* Amount of bytes already sent in the current
buffer or object being sent. */
// 创建客户端的时间
time_t ctime; /* Client creation time */
// 客户端最后一次和服务器互动的时间
time_t lastinteraction; /* time of the last interaction, used for timeout */
// 客户端的输出缓冲区超过软性限制的时间
time_t obuf_soft_limit_reached_time;
// 客户端状态标志
int flags; /* REDIS_SLAVE | REDIS_MONITOR | REDIS_MULTI ... */
// 当 server.requirepass 不为 NULL 时
// 代表认证的状态
// 0 代表未认证， 1 代表已认证
int authenticated; /* when requirepass is non-NULL */
// 复制状态
int replstate; /* replication state if this is a slave */
// 用于保存主服务器传来的 RDB 文件的文件描述符
int repldbfd; /* replication DB file descriptor */
// 读取主服务器传来的 RDB 文件的偏移量
off_t repldboff; /* replication DB file offset */
// 主服务器传来的 RDB 文件的大小
off_t repldbsize; /* replication DB file size */
sds replpreamble; /* replication DB preamble. */
// 主服务器的复制偏移量
long long reploff; /* replication offset if this is our master */
// 从服务器最后一次发送 REPLCONF ACK 时的偏移量
long long repl_ack_off; /* replication ack offset, if this is a slave */
// 从服务器最后一次发送 REPLCONF ACK 的时间
long long repl_ack_time;/* replication ack time, if this is a slave */
// 主服务器的 master run ID
// 保存在客户端，用于执行部分重同步
char replrunid[REDIS_RUN_ID_SIZE+1]; /* master run id if this is a master */
// 从服务器的监听端口号
int slave_listening_port; /* As configured with: SLAVECONF listening-port */
// 事务状态
multiState mstate; /* MULTI/EXEC state */
// 阻塞类型
int btype; /* Type of blocking op if REDIS_BLOCKED. */
// 阻塞状态
blockingState bpop; /* blocking state */
// 最后被写入的全局复制偏移量
long long woff; /* Last write global replication offset. */
// 被监视的键
list *watched_keys; /* Keys WATCHED for MULTI/EXEC CAS */
// 这个字典记录了客户端所有订阅的频道
// 键为频道名字，值为 NULL
// 也即是，一个频道的集合
dict *pubsub_channels; /* channels a client is interested in (SUBSCRIBE) */
// 链表，包含多个 pubsubPattern 结构
// 记录了所有订阅频道的客户端的信息
// 新 pubsubPattern 结构总是被添加到表尾
list *pubsub_patterns; /* patterns a client is interested in (SUBSCRIBE) */
sds peerid; /* Cached peer ID. */
/* Response buffer */
// 回复偏移量
int bufpos;
// 回复缓冲区
char buf[REDIS_REPLY_CHUNK_BYTES];
} redisClient;当客户端连入后,会以链表的形式挂载在 redisServer 下面.
// 一个链表，保存了所有客户端状态结构
list *clients; /* List of active clients */后续内容就是围绕客户端结构进行一个客户端的介绍,以及所起的作用
13.1 客户端属性
属性分为两类,一种是基本全通用的属性,一种是专属功能的属性.后续会进行详细介绍
13.1.1 套接字描述符
int fd每一个连接都对应这一个描述符,也对应这一个客户端对象.
fd属性的值可以是-1也可以是大于-1的整数:
-1表示伪客户端,比如前面提到的 AOF 文件的加载,就是用伪客户端进行命令的遍历发送
普通客户端的fd属性用于记录套接字的描述符,可以理解为客户端和服务器沟通的一个句柄,用于两者的连接.
13.1.2 名字
// 客户端的名字
robj *name; /* As set by CLIENT SETNAME */正常情况下,客户端是没有名字的,但是我们可以自己制定一个名字,用于更清晰的区分
CLIENT name可以进行当前客户端的命名行为
13.1.3 标志
int flagsflags 记录了客户端的角色,以及客户端当前的一个状态
/* Client flags */
#define REDIS_SLAVE (1<<0) /* This client is a slave server */
#define REDIS_MASTER (1<<1) /* This client is a master server */
#define REDIS_MONITOR (1<<2) /* This client is a slave monitor, see MONITOR */
#define REDIS_MULTI (1<<3) /* This client is in a MULTI context */
#define REDIS_BLOCKED (1<<4) /* The client is waiting in a blocking operation */
#define REDIS_DIRTY_CAS (1<<5) /* Watched keys modified. EXEC will fail. */
#define REDIS_CLOSE_AFTER_REPLY (1<<6) /* Close after writing entire reply. */
#define REDIS_UNBLOCKED (1<<7) /* This client was unblocked and is stored in
server.unblocked_clients */
#define REDIS_LUA_CLIENT (1<<8) /* This is a non connected client used by Lua */
#define REDIS_ASKING (1<<9) /* Client issued the ASKING command */
#define REDIS_CLOSE_ASAP (1<<10)/* Close this client ASAP */
#define REDIS_UNIX_SOCKET (1<<11) /* Client connected via Unix domain socket */
#define REDIS_DIRTY_EXEC (1<<12) /* EXEC will fail for errors while queueing */
#define REDIS_MASTER_FORCE_REPLY (1<<13) /* Queue replies even if is master */
#define REDIS_FORCE_AOF (1<<14) /* Force AOF propagation of current cmd. */
#define REDIS_FORCE_REPL (1<<15) /* Force replication of current cmd. */
#define REDIS_PRE_PSYNC (1<<16) /* Instance don't understand PSYNC. */
#define REDIS_READONLY (1<<17) /* Cluster client is in read-only state. */可以看到,标志就是用 bitarr 来进行标记的确认,这种的确好用
标记 | 状态或角色 |
REDIS_SLAVE (1<<0) | 该客户端是从服务器 |
REDIS_MASTER (1<<1) | 该客户端是主服务器 |
REDIS_MONITOR (1<<2) | 该客户端正在执行 MONITOR (监视)命令 |
REDIS_MULTI (1<<3) | 该客户端正在执行事务 |
REDIS_BLOCKED (1<<4) | 该客户端正在被 BRPOP,BLPOP 等命令阻塞 |
REDIS_DIRTY_CAS (1<<5) | 该客户端使用事务而监视的 WATCH 键已经被破坏 |
REDIS_CLOSE_AFTER_REPLY (1<<6) | 该客户端将在回复之后进行一个自身的销毁 |
REDIS_UNBLOCKED (1<<7) | 该客户端已经从阻塞状态中脱离 |
REDIS_LUA_CLIENT (1<<8) | 该客户端是一个 LUA 运行的伪客户端 |
REDIS_ASKING (1<<9) | 该客户端向集群发送了 ASKING 命令 |
REDIS_CLOSE_ASAP (1<<10) | 表示该客户端的输出缓冲区超过了服务器允许范围,将在下一次循环进行一个关闭,也不返回任何信息给客户端 |
REDIS_UNIX_SOCKET (1<<11) | 表示服务器通过 UNI 套接字来客户端 |
REDIS_DIRTY_EXEC (1<<12) | 表示事务在执行命令入队发生了错误 |
REDIS_MASTER_FORCE_REPLY (1<<13) | 从服务器需要发送 REPLICATION ACK 至主服务器,在这之前需要打开该标记 |
REDIS_FORCE_AOF (1<<14) | 表示服务器将该客户端的命令强行写入 AOF 文件 |
REDIS_FORCE_REPL (1<<15) | 表示服务器将该客户端的命令强行传播给其他从服务器 |
REDIS_PRE_PSYNC (1<<16) | 表示客户端版本低于 Redis2.8 的从服务器,主服务器不能用 PSYNC 进行同步 |
REDIS_READONLY (1<<17) | 该客户端只允许进行查询操作 |
因为是 bitarr ,理论上通过 |= 可以任意的组合,但是实际上的表现还要查询相关代码的实现
13.1.4 输入缓冲区
sds querybuf;当客户端向服务器发送了一个命令,命令并不会马上进行一个解析,而是会暂时存储在 querybuf 中.
需要注意的是 querybuf 虽然是动态字符串,但是其大小并不是无限的,当超过 1GB 时,会进行客户端的一个关闭,
13.1.5 命令与命令参数
当命令被载入到 querybuf 后会解析到
robj **argv;
int argc;如
SET key valargv的值为 “SET” “key” “val”
argc为3,"SET"也被记录在内
13.1.6 命令的实现函数
当解析完成后, 服务器将通过 argv[0] 到 命令表中进行命令实现函数的查找,当找到对应的 redisCommand 结构时,将修改客户端状态的 cmd 指针变量的一个指向,这样服务器就可以用 cmd 属性指向的 redisCommand 结构,以及 argv,argc 属性中命令参数信息,调用命令实现函数,执行客户端指定的命令.
/* Our command table.
*
* 命令表
*
* Every entry is composed of the following fields:
*
* 表中的每个项都由以下域组成：
*
* name: a string representing the command name.
* 命令的名字
*
* function: pointer to the C function implementing the command.
* 一个指向命令的实现函数的指针
*
* arity: number of arguments, it is possible to use -N to say >= N
* 参数的数量。可以用 -N 表示 >= N
*
* sflags: command flags as string. See below for a table of flags.
* 字符串形式的 FLAG ，用来计算以下的真实 FLAG
*
* flags: flags as bitmask. Computed by Redis using the 'sflags' field.
* 位掩码形式的 FLAG ，根据 sflags 的字符串计算得出
*
* get_keys_proc: an optional function to get key arguments from a command.
* This is only used when the following three fields are not
* enough to specify what arguments are keys.
* 一个可选的函数，用于从命令中取出 key 参数，仅在以下三个参数都不足以表示 key 参数时使用
*
* first_key_index: first argument that is a key
* 第一个 key 参数的位置
*
* last_key_index: last argument that is a key
* 最后一个 key 参数的位置
*
* key_step: step to get all the keys from first to last argument. For instance
* in MSET the step is two since arguments are key,val,key,val,...
* 从 first 参数和 last 参数之间，所有 key 的步数（step）
* 比如说， MSET 命令的格式为 MSET key value [key value ...]
* 它的 step 就为 2
*
* microseconds: microseconds of total execution time for this command.
* 执行这个命令耗费的总微秒数
*
* calls: total number of calls of this command.
* 命令被执行的总次数
*
* The flags, microseconds and calls fields are computed by Redis and should
* always be set to zero.
*
* microseconds 和 call 由 Redis 计算，总是初始化为 0 。
*
* Command flags are expressed using strings where every character represents
* a flag. Later the populateCommandTable() function will take care of
* populating the real 'flags' field using this characters.
*
* 命令的 FLAG 首先由 SFLAG 域设置，之后 populateCommandTable() 函数从 sflags 属性中计算出真正的 FLAG 到 flags 属性中。
*
* This is the meaning of the flags:
*
* 以下是各个 FLAG 的意义：
*
* w: write command (may modify the key space).
* 写入命令，可能会修改 key space
*
* r: read command (will never modify the key space).
* 读命令，不修改 key space
* m: may increase memory usage once called. Don't allow if out of memory.
* 可能会占用大量内存的命令，调用时对内存占用进行检查
*
* a: admin command, like SAVE or SHUTDOWN.
* 管理用途的命令，比如 SAVE 和 SHUTDOWN
*
* p: Pub/Sub related command.
* 发布/订阅相关的命令
*
* f: force replication of this command, regardless of server.dirty.
* 无视 server.dirty ，强制复制这个命令。
*
* s: command not allowed in scripts.
* 不允许在脚本中使用的命令
*
* R: random command. Command is not deterministic, that is, the same command
* with the same arguments, with the same key space, may have different
* results. For instance SPOP and RANDOMKEY are two random commands.
* 随机命令。
* 命令是非确定性的：对于同样的命令，同样的参数，同样的键，结果可能不同。
* 比如 SPOP 和 RANDOMKEY 就是这样的例子。
*
* S: Sort command output array if called from script, so that the output
* is deterministic.
* 如果命令在 Lua 脚本中执行，那么对输出进行排序，从而得出确定性的输出。
*
* l: Allow command while loading the database.
* 允许在载入数据库时使用的命令。
*
* t: Allow command while a slave has stale data but is not allowed to
* server this data. Normally no command is accepted in this condition
* but just a few.
* 允许在附属节点带有过期数据时执行的命令。
* 这类命令很少有，只有几个。
*
* M: Do not automatically propagate the command on MONITOR.
* 不要在 MONITOR 模式下自动广播的命令。
*
* k: Perform an implicit ASKING for this command, so the command will be
* accepted in cluster mode if the slot is marked as 'importing'.
* 为这个命令执行一个显式的 ASKING ，
* 使得在集群模式下，一个被标示为 importing 的槽可以接收这命令。
*/
struct redisCommand redisCommandTable[] = {
{"get",getCommand,2,"r",0,NULL,1,1,1,0,0},
{"set",setCommand,-3,"wm",0,NULL,1,1,1,0,0},
{"setnx",setnxCommand,3,"wm",0,NULL,1,1,1,0,0},
{"setex",setexCommand,4,"wm",0,NULL,1,1,1,0,0},
{"psetex",psetexCommand,4,"wm",0,NULL,1,1,1,0,0},
{"append",appendCommand,3,"wm",0,NULL,1,1,1,0,0},
{"strlen",strlenCommand,2,"r",0,NULL,1,1,1,0,0},
{"del",delCommand,-2,"w",0,NULL,1,-1,1,0,0},
{"exists",existsCommand,2,"r",0,NULL,1,1,1,0,0},
{"setbit",setbitCommand,4,"wm",0,NULL,1,1,1,0,0},
{"getbit",getbitCommand,3,"r",0,NULL,1,1,1,0,0},
{"setrange",setrangeCommand,4,"wm",0,NULL,1,1,1,0,0},
{"getrange",getrangeCommand,4,"r",0,NULL,1,1,1,0,0},
{"substr",getrangeCommand,4,"r",0,NULL,1,1,1,0,0},
{"incr",incrCommand,2,"wm",0,NULL,1,1,1,0,0},
{"decr",decrCommand,2,"wm",0,NULL,1,1,1,0,0},
{"mget",mgetCommand,-2,"r",0,NULL,1,-1,1,0,0},
{"rpush",rpushCommand,-3,"wm",0,NULL,1,1,1,0,0},
{"lpush",lpushCommand,-3,"wm",0,NULL,1,1,1,0,0},
{"rpushx",rpushxCommand,3,"wm",0,NULL,1,1,1,0,0},
{"lpushx",lpushxCommand,3,"wm",0,NULL,1,1,1,0,0},
{"linsert",linsertCommand,5,"wm",0,NULL,1,1,1,0,0},
{"rpop",rpopCommand,2,"w",0,NULL,1,1,1,0,0},
{"lpop",lpopCommand,2,"w",0,NULL,1,1,1,0,0},
{"brpop",brpopCommand,-3,"ws",0,NULL,1,1,1,0,0},
{"brpoplpush",brpoplpushCommand,4,"wms",0,NULL,1,2,1,0,0},
{"blpop",blpopCommand,-3,"ws",0,NULL,1,-2,1,0,0},
{"llen",llenCommand,2,"r",0,NULL,1,1,1,0,0},
{"lindex",lindexCommand,3,"r",0,NULL,1,1,1,0,0},
{"lset",lsetCommand,4,"wm",0,NULL,1,1,1,0,0},
{"lrange",lrangeCommand,4,"r",0,NULL,1,1,1,0,0},
{"ltrim",ltrimCommand,4,"w",0,NULL,1,1,1,0,0},
{"lrem",lremCommand,4,"w",0,NULL,1,1,1,0,0},
{"rpoplpush",rpoplpushCommand,3,"wm",0,NULL,1,2,1,0,0},
{"sadd",saddCommand,-3,"wm",0,NULL,1,1,1,0,0},
{"srem",sremCommand,-3,"w",0,NULL,1,1,1,0,0},
{"smove",smoveCommand,4,"w",0,NULL,1,2,1,0,0},
{"sismember",sismemberCommand,3,"r",0,NULL,1,1,1,0,0},
{"scard",scardCommand,2,"r",0,NULL,1,1,1,0,0},
{"spop",spopCommand,2,"wRs",0,NULL,1,1,1,0,0},
{"srandmember",srandmemberCommand,-2,"rR",0,NULL,1,1,1,0,0},
{"sinter",sinterCommand,-2,"rS",0,NULL,1,-1,1,0,0},
{"sinterstore",sinterstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
{"sunion",sunionCommand,-2,"rS",0,NULL,1,-1,1,0,0},
{"sunionstore",sunionstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
{"sdiff",sdiffCommand,-2,"rS",0,NULL,1,-1,1,0,0},
{"sdiffstore",sdiffstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
{"smembers",sinterCommand,2,"rS",0,NULL,1,1,1,0,0},
{"sscan",sscanCommand,-3,"rR",0,NULL,1,1,1,0,0},
{"zadd",zaddCommand,-4,"wm",0,NULL,1,1,1,0,0},
{"zincrby",zincrbyCommand,4,"wm",0,NULL,1,1,1,0,0},
{"zrem",zremCommand,-3,"w",0,NULL,1,1,1,0,0},
{"zremrangebyscore",zremrangebyscoreCommand,4,"w",0,NULL,1,1,1,0,0},
{"zremrangebyrank",zremrangebyrankCommand,4,"w",0,NULL,1,1,1,0,0},
{"zremrangebylex",zremrangebylexCommand,4,"w",0,NULL,1,1,1,0,0},
{"zunionstore",zunionstoreCommand,-4,"wm",0,zunionInterGetKeys,0,0,0,0,0},
{"zinterstore",zinterstoreCommand,-4,"wm",0,zunionInterGetKeys,0,0,0,0,0},
{"zrange",zrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
{"zrangebyscore",zrangebyscoreCommand,-4,"r",0,NULL,1,1,1,0,0},
{"zrevrangebyscore",zrevrangebyscoreCommand,-4,"r",0,NULL,1,1,1,0,0},
{"zrangebylex",zrangebylexCommand,-4,"r",0,NULL,1,1,1,0,0},
{"zrevrangebylex",zrevrangebylexCommand,-4,"r",0,NULL,1,1,1,0,0},
{"zcount",zcountCommand,4,"r",0,NULL,1,1,1,0,0},
{"zlexcount",zlexcountCommand,4,"r",0,NULL,1,1,1,0,0},
{"zrevrange",zrevrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
{"zcard",zcardCommand,2,"r",0,NULL,1,1,1,0,0},
{"zscore",zscoreCommand,3,"r",0,NULL,1,1,1,0,0},
{"zrank",zrankCommand,3,"r",0,NULL,1,1,1,0,0},
{"zrevrank",zrevrankCommand,3,"r",0,NULL,1,1,1,0,0},
{"zscan",zscanCommand,-3,"rR",0,NULL,1,1,1,0,0},
{"hset",hsetCommand,4,"wm",0,NULL,1,1,1,0,0},
{"hsetnx",hsetnxCommand,4,"wm",0,NULL,1,1,1,0,0},
{"hget",hgetCommand,3,"r",0,NULL,1,1,1,0,0},
{"hmset",hmsetCommand,-4,"wm",0,NULL,1,1,1,0,0},
{"hmget",hmgetCommand,-3,"r",0,NULL,1,1,1,0,0},
{"hincrby",hincrbyCommand,4,"wm",0,NULL,1,1,1,0,0},
{"hincrbyfloat",hincrbyfloatCommand,4,"wm",0,NULL,1,1,1,0,0},
{"hdel",hdelCommand,-3,"w",0,NULL,1,1,1,0,0},
{"hlen",hlenCommand,2,"r",0,NULL,1,1,1,0,0},
{"hkeys",hkeysCommand,2,"rS",0,NULL,1,1,1,0,0},
{"hvals",hvalsCommand,2,"rS",0,NULL,1,1,1,0,0},
{"hgetall",hgetallCommand,2,"r",0,NULL,1,1,1,0,0},
{"hexists",hexistsCommand,3,"r",0,NULL,1,1,1,0,0},
{"hscan",hscanCommand,-3,"rR",0,NULL,1,1,1,0,0},
{"incrby",incrbyCommand,3,"wm",0,NULL,1,1,1,0,0},
{"decrby",decrbyCommand,3,"wm",0,NULL,1,1,1,0,0},
{"incrbyfloat",incrbyfloatCommand,3,"wm",0,NULL,1,1,1,0,0},
{"getset",getsetCommand,3,"wm",0,NULL,1,1,1,0,0},
{"mset",msetCommand,-3,"wm",0,NULL,1,-1,2,0,0},
{"msetnx",msetnxCommand,-3,"wm",0,NULL,1,-1,2,0,0},
{"randomkey",randomkeyCommand,1,"rR",0,NULL,0,0,0,0,0},
{"select",selectCommand,2,"rl",0,NULL,0,0,0,0,0},
{"move",moveCommand,3,"w",0,NULL,1,1,1,0,0},
{"rename",renameCommand,3,"w",0,NULL,1,2,1,0,0},
{"renamenx",renamenxCommand,3,"w",0,NULL,1,2,1,0,0},
{"expire",expireCommand,3,"w",0,NULL,1,1,1,0,0},
{"expireat",expireatCommand,3,"w",0,NULL,1,1,1,0,0},
{"pexpire",pexpireCommand,3,"w",0,NULL,1,1,1,0,0},
{"pexpireat",pexpireatCommand,3,"w",0,NULL,1,1,1,0,0},
{"keys",keysCommand,2,"rS",0,NULL,0,0,0,0,0},
{"scan",scanCommand,-2,"rR",0,NULL,0,0,0,0,0},
{"dbsize",dbsizeCommand,1,"r",0,NULL,0,0,0,0,0},
{"auth",authCommand,2,"rslt",0,NULL,0,0,0,0,0},
{"ping",pingCommand,1,"rt",0,NULL,0,0,0,0,0},
{"echo",echoCommand,2,"r",0,NULL,0,0,0,0,0},
{"save",saveCommand,1,"ars",0,NULL,0,0,0,0,0},
{"bgsave",bgsaveCommand,1,"ar",0,NULL,0,0,0,0,0},
{"bgrewriteaof",bgrewriteaofCommand,1,"ar",0,NULL,0,0,0,0,0},
{"shutdown",shutdownCommand,-1,"arlt",0,NULL,0,0,0,0,0},
{"lastsave",lastsaveCommand,1,"rR",0,NULL,0,0,0,0,0},
{"type",typeCommand,2,"r",0,NULL,1,1,1,0,0},
{"multi",multiCommand,1,"rs",0,NULL,0,0,0,0,0},
{"exec",execCommand,1,"sM",0,NULL,0,0,0,0,0},
{"discard",discardCommand,1,"rs",0,NULL,0,0,0,0,0},
{"sync",syncCommand,1,"ars",0,NULL,0,0,0,0,0},
{"psync",syncCommand,3,"ars",0,NULL,0,0,0,0,0},
{"replconf",replconfCommand,-1,"arslt",0,NULL,0,0,0,0,0},
{"flushdb",flushdbCommand,1,"w",0,NULL,0,0,0,0,0},
{"flushall",flushallCommand,1,"w",0,NULL,0,0,0,0,0},
{"sort",sortCommand,-2,"wm",0,sortGetKeys,1,1,1,0,0},
{"info",infoCommand,-1,"rlt",0,NULL,0,0,0,0,0},
{"monitor",monitorCommand,1,"ars",0,NULL,0,0,0,0,0},
{"ttl",ttlCommand,2,"r",0,NULL,1,1,1,0,0},
{"pttl",pttlCommand,2,"r",0,NULL,1,1,1,0,0},
{"persist",persistCommand,2,"w",0,NULL,1,1,1,0,0},
{"slaveof",slaveofCommand,3,"ast",0,NULL,0,0,0,0,0},
{"debug",debugCommand,-2,"as",0,NULL,0,0,0,0,0},
{"config",configCommand,-2,"art",0,NULL,0,0,0,0,0},
{"subscribe",subscribeCommand,-2,"rpslt",0,NULL,0,0,0,0,0},
{"unsubscribe",unsubscribeCommand,-1,"rpslt",0,NULL,0,0,0,0,0},
{"psubscribe",psubscribeCommand,-2,"rpslt",0,NULL,0,0,0,0,0},
{"punsubscribe",punsubscribeCommand,-1,"rpslt",0,NULL,0,0,0,0,0},
{"publish",publishCommand,3,"pltr",0,NULL,0,0,0,0,0},
{"pubsub",pubsubCommand,-2,"pltrR",0,NULL,0,0,0,0,0},
{"watch",watchCommand,-2,"rs",0,NULL,1,-1,1,0,0},
{"unwatch",unwatchCommand,1,"rs",0,NULL,0,0,0,0,0},
{"cluster",clusterCommand,-2,"ar",0,NULL,0,0,0,0,0},
{"restore",restoreCommand,-4,"awm",0,NULL,1,1,1,0,0},
{"restore-asking",restoreCommand,-4,"awmk",0,NULL,1,1,1,0,0},
{"migrate",migrateCommand,-6,"aw",0,NULL,0,0,0,0,0},
{"asking",askingCommand,1,"r",0,NULL,0,0,0,0,0},
{"readonly",readonlyCommand,1,"r",0,NULL,0,0,0,0,0},
{"readwrite",readwriteCommand,1,"r",0,NULL,0,0,0,0,0},
{"dump",dumpCommand,2,"ar",0,NULL,1,1,1,0,0},
{"object",objectCommand,-2,"r",0,NULL,2,2,2,0,0},
{"client",clientCommand,-2,"ar",0,NULL,0,0,0,0,0},
{"eval",evalCommand,-3,"s",0,evalGetKeys,0,0,0,0,0},
{"evalsha",evalShaCommand,-3,"s",0,evalGetKeys,0,0,0,0,0},
{"slowlog",slowlogCommand,-2,"r",0,NULL,0,0,0,0,0},
{"script",scriptCommand,-2,"ras",0,NULL,0,0,0,0,0},
{"time",timeCommand,1,"rR",0,NULL,0,0,0,0,0},
{"bitop",bitopCommand,-4,"wm",0,NULL,2,-1,1,0,0},
{"bitcount",bitcountCommand,-2,"r",0,NULL,1,1,1,0,0},
{"bitpos",bitposCommand,-3,"r",0,NULL,1,1,1,0,0},
{"wait",waitCommand,3,"rs",0,NULL,0,0,0,0,0},
{"pfselftest",pfselftestCommand,1,"r",0,NULL,0,0,0,0,0},
{"pfadd",pfaddCommand,-2,"wm",0,NULL,1,1,1,0,0},
{"pfcount",pfcountCommand,-2,"w",0,NULL,1,1,1,0,0},
{"pfmerge",pfmergeCommand,-2,"wm",0,NULL,1,-1,1,0,0},
{"pfdebug",pfdebugCommand,-3,"w",0,NULL,0,0,0,0,0}
};13.1.7 输出缓冲区
服务器对客户端命令的回复会先放到输出缓冲区中,一共有两个缓冲区,一个缓冲区为固定大小,一个是可变大小
固定缓冲区
/* Response buffer */
// 回复偏移量
int bufpos;
// 回复缓冲区
char buf[REDIS_REPLY_CHUNK_BYTES];长度为 16kb 的一个固定缓冲区,可以用来进行一些简短的字符回复
可变长缓冲区
// 回复链表
list *reply;可以突破固定的大小,通过链表的形式来回复非常长的命令回复
13.1.8 身份验证
int authenticated当开启了身份验证功能时,如果没有进行身份的验证,所有的命令都将会被拒绝
通过
AUTH 123进行一个身份验证
13.1.9 时间
客户端对象有几个比较关键的时间属性,用于记录克重时间
// 创建客户端的时间
time_t ctime; /* Client creation time */
// 客户端最后一次和服务器互动的时间
time_t lastinteraction; /* time of the last interaction, used for timeout */
// 客户端的输出缓冲区超过软性限制的时间
time_t obuf_soft_limit_reached_time;13.2 客户端的创建与关闭
将进行客户端的创建与关闭的一个极少
13.2.1 创建普通客户端
当监听套接字变为可读事件,AE_READABLE 时,会调用连接处理器来进行客户端对象的创建,并挂载在 clients 链表的末尾.对,挂载在末尾
13.2.2 关闭客户端
客户端也可能以以下原因而被关闭:
1): 如果客户端进程被杀死,那么网络链接也将断开,从而也造成了客户单的关闭
2): 如果客户端发送了不符合协议格式的命令请求,那么也会被关闭
3): 如果称为了 CLIENT KILL 命令的目标,也会被关闭
4): 如果用户配置了 timeout 选项,那么客户端空转时间超过配置值,那么将被关闭,但是,也有特殊情况,如果客户端是主服务器,服务器是从服务器,当被 BLPOP 等命令进行阻塞的时候,超过了配置值也不会被关闭
5): 如果客户端发送的命令超过了1GB,那么客户端将被关闭,1GB是可以进行修改的
6): 当服务器返回的回复大于缓冲区限制大小,也会被关闭
针对缓冲区限制大小的详细介绍
限制缓冲区大小有两种限制:
1): 硬性限制,超过该值立马关闭.
2): 软性限制,超过该值一段事件后,才会被关闭,通过以下命令进行配置
client-ouput-buffer-limit <class> <hard limit> <sort limt> <sort seconds>
//class 指的 normal 普通客户端, slave 从服务器客户端, pubsub 主服务器客户端13.2.3 LUA脚本的伪客户端
struct redisServer{
redisClient* lua_client;
}lua_client 伪客户端在服务器运行的整个生命周期内会一直存在,只有服务器关闭,伪客户端才会关闭.
lua 客户端负责载入 lua 脚本中包含的命令
13.2.4 AOF 文件的伪客户端
客户端会在载入AOF文件时,用于 AOF 文件的载入,当载入完毕就关闭客户端
总结
1): 客户端都会以连接顺序挂载 redisServer 的 clients 链表上
2): redisClient 的 falgs 属性,用来表示客户端的不同角色,或者客户端当前的状态
3): 输入缓冲区保存了客户端的命令,大小不能超过1GB
4): 命令的参数会被记录在 argv 和argc 属性里, 而 cmd 记录了客户端执行的命令的实现函数
5): 客户端的回复缓冲区,有固定和动态缓冲区两种
6): 输出缓冲区有硬性限制和软性限制,用来对客户端进行一个限制
7): 有多种原因会导致客户端的关闭,详细见上方
8): 处理 LUA 客户端的伪客户端,这个客户端会一直存在,直到服务器关闭
9): 载入 AOF 文件使用的伪客户端,会在载入工作开始时创建,载入完毕后关闭
本章的叙述还是很清晰的,只不过在阅读时,需要根据上下文来确定中文的客户端指代的是客户端进程还是客户端对象.
总结来说,客户端对象主要是用来存储客户端进程发来的命令,以及存放回复命令,给事件处理器做好准,在事件执行的时候进行源数据的提供.
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
