Redis源码研究--redis.h

------------7月3日------------

 1 /* The redisOp structure defines a Redis Operation, that is an instance of
 2  * a command with an argument vector, database ID, propagation target
 3  * (REDIS_PROPAGATE_*), and command pointer.
 4  *
 5  * Currently only used to additionally propagate more commands to AOF/Replication
 6  * after the propagation of the executed command. */
 7 typedef struct redisOp {
 8     robj **argv;
 9     int argc, dbid, target;
10     struct redisCommand *cmd;
11 } redisOp;

argc 参数个数，argv参数数组，跟main函数里的参数一样

dbid，数据库id，target（propagation传播），暂时不懂。

cmd操作命令。

------------7月4日--------------------

 1 struct redisCommand {
 2     char *name;
 3     redisCommandProc *proc;
 4     int arity;
 5     char *sflags; /* Flags as string representation, one char per flag. */
 6     int flags;    /* The actual flags, obtained from the 'sflags' field. */
 7     /* Use a function to determine keys arguments in a command line.
 8      * Used for Redis Cluster redirect. */
 9     redisGetKeysProc *getkeys_proc;
10     /* What keys should be loaded in background when calling this command? */
11     int firstkey; /* The first argument that's a key (0 = no keys) */
12     int lastkey;  /* The last argument that's a key */
13     int keystep;  /* The step between first and last key */
14     long long microseconds, calls;
15 };

给两三个例子就能懂一点，自己看代码

 1 void getCommand(redisClient *c);
 2 void lsetCommand(redisClient *c);
 3 void saddCommand(redisClient *c);
 4 
 5 {"get",getCommand,2,"r",0,NULL,1,1,1,0,0},
 6 {"lset",lsetCommand,4,"wm",0,NULL,1,1,1,0,0},
 7 {"sadd",saddCommand,-3,"wm",0,NULL,1,1,1,0,0}
 8 
 9 /* Our command table.
10  *
11  * Every entry is composed of the following fields:
12  *
13  * name: a string representing the command name.
14  * function: pointer to the C function implementing the command.
15  * arity: number of arguments, it is possible to use -N to say >= N
16  * sflags: command flags as string. See below for a table of flags.
17  * flags: flags as bitmask. Computed by Redis using the 'sflags' field.
18  * get_keys_proc: an optional function to get key arguments from a command.
19  *                This is only used when the following three fields are not
20  *                enough to specify what arguments are keys.
21  * first_key_index: first argument that is a key
22  * last_key_index: last argument that is a key
23  * key_step: step to get all the keys from first to last argument. For instance
24  *           in MSET the step is two since arguments are key,val,key,val,...
25  * microseconds: microseconds of total execution time for this command.
26  * calls: total number of calls of this command.
27  *
28  * The flags, microseconds and calls fields are computed by Redis and should
29  * always be set to zero.
30  *
31  * Command flags are expressed using strings where every character represents
32  * a flag. Later the populateCommandTable() function will take care of
33  * populating the real 'flags' field using this characters.
34  *
35  * This is the meaning of the flags:
36  *
37  * w: write command (may modify the key space).
38  * r: read command  (will never modify the key space).
39  * m: may increase memory usage once called. Don't allow if out of memory.
40  * a: admin command, like SAVE or SHUTDOWN.
41  * p: Pub/Sub related command.
42  * f: force replication of this command, regardless of server.dirty.
43  * s: command not allowed in scripts.
44  * R: random command. Command is not deterministic, that is, the same command
45  *    with the same arguments, with the same key space, may have different
46  *    results. For instance SPOP and RANDOMKEY are two random commands.
47  * S: Sort command output array if called from script, so that the output
48  *    is deterministic.
49  * l: Allow command while loading the database.
50  * t: Allow command while a slave has stale data but is not allowed to
51  *    server this data. Normally no command is accepted in this condition
52  *    but just a few.
53  * M: Do not automatically propagate the command on MONITOR.
54  * k: Perform an implicit ASKING for this command, so the command will be
55  *    accepted in cluster mode if the slot is marked as 'importing'.
56  */

很明显，redisCommandProc是个函数指针，

typedef void redisCommandProc(redisClient *c);

--------------7月5日----------------------

还是说上面的命令吧

{"get",getCommand,2,"r",0,NULL,1,1,1,0,0},

命令名字叫get，具体实现在getCommand里面，参数有两个（包括get?get name），模式为只读（will never modify the key space）。

{"lset",lsetCommand,4,"wm",0,NULL,1,1,1,0,0},
命令名字叫lset，具体实现在lsetCommand函数，参数有4个（lset mylist 3 “juan”），模式为写，会使用内存（may increase memory usage once called. Don't allow if out of memory）。

-----------------7月10日----------------------
redisServer里有个aeEventLoop，牵涉到Redis的事件。
Redis事件分两种：

处理文件事件：在多个客户端中实现多路复用，接受它们发来的命令请求，并将命令的执行结果返回给客户端。
时间事件：实现服务器常规操作。

 1 /* Types and data structures */
 2 typedef void aeFileProc(struct aeEventLoop *eventLoop, int fd, void *clientData, int mask);
 3 typedef int aeTimeProc(struct aeEventLoop *eventLoop, long long id, void *clientData);
 4 typedef void aeEventFinalizerProc(struct aeEventLoop *eventLoop, void *clientData);
 5 
 6 /* File event structure */
 7 typedef struct aeFileEvent {
 8     int mask; /* one of AE_(READABLE|WRITABLE) */
 9     aeFileProc *rfileProc;
10     aeFileProc *wfileProc;
11     void *clientData;
12 } aeFileEvent;
13 
14 /* Time event structure */
15 typedef struct aeTimeEvent {
16     long long id; /* time event identifier. */
17     long when_sec; /* seconds */
18     long when_ms; /* milliseconds */
19     aeTimeProc *timeProc;
20     aeEventFinalizerProc *finalizerProc;
21     void *clientData;
22     struct aeTimeEvent *next;
23 } aeTimeEvent;