mirror of https://mirror.osredm.com/root/redis.git
git mess :)
This commit is contained in:
commit
0c9ca0e11c
|
@ -0,0 +1,8 @@
|
|||
*.o
|
||||
*.rdb
|
||||
redis-cli
|
||||
redis-server
|
||||
redis-benchmark
|
||||
doc-tools
|
||||
mkrelease.sh
|
||||
release
|
2
Makefile
2
Makefile
|
@ -23,7 +23,7 @@ anet.o: anet.c anet.h
|
|||
benchmark.o: benchmark.c ae.h anet.h sds.h adlist.h
|
||||
dict.o: dict.c dict.h
|
||||
redis-cli.o: redis-cli.c anet.h sds.h adlist.h
|
||||
redis.o: redis.c ae.h sds.h anet.h dict.h adlist.h
|
||||
redis.o: redis.c ae.h sds.h anet.h dict.h adlist.h zmalloc.c zmalloc.h
|
||||
sds.o: sds.c sds.h
|
||||
sha1.o: sha1.c sha1.h
|
||||
zmalloc.o: zmalloc.c
|
||||
|
|
12
TODO
12
TODO
|
@ -1,4 +1,4 @@
|
|||
BETA 8 TODO
|
||||
- Protocol changes as discussed in the Redis group
|
||||
- keys expire
|
||||
- sunion ssub
|
||||
- write integers in a special way on disk (and on memory?)
|
||||
|
@ -6,12 +6,4 @@ BETA 8 TODO
|
|||
- network layer stresser in test in demo
|
||||
- maxclients directive
|
||||
- check 'server.dirty' everywere
|
||||
- replication tests
|
||||
- command line client. If the last argument of a bulk command is missing get it from stdin. Example:
|
||||
$ echo "bar" | redis-client SET foo
|
||||
$ redis-client SET foo bar
|
||||
$ redis-client GET foo
|
||||
bar
|
||||
$
|
||||
- Make Redis aware of the memory it is using thanks to getrusage() and report this info with the INFO command.
|
||||
- INFO command: clients, slave/master, requests/second in the last N seconds, memory usage, uptime, dirty, lastsave
|
||||
- replication automated tests
|
||||
|
|
File diff suppressed because one or more lines are too long
|
@ -16,7 +16,7 @@
|
|||
<div id="pagecontent">
|
||||
<div class="index">
|
||||
<!-- This is a (PRE) block. Make sure it's left aligned or your toc title will be off. -->
|
||||
<b>ProtocolSpecification: Contents</b><br> <a href="#Protocol Specification">Protocol Specification</a><br> <a href="#Networking layer">Networking layer</a><br> <a href="#Simple INLINE commands">Simple INLINE commands</a><br> <a href="#Bulk commands">Bulk commands</a><br> <a href="#Bulk replies">Bulk replies</a><br> <a href="#Bulk reply error reporting">Bulk reply error reporting</a><br> <a href="#Multi-Bulk replies">Multi-Bulk replies</a><br> <a href="#Nil elements in Multi-Bulk replies">Nil elements in Multi-Bulk replies</a><br> <a href="#Multi-Bulk replies errors">Multi-Bulk replies errors</a><br> <a href="#Status code reply">Status code reply</a><br> <a href="#Integer reply">Integer reply</a><br> <a href="#Single line reply">Single line reply</a><br> <a href="#Multiple commands and pipelining">Multiple commands and pipelining</a>
|
||||
<b>ProtocolSpecification: Contents</b><br> <a href="#Protocol Specification">Protocol Specification</a><br> <a href="#Networking layer">Networking layer</a><br> <a href="#Simple INLINE commands">Simple INLINE commands</a><br> <a href="#Bulk commands">Bulk commands</a><br> <a href="#Bulk replies">Bulk replies</a><br> <a href="#Multi-Bulk replies">Multi-Bulk replies</a><br> <a href="#Nil elements in Multi-Bulk replies">Nil elements in Multi-Bulk replies</a><br> <a href="#Single line reply">Single line reply</a><br> <a href="#Integer reply">Integer reply</a><br> <a href="#Multiple commands and pipelining">Multiple commands and pipelining</a>
|
||||
</div>
|
||||
|
||||
<h1 class="wikiname">ProtocolSpecification</h1>
|
||||
|
@ -35,14 +35,12 @@ terminated by "\r\n" (CRLF).<h2><a name="Simple INLINE commands">Simpl
|
|||
server/client chat (the server chat starts with S:, the client chat with C:)<br/><br/><pre class="codeblock python" name="code">
|
||||
C: PING
|
||||
S: +PONG
|
||||
</pre>An inline command is a CRLF-terminated string sent to the client. The server
|
||||
usually replies to inline commands with a single line that can be a number
|
||||
or a return code.<br/><br/>When the server replies with a status code (that is a one line reply just indicating if the operation succeeded or not), if the first character of the
|
||||
reply is a "+" then the command succeeded, if it is a "-" then the following
|
||||
part of the string is an error.<br/><br/>The following is another example of an INLINE command returning an integer:<br/><br/><pre class="codeblock python python" name="code">
|
||||
</pre>An inline command is a CRLF-terminated string sent to the client. The server can reply to commands in different ways:
|
||||
<ul><li> With an error message (the first byte of the reply will be "-")</li><li> With a single line reply (the first byte of the reply will be "+)</li><li> With bulk data (the first byte of the reply will be "$")</li><li> With multi-bulk data, a list of values (the first byte of the reply will be "<code name="code" class="python">*</code>")</li><li> With an integer number (the first byte of the reply will be ":")</li></ul>
|
||||
The following is another example of an INLINE command returning an integer:<br/><br/><pre class="codeblock python python" name="code">
|
||||
C: EXISTS somekey
|
||||
S: 0
|
||||
</pre>Since 'somekey' does not exist the server returned '0'.<br/><br/>Note that the EXISTS command takes one argument. Arguments are separated
|
||||
S: :0
|
||||
</pre>Since 'somekey' does not exist the server returned ':0'.<br/><br/>Note that the EXISTS command takes one argument. Arguments are separated
|
||||
simply by spaces.<h2><a name="Bulk commands">Bulk commands</a></h2>A bulk command is exactly like an inline command, but the last argument
|
||||
of the command must be a stream of bytes in order to send data to the server.
|
||||
the "SET" command is a bulk command, see the following example:<br/><br/><pre class="codeblock python python python" name="code">
|
||||
|
@ -58,82 +56,60 @@ sent by the client in the above sample:<br/><br/><blockquote>"SET mykey 6\r
|
|||
<h2><a name="Bulk replies">Bulk replies</a></h2>The server may reply to an inline or bulk command with a bulk reply. See
|
||||
the following example:<br/><br/><pre class="codeblock python python python python" name="code">
|
||||
C: GET mykey
|
||||
S: 6
|
||||
S: $6
|
||||
S: foobar
|
||||
</pre>A bulk reply is very similar to the last argument of a bulk command. The
|
||||
server sends as the first line the number of bytes of the actual reply
|
||||
followed by CRLF, then the bytes are sent followed by additional two bytes
|
||||
for the final CRLF. The exact sequence sent by the server is:<br/><br/><blockquote>"6\r\nfoobar\r\n"</blockquote>
|
||||
server sends as the first line a "$" byte followed by the number of bytes
|
||||
of the actual reply followed by CRLF, then the bytes are sent followed by
|
||||
additional two bytes for the final CRLF. The exact sequence sent by the
|
||||
server is:<br/><br/><blockquote>"$6\r\nfoobar\r\n"</blockquote>
|
||||
If the requested value does not exist the bulk reply will use the special
|
||||
value 'nil' instead to send the line containing the number of bytes to read.
|
||||
This is an example:<br/><br/><pre class="codeblock python python python python python" name="code">
|
||||
value -1 as data length, example:<br/><br/><pre class="codeblock python python python python python" name="code">
|
||||
C: GET nonexistingkey
|
||||
S: nil
|
||||
</pre>The client library API should not return an empty string, but a nil object.
|
||||
S: $-1
|
||||
</pre>The client library API should not return an empty string, but a nil object, when the requested object does not exist.
|
||||
For example a Ruby library should return 'nil' while a C library should return
|
||||
NULL.<h2><a name="Bulk reply error reporting">Bulk reply error reporting</a></h2>Bulk replies can signal errors, for example trying to use GET against a list
|
||||
value is not permitted. Bulk replies use a negative bytes count in order to
|
||||
signal an error. An error string of ABS(bytes_count) bytes will follow. See
|
||||
the following example:<br/><br/><pre class="codeblock python python python python python python" name="code">
|
||||
S: GET alistkey
|
||||
S: -38
|
||||
S: -ERR Requested element is not a string
|
||||
</pre>-38 means: sorry your operation resulted in an error, but a 38 bytes string
|
||||
that explains this error will follow. Client APIs should abort on this kind
|
||||
of errors, for example a PHP client should call the die() function.<br/><br/>The following commands reply with a bulk reply: GET, KEYS, LINDEX, LPOP, RPOP<h2><a name="Multi-Bulk replies">Multi-Bulk replies</a></h2>Commands similar to LRANGE needs to return multiple values (every element
|
||||
NULL, and so forth.<h2><a name="Multi-Bulk replies">Multi-Bulk replies</a></h2>Commands similar to LRANGE needs to return multiple values (every element
|
||||
of the list is a value, and LRANGE needs to return more than a single element). This is accomplished using multiple bulk writes,
|
||||
prefixed by an initial line indicating how many bulk writes will follow.
|
||||
Example:<br/><br/><pre class="codeblock python python python python python python python" name="code">
|
||||
The first byte of a multi bulk reply is always <code name="code" class="python">*</code>. Example:<br/><br/><pre class="codeblock python python python python python python" name="code">
|
||||
C: LRANGE mylist 0 3
|
||||
S: 4
|
||||
S: 3
|
||||
S: *4
|
||||
S: $3
|
||||
S: foo
|
||||
S: 3
|
||||
S: $3
|
||||
S: bar
|
||||
S: 5
|
||||
S: $5
|
||||
S: Hello
|
||||
S: 5
|
||||
S: $5
|
||||
S: World
|
||||
</pre>The first line the server sent is "4\r\n" in order to specify that four bulk
|
||||
</pre>The first line the server sent is "<b>4\r\n" in order to specify that four bulk
|
||||
write will follow. Then every bulk write is transmitted.<br/><br/>If the specified key does not exist instead of the number of elements in the
|
||||
list, the special value 'nil' is sent. Example:<br/><br/><pre class="codeblock python python python python python python python python" name="code">
|
||||
list, the special value -1 is sent as count. Example:<br/><br/><pre class="codeblock python python python python python python python" name="code">
|
||||
C: LRANGE nokey 0 1
|
||||
S: nil
|
||||
S: *-1
|
||||
</pre>A client library API SHOULD return a nil object and not an empty list when this
|
||||
happens. This makes possible to distinguish between empty list and non existing ones.<h2><a name="Nil elements in Multi-Bulk replies">Nil elements in Multi-Bulk replies</a></h2>Single elements of a multi bulk reply may have -1 length, in order to signal that this elements are missing and not empty strings. This can happen with the SORT command when used with the GET <i>pattern</i> option when the specified key is missing. Example of a multi bulk reply containing an empty element:<br/><br/><pre class="codeblock python python python python python python python python python" name="code">
|
||||
S: 3
|
||||
S: 3
|
||||
happens. This makes possible to distinguish between empty list and non existing ones.<h2><a name="Nil elements in Multi-Bulk replies">Nil elements in Multi-Bulk replies</a></h2>Single elements of a multi bulk reply may have -1 length, in order to signal that this elements are missing and not empty strings. This can happen with the SORT command when used with the GET <i>pattern</i> option when the specified key is missing. Example of a multi bulk reply containing an empty element:<br/><br/><pre class="codeblock python python python python python python python python" name="code">
|
||||
S: *3
|
||||
S: $3
|
||||
S: foo
|
||||
S: -1
|
||||
S: 3
|
||||
S: $-1
|
||||
S: $3
|
||||
S: bar
|
||||
</pre>The second element is nul. The client library should return something like this:<br/><br/><pre class="codeblock python python python python python python python python python python" name="code">
|
||||
</pre>The second element is nul. The client library should return something like this:<br/><br/><pre class="codeblock python python python python python python python python python" name="code">
|
||||
["foo",nil,"bar"]
|
||||
</pre><h2><a name="Multi-Bulk replies errors">Multi-Bulk replies errors</a></h2>Like bulk reply errors Multi-bulk reply errors are reported using a negative
|
||||
count. Example:<br/><br/><pre class="codeblock python python python python python python python python python python python" name="code">
|
||||
C: LRANGE stringkey 0 1
|
||||
S: -38
|
||||
S: -ERR Requested element is not a string
|
||||
</pre>The following commands reply with a multi-bulk reply: LRANGE, LINTER<br/><br/>Check the Bulk replies errors section for more information.<h2><a name="Status code reply">Status code reply</a></h2>As already seen a status code reply is in the form of a single line string
|
||||
terminated by "\r\n". For example:<br/><br/><pre class="codeblock python python python python python python python python python python python python" name="code">
|
||||
</pre><h2><a name="Single line reply">Single line reply</a></h2>As already seen a single line reply is in the form of a single line string
|
||||
starting with "+" terminated by "\r\n". For example:<br/><br/><pre class="codeblock python python python python python python python python python python" name="code">
|
||||
+OK
|
||||
</pre>and<br/><br/><pre class="codeblock python python python python python python python python python python python python python" name="code">
|
||||
-ERR no suck key
|
||||
</pre>are two examples of status code replies. The first character of a status code reply is always "+" or "-".<br/><br/>The following commands reply with a status code reply:
|
||||
PING, SET, SELECT, SAVE, BGSAVE, SHUTDOWN, RENAME, LPUSH, RPUSH, LSET, LTRIM<h2><a name="Integer reply">Integer reply</a></h2>This type of reply is just a CRLF terminated string representing an integer. For example "0\r\n", or "1000\r\n" are integer replies.<br/><br/>With commands like INCR or LASTSAVE using the integer reply to actually return a value there is no special meaning for the returned integer. It is just an incremental number for INCR, a UNIX time for LASTSAVE and so on.<br/><br/>Some commands like EXISTS will return 1 for true and 0 for false.<br/><br/>Other commands like SADD, SREM and SETNX will return 1 if the operation was actually done, 0 otherwise, and <b>a negative value</b> if the operation is invalid (for example SADD against a non-set value), accordingly to this table:
|
||||
<pre class="codeblock python python python python python python python python python python python python python python" name="code">
|
||||
-1 no such key
|
||||
-2 operation against the a key holding a value of the wrong type
|
||||
-3 source and destiantion objects/dbs are the same
|
||||
-4 argument out of range
|
||||
</pre>
|
||||
In all this cases it is mandatory that the client raises an error instead to pass the negative value to the caller. Please check the commands documentation for the exact behaviour.<br/><br/>The following commands will reply with an integer reply: SETNX, DEL, EXISTS, INCR, INCRBY, DECR, DECRBY, DBSIZE, LASTSAVE, RENAMENX, MOVE, LLEN, SADD, SREM, SISMEMBER, SCARD<br/><br/>The commands that will never return a negative integer (commands that can't fail) are: INCR, DECR, INCRBY, DECRBY, LASTSAVE, EXISTS, SETNX, DEL, DBSIZE.<h2><a name="Single line reply">Single line reply</a></h2>This replies are just single line strings terminated by CRLF. Only two commands reply in this way currently, RANDOMKEY and TYPE.<h2><a name="Multiple commands and pipelining">Multiple commands and pipelining</a></h2>A client can use the same connection in order to issue multiple commands.
|
||||
</pre>The client library should return everything after the "+", that is, the string "OK" in the example.<br/><br/>The following commands reply with a status code reply:
|
||||
PING, SET, SELECT, SAVE, BGSAVE, SHUTDOWN, RENAME, LPUSH, RPUSH, LSET, LTRIM<h2><a name="Integer reply">Integer reply</a></h2>This type of reply is just a CRLF terminated string representing an integer, prefixed by a ":" byte. For example ":0\r\n", or ":1000\r\n" are integer replies.<br/><br/>With commands like INCR or LASTSAVE using the integer reply to actually return a value there is no special meaning for the returned integer. It is just an incremental number for INCR, a UNIX time for LASTSAVE and so on.<br/><br/>Some commands like EXISTS will return 1 for true and 0 for false.<br/><br/>Other commands like SADD, SREM and SETNX will return 1 if the operation was actually done, 0 otherwise.<br/><br/>The following commands will reply with an integer reply: SETNX, DEL, EXISTS, INCR, INCRBY, DECR, DECRBY, DBSIZE, LASTSAVE, RENAMENX, MOVE, LLEN, SADD, SREM, SISMEMBER, SCARD<h2><a name="Multiple commands and pipelining">Multiple commands and pipelining</a></h2>A client can use the same connection in order to issue multiple commands.
|
||||
Pipelining is supported so multiple commands can be sent with a single
|
||||
write operation by the client, it is not needed to read the server reply
|
||||
in order to issue the next command. All the replies can be read at the end.<br/><br/>Usually Redis server and client will have a very fast link so this is not
|
||||
very important to support this feature in a client implementation, still
|
||||
if an application needs to issue a very large number of commands in short
|
||||
time to use pipelining can be much faster.<br/><br/>
|
||||
time to use pipelining can be much faster.
|
||||
</b>
|
||||
</div>
|
||||
|
||||
</div>
|
||||
|
|
171
redis-cli.c
171
redis-cli.c
|
@ -40,11 +40,6 @@
|
|||
|
||||
#define REDIS_CMD_INLINE 1
|
||||
#define REDIS_CMD_BULK 2
|
||||
#define REDIS_CMD_INTREPLY 4
|
||||
#define REDIS_CMD_RETCODEREPLY 8
|
||||
#define REDIS_CMD_BULKREPLY 16
|
||||
#define REDIS_CMD_MULTIBULKREPLY 32
|
||||
#define REDIS_CMD_SINGLELINEREPLY 64
|
||||
|
||||
#define REDIS_NOTUSED(V) ((void) V)
|
||||
|
||||
|
@ -60,54 +55,56 @@ struct redisCommand {
|
|||
};
|
||||
|
||||
static struct redisCommand cmdTable[] = {
|
||||
{"get",2,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY},
|
||||
{"set",3,REDIS_CMD_BULK|REDIS_CMD_RETCODEREPLY},
|
||||
{"setnx",3,REDIS_CMD_BULK|REDIS_CMD_INTREPLY},
|
||||
{"del",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"exists",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"incr",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"decr",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"rpush",3,REDIS_CMD_BULK|REDIS_CMD_RETCODEREPLY},
|
||||
{"lpush",3,REDIS_CMD_BULK|REDIS_CMD_RETCODEREPLY},
|
||||
{"rpop",2,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY},
|
||||
{"lpop",2,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY},
|
||||
{"llen",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"lindex",3,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY},
|
||||
{"lset",4,REDIS_CMD_BULK|REDIS_CMD_RETCODEREPLY},
|
||||
{"lrange",4,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY},
|
||||
{"ltrim",4,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"lrem",4,REDIS_CMD_BULK|REDIS_CMD_INTREPLY},
|
||||
{"sadd",3,REDIS_CMD_BULK|REDIS_CMD_INTREPLY},
|
||||
{"srem",3,REDIS_CMD_BULK|REDIS_CMD_INTREPLY},
|
||||
{"sismember",3,REDIS_CMD_BULK|REDIS_CMD_INTREPLY},
|
||||
{"scard",2,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"sinter",-2,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY},
|
||||
{"sinterstore",-3,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"smembers",2,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY},
|
||||
{"incrby",3,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"decrby",3,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"randomkey",1,REDIS_CMD_INLINE|REDIS_CMD_SINGLELINEREPLY},
|
||||
{"select",2,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"move",3,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"rename",3,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"renamenx",3,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"keys",2,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY},
|
||||
{"dbsize",1,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"ping",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"echo",2,REDIS_CMD_BULK|REDIS_CMD_BULKREPLY},
|
||||
{"save",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"bgsave",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"shutdown",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"lastsave",1,REDIS_CMD_INLINE|REDIS_CMD_INTREPLY},
|
||||
{"type",2,REDIS_CMD_INLINE|REDIS_CMD_SINGLELINEREPLY},
|
||||
{"flushdb",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"flushall",1,REDIS_CMD_INLINE|REDIS_CMD_RETCODEREPLY},
|
||||
{"sort",-2,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY},
|
||||
{"info",1,REDIS_CMD_INLINE|REDIS_CMD_BULKREPLY},
|
||||
{"mget",-2,REDIS_CMD_INLINE|REDIS_CMD_MULTIBULKREPLY},
|
||||
{"get",2,REDIS_CMD_INLINE},
|
||||
{"set",3,REDIS_CMD_BULK},
|
||||
{"setnx",3,REDIS_CMD_BULK},
|
||||
{"del",2,REDIS_CMD_INLINE},
|
||||
{"exists",2,REDIS_CMD_INLINE},
|
||||
{"incr",2,REDIS_CMD_INLINE},
|
||||
{"decr",2,REDIS_CMD_INLINE},
|
||||
{"rpush",3,REDIS_CMD_BULK},
|
||||
{"lpush",3,REDIS_CMD_BULK},
|
||||
{"rpop",2,REDIS_CMD_INLINE},
|
||||
{"lpop",2,REDIS_CMD_INLINE},
|
||||
{"llen",2,REDIS_CMD_INLINE},
|
||||
{"lindex",3,REDIS_CMD_INLINE},
|
||||
{"lset",4,REDIS_CMD_BULK},
|
||||
{"lrange",4,REDIS_CMD_INLINE},
|
||||
{"ltrim",4,REDIS_CMD_INLINE},
|
||||
{"lrem",4,REDIS_CMD_BULK},
|
||||
{"sadd",3,REDIS_CMD_BULK},
|
||||
{"srem",3,REDIS_CMD_BULK},
|
||||
{"sismember",3,REDIS_CMD_BULK},
|
||||
{"scard",2,REDIS_CMD_INLINE},
|
||||
{"sinter",-2,REDIS_CMD_INLINE},
|
||||
{"sinterstore",-3,REDIS_CMD_INLINE},
|
||||
{"smembers",2,REDIS_CMD_INLINE},
|
||||
{"incrby",3,REDIS_CMD_INLINE},
|
||||
{"decrby",3,REDIS_CMD_INLINE},
|
||||
{"randomkey",1,REDIS_CMD_INLINE},
|
||||
{"select",2,REDIS_CMD_INLINE},
|
||||
{"move",3,REDIS_CMD_INLINE},
|
||||
{"rename",3,REDIS_CMD_INLINE},
|
||||
{"renamenx",3,REDIS_CMD_INLINE},
|
||||
{"keys",2,REDIS_CMD_INLINE},
|
||||
{"dbsize",1,REDIS_CMD_INLINE},
|
||||
{"ping",1,REDIS_CMD_INLINE},
|
||||
{"echo",2,REDIS_CMD_BULK},
|
||||
{"save",1,REDIS_CMD_INLINE},
|
||||
{"bgsave",1,REDIS_CMD_INLINE},
|
||||
{"shutdown",1,REDIS_CMD_INLINE},
|
||||
{"lastsave",1,REDIS_CMD_INLINE},
|
||||
{"type",2,REDIS_CMD_INLINE},
|
||||
{"flushdb",1,REDIS_CMD_INLINE},
|
||||
{"flushall",1,REDIS_CMD_INLINE},
|
||||
{"sort",-2,REDIS_CMD_INLINE},
|
||||
{"info",1,REDIS_CMD_INLINE},
|
||||
{"mget",-2,REDIS_CMD_INLINE},
|
||||
{NULL,0,0}
|
||||
};
|
||||
|
||||
static int cliReadReply(int fd);
|
||||
|
||||
static struct redisCommand *lookupCommand(char *name) {
|
||||
int j = 0;
|
||||
while(cmdTable[j].name != NULL) {
|
||||
|
@ -135,11 +132,13 @@ static sds cliReadLine(int fd) {
|
|||
|
||||
while(1) {
|
||||
char c;
|
||||
ssize_t ret;
|
||||
|
||||
if (read(fd,&c,1) == -1) {
|
||||
ret = read(fd,&c,1);
|
||||
if (ret == -1) {
|
||||
sdsfree(line);
|
||||
return NULL;
|
||||
} else if (c == '\n') {
|
||||
} else if ((ret == 0) || (c == '\n')) {
|
||||
break;
|
||||
} else {
|
||||
line = sdscatlen(line,&c,1);
|
||||
|
@ -148,38 +147,26 @@ static sds cliReadLine(int fd) {
|
|||
return sdstrim(line,"\r\n");
|
||||
}
|
||||
|
||||
static int cliReadInlineReply(int fd, int type) {
|
||||
static int cliReadSingleLineReply(int fd) {
|
||||
sds reply = cliReadLine(fd);
|
||||
|
||||
if (reply == NULL) return 1;
|
||||
printf("%s\n", reply);
|
||||
if (type == REDIS_CMD_SINGLELINEREPLY) return 0;
|
||||
if (type == REDIS_CMD_INTREPLY) return atoi(reply) < 0;
|
||||
if (type == REDIS_CMD_RETCODEREPLY) return reply[0] == '-';
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cliReadBulkReply(int fd, int multibulk) {
|
||||
static int cliReadBulkReply(int fd) {
|
||||
sds replylen = cliReadLine(fd);
|
||||
char *reply, crlf[2];
|
||||
int bulklen, error = 0;
|
||||
int bulklen;
|
||||
|
||||
if (replylen == NULL) return 1;
|
||||
if (strcmp(replylen,"nil") == 0) {
|
||||
sdsfree(replylen);
|
||||
printf("(nil)\n");
|
||||
return 0;
|
||||
}
|
||||
bulklen = atoi(replylen);
|
||||
if (multibulk && bulklen == -1) {
|
||||
if (bulklen == -1) {
|
||||
sdsfree(replylen);
|
||||
printf("(nil)");
|
||||
return 0;
|
||||
}
|
||||
if (bulklen < 0) {
|
||||
bulklen = -bulklen;
|
||||
error = 1;
|
||||
}
|
||||
reply = zmalloc(bulklen);
|
||||
anetRead(fd,reply,bulklen);
|
||||
anetRead(fd,crlf,2);
|
||||
|
@ -187,10 +174,10 @@ static int cliReadBulkReply(int fd, int multibulk) {
|
|||
zfree(reply);
|
||||
return 1;
|
||||
}
|
||||
if (!multibulk && isatty(fileno(stdout)) && reply[bulklen-1] != '\n')
|
||||
if (isatty(fileno(stdout)) && reply[bulklen-1] != '\n')
|
||||
printf("\n");
|
||||
zfree(reply);
|
||||
return error;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cliReadMultiBulkReply(int fd) {
|
||||
|
@ -198,21 +185,45 @@ static int cliReadMultiBulkReply(int fd) {
|
|||
int elements, c = 1;
|
||||
|
||||
if (replylen == NULL) return 1;
|
||||
if (strcmp(replylen,"nil") == 0) {
|
||||
elements = atoi(replylen);
|
||||
if (elements == -1) {
|
||||
sdsfree(replylen);
|
||||
printf("(nil)\n");
|
||||
return 0;
|
||||
}
|
||||
elements = atoi(replylen);
|
||||
if (elements == 0) {
|
||||
printf("(empty list or set)\n");
|
||||
}
|
||||
while(elements--) {
|
||||
printf("%d. ", c);
|
||||
if (cliReadBulkReply(fd,1)) return 1;
|
||||
printf("\n");
|
||||
if (cliReadReply(fd)) return 1;
|
||||
c++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int cliReadReply(int fd) {
|
||||
char type;
|
||||
|
||||
if (anetRead(fd,&type,1) <= 0) exit(1);
|
||||
switch(type) {
|
||||
case '-':
|
||||
printf("(error) ");
|
||||
cliReadSingleLineReply(fd);
|
||||
return 1;
|
||||
case '+':
|
||||
case ':':
|
||||
return cliReadSingleLineReply(fd);
|
||||
case '$':
|
||||
return cliReadBulkReply(fd);
|
||||
case '*':
|
||||
return cliReadMultiBulkReply(fd);
|
||||
default:
|
||||
printf("protocol error, got '%c' as reply type byte\n", type);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
static int cliSendCommand(int argc, char **argv) {
|
||||
struct redisCommand *rc = lookupCommand(argv[0]);
|
||||
int fd, j, retval = 0;
|
||||
|
@ -245,17 +256,7 @@ static int cliSendCommand(int argc, char **argv) {
|
|||
cmd = sdscat(cmd,"\r\n");
|
||||
}
|
||||
anetWrite(fd,cmd,sdslen(cmd));
|
||||
if (rc->flags & REDIS_CMD_INTREPLY) {
|
||||
retval = cliReadInlineReply(fd,REDIS_CMD_INTREPLY);
|
||||
} else if (rc->flags & REDIS_CMD_RETCODEREPLY) {
|
||||
retval = cliReadInlineReply(fd,REDIS_CMD_RETCODEREPLY);
|
||||
} else if (rc->flags & REDIS_CMD_SINGLELINEREPLY) {
|
||||
retval = cliReadInlineReply(fd,REDIS_CMD_SINGLELINEREPLY);
|
||||
} else if (rc->flags & REDIS_CMD_BULKREPLY) {
|
||||
retval = cliReadBulkReply(fd,0);
|
||||
} else if (rc->flags & REDIS_CMD_MULTIBULKREPLY) {
|
||||
retval = cliReadMultiBulkReply(fd);
|
||||
}
|
||||
retval = cliReadReply(fd);
|
||||
if (retval) {
|
||||
close(fd);
|
||||
return retval;
|
||||
|
|
248
redis.c
248
redis.c
|
@ -27,7 +27,7 @@
|
|||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#define REDIS_VERSION "0.07"
|
||||
#define REDIS_VERSION "0.08"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
@ -89,6 +89,7 @@
|
|||
#define REDIS_CLOSE 1 /* This client connection should be closed ASAP */
|
||||
#define REDIS_SLAVE 2 /* This client is a slave server */
|
||||
#define REDIS_MASTER 4 /* This client is a master server */
|
||||
#define REDIS_MONITOR 8 /* This client is a slave monitor, see MONITOR */
|
||||
|
||||
/* Server replication state */
|
||||
#define REDIS_REPL_NONE 0 /* No active replication */
|
||||
|
@ -138,7 +139,7 @@ typedef struct redisClient {
|
|||
list *reply;
|
||||
int sentlen;
|
||||
time_t lastinteraction; /* time of the last interaction, used for timeout */
|
||||
int flags; /* REDIS_CLOSE | REDIS_SLAVE */
|
||||
int flags; /* REDIS_CLOSE | REDIS_SLAVE | REDIS_MONITOR */
|
||||
int slaveseldb; /* slave selected db, if this client is a slave */
|
||||
} redisClient;
|
||||
|
||||
|
@ -154,7 +155,7 @@ struct redisServer {
|
|||
dict **dict;
|
||||
long long dirty; /* changes to DB from the last save */
|
||||
list *clients;
|
||||
list *slaves;
|
||||
list *slaves, *monitors;
|
||||
char neterr[ANET_ERR_LEN];
|
||||
aeEventLoop *el;
|
||||
int cronloops; /* number of times the cron function run */
|
||||
|
@ -171,6 +172,7 @@ struct redisServer {
|
|||
int maxidletime;
|
||||
int dbnum;
|
||||
int daemonize;
|
||||
char *pidfile;
|
||||
int bgsaveinprogress;
|
||||
struct saveparam *saveparams;
|
||||
int saveparamslen;
|
||||
|
@ -212,10 +214,10 @@ typedef struct _redisSortOperation {
|
|||
} redisSortOperation;
|
||||
|
||||
struct sharedObjectsStruct {
|
||||
robj *crlf, *ok, *err, *zerobulk, *nil, *zero, *one, *pong, *space,
|
||||
*minus1, *minus2, *minus3, *minus4,
|
||||
*wrongtypeerr, *nokeyerr, *wrongtypeerrbulk, *nokeyerrbulk,
|
||||
*syntaxerr, *syntaxerrbulk,
|
||||
robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *pong, *space,
|
||||
*colon, *minus1, *nullbulk, *nullmultibulk,
|
||||
*emptymultibulk, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
|
||||
*outofrangeerr, *plus,
|
||||
*select0, *select1, *select2, *select3, *select4,
|
||||
*select5, *select6, *select7, *select8, *select9;
|
||||
} shared;
|
||||
|
@ -234,7 +236,7 @@ static void addReplySds(redisClient *c, sds s);
|
|||
static void incrRefCount(robj *o);
|
||||
static int saveDbBackground(char *filename);
|
||||
static robj *createStringObject(char *ptr, size_t len);
|
||||
static void replicationFeedSlaves(struct redisCommand *cmd, int dictid, robj **argv, int argc);
|
||||
static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc);
|
||||
static int syncWithMaster(void);
|
||||
|
||||
static void pingCommand(redisClient *c);
|
||||
|
@ -282,6 +284,7 @@ static void sortCommand(redisClient *c);
|
|||
static void lremCommand(redisClient *c);
|
||||
static void infoCommand(redisClient *c);
|
||||
static void mgetCommand(redisClient *c);
|
||||
static void monitorCommand(redisClient *c);
|
||||
|
||||
/*================================= Globals ================================= */
|
||||
|
||||
|
@ -334,6 +337,7 @@ static struct redisCommand cmdTable[] = {
|
|||
{"flushall",flushallCommand,1,REDIS_CMD_INLINE},
|
||||
{"sort",sortCommand,-2,REDIS_CMD_INLINE},
|
||||
{"info",infoCommand,1,REDIS_CMD_INLINE},
|
||||
{"monitor",monitorCommand,1,REDIS_CMD_INLINE},
|
||||
{NULL,NULL,0,0}
|
||||
};
|
||||
|
||||
|
@ -656,29 +660,28 @@ static void createSharedObjects(void) {
|
|||
shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
|
||||
shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
|
||||
shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
|
||||
shared.zerobulk = createObject(REDIS_STRING,sdsnew("0\r\n\r\n"));
|
||||
shared.nil = createObject(REDIS_STRING,sdsnew("nil\r\n"));
|
||||
shared.zero = createObject(REDIS_STRING,sdsnew("0\r\n"));
|
||||
shared.one = createObject(REDIS_STRING,sdsnew("1\r\n"));
|
||||
shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));
|
||||
shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));
|
||||
shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
|
||||
shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
|
||||
shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));
|
||||
shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));
|
||||
/* no such key */
|
||||
shared.minus1 = createObject(REDIS_STRING,sdsnew("-1\r\n"));
|
||||
/* operation against key holding a value of the wrong type */
|
||||
shared.minus2 = createObject(REDIS_STRING,sdsnew("-2\r\n"));
|
||||
/* src and dest objects are the same */
|
||||
shared.minus3 = createObject(REDIS_STRING,sdsnew("-3\r\n"));
|
||||
/* out of range argument */
|
||||
shared.minus4 = createObject(REDIS_STRING,sdsnew("-4\r\n"));
|
||||
shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));
|
||||
shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
|
||||
"-ERR Operation against a key holding the wrong kind of value\r\n"));
|
||||
shared.wrongtypeerrbulk = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%d\r\n%s",-sdslen(shared.wrongtypeerr->ptr)+2,shared.wrongtypeerr->ptr));
|
||||
shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
|
||||
"-ERR no such key\r\n"));
|
||||
shared.nokeyerrbulk = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%d\r\n%s",-sdslen(shared.nokeyerr->ptr)+2,shared.nokeyerr->ptr));
|
||||
shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
|
||||
"-ERR syntax error\r\n"));
|
||||
shared.syntaxerrbulk = createObject(REDIS_STRING,sdscatprintf(sdsempty(),"%d\r\n%s",-sdslen(shared.syntaxerr->ptr)+2,shared.syntaxerr->ptr));
|
||||
shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
|
||||
"-ERR source and destination objects are the same\r\n"));
|
||||
shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
|
||||
"-ERR index out of range\r\n"));
|
||||
shared.space = createObject(REDIS_STRING,sdsnew(" "));
|
||||
shared.colon = createObject(REDIS_STRING,sdsnew(":"));
|
||||
shared.plus = createObject(REDIS_STRING,sdsnew("+"));
|
||||
shared.select0 = createStringObject("select 0\r\n",10);
|
||||
shared.select1 = createStringObject("select 1\r\n",10);
|
||||
shared.select2 = createStringObject("select 2\r\n",10);
|
||||
|
@ -715,6 +718,7 @@ static void initServerConfig() {
|
|||
server.bindaddr = NULL;
|
||||
server.glueoutputbuf = 1;
|
||||
server.daemonize = 0;
|
||||
server.pidfile = "/var/run/redis.pid";
|
||||
server.dbfilename = "dump.rdb";
|
||||
ResetServerSaveParams();
|
||||
|
||||
|
@ -737,11 +741,12 @@ static void initServer() {
|
|||
|
||||
server.clients = listCreate();
|
||||
server.slaves = listCreate();
|
||||
server.monitors = listCreate();
|
||||
server.objfreelist = listCreate();
|
||||
createSharedObjects();
|
||||
server.el = aeCreateEventLoop();
|
||||
server.dict = zmalloc(sizeof(dict*)*server.dbnum);
|
||||
if (!server.dict || !server.clients || !server.slaves || !server.el || !server.objfreelist)
|
||||
if (!server.dict || !server.clients || !server.slaves || !server.monitors || !server.el || !server.objfreelist)
|
||||
oom("server initialization"); /* Fatal OOM */
|
||||
server.fd = anetTcpServer(server.neterr, server.port, server.bindaddr);
|
||||
if (server.fd == -1) {
|
||||
|
@ -878,6 +883,8 @@ static void loadServerConfig(char *filename) {
|
|||
else {
|
||||
err = "argument must be 'yes' or 'no'"; goto loaderr;
|
||||
}
|
||||
} else if (!strcmp(argv[0],"pidfile") && argc == 2) {
|
||||
server.pidfile = zstrdup(argv[1]);
|
||||
} else {
|
||||
err = "Bad directive or wrong number of arguments"; goto loaderr;
|
||||
}
|
||||
|
@ -918,9 +925,10 @@ static void freeClient(redisClient *c) {
|
|||
assert(ln != NULL);
|
||||
listDelNode(server.clients,ln);
|
||||
if (c->flags & REDIS_SLAVE) {
|
||||
ln = listSearchKey(server.slaves,c);
|
||||
list *l = (c->flags & REDIS_MONITOR) ? server.monitors : server.slaves;
|
||||
ln = listSearchKey(l,c);
|
||||
assert(ln != NULL);
|
||||
listDelNode(server.slaves,ln);
|
||||
listDelNode(l,ln);
|
||||
}
|
||||
if (c->flags & REDIS_MASTER) {
|
||||
server.master = NULL;
|
||||
|
@ -1079,7 +1087,9 @@ static int processCommand(redisClient *c) {
|
|||
dirty = server.dirty;
|
||||
cmd->proc(c);
|
||||
if (server.dirty-dirty != 0 && listLength(server.slaves))
|
||||
replicationFeedSlaves(cmd,c->dictid,c->argv,c->argc);
|
||||
replicationFeedSlaves(server.slaves,cmd,c->dictid,c->argv,c->argc);
|
||||
if (listLength(server.monitors))
|
||||
replicationFeedSlaves(server.monitors,cmd,c->dictid,c->argv,c->argc);
|
||||
server.stat_numcommands++;
|
||||
|
||||
/* Prepare the client for the next command */
|
||||
|
@ -1091,8 +1101,8 @@ static int processCommand(redisClient *c) {
|
|||
return 1;
|
||||
}
|
||||
|
||||
static void replicationFeedSlaves(struct redisCommand *cmd, int dictid, robj **argv, int argc) {
|
||||
listNode *ln = server.slaves->head;
|
||||
static void replicationFeedSlaves(list *slaves, struct redisCommand *cmd, int dictid, robj **argv, int argc) {
|
||||
listNode *ln = slaves->head;
|
||||
robj *outv[REDIS_MAX_ARGS*4]; /* enough room for args, spaces, newlines */
|
||||
int outc = 0, j;
|
||||
|
||||
|
@ -1643,7 +1653,7 @@ static void pingCommand(redisClient *c) {
|
|||
}
|
||||
|
||||
static void echoCommand(redisClient *c) {
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
|
||||
(int)sdslen(c->argv[1]->ptr)));
|
||||
addReply(c,c->argv[1]);
|
||||
addReply(c,shared.crlf);
|
||||
|
@ -1660,7 +1670,7 @@ static void setGenericCommand(redisClient *c, int nx) {
|
|||
dictReplace(c->dict,c->argv[1],c->argv[2]);
|
||||
incrRefCount(c->argv[2]);
|
||||
} else {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
|
@ -1668,7 +1678,7 @@ static void setGenericCommand(redisClient *c, int nx) {
|
|||
incrRefCount(c->argv[2]);
|
||||
}
|
||||
server.dirty++;
|
||||
addReply(c, nx ? shared.one : shared.ok);
|
||||
addReply(c, nx ? shared.cone : shared.ok);
|
||||
}
|
||||
|
||||
static void setCommand(redisClient *c) {
|
||||
|
@ -1684,14 +1694,14 @@ static void getCommand(redisClient *c) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.nil);
|
||||
addReply(c,shared.nullbulk);
|
||||
} else {
|
||||
robj *o = dictGetEntryVal(de);
|
||||
|
||||
if (o->type != REDIS_STRING) {
|
||||
addReply(c,shared.wrongtypeerrbulk);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
} else {
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(o->ptr)));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(o->ptr)));
|
||||
addReply(c,o);
|
||||
addReply(c,shared.crlf);
|
||||
}
|
||||
|
@ -1702,18 +1712,18 @@ static void mgetCommand(redisClient *c) {
|
|||
dictEntry *de;
|
||||
int j;
|
||||
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",c->argc-1));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",c->argc-1));
|
||||
for (j = 1; j < c->argc; j++) {
|
||||
de = dictFind(c->dict,c->argv[j]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.minus1);
|
||||
addReply(c,shared.nullbulk);
|
||||
} else {
|
||||
robj *o = dictGetEntryVal(de);
|
||||
|
||||
if (o->type != REDIS_STRING) {
|
||||
addReply(c,shared.minus1);
|
||||
addReply(c,shared.nullbulk);
|
||||
} else {
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(o->ptr)));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(o->ptr)));
|
||||
addReply(c,o);
|
||||
addReply(c,shared.crlf);
|
||||
}
|
||||
|
@ -1751,6 +1761,7 @@ static void incrDecrCommand(redisClient *c, int incr) {
|
|||
incrRefCount(c->argv[1]);
|
||||
}
|
||||
server.dirty++;
|
||||
addReply(c,shared.colon);
|
||||
addReply(c,o);
|
||||
addReply(c,shared.crlf);
|
||||
}
|
||||
|
@ -1778,9 +1789,9 @@ static void decrbyCommand(redisClient *c) {
|
|||
static void delCommand(redisClient *c) {
|
||||
if (dictDelete(c->dict,c->argv[1]) == DICT_OK) {
|
||||
server.dirty++;
|
||||
addReply(c,shared.one);
|
||||
addReply(c,shared.cone);
|
||||
} else {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1789,9 +1800,9 @@ static void existsCommand(redisClient *c) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL)
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
else
|
||||
addReply(c,shared.one);
|
||||
addReply(c,shared.cone);
|
||||
}
|
||||
|
||||
static void selectCommand(redisClient *c) {
|
||||
|
@ -1811,6 +1822,7 @@ static void randomkeyCommand(redisClient *c) {
|
|||
if (de == NULL) {
|
||||
addReply(c,shared.crlf);
|
||||
} else {
|
||||
addReply(c,shared.plus);
|
||||
addReply(c,dictGetEntryKey(de));
|
||||
addReply(c,shared.crlf);
|
||||
}
|
||||
|
@ -1841,18 +1853,18 @@ static void keysCommand(redisClient *c) {
|
|||
}
|
||||
}
|
||||
dictReleaseIterator(di);
|
||||
lenobj->ptr = sdscatprintf(sdsempty(),"%lu\r\n",keyslen+(numkeys ? (numkeys-1) : 0));
|
||||
lenobj->ptr = sdscatprintf(sdsempty(),"$%lu\r\n",keyslen+(numkeys ? (numkeys-1) : 0));
|
||||
addReply(c,shared.crlf);
|
||||
}
|
||||
|
||||
static void dbsizeCommand(redisClient *c) {
|
||||
addReplySds(c,
|
||||
sdscatprintf(sdsempty(),"%lu\r\n",dictGetHashTableUsed(c->dict)));
|
||||
sdscatprintf(sdsempty(),":%lu\r\n",dictGetHashTableUsed(c->dict)));
|
||||
}
|
||||
|
||||
static void lastsaveCommand(redisClient *c) {
|
||||
addReplySds(c,
|
||||
sdscatprintf(sdsempty(),"%lu\r\n",server.lastsave));
|
||||
sdscatprintf(sdsempty(),":%lu\r\n",server.lastsave));
|
||||
}
|
||||
|
||||
static void typeCommand(redisClient *c) {
|
||||
|
@ -1861,14 +1873,14 @@ static void typeCommand(redisClient *c) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
type = "none";
|
||||
type = "+none";
|
||||
} else {
|
||||
robj *o = dictGetEntryVal(de);
|
||||
|
||||
switch(o->type) {
|
||||
case REDIS_STRING: type = "string"; break;
|
||||
case REDIS_LIST: type = "list"; break;
|
||||
case REDIS_SET: type = "set"; break;
|
||||
case REDIS_STRING: type = "+string"; break;
|
||||
case REDIS_LIST: type = "+list"; break;
|
||||
case REDIS_SET: type = "+set"; break;
|
||||
default: type = "unknown"; break;
|
||||
}
|
||||
}
|
||||
|
@ -1899,6 +1911,9 @@ static void bgsaveCommand(redisClient *c) {
|
|||
static void shutdownCommand(redisClient *c) {
|
||||
redisLog(REDIS_WARNING,"User requested shutdown, saving DB...");
|
||||
if (saveDb(server.dbfilename) == REDIS_OK) {
|
||||
if (server.daemonize) {
|
||||
unlink(server.pidfile);
|
||||
}
|
||||
redisLog(REDIS_WARNING,"Server exit now, bye bye...");
|
||||
exit(1);
|
||||
} else {
|
||||
|
@ -1913,19 +1928,13 @@ static void renameGenericCommand(redisClient *c, int nx) {
|
|||
|
||||
/* To use the same key as src and dst is probably an error */
|
||||
if (sdscmp(c->argv[1]->ptr,c->argv[2]->ptr) == 0) {
|
||||
if (nx)
|
||||
addReply(c,shared.minus3);
|
||||
else
|
||||
addReplySds(c,sdsnew("-ERR src and dest key are the same\r\n"));
|
||||
addReply(c,shared.sameobjecterr);
|
||||
return;
|
||||
}
|
||||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
if (nx)
|
||||
addReply(c,shared.minus1);
|
||||
else
|
||||
addReply(c,shared.nokeyerr);
|
||||
addReply(c,shared.nokeyerr);
|
||||
return;
|
||||
}
|
||||
o = dictGetEntryVal(de);
|
||||
|
@ -1933,7 +1942,7 @@ static void renameGenericCommand(redisClient *c, int nx) {
|
|||
if (dictAdd(c->dict,c->argv[2],o) == DICT_ERR) {
|
||||
if (nx) {
|
||||
decrRefCount(o);
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
return;
|
||||
}
|
||||
dictReplace(c->dict,c->argv[2],o);
|
||||
|
@ -1942,7 +1951,7 @@ static void renameGenericCommand(redisClient *c, int nx) {
|
|||
}
|
||||
dictDelete(c->dict,c->argv[1]);
|
||||
server.dirty++;
|
||||
addReply(c,nx ? shared.one : shared.ok);
|
||||
addReply(c,nx ? shared.cone : shared.ok);
|
||||
}
|
||||
|
||||
static void renameCommand(redisClient *c) {
|
||||
|
@ -1963,7 +1972,7 @@ static void moveCommand(redisClient *c) {
|
|||
src = c->dict;
|
||||
srcid = c->dictid;
|
||||
if (selectDb(c,atoi(c->argv[2]->ptr)) == REDIS_ERR) {
|
||||
addReply(c,shared.minus4);
|
||||
addReply(c,shared.outofrangeerr);
|
||||
return;
|
||||
}
|
||||
dst = c->dict;
|
||||
|
@ -1973,14 +1982,14 @@ static void moveCommand(redisClient *c) {
|
|||
/* If the user is moving using as target the same
|
||||
* DB as the source DB it is probably an error. */
|
||||
if (src == dst) {
|
||||
addReply(c,shared.minus3);
|
||||
addReply(c,shared.sameobjecterr);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Check if the element exists and get a reference */
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (!de) {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -1988,7 +1997,7 @@ static void moveCommand(redisClient *c) {
|
|||
key = dictGetEntryKey(de);
|
||||
o = dictGetEntryVal(de);
|
||||
if (dictAdd(dst,key,o) == DICT_ERR) {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
return;
|
||||
}
|
||||
incrRefCount(key);
|
||||
|
@ -1997,7 +2006,7 @@ static void moveCommand(redisClient *c) {
|
|||
/* OK! key moved, free the entry in the source DB */
|
||||
dictDelete(src,c->argv[1]);
|
||||
server.dirty++;
|
||||
addReply(c,shared.one);
|
||||
addReply(c,shared.cone);
|
||||
}
|
||||
|
||||
/* =================================== Lists ================================ */
|
||||
|
@ -2050,15 +2059,15 @@ static void llenCommand(redisClient *c) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
return;
|
||||
} else {
|
||||
robj *o = dictGetEntryVal(de);
|
||||
if (o->type != REDIS_LIST) {
|
||||
addReply(c,shared.minus2);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
} else {
|
||||
l = o->ptr;
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",listLength(l)));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",listLength(l)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2069,22 +2078,22 @@ static void lindexCommand(redisClient *c) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.nil);
|
||||
addReply(c,shared.nullbulk);
|
||||
} else {
|
||||
robj *o = dictGetEntryVal(de);
|
||||
|
||||
if (o->type != REDIS_LIST) {
|
||||
addReply(c,shared.wrongtypeerrbulk);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
} else {
|
||||
list *list = o->ptr;
|
||||
listNode *ln;
|
||||
|
||||
ln = listIndex(list, index);
|
||||
if (ln == NULL) {
|
||||
addReply(c,shared.nil);
|
||||
addReply(c,shared.nullbulk);
|
||||
} else {
|
||||
robj *ele = listNodeValue(ln);
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(ele->ptr)));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));
|
||||
addReply(c,ele);
|
||||
addReply(c,shared.crlf);
|
||||
}
|
||||
|
@ -2110,7 +2119,7 @@ static void lsetCommand(redisClient *c) {
|
|||
|
||||
ln = listIndex(list, index);
|
||||
if (ln == NULL) {
|
||||
addReplySds(c,sdsnew("-ERR index out of range\r\n"));
|
||||
addReply(c,shared.outofrangeerr);
|
||||
} else {
|
||||
robj *ele = listNodeValue(ln);
|
||||
|
||||
|
@ -2129,12 +2138,12 @@ static void popGenericCommand(redisClient *c, int where) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.nil);
|
||||
addReply(c,shared.nullbulk);
|
||||
} else {
|
||||
robj *o = dictGetEntryVal(de);
|
||||
|
||||
if (o->type != REDIS_LIST) {
|
||||
addReply(c,shared.wrongtypeerrbulk);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
} else {
|
||||
list *list = o->ptr;
|
||||
listNode *ln;
|
||||
|
@ -2145,10 +2154,10 @@ static void popGenericCommand(redisClient *c, int where) {
|
|||
ln = listLast(list);
|
||||
|
||||
if (ln == NULL) {
|
||||
addReply(c,shared.nil);
|
||||
addReply(c,shared.nullbulk);
|
||||
} else {
|
||||
robj *ele = listNodeValue(ln);
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(ele->ptr)));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));
|
||||
addReply(c,ele);
|
||||
addReply(c,shared.crlf);
|
||||
listDelNode(list,ln);
|
||||
|
@ -2173,12 +2182,12 @@ static void lrangeCommand(redisClient *c) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.nil);
|
||||
addReply(c,shared.nullmultibulk);
|
||||
} else {
|
||||
robj *o = dictGetEntryVal(de);
|
||||
|
||||
if (o->type != REDIS_LIST) {
|
||||
addReply(c,shared.wrongtypeerrbulk);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
} else {
|
||||
list *list = o->ptr;
|
||||
listNode *ln;
|
||||
|
@ -2195,7 +2204,7 @@ static void lrangeCommand(redisClient *c) {
|
|||
/* indexes sanity checks */
|
||||
if (start > end || start >= llen) {
|
||||
/* Out of range start or start > end result in empty list */
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.emptymultibulk);
|
||||
return;
|
||||
}
|
||||
if (end >= llen) end = llen-1;
|
||||
|
@ -2203,10 +2212,10 @@ static void lrangeCommand(redisClient *c) {
|
|||
|
||||
/* Return the result in form of a multi-bulk reply */
|
||||
ln = listIndex(list, start);
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",rangelen));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",rangelen));
|
||||
for (j = 0; j < rangelen; j++) {
|
||||
ele = listNodeValue(ln);
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",(int)sdslen(ele->ptr)));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",(int)sdslen(ele->ptr)));
|
||||
addReply(c,ele);
|
||||
addReply(c,shared.crlf);
|
||||
ln = ln->next;
|
||||
|
@ -2276,7 +2285,7 @@ static void lremCommand(redisClient *c) {
|
|||
robj *o = dictGetEntryVal(de);
|
||||
|
||||
if (o->type != REDIS_LIST) {
|
||||
addReply(c,shared.minus2);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
} else {
|
||||
list *list = o->ptr;
|
||||
listNode *ln, *next;
|
||||
|
@ -2300,7 +2309,7 @@ static void lremCommand(redisClient *c) {
|
|||
}
|
||||
ln = next;
|
||||
}
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",removed));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",removed));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2319,16 +2328,16 @@ static void saddCommand(redisClient *c) {
|
|||
} else {
|
||||
set = dictGetEntryVal(de);
|
||||
if (set->type != REDIS_SET) {
|
||||
addReply(c,shared.minus2);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (dictAdd(set->ptr,c->argv[2],NULL) == DICT_OK) {
|
||||
incrRefCount(c->argv[2]);
|
||||
server.dirty++;
|
||||
addReply(c,shared.one);
|
||||
addReply(c,shared.cone);
|
||||
} else {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2337,20 +2346,20 @@ static void sremCommand(redisClient *c) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
} else {
|
||||
robj *set;
|
||||
|
||||
set = dictGetEntryVal(de);
|
||||
if (set->type != REDIS_SET) {
|
||||
addReply(c,shared.minus2);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
return;
|
||||
}
|
||||
if (dictDelete(set->ptr,c->argv[2]) == DICT_OK) {
|
||||
server.dirty++;
|
||||
addReply(c,shared.one);
|
||||
addReply(c,shared.cone);
|
||||
} else {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2360,19 +2369,19 @@ static void sismemberCommand(redisClient *c) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
} else {
|
||||
robj *set;
|
||||
|
||||
set = dictGetEntryVal(de);
|
||||
if (set->type != REDIS_SET) {
|
||||
addReply(c,shared.minus2);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
return;
|
||||
}
|
||||
if (dictFind(set->ptr,c->argv[2]))
|
||||
addReply(c,shared.one);
|
||||
addReply(c,shared.cone);
|
||||
else
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -2382,15 +2391,15 @@ static void scardCommand(redisClient *c) {
|
|||
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.zero);
|
||||
addReply(c,shared.czero);
|
||||
return;
|
||||
} else {
|
||||
robj *o = dictGetEntryVal(de);
|
||||
if (o->type != REDIS_SET) {
|
||||
addReply(c,shared.minus2);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
} else {
|
||||
s = o->ptr;
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",
|
||||
addReplySds(c,sdscatprintf(sdsempty(),":%d\r\n",
|
||||
dictGetHashTableUsed(s)));
|
||||
}
|
||||
}
|
||||
|
@ -2417,13 +2426,13 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
|
|||
de = dictFind(c->dict,setskeys[j]);
|
||||
if (!de) {
|
||||
zfree(dv);
|
||||
addReply(c,dstkey ? shared.nokeyerr : shared.nil);
|
||||
addReply(c,shared.nokeyerr);
|
||||
return;
|
||||
}
|
||||
setobj = dictGetEntryVal(de);
|
||||
if (setobj->type != REDIS_SET) {
|
||||
zfree(dv);
|
||||
addReply(c,dstkey ? shared.wrongtypeerr : shared.wrongtypeerrbulk);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
return;
|
||||
}
|
||||
dv[j] = setobj->ptr;
|
||||
|
@ -2465,7 +2474,7 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
|
|||
continue; /* at least one set does not contain the member */
|
||||
ele = dictGetEntryKey(de);
|
||||
if (!dstkey) {
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",sdslen(ele->ptr)));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(ele->ptr)));
|
||||
addReply(c,ele);
|
||||
addReply(c,shared.crlf);
|
||||
cardinality++;
|
||||
|
@ -2477,7 +2486,7 @@ static void sinterGenericCommand(redisClient *c, robj **setskeys, int setsnum, r
|
|||
dictReleaseIterator(di);
|
||||
|
||||
if (!dstkey)
|
||||
lenobj->ptr = sdscatprintf(sdsempty(),"%d\r\n",cardinality);
|
||||
lenobj->ptr = sdscatprintf(sdsempty(),"*%d\r\n",cardinality);
|
||||
else
|
||||
addReply(c,shared.ok);
|
||||
zfree(dv);
|
||||
|
@ -2607,19 +2616,19 @@ static void sortCommand(redisClient *c) {
|
|||
/* Lookup the key to sort. It must be of the right types */
|
||||
de = dictFind(c->dict,c->argv[1]);
|
||||
if (de == NULL) {
|
||||
addReply(c,shared.nokeyerrbulk);
|
||||
addReply(c,shared.nokeyerr);
|
||||
return;
|
||||
}
|
||||
sortval = dictGetEntryVal(de);
|
||||
if (sortval->type != REDIS_SET && sortval->type != REDIS_LIST) {
|
||||
addReply(c,shared.wrongtypeerrbulk);
|
||||
addReply(c,shared.wrongtypeerr);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Create a list of operations to perform for every sorted element.
|
||||
* Operations can be GET/DEL/INCR/DECR */
|
||||
operations = listCreate();
|
||||
listSetFreeMethod(operations,free);
|
||||
listSetFreeMethod(operations,zfree);
|
||||
j = 2;
|
||||
|
||||
/* Now we need to protect sortval incrementing its count, in the future
|
||||
|
@ -2666,7 +2675,7 @@ static void sortCommand(redisClient *c) {
|
|||
} else {
|
||||
decrRefCount(sortval);
|
||||
listRelease(operations);
|
||||
addReply(c,shared.syntaxerrbulk);
|
||||
addReply(c,shared.syntaxerr);
|
||||
return;
|
||||
}
|
||||
j++;
|
||||
|
@ -2747,11 +2756,11 @@ static void sortCommand(redisClient *c) {
|
|||
/* Send command output to the output buffer, performing the specified
|
||||
* GET/DEL/INCR/DECR operations if any. */
|
||||
outputlen = getop ? getop*(end-start+1) : end-start+1;
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",outputlen));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"*%d\r\n",outputlen));
|
||||
for (j = start; j <= end; j++) {
|
||||
listNode *ln = operations->head;
|
||||
if (!getop) {
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
|
||||
sdslen(vector[j].obj->ptr)));
|
||||
addReply(c,vector[j].obj);
|
||||
addReply(c,shared.crlf);
|
||||
|
@ -2763,9 +2772,9 @@ static void sortCommand(redisClient *c) {
|
|||
|
||||
if (sop->type == REDIS_SORT_GET) {
|
||||
if (!val || val->type != REDIS_STRING) {
|
||||
addReply(c,shared.minus1);
|
||||
addReply(c,shared.nullbulk);
|
||||
} else {
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",
|
||||
sdslen(val->ptr)));
|
||||
addReply(c,val);
|
||||
addReply(c,shared.crlf);
|
||||
|
@ -2813,7 +2822,7 @@ static void infoCommand(redisClient *c) {
|
|||
uptime,
|
||||
uptime/(3600*24)
|
||||
);
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"%d\r\n",sdslen(info)));
|
||||
addReplySds(c,sdscatprintf(sdsempty(),"$%d\r\n",sdslen(info)));
|
||||
addReplySds(c,info);
|
||||
addReply(c,shared.crlf);
|
||||
}
|
||||
|
@ -2905,6 +2914,9 @@ static void syncCommand(redisClient *c) {
|
|||
time_t start = time(NULL);
|
||||
char sizebuf[32];
|
||||
|
||||
/* ignore SYNC if aleady slave or in monitor mode */
|
||||
if (c->flags & REDIS_SLAVE) return;
|
||||
|
||||
redisLog(REDIS_NOTICE,"Slave ask for syncronization");
|
||||
if (flushClientOutput(c) == REDIS_ERR || saveDb(server.dbfilename) != REDIS_OK)
|
||||
goto closeconn;
|
||||
|
@ -2913,7 +2925,7 @@ static void syncCommand(redisClient *c) {
|
|||
if (fd == -1 || fstat(fd,&sb) == -1) goto closeconn;
|
||||
len = sb.st_size;
|
||||
|
||||
snprintf(sizebuf,32,"%d\r\n",len);
|
||||
snprintf(sizebuf,32,"$%d\r\n",len);
|
||||
if (syncWrite(c->fd,sizebuf,strlen(sizebuf),5) == -1) goto closeconn;
|
||||
while(len) {
|
||||
char buf[1024];
|
||||
|
@ -2965,7 +2977,7 @@ static int syncWithMaster(void) {
|
|||
strerror(errno));
|
||||
return REDIS_ERR;
|
||||
}
|
||||
dumpsize = atoi(buf);
|
||||
dumpsize = atoi(buf+1);
|
||||
redisLog(REDIS_NOTICE,"Receiving %d bytes data dump from MASTER",dumpsize);
|
||||
/* Read the bulk write data on a temp file */
|
||||
snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)time(NULL),(long int)random());
|
||||
|
@ -3014,6 +3026,16 @@ static int syncWithMaster(void) {
|
|||
return REDIS_OK;
|
||||
}
|
||||
|
||||
static void monitorCommand(redisClient *c) {
|
||||
/* ignore MONITOR if aleady slave or in monitor mode */
|
||||
if (c->flags & REDIS_SLAVE) return;
|
||||
|
||||
c->flags |= (REDIS_SLAVE|REDIS_MONITOR);
|
||||
c->slaveseldb = 0;
|
||||
if (!listAddNodeTail(server.monitors,c)) oom("listAddNodeTail");
|
||||
addReply(c,shared.ok);
|
||||
}
|
||||
|
||||
/* =================================== Main! ================================ */
|
||||
|
||||
static void daemonize(void) {
|
||||
|
@ -3033,7 +3055,7 @@ static void daemonize(void) {
|
|||
if (fd > STDERR_FILENO) close(fd);
|
||||
}
|
||||
/* Try to write the pid file */
|
||||
fp = fopen("/var/run/redis.pid","w");
|
||||
fp = fopen(server.pidfile,"w");
|
||||
if (fp) {
|
||||
fprintf(fp,"%d\n",getpid());
|
||||
fclose(fp);
|
||||
|
@ -3056,7 +3078,7 @@ int main(int argc, char **argv) {
|
|||
redisLog(REDIS_NOTICE,"DB loaded from disk");
|
||||
if (aeCreateFileEvent(server.el, server.fd, AE_READABLE,
|
||||
acceptHandler, NULL, NULL) == AE_ERR) oom("creating file event");
|
||||
redisLog(REDIS_NOTICE,"The server is now ready to accept connections");
|
||||
redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port);
|
||||
aeMain(server.el);
|
||||
aeDeleteEventLoop(server.el);
|
||||
return 0;
|
||||
|
|
|
@ -4,6 +4,10 @@
|
|||
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
|
||||
daemonize no
|
||||
|
||||
# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
|
||||
# You can specify a custom pid file location here.
|
||||
pidfile /var/run/redis.pid
|
||||
|
||||
# Accept connections on the specified port, default is 6379
|
||||
port 6379
|
||||
|
||||
|
|
190
test-redis.tcl
190
test-redis.tcl
|
@ -124,16 +124,16 @@ proc main {server port} {
|
|||
puts -nonewline $fd "SET k1 4\r\nxyzk\r\nGET k1\r\nPING\r\n"
|
||||
flush $fd
|
||||
set res {}
|
||||
append res [string match +OK* [redis_read_retcode $fd]]
|
||||
append res [redis_bulk_read $fd]
|
||||
append res [string match +PONG* [redis_read_retcode $fd]]
|
||||
append res [string match OK* [redis_read_reply $fd]]
|
||||
append res [redis_read_reply $fd]
|
||||
append res [string match PONG* [redis_read_reply $fd]]
|
||||
format $res
|
||||
} {1xyzk1}
|
||||
|
||||
test {Non existing command} {
|
||||
puts -nonewline $fd "foo\r\n"
|
||||
flush $fd
|
||||
string match -ERR* [redis_read_retcode $fd]
|
||||
string match ERR* [redis_read_reply $fd]
|
||||
} {1}
|
||||
|
||||
test {Basic LPUSH, RPUSH, LLENGTH, LINDEX} {
|
||||
|
@ -181,19 +181,19 @@ proc main {server port} {
|
|||
redis_del $fd mylist
|
||||
redis_set $fd mylist foobar
|
||||
redis_llen $fd mylist
|
||||
} {-2}
|
||||
} {ERR*}
|
||||
|
||||
test {LINDEX against non-list value error} {
|
||||
redis_lindex $fd mylist 0
|
||||
} {*ERROR*}
|
||||
} {ERR*}
|
||||
|
||||
test {LPUSH against non-list value error} {
|
||||
redis_lpush $fd mylist 0
|
||||
} {-ERR*}
|
||||
} {ERR*}
|
||||
|
||||
test {RPUSH against non-list value error} {
|
||||
redis_rpush $fd mylist 0
|
||||
} {-ERR*}
|
||||
} {ERR*}
|
||||
|
||||
test {RENAME basic usage} {
|
||||
redis_set $fd mykey hello
|
||||
|
@ -236,11 +236,11 @@ proc main {server port} {
|
|||
|
||||
test {RENAME against non existing source key} {
|
||||
redis_rename $fd nokey foobar
|
||||
} {-ERR*}
|
||||
} {ERR*}
|
||||
|
||||
test {RENAME where source and dest key is the same} {
|
||||
redis_rename $fd mykey mykey
|
||||
} {-ERR*}
|
||||
} {ERR*}
|
||||
|
||||
test {DEL all keys again (DB 0)} {
|
||||
foreach key [redis_keys $fd *] {
|
||||
|
@ -309,7 +309,7 @@ proc main {server port} {
|
|||
test {LPOP against non list value} {
|
||||
redis_set $fd notalist foo
|
||||
redis_lpop $fd notalist
|
||||
} {*ERROR*against*}
|
||||
} {ERR*kind*}
|
||||
|
||||
test {Mass LPUSH/LPOP} {
|
||||
set sum 0
|
||||
|
@ -363,16 +363,16 @@ proc main {server port} {
|
|||
|
||||
test {LSET out of range index} {
|
||||
redis_lset $fd mylist 10 foo
|
||||
} {-ERR*range*}
|
||||
} {ERR*range*}
|
||||
|
||||
test {LSET against non existing key} {
|
||||
redis_lset $fd nosuchkey 10 foo
|
||||
} {-ERR*key*}
|
||||
} {ERR*key*}
|
||||
|
||||
test {LSET against non list value} {
|
||||
redis_set $fd nolist foobar
|
||||
redis_lset $fd nolist 0 foo
|
||||
} {-ERR*value*}
|
||||
} {ERR*value*}
|
||||
|
||||
test {SADD, SCARD, SISMEMBER, SMEMBERS basics} {
|
||||
redis_sadd $fd myset foo
|
||||
|
@ -391,7 +391,7 @@ proc main {server port} {
|
|||
|
||||
test {SADD against non set} {
|
||||
redis_sadd $fd mylist foo
|
||||
} {-2}
|
||||
} {ERR*kind*}
|
||||
|
||||
test {SREM basics} {
|
||||
redis_sadd $fd myset ciao
|
||||
|
@ -431,7 +431,7 @@ proc main {server port} {
|
|||
redis_set $fd myemptykey {}
|
||||
redis_set $fd mynormalkey {blablablba}
|
||||
redis_save $fd
|
||||
} {+OK}
|
||||
} {OK}
|
||||
|
||||
test {Create a random list} {
|
||||
set tosort {}
|
||||
|
@ -606,225 +606,255 @@ proc redis_readnl {fd len} {
|
|||
return $buf
|
||||
}
|
||||
|
||||
proc redis_bulk_read {fd {multi 0}} {
|
||||
set count [redis_read_integer $fd]
|
||||
if {$count eq {nil}} return {}
|
||||
if {$multi && $count == -1} return {}
|
||||
set len [expr {abs($count)}]
|
||||
set buf [redis_readnl $fd $len]
|
||||
if {$count < 0} {return "***ERROR*** $buf"}
|
||||
proc redis_bulk_read {fd} {
|
||||
set count [redis_read_line $fd]
|
||||
if {$count == -1} return {}
|
||||
set buf [redis_readnl $fd $count]
|
||||
return $buf
|
||||
}
|
||||
|
||||
proc redis_multi_bulk_read fd {
|
||||
set count [redis_read_integer $fd]
|
||||
if {$count eq {nil}} return {}
|
||||
if {$count < 0} {
|
||||
set len [expr {abs($count)}]
|
||||
set buf [redis_readnl $fd $len]
|
||||
return "***ERROR*** $buf"
|
||||
}
|
||||
set count [redis_read_line $fd]
|
||||
if {$count == -1} return {}
|
||||
set l {}
|
||||
for {set i 0} {$i < $count} {incr i} {
|
||||
lappend l [redis_bulk_read $fd 1]
|
||||
lappend l [redis_read_reply $fd]
|
||||
}
|
||||
return $l
|
||||
}
|
||||
|
||||
proc redis_read_retcode fd {
|
||||
set retcode [string trim [gets $fd]]
|
||||
# puts "S: $retcode"
|
||||
return $retcode
|
||||
proc redis_read_line fd {
|
||||
string trim [gets $fd]
|
||||
}
|
||||
|
||||
proc redis_read_integer fd {
|
||||
string trim [gets $fd]
|
||||
proc redis_read_reply fd {
|
||||
set type [read $fd 1]
|
||||
if {$type eq {:}} {
|
||||
redis_read_line $fd
|
||||
} elseif {$type eq {-}} {
|
||||
redis_read_line $fd
|
||||
} elseif {$type eq {+}} {
|
||||
redis_read_line $fd
|
||||
} elseif {$type eq {$}} {
|
||||
redis_bulk_read $fd
|
||||
} elseif {$type eq {*}} {
|
||||
redis_multi_bulk_read $fd
|
||||
} else {
|
||||
error "Bad protocol: $type as initial reply byte"
|
||||
}
|
||||
}
|
||||
|
||||
### Actual API ###
|
||||
|
||||
proc redis_set {fd key val} {
|
||||
redis_writenl $fd "set $key [string length $val]\r\n$val"
|
||||
redis_read_retcode $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_setnx {fd key val} {
|
||||
redis_writenl $fd "setnx $key [string length $val]\r\n$val"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_get {fd key} {
|
||||
redis_writenl $fd "get $key"
|
||||
redis_bulk_read $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_select {fd id} {
|
||||
redis_writenl $fd "select $id"
|
||||
redis_read_retcode $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_move {fd key id} {
|
||||
redis_writenl $fd "move $key $id"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_del {fd key} {
|
||||
redis_writenl $fd "del $key"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_keys {fd pattern} {
|
||||
redis_writenl $fd "keys $pattern"
|
||||
split [redis_bulk_read $fd]
|
||||
split [redis_read_reply $fd]
|
||||
}
|
||||
|
||||
proc redis_dbsize {fd} {
|
||||
redis_writenl $fd "dbsize"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_incr {fd key} {
|
||||
redis_writenl $fd "incr $key"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_decr {fd key} {
|
||||
redis_writenl $fd "decr $key"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_exists {fd key} {
|
||||
redis_writenl $fd "exists $key"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_lpush {fd key val} {
|
||||
redis_writenl $fd "lpush $key [string length $val]\r\n$val"
|
||||
redis_read_retcode $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_rpush {fd key val} {
|
||||
redis_writenl $fd "rpush $key [string length $val]\r\n$val"
|
||||
redis_read_retcode $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_llen {fd key} {
|
||||
redis_writenl $fd "llen $key"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_scard {fd key} {
|
||||
redis_writenl $fd "scard $key"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_lindex {fd key index} {
|
||||
redis_writenl $fd "lindex $key $index"
|
||||
redis_bulk_read $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_lrange {fd key first last} {
|
||||
redis_writenl $fd "lrange $key $first $last"
|
||||
redis_multi_bulk_read $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_mget {fd args} {
|
||||
redis_writenl $fd "mget [join $args]"
|
||||
redis_multi_bulk_read $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_sort {fd key {params {}}} {
|
||||
redis_writenl $fd "sort $key $params"
|
||||
redis_multi_bulk_read $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_ltrim {fd key first last} {
|
||||
redis_writenl $fd "ltrim $key $first $last"
|
||||
redis_read_retcode $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_rename {fd key1 key2} {
|
||||
redis_writenl $fd "rename $key1 $key2"
|
||||
redis_read_retcode $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_renamenx {fd key1 key2} {
|
||||
redis_writenl $fd "renamenx $key1 $key2"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_lpop {fd key} {
|
||||
redis_writenl $fd "lpop $key"
|
||||
redis_bulk_read $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_rpop {fd key} {
|
||||
redis_writenl $fd "rpop $key"
|
||||
redis_bulk_read $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_lset {fd key index val} {
|
||||
redis_writenl $fd "lset $key $index [string length $val]\r\n$val"
|
||||
redis_read_retcode $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_sadd {fd key val} {
|
||||
redis_writenl $fd "sadd $key [string length $val]\r\n$val"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_srem {fd key val} {
|
||||
redis_writenl $fd "srem $key [string length $val]\r\n$val"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_sismember {fd key val} {
|
||||
redis_writenl $fd "sismember $key [string length $val]\r\n$val"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_sinter {fd args} {
|
||||
redis_writenl $fd "sinter [join $args]\r\n"
|
||||
redis_multi_bulk_read $fd
|
||||
redis_writenl $fd "sinter [join $args]"
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_sinterstore {fd args} {
|
||||
redis_writenl $fd "sinterstore [join $args]\r\n"
|
||||
redis_read_retcode $fd
|
||||
redis_writenl $fd "sinterstore [join $args]"
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_smembers {fd key} {
|
||||
redis_writenl $fd "smembers $key\r\n"
|
||||
redis_multi_bulk_read $fd
|
||||
redis_writenl $fd "smembers $key"
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_echo {fd str} {
|
||||
redis_writenl $fd "echo [string length $str]\r\n$str\r\n"
|
||||
redis_writenl $fd "smembers $key\r\n"
|
||||
redis_writenl $fd "echo [string length $str]\r\n$str"
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_save {fd} {
|
||||
redis_writenl $fd "save\r\n"
|
||||
redis_read_retcode $fd
|
||||
redis_writenl $fd "save"
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_flushall {fd} {
|
||||
redis_writenl $fd "flushall\r\n"
|
||||
redis_read_retcode $fd
|
||||
redis_writenl $fd "flushall"
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_flushdb {fd} {
|
||||
redis_writenl $fd "flushdb\r\n"
|
||||
redis_read_retcode $fd
|
||||
redis_writenl $fd "flushdb"
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc redis_lrem {fd key count val} {
|
||||
redis_writenl $fd "lrem $key $count [string length $val]\r\n$val"
|
||||
redis_read_integer $fd
|
||||
redis_read_reply $fd
|
||||
}
|
||||
|
||||
proc stress {} {
|
||||
set fd [socket 127.0.0.1 6379]
|
||||
fconfigure $fd -translation binary
|
||||
redis_flushall $fd
|
||||
while 1 {
|
||||
set randkey [expr int(rand()*10000)]
|
||||
set randval [expr int(rand()*10000)]
|
||||
set randidx0 [expr int(rand()*10)]
|
||||
set randidx1 [expr int(rand()*10)]
|
||||
set cmd [expr int(rand()*10)]
|
||||
if {$cmd == 0} {redis_set $fd $randkey $randval}
|
||||
if {$cmd == 1} {redis_get $fd $randkey}
|
||||
if {$cmd == 2} {redis_incr $fd $randkey}
|
||||
if {$cmd == 3} {redis_lpush $fd $randkey $randval}
|
||||
if {$cmd == 4} {redis_rpop $fd $randkey}
|
||||
if {$cmd == 5} {redis_del $fd $randkey}
|
||||
if {$cmd == 6} {redis_lrange $fd $randkey $randidx0 $randidx1}
|
||||
if {$cmd == 7} {redis_ltrim $fd $randkey $randidx0 $randidx1}
|
||||
if {$cmd == 8} {redis_lindex $fd $randkey $randidx0}
|
||||
if {$cmd == 9} {redis_lset $fd $randkey $randidx0 $randval}
|
||||
flush stdout
|
||||
}
|
||||
close $fd
|
||||
}
|
||||
|
||||
if {[llength $argv] == 0} {
|
||||
main 127.0.0.1 6379
|
||||
} elseif {[llength $argv] == 1 && [lindex $argv 0] eq {stress}} {
|
||||
stress
|
||||
} else {
|
||||
main [lindex $argv 0] [lindex $argv 1]
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue