Peter M. Groen / redox

Fix the path for logger.hpp, otherwise make install fails.

Change-Id: I50aa9667e512c4fdf6de471dc16312d9eb3dbe30

User can now enable no-wait mode, which chooses whether we use the
EVRUN_NOWAIT flag in ev_run. The default is off, so that we don't
use 100% CPU. Note added in tutorial to enable when performance
is critical. Added to the speed test examples.

Bump to 0.2.1. Remove patch number from HISTORY entry - that's what the
git log is for. Make note on minor release.

Useful for analyzing the delay between signals.

This makes more sense logically, and lets the Redox object get default
constructed with nothing but the optional logger parameters.

Separate include directory so that examples can reference the same thing
whether installed in the system or from the local folder.

Made redox into a more formal package with CMake. It now by default
builds a dynamic library in release mode. Tests and examples can be
enabled with options. Added semantic versioning. Documented the install
from source procedure which is very easy, just make and make install.

Users now have to just link one library (redox) and include one header
(redox.hpp), and the rest is linked from those.

Used CPack to add capability to create a debian package. Useful for
getting it into the apt repos.

Also redid the readme introduction.

Configure CMake to generate libredox.so and libredox_static.a, and have
all examples use the dynamic library. This is how Redox should be used
in practice, and greatly reduces the compilation time of the examples.

Also renamed redox.[ch]pp to client.[ch]pp and created one master header
redox.hpp for users to include. This header right now just includes
client.hpp, command.hpp, and subscriber.hpp.

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.

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.

subscribe/unsubscribe/publish with proper and working callbacks. Guard
added that throws an exception if a non-pubsub command is issued after a
subscribe.

Also removed all std:: prefixes from redox.cpp. Just made the decision
for "using namespace std" there for readability. Not a header, of
course.

Also added another async watcher for breaking the loop, since ev_break
doesn't actually do anything when called outside of an ev_run callback.

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.

Implemented limited but useful binary data support without breaking the
API. If the last character of the command is a ", look for the first ",
and everything in between the quotes treat as binary data. Takes care of
setting a key with a binary value. Not useful if there need to be
multiple binary entries in one command, or for binary keys. Also need to
be careful if the last character of the value actually needs to be a
quote, in which case we need to quote the value.

Added GTest under test/. Great for unit testing commands. Added some
nice helper functions to make writing tests easy.

Added options to CMakeLists to build the library, tests, and examples
separately, configurable through ccmake. Also default the build type
to RelWithDebInfo, but don't override user settings.

Consolidated user callbacks into one, improved some logic.

Created an atomic_int connect_state that keeps track of not yet
connected, connected, disconnected, and errors. Used to implement good
error behavior when the server is down and you start() a Redox instance,
or when the server goes down in the middle of running commands. Now,
nothing should hang, but should return errors (or throw exceptions) when
the server goes down.

Also added hooks for a user connect/disconnect callback in the
constructor, which is helpful for client programs.

Added an example with three Redox clients in one thread.

Finally getting rid of the busy loop in the event thread. Now, we use
an ev_async watcher that processes commands in the queue, which we
can signal in a thread-safe manner using ev_async_send.

Also plan to add in set<string> and unordered_set<string>. Maybe
queue<string>. Looking at likely removing char* as an option, if it
shows to be about the same speed as string.

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.

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.

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.

Uses libev timer watchers to queue commands on a regular
interval. Very fast. Still need to handle deactivation of
timers from the user side.

Improved examples, added a threaded getter/setter example
and cleaned up the other. Generally refactored code in the
core files and cleaned up the details to make the slickest
possible API. Implemented a to_exit variable as a stop
condition for the event thread.

The event loop (now libev) now runs in a separate detached thread,
which is abstracted away from the user, who only calls a nonblocking
.start() method. This thread loops continously, alternating telling
Redis about asynchronous commands ready to send, and running one
iteration of the event loop, where all pending events are taken
care of. This greatly simplifies the user code.

Additionally, some clever tricker is implemented now to handle
memory management well with the templated command types. The
difficulty comes from the fact that we pass redis a void pointer
only, and must retreive everything from that (so, we can't use
shared_ptr for the whole thing). Thus, we use maps of void pointers
to their templated data structure pointers, where the memory address
of the pointer serves as the key.

Basic CMake setup, redisx implementation, and one example program.