redis中客户端结构体

客户端结构体用来存储client端连接的所有信息。

typedef struct client {

    uint64_t id;            /* Client incremental unique ID. */

    connection *conn;

    int resp;               /* RESP protocol version. Can be 2 or 3. */

    redisDb *db;            /* Pointer to currently SELECTed DB. */

    robj *name;             /* As set by CLIENT SETNAME. */

    sds querybuf;           /* Buffer we use to accumulate client queries. */

    size_t qb_pos;          /* The position we have read in querybuf. */

    sds pending_querybuf;   /* If this client is flagged as master, this buffer

                               represents the yet not applied portion of the

                               replication stream that we are receiving from

                               the master. */

    size_t querybuf_peak;   /* Recent (100ms or more) peak of querybuf size. */

    int argc;               /* Num of arguments of current command. */

    robj **argv;            /* Arguments of current command. */

    int original_argc;      /* Num of arguments of original command if arguments were rewritten. */

    robj **original_argv;   /* Arguments of original command if arguments were rewritten. */

    size_t argv_len_sum;    /* Sum of lengths of objects in argv list. */

    struct redisCommand *cmd, *lastcmd;  /* Last command executed. */

    user *user;             /* User associated with this connection. If the

                               user is set to NULL the connection can do

                               anything (admin). */

    int reqtype;            /* Request protocol type: PROTO_REQ_* */

    int multibulklen;       /* Number of multi bulk arguments left to read. */

    long bulklen;           /* Length of bulk argument in multi bulk request. */

    list *reply;            /* List of reply objects to send to the client. */

    unsigned long long reply_bytes; /* Tot bytes of objects in reply list. */

    size_t sentlen;         /* Amount of bytes already sent in the current

                               buffer or object being sent. */

    time_t ctime;           /* Client creation time. */

    long duration;          /* Current command duration. Used for measuring latency of blocking/non-blocking cmds */

    time_t lastinteraction; /* Time of the last interaction, used for timeout */

    time_t obuf_soft_limit_reached_time;

    uint64_t flags;         /* Client flags: CLIENT_* macros. */

    int authenticated;      /* Needed when the default user requires auth. */

    int replstate;          /* Replication state if this is a slave. */

    int repl_put_online_on_ack; /* Install slave write handler on first ACK. */

    int repldbfd;           /* Replication DB file descriptor. */

    off_t repldboff;        /* Replication DB file offset. */

    off_t repldbsize;       /* Replication DB file size. */

    sds replpreamble;       /* Replication DB preamble. */

    long long read_reploff; /* Read replication offset if this is a master. */

    long long reploff;      /* Applied replication offset if this is a master. */

    long long repl_ack_off; /* Replication ack offset, if this is a slave. */

    long long repl_ack_time;/* Replication ack time, if this is a slave. */

    long long repl_last_partial_write; /* The last time the server did a partial write from the RDB child pipe to this replica  */

    long long psync_initial_offset; /* FULLRESYNC reply offset other slaves

                                       copying this slave output buffer

                                       should use. */

    char replid[CONFIG_RUN_ID_SIZE+1]; /* Master replication ID (if master). */

    int slave_listening_port; /* As configured with: REPLCONF listening-port */

    char *slave_addr;       /* Optionally given by REPLCONF ip-address */

    int slave_capa;         /* Slave capabilities: SLAVE_CAPA_* bitwise OR. */

    multiState mstate;      /* MULTI/EXEC state */

    int btype;              /* Type of blocking op if CLIENT_BLOCKED. */

    blockingState bpop;     /* blocking state */

    long long woff;         /* Last write global replication offset. */

    list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */

    dict *pubsub_channels;  /* channels a client is interested in (SUBSCRIBE) */

    list *pubsub_patterns;  /* patterns a client is interested in (SUBSCRIBE) */

    sds peerid;             /* Cached peer ID. */

    sds sockname;           /* Cached connection target address. */

    listNode *client_list_node; /* list node in client list */

    listNode *paused_list_node; /* list node within the pause list */

    RedisModuleUserChangedFunc auth_callback; /* Module callback to execute

                                               * when the authenticated user

                                               * changes. */

    void *auth_callback_privdata; /* Private data that is passed when the auth

                                   * changed callback is executed. Opaque for

                                   * Redis Core. */

    void *auth_module;      /* The module that owns the callback, which is used

                             * to disconnect the client if the module is

                             * unloaded for cleanup. Opaque for Redis Core.*/

    /* If this client is in tracking mode and this field is non zero,

     * invalidation messages for keys fetched by this client will be send to

     * the specified client ID. */

    uint64_t client_tracking_redirection;

    rax *client_tracking_prefixes; /* A dictionary of prefixes we are already

                                      subscribed to in BCAST mode, in the

                                      context of client side caching. */

    /* In clientsCronTrackClientsMemUsage() we track the memory usage of

     * each client and add it to the sum of all the clients of a given type,

     * however we need to remember what was the old contribution of each

     * client, and in which categoty the client was, in order to remove it

     * before adding it the new value. */

    uint64_t client_cron_last_memory_usage;

    int      client_cron_last_memory_type;

    /* Response buffer */

    int bufpos;

    char buf[PROTO_REPLY_CHUNK_BYTES];

} client;

 

整个字段比较多。我挑几个重要的做下记录。

id：客户端的唯一ID。全局变量。

由server.c/initServerConfig中

server.next_client_id = 1; /* Client IDs, start from 1 .*/

定义的。从1开始。

conn下有个fd：客户端socket文件描述符。

db：client所select的数据库对象。我一直感觉这个字段是能删掉的。我工作以来就没用上过db这个概念。甚至这几年，redis官方也一直在淡化这个概念。

name:client的名称，可以用 client setname设置。

lastinteraction：client上次与server交互的时间，用来做client过期处理。

querybuf：输入缓冲区，recv接受的client命令会放在这里。

argc：命令的数量。

argv：具体的命令被存放在robj对象里。

cmd：这是一个redisCommand对象。可以理解成，每一个被解析出来的命令，其实有对应的命令对象。这个就是用来存放命令对象的。

reply：一个list，输出列表。存放待返回client的数据。具体是放在这的：

/* This structure is used in order to represent the output buffer of a client,

 * which is actually a linked list of blocks like that, that is: client->reply. */

typedef struct clientReplyBlock {

    size_t size, used;

    char buf[];

} clientReplyBlock;

size表示的是总大小，used表示的是已使用大小。

 

reply_bytes：输出链表中空间总和。

sentlen：已返回给客户端的字节数。

buf：输出缓冲区，存储待返回给client的数据。bufpos表示输出缓冲区中数据的最大字节位置。所以，sentlen到bufpos都是需要返回给client的。而reply和buf，看着是一样的东西，其实返回的内容不一样。