Add middlewares management

[twidi]

The goal of this middleware system is to add an entry point to help enhance the limpyd behavior without touching its core.

A middleware is a class which surround a redis call when a command n a field is called.

The pre_command method of each middleware, is called before the redis call, then the post_command method of each middleware in reverse order.

If a pre_command method returns something (not None), the redis call won't be done and the result value will be used instead (and other pre_command methods won't be called too).

A post_command method must return a Result object, which contains the value got from redis (or from a pre_command method).

A pre_command method accepts two arguments:

• command, a Command object, with three fields (name (of the command) and args and kwargs to pass to the command)
• context, a dict initialized with a sender entry, which is the object on which the original command apply (a field or a model)

The command object can be modified if wanted, before used to call redis.
The context dict can also be modified, to add properties useful to the middleware that it would need in the post_command for example. Note that each called middleware share the same context dictionary.

A post_command method accepts three arguments:

• command, the Command object passed through the pre_command methods
• result, a Result object with a single field, value, which hold the result of the redis call
• context, the same dictionary passed through the pre_command methods.

The result can be modified, and it's value returned from the last post_command metho will be used as a result to the call. (The command and context objects can still be modified, but it is not really useful)

To define a new middleware, simply inherit from BaseMiddleware in limpyd.middlewares and define a pre_command and/or a post_command (they are both optional, only the existing methods will be used).

To use middlewares, you must declare it when creating your database:

database = RedisDatabase(
    middlewares=[
            AMiddleware(with_some=params),
            AnotherMiddleware(),
        ], 
    **my_connection_settings
)

An example (but usable) middleware is provided in limpyd.middlewares, to log commands, their results (optional) and the duration (optional too): LoggingMiddleware. It can log stuff like:

[#1] Command(name='set', args=(u'mynamespace:mymodel:1:myfield', 'foo'), kwargs={})"
[#1, in 321µs] Result(value=1)

[twidi]

Missing docs, but what about using my loooong PR description ?

[yohanboniface]

Yes, for the doc :)
Just add a field in doc/ and point to it in index.rst.

[yohanboniface]

As usual, I don't feel comfortable when changing the method behaviour from a parameter. IMHO, here we need two methods.

[yohanboniface]

BTW, I don't get the need of this direct call. Is there a constraint not to call a middleware from inside a command call ? Or is it specific to index calls? Need your lights here ;)

[twidi]

We have to decide: ALL redis commands are passed to the middleware, or ONLY ones issued by the user.
Because when we manage indexes, we have mainly direct calls to redis (sadd...), but also some proxy_get, and both should be managed the same way for consistency

NB1: btw i knew you wouldn't like this update, it was here to initiate the conversation ;)
NB2: i'll merge master into this branch later, when done

[yohanboniface]

Humm, not easy.
Except for performance reasons, I think we need a very generic hook, so at this point my preference goes to calling middlewares for every calls from Limpyd.
About performance, I don't know what can be the cost of calling the middlewares hook for every call.

[twidi]

if result is not None ?

[twidi]

maybe the check is not None is not necessary

[twidi]

could use @cached_property