]> git.saurik.com Git - redis.git/log
redis.git
12 years agoMerge pull request #707 from NanXiao/patch-1
Salvatore Sanfilippo [Wed, 10 Oct 2012 09:18:14 +0000 (02:18 -0700)] 
Merge pull request #707 from NanXiao/patch-1

Update src/redis-benchmark.c

12 years agoUpdate src/redis-benchmark.c
NanXiao [Wed, 10 Oct 2012 09:08:43 +0000 (17:08 +0800)] 
Update src/redis-benchmark.c

The code of current implementation:

if (c->pending == 0) clientDone(c);
In clientDone function, the c's memory has been freed, then the loop will continue: while(c->pending). The memory of c has been freed now, so c->pending is invalid (c is an invalid pointer now), and this will cause memory dump in some platforams(eg: Solaris).

So I think the code should be modified as:
if (c->pending == 0)
{
clientDone(c);
break;
}
and this will not lead to while(c->pending).

12 years agoCONTRIBUTING file updated.
antirez [Sat, 6 Oct 2012 10:04:27 +0000 (12:04 +0200)] 
CONTRIBUTING file updated.

12 years agofixed server install script to rewrite the default configuration file and not a templ...
dvir volk [Fri, 8 Jun 2012 13:03:18 +0000 (16:03 +0300)] 
fixed server install script to rewrite the default configuration file and not a template, and removed the old config template
Conflicts:

utils/redis.conf.tpl

12 years agoHash function switched to murmurhash2.
antirez [Wed, 3 Oct 2012 17:14:46 +0000 (19:14 +0200)] 
Hash function switched to murmurhash2.

The previously used hash function, djbhash, is not secure against
collision attacks even when the seed is randomized as there are simple
ways to find seed-independent collisions.

The new hash function appears to be safe (or much harder to exploit at
least) in this case, and has better distribution.

Better distribution does not always means that's better. For instance in
a fast benchmark with "DEBUG POPULATE 1000000" I obtained the following
results:

    1.6 seconds with djbhash
    2.0 seconds with murmurhash2

This is due to the fact that djbhash will hash objects that follow the
pattern `prefix:<id>` and where the id is numerically near, to near
buckets. This improves the locality.

However in other access patterns with keys that have no relation
murmurhash2 has some (apparently minimal) speed advantage.

On the other hand a better distribution should significantly
improve the quality of the distribution of elements returned with
dictGetRandomKey() that is used in SPOP, SRANDMEMBER, RANDOMKEY, and
other commands.

Everything considered, and under the suspect that this commit fixes a
security issue in Redis, we are switching to the new hash function.
If some serious speed regression will be found in the future we'll be able
to step back easiliy.

This commit fixes issue #663.

12 years agoWarn when configured maxmemory value seems odd.
antirez [Fri, 5 Oct 2012 08:48:49 +0000 (10:48 +0200)] 
Warn when configured maxmemory value seems odd.

This commit warns the user with a log at "warning" level if:

1) After the server startup the maxmemory limit was found to be < 1MB.
2) After a CONFIG SET command modifying the maxmemory setting the limit
is set to a value that is smaller than the currently used memory.

The behaviour of the Redis server is unmodified, and this wil not make
the CONFIG SET command or a wrong configuration in redis.conf less
likely to create problems, but at least this will make aware most users
about a possbile error they committed without resorting to external
help.

However no warning is issued if, as a result of loading the AOF or RDB
file, we are very near the maxmemory setting, or key eviction will be
needed in order to go under the specified maxmemory setting. The reason
is that in servers configured as a cache with an aggressive
maxmemory-policy most of the times restarting the server will cause this
condition to happen if persistence is not switched off.

This fixes issue #429.

12 years agoInclude time.h in ae.c as we now use time().
antirez [Fri, 5 Oct 2012 08:10:34 +0000 (10:10 +0200)] 
Include time.h in ae.c as we now use time().

12 years agoForce expire all timer events when system clock skew is detected.
Jokea [Thu, 30 Aug 2012 07:08:19 +0000 (15:08 +0800)] 
Force expire all timer events when system clock skew is detected.

When system time changes back, the timer will not worker properly
hence some core functionality of redis will stop working(e.g. replication,
bgsave, etc). See issue #633 for details.

The patch saves the previous time and when a system clock skew is detected,
it will force expire all timers.

Modiifed by @antirez: the previous time was moved into the eventLoop
structure to make sure the library is still thread safe as long as you
use different event loops into different threads (otherwise you need
some synchronization). More comments added about the reasoning at the
base of the patch, that's worth reporting here:

/* If the system clock is moved to the future, and then set back to the
 * right value, time events may be delayed in a random way. Often this
 * means that scheduled operations will not be performed soon enough.
 *
 * Here we try to detect system clock skews, and force all the time
 * events to be processed ASAP when this happens: the idea is that
 * processing events earlier is less dangerous than delaying them
 * indefinitely, and practice suggests it is. */

12 years ago"Timeout receiving bulk data" error message modified.
antirez [Thu, 4 Oct 2012 09:49:17 +0000 (11:49 +0200)] 
"Timeout receiving bulk data" error message modified.

The new message now contains an hint about modifying the repl-timeout
configuration directive if the problem persists.

This should normally not be needed, because while the master generates
the RDB file it makes sure to send newlines to the replication channel
to prevent timeouts. However there are times when masters running on
very slow systems can completely stop for seconds during the RDB saving
process. In such a case enlarging the timeout value can fix the problem.

See issue #695 for an example of this problem in an EC2 deployment.

12 years ago"SORT by nosort" (skip sorting) respect sorted set ordering.
antirez [Wed, 3 Oct 2012 09:41:08 +0000 (11:41 +0200)] 
"SORT by nosort" (skip sorting) respect sorted set ordering.

When SORT is called with the option BY set to a string constant not
inclduing the wildcard character "*", there is no way to sort the output
so any ordering is valid. This allows the SORT internals to optimize its
work and don't really sort the output at all.

However it was odd that this option was not able to retain the natural
order of a sorted set. This feature was requested by users multiple
times as sometimes to call SORT with GET against sorted sets as a way to
mass-fetch objects can be handy.

This commit introduces two things:

1) The ability of SORT to return sorted sets elements in their natural
ordering when `BY nosort` is specified, accordingly to `DESC / ASC` options.
2) The ability of SORT to optimize this case further if LIMIT is passed
as well, avoiding to really fetch the whole sorted set, but directly
obtaining the specified range.

Because in this case the sorting is always deterministic, no
post-sorting activity is performed when SORT is called from a Lua
script.

This commit fixes issue #98.

12 years agoRevert "Scripting: redis.NIL to return nil bulk replies."
antirez [Mon, 1 Oct 2012 08:10:03 +0000 (10:10 +0200)] 
Revert "Scripting: redis.NIL to return nil bulk replies."

This reverts commit e061d797d739f2beeb22b9e8ac519d1df070e3a8.

Conflicts:

src/scripting.c

12 years agoScripting: add helper functions redis.error_reply() and redis.status_reply().
antirez [Fri, 28 Sep 2012 14:54:57 +0000 (16:54 +0200)] 
Scripting: add helper functions redis.error_reply() and redis.status_reply().

A previous commit introduced Redis.NIL. This commit adds similar helper
functions to return tables with a single field set to the specified
string so that instead of using 'return {err="My Error"}' it is possible
to use a more idiomatic form:

    return redis.error_reply("My Error")
    return redis.status_reply("OK")

12 years agoScripting: redis.NIL to return nil bulk replies.
antirez [Fri, 28 Sep 2012 12:19:15 +0000 (14:19 +0200)] 
Scripting: redis.NIL to return nil bulk replies.

Lua arrays can't contain nil elements (see
http://www.lua.org/pil/19.1.html for more information), so Lua scripts
were not able to return a multi-bulk reply containing nil bulk
elements inside.

This commit introduces a special conversion: a table with just
a "nilbulk" field set to a boolean value is converted by Redis as a nil
bulk reply, but at the same time for Lua this type is not a "nil" so can
be used inside Lua arrays.

This type is also assigned to redis.NIL, so the following two forms
are equivalent and will be able to return a nil bulk reply as second
element of a three elements array:

    EVAL "return {1,redis.NIL,3}" 0
    EVAL "return {1,{nilbulk=true},3}" 0

The result in redis-cli will be:

    1) (integer) 1
    2) (nil)
    3) (integer) 3

12 years agoSentinel: Support for AUTH.
antirez [Wed, 26 Sep 2012 16:59:54 +0000 (18:59 +0200)] 
Sentinel: Support for AUTH.

12 years agoTest for SRANDMEMBER with <count>.
antirez [Fri, 21 Sep 2012 09:33:06 +0000 (11:33 +0200)] 
Test for SRANDMEMBER with <count>.

12 years agoSRANDMEMBER <count> leak fixed.
antirez [Thu, 20 Sep 2012 14:33:36 +0000 (16:33 +0200)] 
SRANDMEMBER <count> leak fixed.

For "CASE 4" (see code) we need to free the element if it's already in
the result dictionary and adding it failed.

12 years agoAdded the SRANDMEMBER key <count> variant.
antirez [Wed, 19 Sep 2012 19:29:40 +0000 (21:29 +0200)] 
Added the SRANDMEMBER key <count> variant.

SRANDMEMBER called with just the key argument can just return a single
random element from a Redis Set. However many users need to return
multiple unique elements from a Set, this is not a trivial problem to
handle in the client side, and for truly good performance a C
implementation was required.

After many requests for this feature it was finally implemented.

The problem implementing this command is the strategy to follow when
the number of elements the user asks for is near to the number of
elements that are already inside the set. In this case asking random
elements to the dictionary API, and trying to add it to a temporary set,
may result into an extremely poor performance, as most add operations
will be wasted on duplicated elements.

For this reason this implementation uses a different strategy in this
case: the Set is copied, and random elements are returned to reach the
specified count.

The code actually uses 4 different algorithms optimized for the
different cases.

If the count is negative, the command changes behavior and allows for
duplicated elements in the returned subset.

12 years agoFix compilation on FreeBSD. Thanks to @koobs on twitter.
antirez [Mon, 17 Sep 2012 10:45:57 +0000 (12:45 +0200)] 
Fix compilation on FreeBSD. Thanks to @koobs on twitter.

12 years ago.gitignore modified to be more general with less entries.
antirez [Mon, 17 Sep 2012 08:45:56 +0000 (10:45 +0200)] 
.gitignore modified to be more general with less entries.

12 years agoA reimplementation of blocking operation internals.
antirez [Tue, 4 Sep 2012 08:37:49 +0000 (10:37 +0200)] 
A reimplementation of blocking operation internals.

Redis provides support for blocking operations such as BLPOP or BRPOP.
This operations are identical to normal LPOP and RPOP operations as long
as there are elements in the target list, but if the list is empty they
block waiting for new data to arrive to the list.

All the clients blocked waiting for th same list are served in a FIFO
way, so the first that blocked is the first to be served when there is
more data pushed by another client into the list.

The previous implementation of blocking operations was conceived to
serve clients in the context of push operations. For for instance:

1) There is a client "A" blocked on list "foo".
2) The client "B" performs `LPUSH foo somevalue`.
3) The client "A" is served in the context of the "B" LPUSH,
synchronously.

Processing things in a synchronous way was useful as if "A" pushes a
value that is served by "B", from the point of view of the database is a
NOP (no operation) thing, that is, nothing is replicated, nothing is
written in the AOF file, and so forth.

However later we implemented two things:

1) Variadic LPUSH that could add multiple values to a list in the
context of a single call.
2) BRPOPLPUSH that was a version of BRPOP that also provided a "PUSH"
side effect when receiving data.

This forced us to make the synchronous implementation more complex. If
client "B" is waiting for data, and "A" pushes three elemnents in a
single call, we needed to propagate an LPUSH with a missing argument
in the AOF and replication link. We also needed to make sure to
replicate the LPUSH side of BRPOPLPUSH, but only if in turn did not
happened to serve another blocking client into another list ;)

This were complex but with a few of mutually recursive functions
everything worked as expected... until one day we introduced scripting
in Redis.

Scripting + synchronous blocking operations = Issue #614.

Basically you can't "rewrite" a script to have just a partial effect on
the replicas and AOF file if the script happened to serve a few blocked
clients.

The solution to all this problems, implemented by this commit, is to
change the way we serve blocked clients. Instead of serving the blocked
clients synchronously, in the context of the command performing the PUSH
operation, it is now an asynchronous and iterative process:

1) If a key that has clients blocked waiting for data is the subject of
a list push operation, We simply mark keys as "ready" and put it into a
queue.
2) Every command pushing stuff on lists, as a variadic LPUSH, a script,
or whatever it is, is replicated verbatim without any rewriting.
3) Every time a Redis command, a MULTI/EXEC block, or a script,
completed its execution, we run the list of keys ready to serve blocked
clients (as more data arrived), and process this list serving the
blocked clients.
4) As a result of "3" maybe more keys are ready again for other clients
(as a result of BRPOPLPUSH we may have push operations), so we iterate
back to step "3" if it's needed.

The new code has a much simpler semantics, and a simpler to understand
implementation, with the disadvantage of not being able to "optmize out"
a PUSH+BPOP as a No OP.

This commit will be tested with care before the final merge, more tests
will be added likely.

12 years agoMake sure that SELECT argument is an integer or return an error.
antirez [Tue, 11 Sep 2012 08:32:04 +0000 (10:32 +0200)] 
Make sure that SELECT argument is an integer or return an error.

Unfortunately we had still the lame atoi() without any error checking in
place, so "SELECT foo" would work as "SELECT 0". This was not an huge
problem per se but some people expected that DB can be strings and not
just numbers, and without errors you get the feeling that they can be
numbers, but not the behavior.

Now getLongFromObjectOrReply() is used as almost everybody else across
the code, generating an error if the number is not an integer or
overflows the long type.

Thanks to @mipearson for reporting that on Twitter.

12 years agoMatch printf format with actual type in genRedisInfoString().
antirez [Mon, 10 Sep 2012 10:42:55 +0000 (12:42 +0200)] 
Match printf format with actual type in genRedisInfoString().

12 years agoBITCOUNT regression test for #582 fixed for 32 bit target.
antirez [Wed, 5 Sep 2012 15:46:06 +0000 (17:46 +0200)] 
BITCOUNT regression test for #582 fixed for 32 bit target.

Bug #582 was not present in 32 bit builds of Redis as
getObjectFromLong() will return an error for overflow.

This commit makes sure that the test does not fail because of the error
returned when running against 32 bit builds.

12 years agoBITCOUNT: fix segmentation fault.
Haruto Otake [Sun, 15 Jul 2012 09:38:30 +0000 (18:38 +0900)] 
BITCOUNT: fix segmentation fault.

remove unsafe and unnecessary cast.
until now, this cast may lead segmentation fault when end > UINT_MAX

setbit foo 0 1
bitcount  0 4294967295
=> ok
bitcount  0 4294967296
=> cause segmentation fault.

Note by @antirez: the commit was modified a bit to also change the
string length type to long, since it's guaranteed to be at max 512 MB in
size, so we can work with the same type across all the code path.

A regression test was also added.

12 years agoMerge pull request #576 from saj/fix-slave-ping-period
Salvatore Sanfilippo [Wed, 5 Sep 2012 13:59:37 +0000 (06:59 -0700)] 
Merge pull request #576 from saj/fix-slave-ping-period

Bug fix: slaves being pinged every second

12 years agoScripting: Force SORT BY constant determinism inside SORT itself.
antirez [Tue, 4 Sep 2012 23:12:41 +0000 (01:12 +0200)] 
Scripting: Force SORT BY constant determinism inside SORT itself.

SORT is able to return (faster than when ordering) unordered output if
the "BY" clause is used with a constant value. However we try to play
well with scripting requirements of determinism providing always sorted
outputs when SORT (and other similar commands) are called by Lua
scripts.

However we used the general mechanism in place in scripting in order to
reorder SORT output, that is, if the command has the "S" flag set, the
Lua scripting engine will take an additional step when converting a
multi bulk reply to Lua value, calling a Lua sorting function.

This is suboptimal as we can do it faster inside SORT itself.
This is also broken as issue #545 shows us: basically when SORT is used
with a constant BY, and additionally also GET is used, the Lua scripting
engine was trying to order the output as a flat array, while it was
actually a list of key-value pairs.

What we do know is to recognized if the caller of SORT is the Lua client
(since we can check this using the REDIS_LUA_CLIENT flag). If so, and if
a "don't sort" condition is triggered by the BY option with a constant
string, we force the lexicographical sorting.

This commit fixes this bug and improves the performance, and at the same
time simplifies the implementation. This does not mean I'm smart today,
it means I was stupid when I committed the original implementation ;)

12 years agoSentinel: reply -IDONTKNOW to get-master-addr-by-name on lack of info.
antirez [Tue, 4 Sep 2012 14:06:53 +0000 (16:06 +0200)] 
Sentinel: reply -IDONTKNOW to get-master-addr-by-name on lack of info.

If we don't have any clue about a master since it never replied to INFO
so far, reply with an -IDONTKNOW error to SENTINEL
get-master-addr-by-name requests.

12 years agoSentinel: more easy master redirection if master is a slave.
antirez [Tue, 4 Sep 2012 13:52:04 +0000 (15:52 +0200)] 
Sentinel: more easy master redirection if master is a slave.

Before this commit Sentienl used to redirect master ip/addr if the
current instance reported to be a slave only if this was the first INFO
output received, and the role was found to be slave.

Now instead also if we find that the runid is different, and the
reported role is slave, we also redirect to the reported master ip/addr.

This unifies the behavior of Sentinel in the case of a reboot (where it
will see the first INFO output with the wrong role and will perform the
redirection), with the behavior of Sentinel in the case of a change in
what it sees in the INFO output of the master.

12 years agoSend an async PING before starting replication with master.
antirez [Fri, 31 Aug 2012 13:32:57 +0000 (15:32 +0200)] 
Send an async PING before starting replication with master.

During the first synchronization step of the replication process, a Redis
slave connects with the master in a non blocking way. However once the
connection is established the replication continues sending the REPLCONF
command, and sometimes the AUTH command if needed. Those commands are
send in a partially blocking way (blocking with timeout in the order of
seconds).

Because it is common for a blocked master to accept connections even if
it is actually not able to reply to the slave requests, it was easy for
a slave to block if the master had serious issues, but was still able to
accept connections in the listening socket.

For this reason we now send an asynchronous PING request just after the
non blocking connection ended in a successful way, and wait for the
reply before to continue with the replication process. It is very
unlikely that a master replying to PING can't reply to the other
commands.

This solution was proposed by Didier Spezia (Thanks!) so that we don't
need to turn all the replication process into a non blocking affair, but
still the probability of a slave blocked is minimal even in the event of
a failing master.

Also we now use getsockopt(SO_ERROR) in order to check errors ASAP
in the event handler, instead of waiting for actual I/O to return an
error.

This commit fixes issue #632.

12 years agoScripting: Reset Lua fake client reply_bytes after command execution.
antirez [Fri, 31 Aug 2012 09:08:53 +0000 (11:08 +0200)] 
Scripting: Reset Lua fake client reply_bytes after command execution.

Lua scripting uses a fake client in order to run commands in the context
of a client, accumulate the reply, and convert it into a Lua object
to return to the caller. This client is reused again and again, and is
referenced by the server.lua_client globally accessible pointer.

However after every call to redis.call() or redis.pcall(), that is
handled by the luaRedisGenericCommand() function, the reply_bytes field
of the client was not set back to zero. This filed is used to estimate
the amount of memory currently used in the reply. Because of the lack of
reset, script after script executed, this value used to get bigger and
bigger, and in the end on 32 bit systems it triggered the following
assert:

    redisAssert(c->reply_bytes < ULONG_MAX-(1024*64));

On 64 bit systems this does not happen because it takes too much time to
reach values near to 2^64 for users to see the practical effect of the
bug.

Now in the cleanup stage of luaRedisGenericCommand() we reset the
reply_bytes counter to zero, avoiding the issue. It is not practical to
add a test for this bug, but the fix was manually tested using a
debugger.

This commit fixes issue #656.

12 years agoScripting: require at least one argument for redis.call().
antirez [Fri, 31 Aug 2012 08:22:21 +0000 (10:22 +0200)] 
Scripting: require at least one argument for redis.call().

Redis used to crash with a call like the following:

    EVAL "redis.call()" 0

Now the explicit check for at least one argument prevents the problem.

This commit fixes issue #655.

12 years agoSentinel: do not crash against slaves not publishing the runid.
antirez [Thu, 30 Aug 2012 15:57:02 +0000 (17:57 +0200)] 
Sentinel: do not crash against slaves not publishing the runid.

Older versions of Redis (before 2.4.17) don't publish the runid field in
INFO. This commit makes Sentinel able to handle that without crashing.

12 years agoSentinel: INFO command implementation.
antirez [Wed, 29 Aug 2012 10:44:24 +0000 (12:44 +0200)] 
Sentinel: INFO command implementation.

12 years agoSentinel: add Redis execution mode to INFO output.
antirez [Wed, 29 Aug 2012 09:44:01 +0000 (11:44 +0200)] 
Sentinel: add Redis execution mode to INFO output.

The new "redis_mode" field in the INFO output will show if Redis is
running in standalone mode, cluster, or sentinel mode.

12 years agoSentinel: added documentation about slave-priority in redis.conf
antirez [Tue, 28 Aug 2012 15:53:18 +0000 (17:53 +0200)] 
Sentinel: added documentation about slave-priority in redis.conf

12 years agoSentinel: Sentinel-side support for slave priority.
antirez [Tue, 28 Aug 2012 15:45:01 +0000 (17:45 +0200)] 
Sentinel: Sentinel-side support for slave priority.

The slave priority that is now published by Redis in INFO output is
now used by Sentinel in order to select the slave with minimum priority
for promotion, and in order to consider slaves with priority set to 0 as
not able to play the role of master (they will never be promoted by
Sentinel).

The "slave-priority" field is now one of the fileds that Sentinel
publishes when describing an instance via the SENTINEL commands such as
"SENTINEL slaves mastername".

12 years agoSentinel: Redis-side support for slave priority.
antirez [Tue, 28 Aug 2012 15:20:26 +0000 (17:20 +0200)] 
Sentinel: Redis-side support for slave priority.

A Redis slave can now be configured with a priority, that is an integer
number that is shown in INFO output and can be get and set using the
redis.conf file or the CONFIG GET/SET command.

This field is used by Sentinel during slave election. A slave with lower
priority is preferred. A slave with priority zero is never elected (and
is considered to be impossible to elect even if it is the only slave
available).

A next commit will add support in the Sentinel side as well.

12 years agoSentinel: suppress harmless warning by initializing 'table' to NULL.
antirez [Tue, 28 Aug 2012 10:56:05 +0000 (12:56 +0200)] 
Sentinel: suppress harmless warning by initializing 'table' to NULL.

Note that the assertion guarantees that one of the if branches setting
table is always entered.

12 years agoIncrementally flush RDB on disk while loading it from a master.
antirez [Fri, 24 Aug 2012 17:28:44 +0000 (19:28 +0200)] 
Incrementally flush RDB on disk while loading it from a master.

This fixes issue #539.

Basically if there is enough free memory the OS may buffer the RDB file
that the slave transfers on disk from the master. The file may
actually be flused on disk at once by the operating system when it gets
closed by Redis, causing the close system call to block for a long time.

This patch is a modified version of one provided by yoav-steinberg of
@garantiadata (the original version was posted in the issue #539
comments), and tries to flush the OS buffers incrementally (every 8 MB
of loaded data).

12 years agoFix a forget zmalloc_oom() -> zmalloc_oom_handler() replacement.
antirez [Fri, 24 Aug 2012 13:40:22 +0000 (15:40 +0200)] 
Fix a forget zmalloc_oom() -> zmalloc_oom_handler() replacement.

12 years agoBetter Out of Memory handling.
antirez [Fri, 24 Aug 2012 10:55:37 +0000 (12:55 +0200)] 
Better Out of Memory handling.

The previous implementation of zmalloc.c was not able to handle out of
memory in an application-specific way. It just logged an error on
standard error, and aborted.

The result was that in the case of an actual out of memory in Redis
where malloc returned NULL (In Linux this actually happens under
specific overcommit policy settings and/or with no or little swap
configured) the error was not properly logged in the Redis log.

This commit fixes this problem, fixing issue #509.
Now the out of memory is properly reported in the Redis log and a stack
trace is generated.

The approach used is to provide a configurable out of memory handler
to zmalloc (otherwise the default one logging the event on the
standard output is used).

12 years agoSentinel: send SCRIPT KILL on -BUSY reply and SDOWN instance.
antirez [Fri, 24 Aug 2012 10:29:54 +0000 (12:29 +0200)] 
Sentinel: send SCRIPT KILL on -BUSY reply and SDOWN instance.

From the point of view of Redis an instance replying -BUSY is down,
since it is effectively not able to reply to user requests. However
a looping script is a recoverable condition in Redis if the script still
did not performed any write to the dataset. In that case performing a
fail over is not optimal, so Sentinel now tries to restore the normal server
condition killing the script with a SCRIPT KILL command.

If the script already performed some write before entering an infinite
(or long enough to timeout) loop, SCRIPT KILL will not work and the
fail over will be triggered anyway.

12 years agoSentinel: fixed a crash on script execution.
antirez [Fri, 24 Aug 2012 10:10:24 +0000 (12:10 +0200)] 
Sentinel: fixed a crash on script execution.

The call to sentinelScheduleScriptExecution() lacked the final NULL
argument to signal the end of arguments. This resulted into a crash.

12 years agoMerge pull request #628 from pietern/unstable-zip
Salvatore Sanfilippo [Wed, 22 Aug 2012 09:32:27 +0000 (02:32 -0700)] 
Merge pull request #628 from pietern/unstable-zip

Fix ziplist edge case

12 years agoredis-benchmark: disable big buffer cleanup in hiredis context.
antirez [Tue, 21 Aug 2012 15:31:44 +0000 (17:31 +0200)] 
redis-benchmark: disable big buffer cleanup in hiredis context.

This new hiredis features allows us to reuse a previous context reader
buffer even if already very big in order to maximize performances with
big payloads (Usually hiredis re-creates buffers when they are too big
and unused in order to save memory).

12 years agohiredis library updated.
antirez [Tue, 21 Aug 2012 15:27:01 +0000 (17:27 +0200)] 
hiredis library updated.

This version of hiredis merges modifications of the Redis fork with
latest changes in the hiredis repository.

The same version was pushed on the hiredis repository and will probably
merged into the master branch in short time.

12 years agoSet p to its new offset before modifying it
Pieter Noordhuis [Mon, 13 Aug 2012 19:39:49 +0000 (12:39 -0700)] 
Set p to its new offset before modifying it

12 years agoAdd ziplist test for deleting next to last entries
Pieter Noordhuis [Mon, 13 Aug 2012 21:09:40 +0000 (14:09 -0700)] 
Add ziplist test for deleting next to last entries

12 years agoSentinel: SENTINEL FAILOVER command implemented.
antirez [Fri, 3 Aug 2012 10:39:13 +0000 (12:39 +0200)] 
Sentinel: SENTINEL FAILOVER command implemented.

This command can be used in order to force a Sentinel instance to start
a failover for the specified master, as leader, forcing the failover
even if the master is up.

The commit also adds some minor refactoring and other improvements to
functions already implemented that make them able to work when the
master is not in SDOWN condition. For instance slave selection
assumed that we ask INFO every second to every slave, this is true
only when the master is in SDOWN condition, so slave selection did not
worked when the master was not in SDOWN condition.

12 years agoSentinel: client reconfiguration script execution.
antirez [Thu, 2 Aug 2012 16:40:30 +0000 (18:40 +0200)] 
Sentinel: client reconfiguration script execution.

This commit adds support to optionally execute a script when one of the
following events happen:

* The failover starts (with a slave already promoted).
* The failover ends.
* The failover is aborted.

The script is called with enough parameters (documented in the example
sentinel.conf file) to provide information about the old and new ip:port
pair of the master, the role of the sentinel (leader or observer) and
the name of the master.

The goal of the script is to inform clients of the configuration change
in a way specific to the environment Sentinel is running, that can't be
implemented in a genereal way inside Sentinel itself.

12 years agoMerge pull request #613 from tobstarr/patch-1
Salvatore Sanfilippo [Thu, 2 Aug 2012 12:37:10 +0000 (05:37 -0700)] 
Merge pull request #613 from tobstarr/patch-1

Fix version numbers

12 years agoFix version numbers
Tobias Schwab [Thu, 2 Aug 2012 12:10:51 +0000 (15:10 +0300)] 
Fix version numbers

12 years agoSentinel: when leader in wait-start, sense another leader as race.
antirez [Tue, 31 Jul 2012 15:11:26 +0000 (17:11 +0200)] 
Sentinel: when leader in wait-start, sense another leader as race.

When we are in wait start, if another leader (or any other external
entity) turns a slave into a master, abort the failover, and detect it
as an observer.

Note that the wait-start state is mainly there for this reason but the
abort was yet not implemented.

This adds a new sentinel event -failover-abort-race.

12 years agoSentinel: sentinelRefreshInstanceInfo() comments improved a bit.
antirez [Tue, 31 Jul 2012 14:18:15 +0000 (16:18 +0200)] 
Sentinel: sentinelRefreshInstanceInfo() comments improved a bit.

12 years agoUse correct variable name for value to convert.
Michael Parker [Thu, 26 Jul 2012 06:51:22 +0000 (23:51 -0700)] 
Use correct variable name for value to convert.

Note by @antirez: this code was never compiled because utils.c lacked the
float.h include, so we never noticed this variable was mispelled in the
past.

This should provide a noticeable speed boost when saving certain types
of databases with many sorted sets inside.

12 years agoSentinel: sentinel.conf self-documenation improved.
antirez [Tue, 31 Jul 2012 09:05:21 +0000 (11:05 +0200)] 
Sentinel: sentinel.conf self-documenation improved.

12 years agoSentinel: abort failover when in wait-start if master is back.
antirez [Tue, 31 Jul 2012 08:14:23 +0000 (10:14 +0200)] 
Sentinel: abort failover when in wait-start if master is back.

When we are a Leader Sentinel in wait-start state, starting with this
commit the failover is aborted if the master returns online.

This improves the way we handle a notable case of net split, that is the
split between Sentinels and Redis servers, that will be a very common
case of split becase Sentinels will often be installed in the client's
network and servers can be in a differnt arm of the network.

When Sentinels and Redis servers are isolated the master is in ODOWN
condition since the Sentinels can agree about this state, however the
failover does not start since there are no good slaves to promote (in
this specific case all the slaves are unreachable).

However when the split is resolved, Sentinels may sense the slave back
a moment before they sense the master is back, so the failover may start
without a good reason (since the master is actually working too).

Now this condition is reversible, so the failover will be aborted
immediately after if the master is detected to be working again, that
is, not in SDOWN nor in ODOWN condition.

12 years agoMerge remote-tracking branch 'origin/unstable' into unstable
antirez [Sat, 28 Jul 2012 18:55:17 +0000 (20:55 +0200)] 
Merge remote-tracking branch 'origin/unstable' into unstable

12 years agoSentinel: scripts execution engine improved.
antirez [Fri, 27 Jul 2012 08:39:39 +0000 (10:39 +0200)] 
Sentinel: scripts execution engine improved.

We no longer use a vanilla fork+execve but take a queue of jobs of
scripts to execute, with retry on error, timeouts, and so forth.

Currently this is used only for notifications but soon the ability to
also call clients reconfiguration scripts will be added.

12 years agocomment fix
Jeremy Zawodny [Wed, 25 Jul 2012 15:29:11 +0000 (08:29 -0700)] 
comment fix

improve English a bit. :-)

12 years agoMerge pull request #606 from badboy/patch-1
Salvatore Sanfilippo [Sat, 28 Jul 2012 09:51:56 +0000 (02:51 -0700)] 
Merge pull request #606 from badboy/patch-1

Include sys/wait.h to avoid compiler warning

12 years agoInclude sys/wait.h to avoid compiler warning
Jan-Erik Rediger [Sat, 28 Jul 2012 09:33:01 +0000 (12:33 +0300)] 
Include sys/wait.h to avoid compiler warning

gcc warned about an implicit declaration of function 'wait3'.
Including this header fixes this.

12 years agoMerge pull request #587 from saj/truncate-short-write-from-aof
Salvatore Sanfilippo [Fri, 27 Jul 2012 10:56:48 +0000 (03:56 -0700)] 
Merge pull request #587 from saj/truncate-short-write-from-aof

Truncate short write from the AOF

12 years agoMerge pull request #586 from saj/aof_last_bgrewrite_status
Salvatore Sanfilippo [Fri, 27 Jul 2012 10:55:20 +0000 (03:55 -0700)] 
Merge pull request #586 from saj/aof_last_bgrewrite_status

New in INFO: aof_last_bgrewrite_status

12 years agoSentinel: don't start a failover as leader if there is no good slave.
antirez [Thu, 26 Jul 2012 10:09:40 +0000 (12:09 +0200)] 
Sentinel: don't start a failover as leader if there is no good slave.

12 years agoMerge pull request #604 from jzawodn/patch-1
Salvatore Sanfilippo [Wed, 25 Jul 2012 15:31:57 +0000 (08:31 -0700)] 
Merge pull request #604 from jzawodn/patch-1

comment fix

12 years agocomment fix
Jeremy Zawodny [Wed, 25 Jul 2012 15:29:11 +0000 (08:29 -0700)] 
comment fix

improve English a bit. :-)

12 years agoSentinel: ability to execute notification scripts.
antirez [Wed, 25 Jul 2012 14:33:37 +0000 (16:33 +0200)] 
Sentinel: ability to execute notification scripts.

12 years agoMerge pull request #603 from mrb/fix_sentinel_config_warning
Salvatore Sanfilippo [Wed, 25 Jul 2012 14:15:53 +0000 (07:15 -0700)] 
Merge pull request #603 from mrb/fix_sentinel_config_warning

Fix warning in redis.c for sentinel config load

12 years agoMerge pull request #602 from mrb/sentinel_docs
Salvatore Sanfilippo [Wed, 25 Jul 2012 14:15:02 +0000 (07:15 -0700)] 
Merge pull request #602 from mrb/sentinel_docs

Some cleanup in sentinel.conf

12 years agoFix warning in redis.c for sentinel config load
mrb [Wed, 25 Jul 2012 13:55:53 +0000 (09:55 -0400)] 
Fix warning in redis.c for sentinel config load

12 years agoSome cleanup in sentinel.conf
mrb [Wed, 25 Jul 2012 13:52:26 +0000 (09:52 -0400)] 
Some cleanup in sentinel.conf

12 years agoSentinel: abort failover if no good slave is available.
antirez [Wed, 25 Jul 2012 09:32:19 +0000 (11:32 +0200)] 
Sentinel: abort failover if no good slave is available.

The previous behavior of the state machine was to wait some time and
retry the slave selection, but this is not robust enough against drastic
changes in the conditions of the monitored instances.

What we do now when the slave selection fails is to abort the failover
and return back monitoring the master. If the ODOWN condition is still
present a new failover will be triggered and so forth.

This commit also refactors the code we use to abort a failover.

12 years agoSentinel: reset pending_commands in a more generic way.
antirez [Tue, 24 Jul 2012 16:57:26 +0000 (18:57 +0200)] 
Sentinel: reset pending_commands in a more generic way.

12 years agoPrevent a spurious +sdown event on switch.
antirez [Tue, 24 Jul 2012 16:46:04 +0000 (18:46 +0200)] 
Prevent a spurious +sdown event on switch.

When we reset the master we should start with clean timestamps for ping
replies otherwise we'll detect a spurious +sdown event, because on
+master-switch event the previous master instance was probably in +sdown
condition. Since we updated the address we should count time from
scratch again.

Also this commit makes sure to explicitly reset the count of pending
commands, now we can do this because of the new way the hiredis link
is closed.

12 years agoSentinel: debugging message removed.
antirez [Tue, 24 Jul 2012 16:20:05 +0000 (18:20 +0200)] 
Sentinel: debugging message removed.

12 years agoSentinel: changes to connection handling and redirection.
antirez [Tue, 24 Jul 2012 16:15:44 +0000 (18:15 +0200)] 
Sentinel: changes to connection handling and redirection.

We disconnect the Redis instances hiredis link in a more robust way now.
Also we change the way we perform the redirection for the +switch-master
event, that is not just an instance reset with an address change.

Using the same system we now implement the +redirect-to-master event
that is triggered by an instance that is configured to be master but
found to be a slave at the first INFO reply. In that case we monitor the
master instead, logging the incident as an event.

12 years agoSentinel: check that instance still exists in reply callbacks.
antirez [Tue, 24 Jul 2012 14:35:23 +0000 (16:35 +0200)] 
Sentinel: check that instance still exists in reply callbacks.

We can't be sure the instance object still exists when the reply
callback is called.

12 years agoSentinel: more robust failover detection as observer.
antirez [Tue, 24 Jul 2012 10:42:40 +0000 (12:42 +0200)] 
Sentinel: more robust failover detection as observer.

Sentinel observers detect failover checking if a slave attached to the
monitored master turns into its replication state from slave to master.
However while this change may in theory only happen after a SLAVEOF NO
ONE command, in practie it is very easy to reboot a slave instance with
a wrong configuration that turns it into a master, especially if it was
a past master before a successfull failover.

This commit changes the detection policy so that if an instance goes
from slave to master, but at the same time the runid has changed, we
sense a reboot, and in that case we don't detect a failover at all.

This commit also introduces the "reboot" sentinel event, that is logged
at "warning" level (so this will trigger an admin notification).

The commit also fixes a problem in the disconnect handler that assumed
that the instance object always existed, that is not the case. Now we
no longer assume that redisAsyncFree() will call the disconnection
handler before returning.

12 years agoFixed an error in the example sentinel.conf.
antirez [Mon, 23 Jul 2012 13:08:36 +0000 (15:08 +0200)] 
Fixed an error in the example sentinel.conf.

12 years agoTypo.
antirez [Mon, 23 Jul 2012 13:06:55 +0000 (15:06 +0200)] 
Typo.

12 years agoFirst implementation of Redis Sentinel.
antirez [Mon, 23 Jul 2012 10:54:52 +0000 (12:54 +0200)] 
First implementation of Redis Sentinel.

This commit implements the first, beta quality implementation of Redis
Sentinel, a distributed monitoring system for Redis with notification
and automatic failover capabilities.

More info at http://redis.io/topics/sentinel

12 years agoMerge remote-tracking branch 'origin/unstable' into unstable
antirez [Sun, 22 Jul 2012 15:18:42 +0000 (17:18 +0200)] 
Merge remote-tracking branch 'origin/unstable' into unstable

12 years agoAllow Pub/Sub in contexts where other commands are blocked.
antirez [Sun, 22 Jul 2012 15:13:49 +0000 (17:13 +0200)] 
Allow Pub/Sub in contexts where other commands are blocked.

Redis loading data from disk, and a Redis slave disconnected from its
master with serve-stale-data disabled, are two conditions where
commands are normally refused by Redis, returning an error.

However there is no reason to disable Pub/Sub commands as well, given
that this layer does not interact with the dataset. To allow Pub/Sub in
as many contexts as possible is especially interesting now that Redis
Sentinel uses Pub/Sub of a Redis master as a communication channel
between Sentinels.

This commit allows Pub/Sub to be used in the above two contexts where
it was previously denied.

12 years agoMerge pull request #593 from steevel/unstable
Salvatore Sanfilippo [Sat, 21 Jul 2012 18:12:35 +0000 (11:12 -0700)] 
Merge pull request #593 from steevel/unstable

Check that we have connection before enabling pipe mode

12 years agoDon't assume that "char" is signed.
antirez [Wed, 18 Jul 2012 10:01:43 +0000 (12:01 +0200)] 
Don't assume that "char" is signed.

For the C standard char can be either signed or unsigned, it's up to the
compiler, but Redis assumed that it was signed in a few places.

The practical effect of this patch is that now Redis 2.6 will run
correctly in every system where char is unsigned, notably the RaspBerry
PI and other ARM systems with GCC.

Thanks to Georgi Marinov (@eesn on twitter) that reported the problem
and allowed me to use his RaspBerry via SSH to trace and fix the issue!

12 years agoTruncate short write from the AOF
Saj Goonatilleke [Mon, 16 Jul 2012 05:33:25 +0000 (15:33 +1000)] 
Truncate short write from the AOF

If Redis only manages to write out a partial buffer, the AOF file won't
load back into Redis the next time it starts up.  It is better to
discard the short write than waste time running redis-check-aof.

12 years agoNew in INFO: aof_last_bgrewrite_status
Saj Goonatilleke [Tue, 17 Jul 2012 02:06:53 +0000 (12:06 +1000)] 
New in INFO: aof_last_bgrewrite_status

Behaves like rdb_last_bgsave_status -- even down to reporting 'ok' when
no rewrite has been done yet.  (You might want to check that
aof_last_rewrite_time_sec is not -1.)

12 years agoCheck that we have connection before enabling pipe mode
Steeve Lennmark [Sun, 15 Jul 2012 12:35:02 +0000 (14:35 +0200)] 
Check that we have connection before enabling pipe mode

12 years agoMerge pull request #569 from jokea/unstable
Salvatore Sanfilippo [Mon, 9 Jul 2012 10:14:08 +0000 (03:14 -0700)] 
Merge pull request #569 from jokea/unstable

mark fd as writable when EPOLLERR or EPOLLHUP is returned by epoll_wait.

12 years agoBug fix: slaves being pinged every second
Saj Goonatilleke [Thu, 5 Jul 2012 04:29:27 +0000 (14:29 +1000)] 
Bug fix: slaves being pinged every second

REDIS_REPL_PING_SLAVE_PERIOD controls how often the master should
transmit a heartbeat (PING) to its slaves.  This period, which defaults
to 10, is measured in seconds.

Redis 2.4 masters used to ping their slaves every ten seconds, just like
it says on the tin.

The Redis 2.6 masters I have been experimenting with, on the other hand,
ping their slaves *every second*.  (master_last_io_seconds_ago never
approaches 10.)  I think the ping period was inadvertently slashed to
one-tenth of its nominal value around the time REDIS_HZ was introduced.
This commit reintroduces correct ping schedule behaviour.

12 years agomark fd as writable when EPOLLERR or EPOLLHUP is returned by epoll_wait.
jokea [Fri, 29 Jun 2012 04:06:38 +0000 (12:06 +0800)] 
mark fd as writable when EPOLLERR or EPOLLHUP is returned by epoll_wait.

12 years agoTypo in comment.
antirez [Wed, 27 Jun 2012 09:26:37 +0000 (11:26 +0200)] 
Typo in comment.

12 years agoREPLCONF internal command introduced.
antirez [Tue, 26 Jun 2012 07:47:47 +0000 (09:47 +0200)] 
REPLCONF internal command introduced.

The REPLCONF command is an internal command (not designed to be directly
used by normal clients) that allows a slave to set some replication
related state in the master before issuing SYNC to start the
replication.

The initial motivation for this command, and the only reason currently
it is used by the implementation, is to let the slave instance
communicate its listening port to the slave, so that the master can
show all the slaves with their listening ports in the "replication"
section of the INFO output.

This allows clients to auto discover and query all the slaves attached
into a master.

Currently only a single option of the REPLCONF command is supported, and
it is called "listening-port", so the slave now starts the replication
process with something like the following chat:

    REPLCONF listening-prot 6380
    SYNC

Note that this works even if the master is an older version of Redis and
does not understand REPLCONF, because the slave ignores the REPLCONF
error.

In the future REPLCONF can be used for partial replication and other
replication related features where there is the need to exchange
information between master and slave.

NOTE: This commit also fixes a bug: the INFO outout already carried
information about slaves, but the port was broken, and was obtained
with getpeername(2), so it was actually just the ephemeral port used
by the slave to connect to the master as a client.

12 years agoFixed comment typo into time_independent_strcmp().
antirez [Thu, 21 Jun 2012 12:25:53 +0000 (14:25 +0200)] 
Fixed comment typo into time_independent_strcmp().

12 years agoFixed a timing attack on AUTH (Issue #560).
antirez [Thu, 21 Jun 2012 09:50:01 +0000 (11:50 +0200)] 
Fixed a timing attack on AUTH (Issue #560).

The way we compared the authentication password using strcmp() allowed
an attacker to gain information about the password using a well known
class of attacks called "timing attacks".

The bug appears to be practically not exploitable in most modern systems
running Redis since even using multiple bytes of differences in the
input at a time instead of one the difference in running time in in the
order of 10 nanoseconds, making it hard to exploit even on LAN. However
attacks always get better so we are providing a fix ASAP.

The new implementation uses two fixed length buffers and a constant time
comparison function, with the goal of:

1) Completely avoid leaking information about the content of the
password, since the comparison is always performed between 512
characters and without conditionals.
2) Partially avoid leaking information about the length of the
password.

About "2" we still have a stage in the code where the real password and
the user provided password are copied in the static buffers, we also run
two strlen() operations against the two inputs, so the running time
of the comparison is a fixed amount plus a time proportional to
LENGTH(A)+LENGTH(B). This means that the absolute time of the operation
performed is still related to the length of the password in some way,
but there is no way to change the input in order to get a difference in
the execution time in the comparison that is not just proportional to
the string provided by the user (because the password length is fixed).

Thus in practical terms the user should try to discover LENGTH(PASSWORD)
looking at the whole execution time of the AUTH command and trying to
guess a proportionality between the whole execution time and the
password length: this appears to be mostly unfeasible in the real world.

Also protecting from this attack is not very useful in the case of Redis
as a brute force attack is anyway feasible if the password is too short,
while with a long password makes it not an issue that the attacker knows
the length.

12 years agoFix c->reply_bytes computation in setDeferredMultiBulkLength()
antirez [Fri, 15 Jun 2012 08:03:25 +0000 (10:03 +0200)] 
Fix c->reply_bytes computation in setDeferredMultiBulkLength()

In order to implement reply buffer limits introduced in 2.6 and useful
to close the connection under user-selected circumastances of big output
buffers (for instance slow consumers in pub/sub, a blocked slave, and so
forth) Redis takes a counter with the amount of used memory in objects
inside the output list stored into c->reply.

The computation was broken in the function setDeferredMultiBulkLength(),
in the case the object was glued with the next one. This caused the
c->reply_bytes field to go out of sync, be subtracted more than needed,
and wrap back near to ULONG_MAX values.

This commit fixes this bug and adds an assertion that is able to trap
this class of problems.

This problem was discovered looking at the INFO output of an unrelated
issue (issue #547).

12 years agoziplistFind(): don't assume that entries are comparable by encoding.
antirez [Thu, 14 Jun 2012 13:59:25 +0000 (15:59 +0200)] 
ziplistFind(): don't assume that entries are comparable by encoding.

Because Redis 2.6 introduced new integer encodings it is no longer true
that if two entries have a different encoding they are not equal.

An old ziplist can be loaded from an RDB file generated with Redis 2.4,
in this case for instance a small unsigned integers is encoded with a
16 bit encoding, while in Redis 2.6 a more specific 8 bit encoding
format is used.

Because of this bug hashes ended with duplicated values or fields lookup
failed, causing many bad behaviors.
This in turn caused a crash while converting the ziplist encoded hash into
a real hash table because an assertion was raised on duplicated elements.

This commit fixes issue #547.

Many thanks to Pinterest's Marty Weiner and colleagues for discovering
the problem and helping us in the debugging process.

12 years agoMerge pull request #552 from tnm/unstable
Salvatore Sanfilippo [Wed, 13 Jun 2012 08:25:52 +0000 (01:25 -0700)] 
Merge pull request #552 from tnm/unstable

Standardize punctuation in redis-cli help.

12 years agoStandardize punctuation in redis-cli help.
Ted Nyman [Wed, 13 Jun 2012 05:35:00 +0000 (22:35 -0700)] 
Standardize punctuation in redis-cli help.

Right there is a mix of help entries ending with periods or
without periods. This standardizes the end of command as without
periods, which seems to be the general custom in most unix tools,
at least.