def __getitem__(self, alias): try: return getattr(self._caches, alias) except AttributeError: pass if alias not in settings.CACHES: raise InvalidCacheBackendError( "Could not find config for '%s' in settings.CACHES" % alias) cache = _create_cache(alias) setattr(self._caches, alias, cache) return cache
def _create_cache(backend, **kwargs): try: # Try to get the CACHES entry for the given profiles name first try: conf = settings.CACHES[backend] except KeyError: try: # Trying to import the given profiles, in case it's a dotted path import_string(backend) except ImportError as e: raise InvalidCacheBackendError( "Could not find profiles '%s': %s" % (backend, e)) location = kwargs.pop('LOCATION', '') params = kwargs else: params = {**conf, **kwargs} backend = params.pop('BACKEND') location = params.pop('LOCATION', '') backend_cls = import_string(backend) except ImportError as e: raise InvalidCacheBackendError("Could not find profiles '%s': %s" % (backend, e)) return backend_cls(location, params)
def parse_backend_uri(backend_uri): """ Converts the "backend_uri" into a cache scheme ('db', 'memcached', etc), a host and any extra params that are required for the backend. Returns a (scheme, host, params) tuple. """ if backend_uri.find(':') == -1: raise InvalidCacheBackendError("Backend URI must start with scheme://") scheme, rest = backend_uri.split(':', 1) if not rest.startswith('//'): raise InvalidCacheBackendError("Backend URI must start with scheme://") host = rest[2:] qpos = rest.find('?') if qpos != -1: params = dict(parse_qsl(rest[qpos + 1:])) host = rest[2:qpos] else: params = {} if host.endswith('/'): host = host[:-1] return scheme, host, params
def _create_cache(backend, **kwargs): try: # Try to get the CACHES entry for the given backend name first try: conf = settings.CACHES[backend] except KeyError: try: # Trying to import the given backend, in case it's a dotted path import_by_path(backend) except ImproperlyConfigured as e: raise InvalidCacheBackendError("Could not find backend '%s': %s" % ( backend, e)) location = kwargs.pop('LOCATION', '') params = kwargs else: params = conf.copy() params.update(kwargs) backend = params.pop('BACKEND') location = params.pop('LOCATION', '') backend_cls = import_by_path(backend) except (AttributeError, ImportError, ImproperlyConfigured) as e: raise InvalidCacheBackendError( "Could not find backend '%s': %s" % (backend, e)) return backend_cls(location, params)
def parse_backend_conf(backend, **kwargs): """ Helper function to parse the backend configuration that doesn't use the URI notation. """ # Try to get the CACHES entry for the given backend name first conf = settings.CACHES.get(backend, None) if conf is not None: args = conf.copy() backend = args.pop('BACKEND') location = args.pop('LOCATION', '') return backend, location, args else: # Trying to import the given backend, in case it's a dotted path mod_path, cls_name = backend.rsplit('.', 1) try: mod = importlib.import_module(mod_path) backend_cls = getattr(mod, cls_name) except (AttributeError, ImportError): raise InvalidCacheBackendError("Could not find backend '%s'" % backend) location = kwargs.pop('LOCATION', '') return backend, location, kwargs raise InvalidCacheBackendError( "Couldn't find a cache backend named '%s'" % backend)
def __getitem__(self, alias): try: return self._caches.caches[alias] except AttributeError: self._caches.caches = {} except KeyError: pass if alias not in settings.CACHES: raise InvalidCacheBackendError( "Could not find config for '%s' in settings.CACHES" % alias) cache = _create_cache(alias) self._caches.caches[alias] = cache return cache
def __init__(self, server, params): import warnings warnings.warn( "memcached.CacheClass has been split into memcached.MemcachedCache and memcached.PyLibMCCache. Please update your cache backend setting.", DeprecationWarning ) try: import memcache except ImportError: raise InvalidCacheBackendError( "Memcached cache backend requires either the 'memcache' or 'cmemcache' library" ) super(CacheClass, self).__init__(server, params, library=memcache, value_not_found_exception=ValueError)
def get_cache(backend, **kwargs): """ Function to load a cache backend dynamically. This is flexible by design to allow different use cases: To load a backend with the old URI-based notation:: cache = get_cache('locmem://') To load a backend that is pre-defined in the settings:: cache = get_cache('default') To load a backend with its dotted import path, including arbitrary options:: cache = get_cache('django.core.cache.backends.memcached.MemcachedCache', **{ 'LOCATION': '127.0.0.1:11211', 'TIMEOUT': 30, }) """ try: if '://' in backend: # for backwards compatibility backend, location, params = parse_backend_uri(backend) if backend in BACKENDS: backend = 'django.core.cache.backends.%s' % BACKENDS[backend] params.update(kwargs) mod = importlib.import_module(backend) backend_cls = mod.CacheClass else: backend, location, params = parse_backend_conf(backend, **kwargs) mod_path, cls_name = backend.rsplit('.', 1) mod = importlib.import_module(mod_path) backend_cls = getattr(mod, cls_name) except (AttributeError, ImportError) as e: raise InvalidCacheBackendError("Could not find backend '%s': %s" % (backend, e)) cache = backend_cls(location, params) # Some caches -- python-memcached in particular -- need to do a cleanup at the # end of a request cycle. If the cache provides a close() method, wire it up # here. if hasattr(cache, 'close'): signals.request_finished.connect(cache.close) return cache
def __init__(self, server, params): try: import cmemcache as memcache import warnings warnings.warn( "Support for the 'cmemcache' library has been deprecated. Please use python-memcached or pyblimc instead.", DeprecationWarning) except ImportError: try: import memcache except: raise InvalidCacheBackendError( "Memcached cache backend requires either the 'memcache' or 'cmemcache' library" ) super(CacheClass, self).__init__(server, params, library=memcache, value_not_found_exception=ValueError)
def parse_backend_conf(backend, **kwargs): """ Helper function to parse the backend configuration that doesn't use the URI notation. """ # Try to get the CACHES entry for the given backend name first conf = settings.CACHES.get(backend, None) if conf is not None: args = conf.copy() args.update(kwargs) backend = args.pop('BACKEND') location = args.pop('LOCATION', '') return backend, location, args else: try: # Trying to import the given backend, in case it's a dotted path import_by_path(backend) except ImproperlyConfigured as e: raise InvalidCacheBackendError("Could not find backend '%s': %s" % (backend, e)) location = kwargs.pop('LOCATION', '') return backend, location, kwargs
def get_cache(backend, **kwargs): """ Function to load a cache backend dynamically. This is flexible by design to allow different use cases: To load a backend with the old URI-based notation:: cache = get_cache('locmem://') To load a backend that is pre-defined in the settings:: cache = get_cache('default') To load a backend with its dotted import path, including arbitrary options:: cache = get_cache('django.core.cache.backends.memcached.MemcachedCache', **{ 'LOCATION': '127.0.0.1:11211', 'TIMEOUT': 30, }) """ try: if '://' in backend: # for backwards compatibility backend, location, params = parse_backend_uri(backend) if backend in BACKENDS: backend = 'django.core.cache.backends.%s' % BACKENDS[backend] params.update(kwargs) mod = importlib.import_module(backend) backend_cls = mod.CacheClass else: backend, location, params = parse_backend_conf(backend, **kwargs) mod_path, cls_name = backend.rsplit('.', 1) mod = importlib.import_module(mod_path) backend_cls = getattr(mod, cls_name) except (AttributeError, ImportError), e: raise InvalidCacheBackendError( "Could not find backend '%s': %s" % (backend, e))
def parse_backend_uri(backend_uri): """ Converts the "backend_uri" into a host and any extra params that are required for the backend. Returns a (host, params) tuple. """ backend_uri_sliced = backend_uri.split('://') if len(backend_uri_sliced) > 2: raise InvalidCacheBackendError("Backend URI can't have more than one scheme://") elif len(backend_uri_sliced) == 2: rest = backend_uri_sliced[1] else: rest = backend_uri_sliced[0] host = rest[2:] qpos = rest.find('?') if qpos != -1: params = dict(parse_qsl(rest[qpos+1:])) host = rest[2:qpos] else: params = {} if host.endswith('/'): host = host[:-1] return host, params
"Memcached cache backend" from django.core.cache.backends.base import BaseCache, InvalidCacheBackendError from django.utils.encoding import smart_unicode, smart_str try: import cmemcache as memcache except ImportError: try: import memcache except: raise InvalidCacheBackendError( "Memcached cache backend requires either the 'memcache' or 'cmemcache' library" ) class CacheClass(BaseCache): def __init__(self, server, params): BaseCache.__init__(self, params) self._cache = memcache.Client(server.split(';')) def add(self, key, value, timeout=0): self._cache.add(key.encode('ascii', 'ignore'), value, timeout or self.default_timeout) def get(self, key, default=None): val = self._cache.get(smart_str(key)) if val is None: return default else: if isinstance(val, basestring):
from django.core.cache.backends.base import ( BaseCache, DEFAULT_TIMEOUT, InvalidCacheBackendError, ) from django.core.exceptions import ImproperlyConfigured try: import redis except ImportError: raise InvalidCacheBackendError( "Redis cache backend requires the 'redis-py' library") from redis.connection import DefaultParser from redis_cache.connection import pool from redis_cache.utils import (CacheKey, get_servers, parse_connection_kwargs, import_class) from functools import wraps def get_client(write=False): def wrapper(method): @wraps(method) def wrapped(self, key, *args, **kwargs): version = kwargs.pop('version', None) client = self.get_client(key, write=write) key = self.make_key(key, version=version) return method(self, client, key, *args, **kwargs)
""" django_casscache ~~~~~~~~~~~~~~~~ :copyright: (c) 2013 by Matt Robenolt. :license: BSD, see LICENSE for more details. """ from django.core.cache.backends.base import InvalidCacheBackendError from django.core.cache.backends.memcached import BaseMemcachedCache try: import casscache except ImportError: raise InvalidCacheBackendError('Could not import casscache') __all__ = ['CasscacheCache'] class CasscacheCache(BaseMemcachedCache): "An implementation of a cache binding using casscache" def __init__(self, server, params): super(CasscacheCache, self).__init__(server, params, library=casscache, value_not_found_exception=ValueError) @property def _cache(self):
import logging from django.core.cache.backends.base import BaseCache, InvalidCacheBackendError from hazelcast_cache.utils import import_class, CacheKey try: import hazelcast except ImportError: raise InvalidCacheBackendError( "Hazelcast cache backend requires the 'hazelcast-python-client' library" ) from functools import wraps logging.basicConfig( format='%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s', datefmt="%H:%M%:%S,") logging.getLogger().setLevel(logging.INFO) logger = logging.getLogger("main") DEFAULT_TIMEOUT = 1000 def get_client(write=False): def wrapper(method): @wraps(method) def wrapped(self, key, *args, **kwargs): version = kwargs.pop('version', None) client = self.get_client(key, write=write) key = self.make_key(key, version=version)
from django.core.cache.backends import memcached from django.core.cache.backends.base import InvalidCacheBackendError from django.utils.encoding import smart_str from cachebot.backends import version_key_decorator from cachebot.logger import CacheLogger try: import cmemcache as memcache except ImportError: try: import memcache except: raise InvalidCacheBackendError( "libmemcached backend requires either the 'python-memcached' or 'cmemcached' library" ) class CacheClass(memcached.CacheClass): def __init__(self, *args, **kwargs): super(CacheClass, self).__init__(*args, **kwargs) self._logger = CacheLogger() @version_key_decorator def add(self, key, value, timeout=None): if isinstance(value, unicode): value = value.encode('utf-8') if timeout is None: timeout = self.default_timeout return self._cache.add(smart_str(key), value, timeout)
# for backwards compatibility backend, location, params = parse_backend_uri(backend) if backend in BACKENDS: backend = 'django.core.cache.backends.%s' % BACKENDS[backend] params.update(kwargs) mod = importlib.import_module(backend) backend_cls = mod.CacheClass 厉害, 每个模块中都有一个 CacheClass else: backend, location, params = parse_backend_conf(backend, **kwargs) mod_path, cls_name = backend.rsplit('.', 1) mod = importlib.import_module(mod_path) backend_cls = getattr(mod, cls_name) except (AttributeError, ImportError) as e: raise InvalidCacheBackendError( "Could not find backend '%s': %s" % (backend, e)) cache = backend_cls(location, params) # Some caches -- python-memcached in particular -- need to do a cleanup at the # end of a request cycle. If the cache provides a close() method, wire it up # here. if hasattr(cache, 'close'): signals.request_finished.connect(cache.close) 不懂 return cache cache = get_cache(DEFAULT_CACHE_ALIAS)
from django.utils import importlib except ImportError: import importlib try: import pylibmc as memcache NotFoundError = memcache.NotFound using_pylibmc = True except ImportError: using_pylibmc = False try: import memcache NotFoundError = ValueError except ImportError: raise InvalidCacheBackendError( 'Memcached cache backend requires ' + 'either the "pylibmc" or "memcache" library') # Flavor is used amongst multiple apps to differentiate the "flavor" of the # environment. Examples of flavors are 'prod', 'staging', 'dev', and 'test'. FLAVOR = getattr(settings, 'FLAVOR', '') CACHE_VERSION = str(getattr(settings, 'CACHE_VERSION', 1)) CACHE_BEHAVIORS = getattr(settings, 'CACHE_BEHAVIORS', {'hash': 'crc'}) CACHE_KEY_MODULE = getattr(settings, 'CACHE_KEY_MODULE', 'newcache') CACHE_HERD_TIMEOUT = getattr(settings, 'CACHE_HERD_TIMEOUT', 60) class Marker(object): pass
def memcache_info(request): """ View to display memcache statistics Only works with Django 1.3+ using the settings.CACHES setting. """ try: # Check if memcache is used: hosts = [] for backend in settings.CACHES.values(): if backend[ "BACKEND"] == 'django.core.cache.backends.memcached.MemcachedCache': hosts.extend(backend["LOCATION"]) if not hosts: raise InvalidCacheBackendError( "You are not using memcache as cache backend - %s" % settings.CACHES) # Import module try: import memcache except ImportError: raise InvalidCacheBackendError( "Statistics only works with python-memcache and not e.g. the cmemcache module." ) # Retrieve statistics from servers mc = memcache.Client(hosts, debug=0) stats = mc.get_stats() # Regroup statistics for display purposes. header = [''] keys = [] for host in stats: header.append(host[0]) keys += host[1].keys() keys = list(set(keys)) keys.sort() rows = [] for k in keys: r = [k] for host in stats: try: r.append(host[1][k]) except KeyError: r.append("") rows.append(r) table = [header] + rows return render( request, 'admin/cache/memcache_info.html', { 'title': 'Memcached statistics', 'has_memcache': True, 'stats': table, }) except InvalidCacheBackendError, e: return render( request, 'admin/cache/memcache_info.html', { 'title': 'Memcached statistics', 'has_memcache': False, 'error_message': unicode(e), })
from threading import local from django.core.cache.backends.base import InvalidCacheBackendError from django.core.cache.backends.memcached import BaseMemcachedCache try: from . import client except ImportError: raise InvalidCacheBackendError('Could not import pymemcache.') class PyMemcacheCache(BaseMemcachedCache): """An implementation of a cache binding using pymemcache.""" def __init__(self, server, params): self._local = local() super(PyMemcacheCache, self).__init__( server, params, library=client, value_not_found_exception=KeyError, ) @property def _cache(self): client = getattr(self._local, 'client', None) if client: return client client = self._lib.Client(self._servers, **self._options) if self._options: client.behaviors = self._options
from django.core.cache.backends.base import BaseCache, InvalidCacheBackendError 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=None, version=None): if timeout is None:
Unlike the default Django caching backends, this backend lets you pass 0 as a timeout, which translates to an infinite timeout in memcached. """ import logging import warnings from threading import local from django.conf import settings from django.core.cache.backends.base import InvalidCacheBackendError from django.core.cache.backends.memcached import BaseMemcachedCache, DEFAULT_TIMEOUT try: import pylibmc from pylibmc import Error as MemcachedError except ImportError: raise InvalidCacheBackendError('Could not import pylibmc.') log = logging.getLogger('django.pylibmc') MIN_COMPRESS_LEN = getattr(settings, 'PYLIBMC_MIN_COMPRESS_LEN', 0) # Disabled if MIN_COMPRESS_LEN > 0 and not pylibmc.support_compression: MIN_COMPRESS_LEN = 0 warnings.warn('A minimum compression length was provided but pylibmc was ' 'not compiled with support for it.') COMPRESS_LEVEL = getattr(settings, 'PYLIBMC_COMPRESS_LEVEL', -1) # zlib.Z_DEFAULT_COMPRESSION if not COMPRESS_LEVEL == -1: if not pylibmc.support_compression: warnings.warn('A compression level was provided but pylibmc was ' 'not compiled with support for it.')