UWSGICache

Complexity

Total Complexity

16

Size/Duplication

Total Lines	51
Duplicated Lines	0 %

Importance

Changes	8
Bugs	2	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	7	2
A	exists()	0	2	1
A	clear()	0	2	1
A	delete()	0	3	1
A	set()	0	3	1
B	_set()	0	13	6
A	__init__()	0	4	1
A	close()	0	2	1
A	add()	0	6	2

"""uWSGI cache backend"""
__version__ = "1.0.1"

try:
    from django.utils.encoding import force_bytes as stringify
except ImportError:
    from django.utils.encoding import smart_str as stringify
from django.core.cache.backends.base import BaseCache, InvalidCacheBackendError, DEFAULT_TIMEOUT
from django.conf import settings

try:
    import cPickle as pickle
except ImportError:
    import pickle

try:
    import uwsgi
except ImportError:
    if getattr(settings, "UWSGI_CACHE_FALLBACK", True):
        uwsgi = None
    else:
        raise InvalidCacheBackendError(
            "You're not running under uWSGI ! "
            "Set UWSGI_CACHE_FALLBACK=True in settings if you want to fallback "
            "to LocMemCache."
        )


if uwsgi:
    class UWSGICache(BaseCache):
        def __init__(self, server, params):
            BaseCache.__init__(self, params)
            self._cache = uwsgi
            self._server = server

        def exists(self, key):
            return self._cache.cache_exists(stringify(key), self._server)

        def add(self, key, value, timeout=True, version=None):
            full_key = self.make_key(key, version=version)
            if self.exists(full_key):
                return False
            self._set(full_key, value, timeout)
            return True

        def get(self, key, default=None, version=None):
            full_key = self.make_key(key, version=version)
            val = self._cache.cache_get(stringify(full_key), self._server)
            if val is None:
                return default
            val = stringify(val)
            return pickle.loads(val)

        def _set(self, full_key, value, timeout):
            if timeout is True or timeout == DEFAULT_TIMEOUT:
                timeout = self.default_timeout

            if timeout is None or timeout is False:
                # Django 1.6+: Explicitly passing in timeout=None will set a non-expiring timeout.
                uwsgi_timeout = 0
            elif timeout == 0:
                # Django 1.6+: Passing in timeout=0 will set-and-expire-immediately the value.
                uwsgi_timeout = -1
            else:
                uwsgi_timeout = timeout
            self._cache.cache_update(stringify(full_key), pickle.dumps(value), uwsgi_timeout, self._server)

        def set(self, key, value, timeout=True, version=None):
            full_key = self.make_key(key, version=version)
            self._set(full_key, value, timeout)

        def delete(self, key, version=None):
            full_key = self.make_key(key, version=version)
            self._cache.cache_del(stringify(full_key), self._server)

        def close(self, **kwargs):
            pass

        def clear(self):
            self._cache.cache_clear(self._server)
else:
    from django.core.cache.backends.locmem import LocMemCache as UWSGICache # flake8: noqa