]>
Commit | Line | Data |
---|---|---|
1 | #ifndef __REDIS_H | |
2 | #define __REDIS_H | |
3 | ||
4 | #include "fmacros.h" | |
5 | #include "config.h" | |
6 | ||
7 | #if defined(__sun) | |
8 | #include "solarisfixes.h" | |
9 | #endif | |
10 | ||
11 | #include <stdio.h> | |
12 | #include <stdlib.h> | |
13 | #include <string.h> | |
14 | #include <time.h> | |
15 | #include <limits.h> | |
16 | #include <unistd.h> | |
17 | #include <errno.h> | |
18 | #include <inttypes.h> | |
19 | #include <pthread.h> | |
20 | #include <syslog.h> | |
21 | #include <netinet/in.h> | |
22 | #include <lua.h> | |
23 | ||
24 | #include "ae.h" /* Event driven programming library */ | |
25 | #include "sds.h" /* Dynamic safe strings */ | |
26 | #include "dict.h" /* Hash tables */ | |
27 | #include "adlist.h" /* Linked lists */ | |
28 | #include "zmalloc.h" /* total memory usage aware version of malloc/free */ | |
29 | #include "anet.h" /* Networking the easy way */ | |
30 | #include "zipmap.h" /* Compact string -> string data structure */ | |
31 | #include "ziplist.h" /* Compact list data structure */ | |
32 | #include "intset.h" /* Compact integer set structure */ | |
33 | #include "version.h" /* Version macro */ | |
34 | #include "util.h" /* Misc functions useful in many places */ | |
35 | ||
36 | /* Error codes */ | |
37 | #define REDIS_OK 0 | |
38 | #define REDIS_ERR -1 | |
39 | ||
40 | /* Static server configuration */ | |
41 | #define REDIS_SERVERPORT 6379 /* TCP port */ | |
42 | #define REDIS_MAXIDLETIME (60*5) /* default client timeout */ | |
43 | #define REDIS_IOBUF_LEN (1024*16) | |
44 | #define REDIS_LOADBUF_LEN 1024 | |
45 | #define REDIS_DEFAULT_DBNUM 16 | |
46 | #define REDIS_CONFIGLINE_MAX 1024 | |
47 | #define REDIS_MAX_SYNC_TIME 60 /* Slave can't take more to sync */ | |
48 | #define REDIS_EXPIRELOOKUPS_PER_CRON 10 /* lookup 10 expires per loop */ | |
49 | #define REDIS_MAX_WRITE_PER_EVENT (1024*64) | |
50 | #define REDIS_REQUEST_MAX_SIZE (1024*1024*256) /* max bytes in inline command */ | |
51 | #define REDIS_SHARED_INTEGERS 10000 | |
52 | #define REDIS_REPLY_CHUNK_BYTES (5*1500) /* 5 TCP packets with default MTU */ | |
53 | #define REDIS_MAX_LOGMSG_LEN 1024 /* Default maximum length of syslog messages */ | |
54 | #define REDIS_AUTO_AOFREWRITE_PERC 100 | |
55 | #define REDIS_AUTO_AOFREWRITE_MIN_SIZE (1024*1024) | |
56 | #define REDIS_SLOWLOG_LOG_SLOWER_THAN 10000 | |
57 | #define REDIS_SLOWLOG_MAX_LEN 64 | |
58 | #define REDIS_MAX_CLIENTS 10000 | |
59 | ||
60 | #define REDIS_REPL_TIMEOUT 60 | |
61 | #define REDIS_REPL_PING_SLAVE_PERIOD 10 | |
62 | ||
63 | /* Hash table parameters */ | |
64 | #define REDIS_HT_MINFILL 10 /* Minimal hash table fill 10% */ | |
65 | ||
66 | /* Command flags. Please check the command table defined in the redis.c file | |
67 | * for more information about the meaning of every flag. */ | |
68 | #define REDIS_CMD_WRITE 1 /* "w" flag */ | |
69 | #define REDIS_CMD_READONLY 2 /* "r" flag */ | |
70 | #define REDIS_CMD_DENYOOM 4 /* "m" flag */ | |
71 | #define REDIS_CMD_FORCE_REPLICATION 8 /* "f" flag */ | |
72 | #define REDIS_CMD_ADMIN 16 /* "a" flag */ | |
73 | #define REDIS_CMD_PUBSUB 32 /* "p" flag */ | |
74 | #define REDIS_CMD_NOSCRIPT 64 /* "s" flag */ | |
75 | #define REDIS_CMD_RANDOM 128 /* "R" flag */ | |
76 | ||
77 | /* Object types */ | |
78 | #define REDIS_STRING 0 | |
79 | #define REDIS_LIST 1 | |
80 | #define REDIS_SET 2 | |
81 | #define REDIS_ZSET 3 | |
82 | #define REDIS_HASH 4 | |
83 | #define REDIS_VMPOINTER 8 | |
84 | ||
85 | /* Objects encoding. Some kind of objects like Strings and Hashes can be | |
86 | * internally represented in multiple ways. The 'encoding' field of the object | |
87 | * is set to one of this fields for this object. */ | |
88 | #define REDIS_ENCODING_RAW 0 /* Raw representation */ | |
89 | #define REDIS_ENCODING_INT 1 /* Encoded as integer */ | |
90 | #define REDIS_ENCODING_HT 2 /* Encoded as hash table */ | |
91 | #define REDIS_ENCODING_ZIPMAP 3 /* Encoded as zipmap */ | |
92 | #define REDIS_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */ | |
93 | #define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */ | |
94 | #define REDIS_ENCODING_INTSET 6 /* Encoded as intset */ | |
95 | #define REDIS_ENCODING_SKIPLIST 7 /* Encoded as skiplist */ | |
96 | ||
97 | /* Object types only used for dumping to disk */ | |
98 | #define REDIS_EXPIRETIME 253 | |
99 | #define REDIS_SELECTDB 254 | |
100 | #define REDIS_EOF 255 | |
101 | ||
102 | /* Defines related to the dump file format. To store 32 bits lengths for short | |
103 | * keys requires a lot of space, so we check the most significant 2 bits of | |
104 | * the first byte to interpreter the length: | |
105 | * | |
106 | * 00|000000 => if the two MSB are 00 the len is the 6 bits of this byte | |
107 | * 01|000000 00000000 => 01, the len is 14 byes, 6 bits + 8 bits of next byte | |
108 | * 10|000000 [32 bit integer] => if it's 01, a full 32 bit len will follow | |
109 | * 11|000000 this means: specially encoded object will follow. The six bits | |
110 | * number specify the kind of object that follows. | |
111 | * See the REDIS_RDB_ENC_* defines. | |
112 | * | |
113 | * Lenghts up to 63 are stored using a single byte, most DB keys, and may | |
114 | * values, will fit inside. */ | |
115 | #define REDIS_RDB_6BITLEN 0 | |
116 | #define REDIS_RDB_14BITLEN 1 | |
117 | #define REDIS_RDB_32BITLEN 2 | |
118 | #define REDIS_RDB_ENCVAL 3 | |
119 | #define REDIS_RDB_LENERR UINT_MAX | |
120 | ||
121 | /* When a length of a string object stored on disk has the first two bits | |
122 | * set, the remaining two bits specify a special encoding for the object | |
123 | * accordingly to the following defines: */ | |
124 | #define REDIS_RDB_ENC_INT8 0 /* 8 bit signed integer */ | |
125 | #define REDIS_RDB_ENC_INT16 1 /* 16 bit signed integer */ | |
126 | #define REDIS_RDB_ENC_INT32 2 /* 32 bit signed integer */ | |
127 | #define REDIS_RDB_ENC_LZF 3 /* string compressed with FASTLZ */ | |
128 | ||
129 | /* Client flags */ | |
130 | #define REDIS_SLAVE 1 /* This client is a slave server */ | |
131 | #define REDIS_MASTER 2 /* This client is a master server */ | |
132 | #define REDIS_MONITOR 4 /* This client is a slave monitor, see MONITOR */ | |
133 | #define REDIS_MULTI 8 /* This client is in a MULTI context */ | |
134 | #define REDIS_BLOCKED 16 /* The client is waiting in a blocking operation */ | |
135 | #define REDIS_DIRTY_CAS 64 /* Watched keys modified. EXEC will fail. */ | |
136 | #define REDIS_CLOSE_AFTER_REPLY 128 /* Close after writing entire reply. */ | |
137 | #define REDIS_UNBLOCKED 256 /* This client was unblocked and is stored in | |
138 | server.unblocked_clients */ | |
139 | #define REDIS_LUA_CLIENT 512 /* This is a non connected client used by Lua */ | |
140 | #define REDIS_ASKING 1024 /* Client issued the ASKING command */ | |
141 | ||
142 | /* Client request types */ | |
143 | #define REDIS_REQ_INLINE 1 | |
144 | #define REDIS_REQ_MULTIBULK 2 | |
145 | ||
146 | /* Slave replication state - slave side */ | |
147 | #define REDIS_REPL_NONE 0 /* No active replication */ | |
148 | #define REDIS_REPL_CONNECT 1 /* Must connect to master */ | |
149 | #define REDIS_REPL_CONNECTING 2 /* Connecting to master */ | |
150 | #define REDIS_REPL_TRANSFER 3 /* Receiving .rdb from master */ | |
151 | #define REDIS_REPL_CONNECTED 4 /* Connected to master */ | |
152 | ||
153 | /* Synchronous read timeout - slave side */ | |
154 | #define REDIS_REPL_SYNCIO_TIMEOUT 5 | |
155 | ||
156 | /* Slave replication state - from the point of view of master | |
157 | * Note that in SEND_BULK and ONLINE state the slave receives new updates | |
158 | * in its output queue. In the WAIT_BGSAVE state instead the server is waiting | |
159 | * to start the next background saving in order to send updates to it. */ | |
160 | #define REDIS_REPL_WAIT_BGSAVE_START 3 /* master waits bgsave to start feeding it */ | |
161 | #define REDIS_REPL_WAIT_BGSAVE_END 4 /* master waits bgsave to start bulk DB transmission */ | |
162 | #define REDIS_REPL_SEND_BULK 5 /* master is sending the bulk DB */ | |
163 | #define REDIS_REPL_ONLINE 6 /* bulk DB already transmitted, receive updates */ | |
164 | ||
165 | /* List related stuff */ | |
166 | #define REDIS_HEAD 0 | |
167 | #define REDIS_TAIL 1 | |
168 | ||
169 | /* Sort operations */ | |
170 | #define REDIS_SORT_GET 0 | |
171 | #define REDIS_SORT_ASC 1 | |
172 | #define REDIS_SORT_DESC 2 | |
173 | #define REDIS_SORTKEY_MAX 1024 | |
174 | ||
175 | /* Log levels */ | |
176 | #define REDIS_DEBUG 0 | |
177 | #define REDIS_VERBOSE 1 | |
178 | #define REDIS_NOTICE 2 | |
179 | #define REDIS_WARNING 3 | |
180 | #define REDIS_LOG_RAW (1<<10) /* Modifier to log without timestamp */ | |
181 | ||
182 | /* Anti-warning macro... */ | |
183 | #define REDIS_NOTUSED(V) ((void) V) | |
184 | ||
185 | #define ZSKIPLIST_MAXLEVEL 32 /* Should be enough for 2^32 elements */ | |
186 | #define ZSKIPLIST_P 0.25 /* Skiplist P = 1/4 */ | |
187 | ||
188 | /* Append only defines */ | |
189 | #define APPENDFSYNC_NO 0 | |
190 | #define APPENDFSYNC_ALWAYS 1 | |
191 | #define APPENDFSYNC_EVERYSEC 2 | |
192 | ||
193 | /* Zip structure related defaults */ | |
194 | #define REDIS_HASH_MAX_ZIPMAP_ENTRIES 512 | |
195 | #define REDIS_HASH_MAX_ZIPMAP_VALUE 64 | |
196 | #define REDIS_LIST_MAX_ZIPLIST_ENTRIES 512 | |
197 | #define REDIS_LIST_MAX_ZIPLIST_VALUE 64 | |
198 | #define REDIS_SET_MAX_INTSET_ENTRIES 512 | |
199 | #define REDIS_ZSET_MAX_ZIPLIST_ENTRIES 128 | |
200 | #define REDIS_ZSET_MAX_ZIPLIST_VALUE 64 | |
201 | ||
202 | /* Sets operations codes */ | |
203 | #define REDIS_OP_UNION 0 | |
204 | #define REDIS_OP_DIFF 1 | |
205 | #define REDIS_OP_INTER 2 | |
206 | ||
207 | /* Redis maxmemory strategies */ | |
208 | #define REDIS_MAXMEMORY_VOLATILE_LRU 0 | |
209 | #define REDIS_MAXMEMORY_VOLATILE_TTL 1 | |
210 | #define REDIS_MAXMEMORY_VOLATILE_RANDOM 2 | |
211 | #define REDIS_MAXMEMORY_ALLKEYS_LRU 3 | |
212 | #define REDIS_MAXMEMORY_ALLKEYS_RANDOM 4 | |
213 | #define REDIS_MAXMEMORY_NO_EVICTION 5 | |
214 | ||
215 | /* Scripting */ | |
216 | #define REDIS_LUA_TIME_LIMIT 5000 /* milliseconds */ | |
217 | ||
218 | /* We can print the stacktrace, so our assert is defined this way: */ | |
219 | #define redisAssertWithInfo(_c,_o,_e) ((_e)?(void)0 : (_redisAssertWithInfo(_c,_o,#_e,__FILE__,__LINE__),_exit(1))) | |
220 | #define redisAssert(_e) ((_e)?(void)0 : (_redisAssert(#_e,__FILE__,__LINE__),_exit(1))) | |
221 | #define redisPanic(_e) _redisPanic(#_e,__FILE__,__LINE__),_exit(1) | |
222 | ||
223 | /*----------------------------------------------------------------------------- | |
224 | * Data types | |
225 | *----------------------------------------------------------------------------*/ | |
226 | ||
227 | /* A redis object, that is a type able to hold a string / list / set */ | |
228 | ||
229 | /* The actual Redis Object */ | |
230 | #define REDIS_LRU_CLOCK_MAX ((1<<21)-1) /* Max value of obj->lru */ | |
231 | #define REDIS_LRU_CLOCK_RESOLUTION 10 /* LRU clock resolution in seconds */ | |
232 | typedef struct redisObject { | |
233 | unsigned type:4; | |
234 | unsigned notused:2; /* Not used */ | |
235 | unsigned encoding:4; | |
236 | unsigned lru:22; /* lru time (relative to server.lruclock) */ | |
237 | int refcount; | |
238 | void *ptr; | |
239 | } robj; | |
240 | ||
241 | /* Macro used to initalize a Redis object allocated on the stack. | |
242 | * Note that this macro is taken near the structure definition to make sure | |
243 | * we'll update it when the structure is changed, to avoid bugs like | |
244 | * bug #85 introduced exactly in this way. */ | |
245 | #define initStaticStringObject(_var,_ptr) do { \ | |
246 | _var.refcount = 1; \ | |
247 | _var.type = REDIS_STRING; \ | |
248 | _var.encoding = REDIS_ENCODING_RAW; \ | |
249 | _var.ptr = _ptr; \ | |
250 | } while(0); | |
251 | ||
252 | typedef struct redisDb { | |
253 | dict *dict; /* The keyspace for this DB */ | |
254 | dict *expires; /* Timeout of keys with a timeout set */ | |
255 | dict *blocking_keys; /* Keys with clients waiting for data (BLPOP) */ | |
256 | dict *watched_keys; /* WATCHED keys for MULTI/EXEC CAS */ | |
257 | int id; | |
258 | } redisDb; | |
259 | ||
260 | /* Client MULTI/EXEC state */ | |
261 | typedef struct multiCmd { | |
262 | robj **argv; | |
263 | int argc; | |
264 | struct redisCommand *cmd; | |
265 | } multiCmd; | |
266 | ||
267 | typedef struct multiState { | |
268 | multiCmd *commands; /* Array of MULTI commands */ | |
269 | int count; /* Total number of MULTI commands */ | |
270 | } multiState; | |
271 | ||
272 | typedef struct blockingState { | |
273 | robj **keys; /* The key we are waiting to terminate a blocking | |
274 | * operation such as BLPOP. Otherwise NULL. */ | |
275 | int count; /* Number of blocking keys */ | |
276 | time_t timeout; /* Blocking operation timeout. If UNIX current time | |
277 | * is >= timeout then the operation timed out. */ | |
278 | robj *target; /* The key that should receive the element, | |
279 | * for BRPOPLPUSH. */ | |
280 | } blockingState; | |
281 | ||
282 | /* With multiplexing we need to take per-clinet state. | |
283 | * Clients are taken in a liked list. */ | |
284 | typedef struct redisClient { | |
285 | int fd; | |
286 | redisDb *db; | |
287 | int dictid; | |
288 | sds querybuf; | |
289 | int argc; | |
290 | robj **argv; | |
291 | struct redisCommand *cmd; | |
292 | int reqtype; | |
293 | int multibulklen; /* number of multi bulk arguments left to read */ | |
294 | long bulklen; /* length of bulk argument in multi bulk request */ | |
295 | list *reply; | |
296 | int sentlen; | |
297 | time_t lastinteraction; /* time of the last interaction, used for timeout */ | |
298 | int flags; /* REDIS_SLAVE | REDIS_MONITOR | REDIS_MULTI ... */ | |
299 | int slaveseldb; /* slave selected db, if this client is a slave */ | |
300 | int authenticated; /* when requirepass is non-NULL */ | |
301 | int replstate; /* replication state if this is a slave */ | |
302 | int repldbfd; /* replication DB file descriptor */ | |
303 | long repldboff; /* replication DB file offset */ | |
304 | off_t repldbsize; /* replication DB file size */ | |
305 | multiState mstate; /* MULTI/EXEC state */ | |
306 | blockingState bpop; /* blocking state */ | |
307 | list *io_keys; /* Keys this client is waiting to be loaded from the | |
308 | * swap file in order to continue. */ | |
309 | list *watched_keys; /* Keys WATCHED for MULTI/EXEC CAS */ | |
310 | dict *pubsub_channels; /* channels a client is interested in (SUBSCRIBE) */ | |
311 | list *pubsub_patterns; /* patterns a client is interested in (SUBSCRIBE) */ | |
312 | ||
313 | /* Response buffer */ | |
314 | int bufpos; | |
315 | char buf[REDIS_REPLY_CHUNK_BYTES]; | |
316 | } redisClient; | |
317 | ||
318 | struct saveparam { | |
319 | time_t seconds; | |
320 | int changes; | |
321 | }; | |
322 | ||
323 | struct sharedObjectsStruct { | |
324 | robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *cnegone, *pong, *space, | |
325 | *colon, *nullbulk, *nullmultibulk, *queued, | |
326 | *emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr, | |
327 | *outofrangeerr, *noscripterr, *loadingerr, *slowscripterr, *plus, | |
328 | *select0, *select1, *select2, *select3, *select4, | |
329 | *select5, *select6, *select7, *select8, *select9, | |
330 | *messagebulk, *pmessagebulk, *subscribebulk, *unsubscribebulk, *mbulk3, | |
331 | *mbulk4, *psubscribebulk, *punsubscribebulk, | |
332 | *integers[REDIS_SHARED_INTEGERS]; | |
333 | }; | |
334 | ||
335 | /* ZSETs use a specialized version of Skiplists */ | |
336 | typedef struct zskiplistNode { | |
337 | robj *obj; | |
338 | double score; | |
339 | struct zskiplistNode *backward; | |
340 | struct zskiplistLevel { | |
341 | struct zskiplistNode *forward; | |
342 | unsigned int span; | |
343 | } level[]; | |
344 | } zskiplistNode; | |
345 | ||
346 | typedef struct zskiplist { | |
347 | struct zskiplistNode *header, *tail; | |
348 | unsigned long length; | |
349 | int level; | |
350 | } zskiplist; | |
351 | ||
352 | typedef struct zset { | |
353 | dict *dict; | |
354 | zskiplist *zsl; | |
355 | } zset; | |
356 | ||
357 | /*----------------------------------------------------------------------------- | |
358 | * Redis cluster data structures | |
359 | *----------------------------------------------------------------------------*/ | |
360 | ||
361 | #define REDIS_CLUSTER_SLOTS 4096 | |
362 | #define REDIS_CLUSTER_OK 0 /* Everything looks ok */ | |
363 | #define REDIS_CLUSTER_FAIL 1 /* The cluster can't work */ | |
364 | #define REDIS_CLUSTER_NEEDHELP 2 /* The cluster works, but needs some help */ | |
365 | #define REDIS_CLUSTER_NAMELEN 40 /* sha1 hex length */ | |
366 | #define REDIS_CLUSTER_PORT_INCR 10000 /* Cluster port = baseport + PORT_INCR */ | |
367 | ||
368 | struct clusterNode; | |
369 | ||
370 | /* clusterLink encapsulates everything needed to talk with a remote node. */ | |
371 | typedef struct clusterLink { | |
372 | int fd; /* TCP socket file descriptor */ | |
373 | sds sndbuf; /* Packet send buffer */ | |
374 | sds rcvbuf; /* Packet reception buffer */ | |
375 | struct clusterNode *node; /* Node related to this link if any, or NULL */ | |
376 | } clusterLink; | |
377 | ||
378 | /* Node flags */ | |
379 | #define REDIS_NODE_MASTER 1 /* The node is a master */ | |
380 | #define REDIS_NODE_SLAVE 2 /* The node is a slave */ | |
381 | #define REDIS_NODE_PFAIL 4 /* Failure? Need acknowledge */ | |
382 | #define REDIS_NODE_FAIL 8 /* The node is believed to be malfunctioning */ | |
383 | #define REDIS_NODE_MYSELF 16 /* This node is myself */ | |
384 | #define REDIS_NODE_HANDSHAKE 32 /* We have still to exchange the first ping */ | |
385 | #define REDIS_NODE_NOADDR 64 /* We don't know the address of this node */ | |
386 | #define REDIS_NODE_MEET 128 /* Send a MEET message to this node */ | |
387 | #define REDIS_NODE_NULL_NAME "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000" | |
388 | ||
389 | struct clusterNode { | |
390 | char name[REDIS_CLUSTER_NAMELEN]; /* Node name, hex string, sha1-size */ | |
391 | int flags; /* REDIS_NODE_... */ | |
392 | unsigned char slots[REDIS_CLUSTER_SLOTS/8]; /* slots handled by this node */ | |
393 | int numslaves; /* Number of slave nodes, if this is a master */ | |
394 | struct clusterNode **slaves; /* pointers to slave nodes */ | |
395 | struct clusterNode *slaveof; /* pointer to the master node */ | |
396 | time_t ping_sent; /* Unix time we sent latest ping */ | |
397 | time_t pong_received; /* Unix time we received the pong */ | |
398 | char *configdigest; /* Configuration digest of this node */ | |
399 | time_t configdigest_ts; /* Configuration digest timestamp */ | |
400 | char ip[16]; /* Latest known IP address of this node */ | |
401 | int port; /* Latest known port of this node */ | |
402 | clusterLink *link; /* TCP/IP link with this node */ | |
403 | }; | |
404 | typedef struct clusterNode clusterNode; | |
405 | ||
406 | typedef struct { | |
407 | char *configfile; | |
408 | clusterNode *myself; /* This node */ | |
409 | int state; /* REDIS_CLUSTER_OK, REDIS_CLUSTER_FAIL, ... */ | |
410 | int node_timeout; | |
411 | dict *nodes; /* Hash table of name -> clusterNode structures */ | |
412 | clusterNode *migrating_slots_to[REDIS_CLUSTER_SLOTS]; | |
413 | clusterNode *importing_slots_from[REDIS_CLUSTER_SLOTS]; | |
414 | clusterNode *slots[REDIS_CLUSTER_SLOTS]; | |
415 | zskiplist *slots_to_keys; | |
416 | } clusterState; | |
417 | ||
418 | /* Redis cluster messages header */ | |
419 | ||
420 | /* Note that the PING, PONG and MEET messages are actually the same exact | |
421 | * kind of packet. PONG is the reply to ping, in the extact format as a PING, | |
422 | * while MEET is a special PING that forces the receiver to add the sender | |
423 | * as a node (if it is not already in the list). */ | |
424 | #define CLUSTERMSG_TYPE_PING 0 /* Ping */ | |
425 | #define CLUSTERMSG_TYPE_PONG 1 /* Pong (reply to Ping) */ | |
426 | #define CLUSTERMSG_TYPE_MEET 2 /* Meet "let's join" message */ | |
427 | #define CLUSTERMSG_TYPE_FAIL 3 /* Mark node xxx as failing */ | |
428 | #define CLUSTERMSG_TYPE_PUBLISH 4 /* Pub/Sub Publish propatagion */ | |
429 | ||
430 | /* Initially we don't know our "name", but we'll find it once we connect | |
431 | * to the first node, using the getsockname() function. Then we'll use this | |
432 | * address for all the next messages. */ | |
433 | typedef struct { | |
434 | char nodename[REDIS_CLUSTER_NAMELEN]; | |
435 | uint32_t ping_sent; | |
436 | uint32_t pong_received; | |
437 | char ip[16]; /* IP address last time it was seen */ | |
438 | uint16_t port; /* port last time it was seen */ | |
439 | uint16_t flags; | |
440 | uint32_t notused; /* for 64 bit alignment */ | |
441 | } clusterMsgDataGossip; | |
442 | ||
443 | typedef struct { | |
444 | char nodename[REDIS_CLUSTER_NAMELEN]; | |
445 | } clusterMsgDataFail; | |
446 | ||
447 | typedef struct { | |
448 | uint32_t channel_len; | |
449 | uint32_t message_len; | |
450 | unsigned char bulk_data[8]; /* defined as 8 just for alignment concerns. */ | |
451 | } clusterMsgDataPublish; | |
452 | ||
453 | union clusterMsgData { | |
454 | /* PING, MEET and PONG */ | |
455 | struct { | |
456 | /* Array of N clusterMsgDataGossip structures */ | |
457 | clusterMsgDataGossip gossip[1]; | |
458 | } ping; | |
459 | ||
460 | /* FAIL */ | |
461 | struct { | |
462 | clusterMsgDataFail about; | |
463 | } fail; | |
464 | ||
465 | /* PUBLISH */ | |
466 | struct { | |
467 | clusterMsgDataPublish msg; | |
468 | } publish; | |
469 | }; | |
470 | ||
471 | typedef struct { | |
472 | uint32_t totlen; /* Total length of this message */ | |
473 | uint16_t type; /* Message type */ | |
474 | uint16_t count; /* Only used for some kind of messages. */ | |
475 | char sender[REDIS_CLUSTER_NAMELEN]; /* Name of the sender node */ | |
476 | unsigned char myslots[REDIS_CLUSTER_SLOTS/8]; | |
477 | char slaveof[REDIS_CLUSTER_NAMELEN]; | |
478 | char configdigest[32]; | |
479 | uint16_t port; /* Sender TCP base port */ | |
480 | unsigned char state; /* Cluster state from the POV of the sender */ | |
481 | unsigned char notused[5]; /* Reserved for future use. For alignment. */ | |
482 | union clusterMsgData data; | |
483 | } clusterMsg; | |
484 | ||
485 | /*----------------------------------------------------------------------------- | |
486 | * Global server state | |
487 | *----------------------------------------------------------------------------*/ | |
488 | ||
489 | struct redisServer { | |
490 | /* General */ | |
491 | redisDb *db; | |
492 | dict *commands; /* Command table hahs table */ | |
493 | aeEventLoop *el; | |
494 | /* Networking */ | |
495 | int port; | |
496 | char *bindaddr; | |
497 | char *unixsocket; | |
498 | mode_t unixsocketperm; | |
499 | int ipfd; | |
500 | int sofd; | |
501 | int cfd; | |
502 | list *clients; | |
503 | list *slaves, *monitors; | |
504 | char neterr[ANET_ERR_LEN]; | |
505 | /* RDB / AOF loading information */ | |
506 | int loading; | |
507 | off_t loading_total_bytes; | |
508 | off_t loading_loaded_bytes; | |
509 | time_t loading_start_time; | |
510 | /* Fast pointers to often looked up command */ | |
511 | struct redisCommand *delCommand, *multiCommand; | |
512 | int cronloops; /* number of times the cron function run */ | |
513 | time_t lastsave; /* Unix time of last save succeeede */ | |
514 | /* Fields used only for stats */ | |
515 | time_t stat_starttime; /* server start time */ | |
516 | long long stat_numcommands; /* number of processed commands */ | |
517 | long long stat_numconnections; /* number of connections received */ | |
518 | long long stat_expiredkeys; /* number of expired keys */ | |
519 | long long stat_evictedkeys; /* number of evicted keys (maxmemory) */ | |
520 | long long stat_keyspace_hits; /* number of successful lookups of keys */ | |
521 | long long stat_keyspace_misses; /* number of failed lookups of keys */ | |
522 | size_t stat_peak_memory; /* max used memory record */ | |
523 | long long stat_fork_time; /* time needed to perform latets fork() */ | |
524 | list *slowlog; | |
525 | long long slowlog_entry_id; | |
526 | long long slowlog_log_slower_than; | |
527 | unsigned long slowlog_max_len; | |
528 | /* Configuration */ | |
529 | int verbosity; | |
530 | int maxidletime; | |
531 | int dbnum; | |
532 | int daemonize; | |
533 | int appendonly; | |
534 | int appendfsync; | |
535 | int no_appendfsync_on_rewrite; | |
536 | int auto_aofrewrite_perc; /* Rewrite AOF if % growth is > M and... */ | |
537 | off_t auto_aofrewrite_min_size; /* the AOF file is at least N bytes. */ | |
538 | off_t auto_aofrewrite_base_size;/* AOF size on latest startup or rewrite. */ | |
539 | off_t appendonly_current_size; /* AOF current size. */ | |
540 | int aofrewrite_scheduled; /* Rewrite once BGSAVE terminates. */ | |
541 | int shutdown_asap; | |
542 | int activerehashing; | |
543 | char *requirepass; | |
544 | /* Persistence */ | |
545 | long long dirty; /* changes to DB from the last save */ | |
546 | long long dirty_before_bgsave; /* used to restore dirty on failed BGSAVE */ | |
547 | time_t lastfsync; | |
548 | int appendfd; | |
549 | int appendseldb; | |
550 | time_t aof_flush_postponed_start; | |
551 | char *pidfile; | |
552 | pid_t bgsavechildpid; | |
553 | pid_t bgrewritechildpid; | |
554 | sds bgrewritebuf; /* buffer taken by parent during oppend only rewrite */ | |
555 | sds aofbuf; /* AOF buffer, written before entering the event loop */ | |
556 | struct saveparam *saveparams; | |
557 | int saveparamslen; | |
558 | char *dbfilename; | |
559 | int rdbcompression; | |
560 | char *appendfilename; | |
561 | /* Logging */ | |
562 | char *logfile; | |
563 | int syslog_enabled; | |
564 | char *syslog_ident; | |
565 | int syslog_facility; | |
566 | /* Replication related */ | |
567 | int isslave; | |
568 | /* Slave specific fields */ | |
569 | char *masterauth; | |
570 | char *masterhost; | |
571 | int masterport; | |
572 | int repl_ping_slave_period; | |
573 | int repl_timeout; | |
574 | redisClient *master; /* client that is master for this slave */ | |
575 | int repl_syncio_timeout; /* timeout for synchronous I/O calls */ | |
576 | int replstate; /* replication status if the instance is a slave */ | |
577 | off_t repl_transfer_left; /* bytes left reading .rdb */ | |
578 | int repl_transfer_s; /* slave -> master SYNC socket */ | |
579 | int repl_transfer_fd; /* slave -> master SYNC temp file descriptor */ | |
580 | char *repl_transfer_tmpfile; /* slave-> master SYNC temp file name */ | |
581 | time_t repl_transfer_lastio; /* unix time of the latest read, for timeout */ | |
582 | int repl_serve_stale_data; /* Serve stale data when link is down? */ | |
583 | time_t repl_down_since; /* unix time at which link with master went down */ | |
584 | /* Limits */ | |
585 | unsigned int maxclients; | |
586 | unsigned long long maxmemory; | |
587 | int maxmemory_policy; | |
588 | int maxmemory_samples; | |
589 | /* Blocked clients */ | |
590 | unsigned int bpop_blocked_clients; | |
591 | list *unblocked_clients; /* list of clients to unblock before next loop */ | |
592 | /* Sort parameters - qsort_r() is only available under BSD so we | |
593 | * have to take this state global, in order to pass it to sortCompare() */ | |
594 | int sort_desc; | |
595 | int sort_alpha; | |
596 | int sort_bypattern; | |
597 | /* Zip structure config */ | |
598 | size_t hash_max_zipmap_entries; | |
599 | size_t hash_max_zipmap_value; | |
600 | size_t list_max_ziplist_entries; | |
601 | size_t list_max_ziplist_value; | |
602 | size_t set_max_intset_entries; | |
603 | size_t zset_max_ziplist_entries; | |
604 | size_t zset_max_ziplist_value; | |
605 | time_t unixtime; /* Unix time sampled every second. */ | |
606 | /* Pubsub */ | |
607 | dict *pubsub_channels; /* Map channels to list of subscribed clients */ | |
608 | list *pubsub_patterns; /* A list of pubsub_patterns */ | |
609 | /* Misc */ | |
610 | unsigned lruclock:22; /* clock incrementing every minute, for LRU */ | |
611 | unsigned lruclock_padding:10; | |
612 | /* Cluster */ | |
613 | int cluster_enabled; | |
614 | clusterState cluster; | |
615 | /* Scripting */ | |
616 | lua_State *lua; /* The Lua interpreter. We use just one for all clients */ | |
617 | redisClient *lua_client; /* The "fake client" to query Redis from Lua */ | |
618 | dict *lua_scripts; /* A dictionary of SHA1 -> Lua scripts */ | |
619 | long long lua_time_limit; | |
620 | long long lua_time_start; | |
621 | int lua_random_dirty; /* True if a random command was called during the | |
622 | exection of the current script. */ | |
623 | int lua_timedout; /* True if we reached the time limit for script | |
624 | execution. */ | |
625 | }; | |
626 | ||
627 | typedef struct pubsubPattern { | |
628 | redisClient *client; | |
629 | robj *pattern; | |
630 | } pubsubPattern; | |
631 | ||
632 | typedef void redisCommandProc(redisClient *c); | |
633 | typedef int *redisGetKeysProc(struct redisCommand *cmd, robj **argv, int argc, int *numkeys, int flags); | |
634 | struct redisCommand { | |
635 | char *name; | |
636 | redisCommandProc *proc; | |
637 | int arity; | |
638 | char *sflags; /* Flags as string represenation, one char per flag. */ | |
639 | int flags; /* The actual flags, obtained from the 'sflags' field. */ | |
640 | /* Use a function to determine keys arguments in a command line. | |
641 | * Used for Redis Cluster redirect. */ | |
642 | redisGetKeysProc *getkeys_proc; | |
643 | /* What keys should be loaded in background when calling this command? */ | |
644 | int firstkey; /* The first argument that's a key (0 = no keys) */ | |
645 | int lastkey; /* THe last argument that's a key */ | |
646 | int keystep; /* The step between first and last key */ | |
647 | long long microseconds, calls; | |
648 | }; | |
649 | ||
650 | struct redisFunctionSym { | |
651 | char *name; | |
652 | unsigned long pointer; | |
653 | }; | |
654 | ||
655 | typedef struct _redisSortObject { | |
656 | robj *obj; | |
657 | union { | |
658 | double score; | |
659 | robj *cmpobj; | |
660 | } u; | |
661 | } redisSortObject; | |
662 | ||
663 | typedef struct _redisSortOperation { | |
664 | int type; | |
665 | robj *pattern; | |
666 | } redisSortOperation; | |
667 | ||
668 | /* Structure to hold list iteration abstraction. */ | |
669 | typedef struct { | |
670 | robj *subject; | |
671 | unsigned char encoding; | |
672 | unsigned char direction; /* Iteration direction */ | |
673 | unsigned char *zi; | |
674 | listNode *ln; | |
675 | } listTypeIterator; | |
676 | ||
677 | /* Structure for an entry while iterating over a list. */ | |
678 | typedef struct { | |
679 | listTypeIterator *li; | |
680 | unsigned char *zi; /* Entry in ziplist */ | |
681 | listNode *ln; /* Entry in linked list */ | |
682 | } listTypeEntry; | |
683 | ||
684 | /* Structure to hold set iteration abstraction. */ | |
685 | typedef struct { | |
686 | robj *subject; | |
687 | int encoding; | |
688 | int ii; /* intset iterator */ | |
689 | dictIterator *di; | |
690 | } setTypeIterator; | |
691 | ||
692 | /* Structure to hold hash iteration abstration. Note that iteration over | |
693 | * hashes involves both fields and values. Because it is possible that | |
694 | * not both are required, store pointers in the iterator to avoid | |
695 | * unnecessary memory allocation for fields/values. */ | |
696 | typedef struct { | |
697 | int encoding; | |
698 | unsigned char *zi; | |
699 | unsigned char *zk, *zv; | |
700 | unsigned int zklen, zvlen; | |
701 | ||
702 | dictIterator *di; | |
703 | dictEntry *de; | |
704 | } hashTypeIterator; | |
705 | ||
706 | #define REDIS_HASH_KEY 1 | |
707 | #define REDIS_HASH_VALUE 2 | |
708 | ||
709 | /*----------------------------------------------------------------------------- | |
710 | * Extern declarations | |
711 | *----------------------------------------------------------------------------*/ | |
712 | ||
713 | extern struct redisServer server; | |
714 | extern struct sharedObjectsStruct shared; | |
715 | extern dictType setDictType; | |
716 | extern dictType zsetDictType; | |
717 | extern dictType clusterNodesDictType; | |
718 | extern dictType dbDictType; | |
719 | extern double R_Zero, R_PosInf, R_NegInf, R_Nan; | |
720 | dictType hashDictType; | |
721 | ||
722 | /*----------------------------------------------------------------------------- | |
723 | * Functions prototypes | |
724 | *----------------------------------------------------------------------------*/ | |
725 | ||
726 | /* Utils */ | |
727 | long long ustime(void); | |
728 | ||
729 | /* networking.c -- Networking and Client related operations */ | |
730 | redisClient *createClient(int fd); | |
731 | void closeTimedoutClients(void); | |
732 | void freeClient(redisClient *c); | |
733 | void resetClient(redisClient *c); | |
734 | void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask); | |
735 | void addReply(redisClient *c, robj *obj); | |
736 | void *addDeferredMultiBulkLength(redisClient *c); | |
737 | void setDeferredMultiBulkLength(redisClient *c, void *node, long length); | |
738 | void addReplySds(redisClient *c, sds s); | |
739 | void processInputBuffer(redisClient *c); | |
740 | void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask); | |
741 | void acceptUnixHandler(aeEventLoop *el, int fd, void *privdata, int mask); | |
742 | void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask); | |
743 | void addReplyBulk(redisClient *c, robj *obj); | |
744 | void addReplyBulkCString(redisClient *c, char *s); | |
745 | void addReplyBulkCBuffer(redisClient *c, void *p, size_t len); | |
746 | void addReplyBulkLongLong(redisClient *c, long long ll); | |
747 | void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask); | |
748 | void addReply(redisClient *c, robj *obj); | |
749 | void addReplySds(redisClient *c, sds s); | |
750 | void addReplyError(redisClient *c, char *err); | |
751 | void addReplyStatus(redisClient *c, char *status); | |
752 | void addReplyDouble(redisClient *c, double d); | |
753 | void addReplyLongLong(redisClient *c, long long ll); | |
754 | void addReplyMultiBulkLen(redisClient *c, long length); | |
755 | void *dupClientReplyValue(void *o); | |
756 | void getClientsMaxBuffers(unsigned long *longest_output_list, | |
757 | unsigned long *biggest_input_buffer); | |
758 | void rewriteClientCommandVector(redisClient *c, int argc, ...); | |
759 | void rewriteClientCommandArgument(redisClient *c, int i, robj *newval); | |
760 | ||
761 | #ifdef __GNUC__ | |
762 | void addReplyErrorFormat(redisClient *c, const char *fmt, ...) | |
763 | __attribute__((format(printf, 2, 3))); | |
764 | void addReplyStatusFormat(redisClient *c, const char *fmt, ...) | |
765 | __attribute__((format(printf, 2, 3))); | |
766 | #else | |
767 | void addReplyErrorFormat(redisClient *c, const char *fmt, ...); | |
768 | void addReplyStatusFormat(redisClient *c, const char *fmt, ...); | |
769 | #endif | |
770 | ||
771 | /* List data type */ | |
772 | void listTypeTryConversion(robj *subject, robj *value); | |
773 | void listTypePush(robj *subject, robj *value, int where); | |
774 | robj *listTypePop(robj *subject, int where); | |
775 | unsigned long listTypeLength(robj *subject); | |
776 | listTypeIterator *listTypeInitIterator(robj *subject, int index, unsigned char direction); | |
777 | void listTypeReleaseIterator(listTypeIterator *li); | |
778 | int listTypeNext(listTypeIterator *li, listTypeEntry *entry); | |
779 | robj *listTypeGet(listTypeEntry *entry); | |
780 | void listTypeInsert(listTypeEntry *entry, robj *value, int where); | |
781 | int listTypeEqual(listTypeEntry *entry, robj *o); | |
782 | void listTypeDelete(listTypeEntry *entry); | |
783 | void listTypeConvert(robj *subject, int enc); | |
784 | void unblockClientWaitingData(redisClient *c); | |
785 | int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele); | |
786 | void popGenericCommand(redisClient *c, int where); | |
787 | ||
788 | /* MULTI/EXEC/WATCH... */ | |
789 | void unwatchAllKeys(redisClient *c); | |
790 | void initClientMultiState(redisClient *c); | |
791 | void freeClientMultiState(redisClient *c); | |
792 | void queueMultiCommand(redisClient *c); | |
793 | void touchWatchedKey(redisDb *db, robj *key); | |
794 | void touchWatchedKeysOnFlush(int dbid); | |
795 | ||
796 | /* Redis object implementation */ | |
797 | void decrRefCount(void *o); | |
798 | void incrRefCount(robj *o); | |
799 | robj *resetRefCount(robj *obj); | |
800 | void freeStringObject(robj *o); | |
801 | void freeListObject(robj *o); | |
802 | void freeSetObject(robj *o); | |
803 | void freeZsetObject(robj *o); | |
804 | void freeHashObject(robj *o); | |
805 | robj *createObject(int type, void *ptr); | |
806 | robj *createStringObject(char *ptr, size_t len); | |
807 | robj *dupStringObject(robj *o); | |
808 | int isObjectRepresentableAsLongLong(robj *o, long long *llongval); | |
809 | robj *tryObjectEncoding(robj *o); | |
810 | robj *getDecodedObject(robj *o); | |
811 | size_t stringObjectLen(robj *o); | |
812 | robj *createStringObjectFromLongLong(long long value); | |
813 | robj *createListObject(void); | |
814 | robj *createZiplistObject(void); | |
815 | robj *createSetObject(void); | |
816 | robj *createIntsetObject(void); | |
817 | robj *createHashObject(void); | |
818 | robj *createZsetObject(void); | |
819 | robj *createZsetZiplistObject(void); | |
820 | int getLongFromObjectOrReply(redisClient *c, robj *o, long *target, const char *msg); | |
821 | int checkType(redisClient *c, robj *o, int type); | |
822 | int getLongLongFromObjectOrReply(redisClient *c, robj *o, long long *target, const char *msg); | |
823 | int getDoubleFromObjectOrReply(redisClient *c, robj *o, double *target, const char *msg); | |
824 | int getLongLongFromObject(robj *o, long long *target); | |
825 | char *strEncoding(int encoding); | |
826 | int compareStringObjects(robj *a, robj *b); | |
827 | int equalStringObjects(robj *a, robj *b); | |
828 | unsigned long estimateObjectIdleTime(robj *o); | |
829 | ||
830 | /* Synchronous I/O with timeout */ | |
831 | int syncWrite(int fd, char *ptr, ssize_t size, int timeout); | |
832 | int syncRead(int fd, char *ptr, ssize_t size, int timeout); | |
833 | int syncReadLine(int fd, char *ptr, ssize_t size, int timeout); | |
834 | ||
835 | /* Replication */ | |
836 | void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc); | |
837 | void replicationFeedMonitors(list *monitors, int dictid, robj **argv, int argc); | |
838 | void updateSlavesWaitingBgsave(int bgsaveerr); | |
839 | void replicationCron(void); | |
840 | ||
841 | /* Generic persistence functions */ | |
842 | void startLoading(FILE *fp); | |
843 | void loadingProgress(off_t pos); | |
844 | void stopLoading(void); | |
845 | ||
846 | /* RDB persistence */ | |
847 | #include "rdb.h" | |
848 | ||
849 | /* AOF persistence */ | |
850 | void flushAppendOnlyFile(int force); | |
851 | void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc); | |
852 | void aofRemoveTempFile(pid_t childpid); | |
853 | int rewriteAppendOnlyFileBackground(void); | |
854 | int loadAppendOnlyFile(char *filename); | |
855 | void stopAppendOnly(void); | |
856 | int startAppendOnly(void); | |
857 | void backgroundRewriteDoneHandler(int exitcode, int bysignal); | |
858 | ||
859 | /* Sorted sets data type */ | |
860 | ||
861 | /* Struct to hold a inclusive/exclusive range spec. */ | |
862 | typedef struct { | |
863 | double min, max; | |
864 | int minex, maxex; /* are min or max exclusive? */ | |
865 | } zrangespec; | |
866 | ||
867 | zskiplist *zslCreate(void); | |
868 | void zslFree(zskiplist *zsl); | |
869 | zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj); | |
870 | unsigned char *zzlInsert(unsigned char *zl, robj *ele, double score); | |
871 | int zslDelete(zskiplist *zsl, double score, robj *obj); | |
872 | zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec range); | |
873 | double zzlGetScore(unsigned char *sptr); | |
874 | void zzlNext(unsigned char *zl, unsigned char **eptr, unsigned char **sptr); | |
875 | void zzlPrev(unsigned char *zl, unsigned char **eptr, unsigned char **sptr); | |
876 | unsigned int zsetLength(robj *zobj); | |
877 | void zsetConvert(robj *zobj, int encoding); | |
878 | ||
879 | /* Core functions */ | |
880 | void freeMemoryIfNeeded(void); | |
881 | int processCommand(redisClient *c); | |
882 | void setupSignalHandlers(void); | |
883 | struct redisCommand *lookupCommand(sds name); | |
884 | struct redisCommand *lookupCommandByCString(char *s); | |
885 | void call(redisClient *c); | |
886 | int prepareForShutdown(); | |
887 | void redisLog(int level, const char *fmt, ...); | |
888 | void redisLogRaw(int level, const char *msg); | |
889 | void usage(); | |
890 | void updateDictResizePolicy(void); | |
891 | int htNeedsResize(dict *dict); | |
892 | void oom(const char *msg); | |
893 | void populateCommandTable(void); | |
894 | void resetCommandTableStats(void); | |
895 | ||
896 | /* Set data type */ | |
897 | robj *setTypeCreate(robj *value); | |
898 | int setTypeAdd(robj *subject, robj *value); | |
899 | int setTypeRemove(robj *subject, robj *value); | |
900 | int setTypeIsMember(robj *subject, robj *value); | |
901 | setTypeIterator *setTypeInitIterator(robj *subject); | |
902 | void setTypeReleaseIterator(setTypeIterator *si); | |
903 | int setTypeNext(setTypeIterator *si, robj **objele, int64_t *llele); | |
904 | robj *setTypeNextObject(setTypeIterator *si); | |
905 | int setTypeRandomElement(robj *setobj, robj **objele, int64_t *llele); | |
906 | unsigned long setTypeSize(robj *subject); | |
907 | void setTypeConvert(robj *subject, int enc); | |
908 | ||
909 | /* Hash data type */ | |
910 | void convertToRealHash(robj *o); | |
911 | void hashTypeTryConversion(robj *subject, robj **argv, int start, int end); | |
912 | void hashTypeTryObjectEncoding(robj *subject, robj **o1, robj **o2); | |
913 | int hashTypeGet(robj *o, robj *key, robj **objval, unsigned char **v, unsigned int *vlen); | |
914 | robj *hashTypeGetObject(robj *o, robj *key); | |
915 | int hashTypeExists(robj *o, robj *key); | |
916 | int hashTypeSet(robj *o, robj *key, robj *value); | |
917 | int hashTypeDelete(robj *o, robj *key); | |
918 | unsigned long hashTypeLength(robj *o); | |
919 | hashTypeIterator *hashTypeInitIterator(robj *subject); | |
920 | void hashTypeReleaseIterator(hashTypeIterator *hi); | |
921 | int hashTypeNext(hashTypeIterator *hi); | |
922 | int hashTypeCurrent(hashTypeIterator *hi, int what, robj **objval, unsigned char **v, unsigned int *vlen); | |
923 | robj *hashTypeCurrentObject(hashTypeIterator *hi, int what); | |
924 | robj *hashTypeLookupWriteOrCreate(redisClient *c, robj *key); | |
925 | ||
926 | /* Pub / Sub */ | |
927 | int pubsubUnsubscribeAllChannels(redisClient *c, int notify); | |
928 | int pubsubUnsubscribeAllPatterns(redisClient *c, int notify); | |
929 | void freePubsubPattern(void *p); | |
930 | int listMatchPubsubPattern(void *a, void *b); | |
931 | int pubsubPublishMessage(robj *channel, robj *message); | |
932 | ||
933 | /* Configuration */ | |
934 | void loadServerConfig(char *filename); | |
935 | void appendServerSaveParams(time_t seconds, int changes); | |
936 | void resetServerSaveParams(); | |
937 | ||
938 | /* db.c -- Keyspace access API */ | |
939 | int removeExpire(redisDb *db, robj *key); | |
940 | void propagateExpire(redisDb *db, robj *key); | |
941 | int expireIfNeeded(redisDb *db, robj *key); | |
942 | time_t getExpire(redisDb *db, robj *key); | |
943 | void setExpire(redisDb *db, robj *key, time_t when); | |
944 | robj *lookupKey(redisDb *db, robj *key); | |
945 | robj *lookupKeyRead(redisDb *db, robj *key); | |
946 | robj *lookupKeyWrite(redisDb *db, robj *key); | |
947 | robj *lookupKeyReadOrReply(redisClient *c, robj *key, robj *reply); | |
948 | robj *lookupKeyWriteOrReply(redisClient *c, robj *key, robj *reply); | |
949 | void dbAdd(redisDb *db, robj *key, robj *val); | |
950 | void dbOverwrite(redisDb *db, robj *key, robj *val); | |
951 | void setKey(redisDb *db, robj *key, robj *val); | |
952 | int dbExists(redisDb *db, robj *key); | |
953 | robj *dbRandomKey(redisDb *db); | |
954 | int dbDelete(redisDb *db, robj *key); | |
955 | long long emptyDb(); | |
956 | int selectDb(redisClient *c, int id); | |
957 | void signalModifiedKey(redisDb *db, robj *key); | |
958 | void signalFlushedDb(int dbid); | |
959 | unsigned int GetKeysInSlot(unsigned int hashslot, robj **keys, unsigned int count); | |
960 | ||
961 | /* API to get key arguments from commands */ | |
962 | #define REDIS_GETKEYS_ALL 0 | |
963 | #define REDIS_GETKEYS_PRELOAD 1 | |
964 | int *getKeysFromCommand(struct redisCommand *cmd, robj **argv, int argc, int *numkeys, int flags); | |
965 | void getKeysFreeResult(int *result); | |
966 | int *noPreloadGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags); | |
967 | int *renameGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags); | |
968 | int *zunionInterGetKeys(struct redisCommand *cmd,robj **argv, int argc, int *numkeys, int flags); | |
969 | ||
970 | /* Cluster */ | |
971 | void clusterInit(void); | |
972 | unsigned short crc16(const char *buf, int len); | |
973 | unsigned int keyHashSlot(char *key, int keylen); | |
974 | clusterNode *createClusterNode(char *nodename, int flags); | |
975 | int clusterAddNode(clusterNode *node); | |
976 | void clusterCron(void); | |
977 | clusterNode *getNodeByQuery(redisClient *c, struct redisCommand *cmd, robj **argv, int argc, int *hashslot, int *ask); | |
978 | void clusterPropagatePublish(robj *channel, robj *message); | |
979 | ||
980 | /* Scripting */ | |
981 | void scriptingInit(void); | |
982 | ||
983 | /* Git SHA1 */ | |
984 | char *redisGitSHA1(void); | |
985 | char *redisGitDirty(void); | |
986 | ||
987 | /* Commands prototypes */ | |
988 | void authCommand(redisClient *c); | |
989 | void pingCommand(redisClient *c); | |
990 | void echoCommand(redisClient *c); | |
991 | void setCommand(redisClient *c); | |
992 | void setnxCommand(redisClient *c); | |
993 | void setexCommand(redisClient *c); | |
994 | void getCommand(redisClient *c); | |
995 | void delCommand(redisClient *c); | |
996 | void existsCommand(redisClient *c); | |
997 | void setbitCommand(redisClient *c); | |
998 | void getbitCommand(redisClient *c); | |
999 | void setrangeCommand(redisClient *c); | |
1000 | void getrangeCommand(redisClient *c); | |
1001 | void incrCommand(redisClient *c); | |
1002 | void decrCommand(redisClient *c); | |
1003 | void incrbyCommand(redisClient *c); | |
1004 | void decrbyCommand(redisClient *c); | |
1005 | void selectCommand(redisClient *c); | |
1006 | void randomkeyCommand(redisClient *c); | |
1007 | void keysCommand(redisClient *c); | |
1008 | void dbsizeCommand(redisClient *c); | |
1009 | void lastsaveCommand(redisClient *c); | |
1010 | void saveCommand(redisClient *c); | |
1011 | void bgsaveCommand(redisClient *c); | |
1012 | void bgrewriteaofCommand(redisClient *c); | |
1013 | void shutdownCommand(redisClient *c); | |
1014 | void moveCommand(redisClient *c); | |
1015 | void renameCommand(redisClient *c); | |
1016 | void renamenxCommand(redisClient *c); | |
1017 | void lpushCommand(redisClient *c); | |
1018 | void rpushCommand(redisClient *c); | |
1019 | void lpushxCommand(redisClient *c); | |
1020 | void rpushxCommand(redisClient *c); | |
1021 | void linsertCommand(redisClient *c); | |
1022 | void lpopCommand(redisClient *c); | |
1023 | void rpopCommand(redisClient *c); | |
1024 | void llenCommand(redisClient *c); | |
1025 | void lindexCommand(redisClient *c); | |
1026 | void lrangeCommand(redisClient *c); | |
1027 | void ltrimCommand(redisClient *c); | |
1028 | void typeCommand(redisClient *c); | |
1029 | void lsetCommand(redisClient *c); | |
1030 | void saddCommand(redisClient *c); | |
1031 | void sremCommand(redisClient *c); | |
1032 | void smoveCommand(redisClient *c); | |
1033 | void sismemberCommand(redisClient *c); | |
1034 | void scardCommand(redisClient *c); | |
1035 | void spopCommand(redisClient *c); | |
1036 | void srandmemberCommand(redisClient *c); | |
1037 | void sinterCommand(redisClient *c); | |
1038 | void sinterstoreCommand(redisClient *c); | |
1039 | void sunionCommand(redisClient *c); | |
1040 | void sunionstoreCommand(redisClient *c); | |
1041 | void sdiffCommand(redisClient *c); | |
1042 | void sdiffstoreCommand(redisClient *c); | |
1043 | void syncCommand(redisClient *c); | |
1044 | void flushdbCommand(redisClient *c); | |
1045 | void flushallCommand(redisClient *c); | |
1046 | void sortCommand(redisClient *c); | |
1047 | void lremCommand(redisClient *c); | |
1048 | void rpoplpushCommand(redisClient *c); | |
1049 | void infoCommand(redisClient *c); | |
1050 | void mgetCommand(redisClient *c); | |
1051 | void monitorCommand(redisClient *c); | |
1052 | void expireCommand(redisClient *c); | |
1053 | void expireatCommand(redisClient *c); | |
1054 | void getsetCommand(redisClient *c); | |
1055 | void ttlCommand(redisClient *c); | |
1056 | void persistCommand(redisClient *c); | |
1057 | void slaveofCommand(redisClient *c); | |
1058 | void debugCommand(redisClient *c); | |
1059 | void msetCommand(redisClient *c); | |
1060 | void msetnxCommand(redisClient *c); | |
1061 | void zaddCommand(redisClient *c); | |
1062 | void zincrbyCommand(redisClient *c); | |
1063 | void zrangeCommand(redisClient *c); | |
1064 | void zrangebyscoreCommand(redisClient *c); | |
1065 | void zrevrangebyscoreCommand(redisClient *c); | |
1066 | void zcountCommand(redisClient *c); | |
1067 | void zrevrangeCommand(redisClient *c); | |
1068 | void zcardCommand(redisClient *c); | |
1069 | void zremCommand(redisClient *c); | |
1070 | void zscoreCommand(redisClient *c); | |
1071 | void zremrangebyscoreCommand(redisClient *c); | |
1072 | void multiCommand(redisClient *c); | |
1073 | void execCommand(redisClient *c); | |
1074 | void discardCommand(redisClient *c); | |
1075 | void blpopCommand(redisClient *c); | |
1076 | void brpopCommand(redisClient *c); | |
1077 | void brpoplpushCommand(redisClient *c); | |
1078 | void appendCommand(redisClient *c); | |
1079 | void strlenCommand(redisClient *c); | |
1080 | void zrankCommand(redisClient *c); | |
1081 | void zrevrankCommand(redisClient *c); | |
1082 | void hsetCommand(redisClient *c); | |
1083 | void hsetnxCommand(redisClient *c); | |
1084 | void hgetCommand(redisClient *c); | |
1085 | void hmsetCommand(redisClient *c); | |
1086 | void hmgetCommand(redisClient *c); | |
1087 | void hdelCommand(redisClient *c); | |
1088 | void hlenCommand(redisClient *c); | |
1089 | void zremrangebyrankCommand(redisClient *c); | |
1090 | void zunionstoreCommand(redisClient *c); | |
1091 | void zinterstoreCommand(redisClient *c); | |
1092 | void hkeysCommand(redisClient *c); | |
1093 | void hvalsCommand(redisClient *c); | |
1094 | void hgetallCommand(redisClient *c); | |
1095 | void hexistsCommand(redisClient *c); | |
1096 | void configCommand(redisClient *c); | |
1097 | void hincrbyCommand(redisClient *c); | |
1098 | void subscribeCommand(redisClient *c); | |
1099 | void unsubscribeCommand(redisClient *c); | |
1100 | void psubscribeCommand(redisClient *c); | |
1101 | void punsubscribeCommand(redisClient *c); | |
1102 | void publishCommand(redisClient *c); | |
1103 | void watchCommand(redisClient *c); | |
1104 | void unwatchCommand(redisClient *c); | |
1105 | void clusterCommand(redisClient *c); | |
1106 | void restoreCommand(redisClient *c); | |
1107 | void migrateCommand(redisClient *c); | |
1108 | void askingCommand(redisClient *c); | |
1109 | void dumpCommand(redisClient *c); | |
1110 | void objectCommand(redisClient *c); | |
1111 | void clientCommand(redisClient *c); | |
1112 | void evalCommand(redisClient *c); | |
1113 | void evalShaCommand(redisClient *c); | |
1114 | void scriptCommand(redisClient *c); | |
1115 | ||
1116 | #if defined(__GNUC__) | |
1117 | void *calloc(size_t count, size_t size) __attribute__ ((deprecated)); | |
1118 | void free(void *ptr) __attribute__ ((deprecated)); | |
1119 | void *malloc(size_t size) __attribute__ ((deprecated)); | |
1120 | void *realloc(void *ptr, size_t size) __attribute__ ((deprecated)); | |
1121 | #endif | |
1122 | ||
1123 | /* Debugging stuff */ | |
1124 | void _redisAssertWithInfo(redisClient *c, robj *o, char *estr, char *file, int line); | |
1125 | void _redisAssert(char *estr, char *file, int line); | |
1126 | void _redisPanic(char *msg, char *file, int line); | |
1127 | ||
1128 | #endif |