Peter M. Groen / redox

Make .free() on commands send a message over an async watcher to the
event loop, just like adding commands. This gets rid of some very tough
to find memory bugs. Combined .cancel() with .free(), so there is only
one method to call, whether for synchronous commands or for looped
commands.

Also debug some horrible segfaults related to Subscriber. Something is
odd with hiredis and subscriptions, need to ask them. It seems when we
flood with commands it doesn't disconnect cleanly. Look for a way to
wait until all commands are processed.

Conform (mostly) to Google C++ guidelines.

Apache license notice and link above each core file.

Refactor state management code to use three methods .connect(),
.disconnect(), and .wait(). Start conforming to uniform coding style
already applied to Command class.

Split off subscribe functionality into its own class Subscriber. This is
good because it was introducing unnecessary state and complexity into
the main client. Now, Redox handles publishing like any other command
and the Subscriber receives messages.

Using free_guard_ as the same mutex in .reply() causes deadlock when a
callback accesses .reply(). Make a separate mutex.

Also make cmd.reply() copy the value and use a mutex to make it thread
safe. No noticable speed hits, probably thanks to RVO.

Split up command into command, command_blocking, and command_looping.
The original command no longer returns anything, which clarifies how it
should be used in most cases. command_looping and command_blocking both
return a command object.

Also added a waiting CV to the Command object, though it is not used in
command_blocking yet.

Now, there is only one callback for command(), and it returns a const
reference to the Command object. The user is responsible for error
checking using c.ok(), c.status(), and getting the reply with c.reply().
This significantly cleans up the library code and the user code.

Greatly refactored the data type specialization code in command.cpp.

* Member variables with trailing underscore
* Methods camelCase
* Explicit template instantiation, move definitions to .cpp
* Reorder methods to make more sense
* Limit public API, comment well

utils/logger.[ch]pp gives a logger implementation based on ostringstream
that is pretty nice. I took this from Stack Overflow and added some
things to make syntax nicer. Changed all cout and cerr statements in
Redox to be of the form logger.{debug/info/warning/error/fatal}() <<
stuff. Arguments for non-printed statements are still evaluated. Gives a
performance hit if we actually add statements on every callback and run
speed tests. For most use cases, doesn't matter. For now, not including
such low level output anyway. Would be nice to have a macro to leave
out/include the low-level logs at compile-time.

submit_command_callback

Thoroughly cleaned up redox.hpp to expose a minimal public API, and
commented those well. Generally cleaned up a bunch of stuff.

Added wrapper function DEL, which could be useful.

Easy few lines for get and set commands that are easy to use.

Implemented a condition variable that blocks run() until the event
loop is running and Redis is connected. Also added a check to
command() that will throw an exception if you try to add a command
before calling run().

Fixed a couple of bugs found with a test case of 100 parallel
asynchronous clients. As of now, there are no known memory
leaks, segfaults, or deadlocks in Redox.

Ran into a nasty segfault when using 100 parallel asynchronous command
loops, where a command's address would match up with a previous
command's
address. To circumvent the whole issue, Redox keeps a counter of how
many Commands it has created and assigns each Command a unique id in
the order they are created.

Changed all data structures and methods to pass around Command IDs, so
nothing uses void* anymore. I consider this a very good thing, but it
did seem to slow down performance 20-30% because of the extra lookups.
Will see if there's a solution later.

Take that, hours of debugging memory leaks! Did lots of structural
tweaks to more smartly keep track of commands and make sure everything
is evenutally freed from the heap.

Created a pointer Command.rdx (Redox*) to allow commands
to increment Redox.cmd_count, and simplify a couple of
other things.

Did a little bit of moving and renaming context objects,
so the context is always .ctx and commands can always
be called c.

Added Command<nullptr_t> which successfully returns NIL
replies from Redis, with REDOX_OK. Also renamed constants
from REDISX_ -> REDOX_.

Moved a bunch of code from redox.cpp into command.cpp, where
it logically makes more sense.

Move as much as possible into the .cpp file, and clean things up.

Found out that ev_timer watchers have a void* data that allows
currying information to the libev callbacks! That means I could
stick the Command* in there and completely get rid of the global
timer_callbacks map that was needed before.

Additionally, we can move ev_timer into the Command object instead
of separately allocating it on the heap. Simplifies management.

Implemented a synchronous loop speed test based on the latest
and greatest command_blocking(). Happy to see it is around
30k/s, which is 100% network delays.

Several hours of multithreaded debugging to find a nasty extra
ampersand. command_blocking() now returns a Command object with
the value and status accessible through methods.

Added the option to free memory or not for Command objects when
command() is called. If free_memory = true, then the Command
object is freed after the callback or error callback returns.
If free_memory = false, then the user must call cmd->free().

To implement this, we have to pass in a blank function to the
freeObject entry in the hiredis redisReader, because otherwise
it automatically frees memory. This was not cool for the blocking
case.

Implemented error callbacks for command(). Now, either the success
or error callbacks are guaranteed to return for any command. Added
constants for error types.

Many improvements and fixes for memory management. Command objects
keep track of pending replies and delete themselves when completed.

Changed ReplyT value to remove the const and reference requirements.
Now, you do command<ReplyT> and the callback should take a
const ReplyT&, whatever the type is. Makes things more uniform.

Renamed CommandAsync to Command to make things simpler, and
refactored into its own file.

command() now returns a pointer to the created Command object,
which the client can pass into cancel() to stop any delayed
or repeating calls. This is very important for an asynchronous
client.