Skip to content
Snippets Groups Projects
cache.py 2.45 KiB
Newer Older
  • Learn to ignore specific revisions
  • import aioredis
    import asyncio
    import json
    
    from django.conf import settings
    
    
    class Backend:
        class NotFound(Exception):
            pass
    
        async def get(self, key):
            raise NotImplementedError
    
    
        async def set(self, key, expire=None):
    
        async def close(self):
            return
    
    
    
    class Dummy(Backend):
        def __init__(self):
            self._cache = {}
    
        async def get(self, key):
            try:
                return self._cache[key]
            except KeyError:
                raise self.NotFound(key)
    
    
        async def set(self, key, value, expire=None):
    
    class Noop(Backend):
        """
        A backend that caches nothing
        """
    
        async def get(self, key):
            raise self.NotFound(key)
    
        async def set(self, key, value, expire=None):
            return
    
    
    
        def __init__(self, params, write_only=False):
    
            self.params = params
            self._redis = None
    
            self.write_only = write_only
    
    
        async def redis(self):
            if self._redis:
                return self._redis
            self._redis = await aioredis.create_redis(
                loop=asyncio.get_event_loop(), **self.params
            )
            return self._redis
    
        async def get(self, key):
    
            if self.write_only:
                raise self.NotFound(key)
    
            r = await self.redis()
            try:
                v = await r.get(key)
            except KeyError:
                raise self.NotFound(key)
    
            if v is None:
                raise self.NotFound(key)
    
            try:
                return json.loads(v)
            except TypeError:
                # Null, empty string, etc.
                return v
    
        async def set(self, key, value, expire=None):
            if expire is None:
                expire = settings.CACHE_DEFAULT_EXPIRATION
    
            if expire:
                return await r.setex(key, expire, json.dumps(value))
            return await r.set(key, json.dumps(value))
    
        async def close(self):
            if not self._redis:
                return
            await self._redis.close()
    
    
    _DEFAULT = None
    
    
    
    _WRITE_ONLY_DEFAULT = None
    
    
    def get_write_only_default():
        global _WRITE_ONLY_DEFAULT
        if _WRITE_ONLY_DEFAULT:
            return _WRITE_ONLY_DEFAULT
        _WRITE_ONLY_DEFAULT = Redis(settings.ASYNC_REDIS_PARAMS, write_only=True)
        return _WRITE_ONLY_DEFAULT
    
    
    def get_default(**kwargs):
    
        global _DEFAULT
        if _DEFAULT:
            return _DEFAULT
    
        _DEFAULT = Redis(settings.ASYNC_REDIS_PARAMS, **kwargs)
    
        return _DEFAULT