Implementation of asynchronous Redis-based cache for Tornado framework

tornado-async-redis-cache

# -*- coding: utf-8 -*-
import functools
import json

from tornado import gen


class RedisCache(object):
    """
    Redis-based cache.
    The following methods should be overridden in order to modify behavior:
     * serialize_key
     * serialize_value
     * deserialize_value
    By default all stored values are serialized and deserialized
    as json objects.
    """
    def __init__(self, redis_client, key_prefix=u''):
        """
        :type redis_client: tornadoredis.Client
        :type key_prefix: unicode
        """
        self._redis_client = redis_client
        self._key_prefix = key_prefix

    def delete(self, key):
        """
        Returns task that returns if value existed before deleting.

        :type key: unknown
        :rtype: gen.Task
        """
        return gen.Task(
            self._redis_client.delete,
            self.serialize_key(key))

    def get(self, key):
        """
        Returns task that returns if value existed before deleting.

        :type key: unknown
        :rtype: gen.Task
        """
        return self._wrap_task(gen.Task(
            self._redis_client.get,
            self.serialize_key(key)))

    def replace(self, key, value):
        """
        :type key: unknown
        :type value: unknown
        :rtype: gen.Task
        """
        return self._wrap_task(gen.Task(
            self._redis_client.getset,
            self.serialize_key(key),
            self.serialize_value(value)))

    def set(self, key, value):
        """
        :type key: unknown
        :type value: unknown
        :rtype: gen.Task
        """
        return gen.Task(
            self._redis_client.set,
            self.serialize_key(key),
            self.serialize_value(value))

    def serialize_key(self, key):
        """
        :type key: unknown
        :rtype: unicode
        """
        return self._key_prefix + unicode(key)

    def serialize_value(self, value):
        """
        :type value: unknown
        :rtype: unicode
        """
        return json.dumps(value)

    def deserialize_value(self, serialized_value):
        """
        :type serialized_value: unicode
        :rtype: unknown or None
        """
        if serialized_value is None:
            return None
        else:
            return json.loads(serialized_value)

    def _wrap_task(self, task):
        """
        :type task: gen.YieldPoint
        :rtype: gen.YieldPoint
        """
        original_get_result = task.get_result
        @functools.wraps(original_get_result)
        def inner():
            return self.deserialize_value(original_get_result())
        task.get_result = inner
        return task