Django

Code

Ticket #6086: simple_cache_deprecate.diff

File simple_cache_deprecate.diff, 6.2 kB (added by pbx, 1 year ago)

  • django/core/cache/__init__.py

    old new  
    2222BACKENDS = { 
    2323    # name for use in settings file --> name of module in "backends" directory 
    2424    'memcached': 'memcached', 
    25     'simple': 'simple', 
    2625    'locmem': 'locmem', 
    2726    'file': 'filebased', 
    2827    'db': 'db', 
    2928    'dummy': 'dummy', 
    3029} 
    3130 
     31DEPRECATED_BACKENDS = { 
     32    # deprecated backend --> replacement module 
     33    'simple': 'locmem', 
     34} 
     35 
    3236def get_cache(backend_uri): 
    3337    if backend_uri.find(':') == -1: 
    3438        raise InvalidCacheBackendError, "Backend URI must start with scheme://" 
    3539    scheme, rest = backend_uri.split(':', 1) 
    3640    if not rest.startswith('//'): 
    3741        raise InvalidCacheBackendError, "Backend URI must start with scheme://" 
     42    if scheme in DEPRECATED_BACKENDS: 
     43        import warnings 
     44        warnings.warn("'%s' backend is deprecated. Use '%s' instead." %  
     45            (scheme, DEPRECATED_BACKENDS[scheme]), DeprecationWarning) 
     46        scheme = DEPRECATED_BACKENDS[scheme] 
    3847    if scheme not in BACKENDS: 
    3948        raise InvalidCacheBackendError, "%r is not a valid cache backend" % scheme 
    4049 

  • django/core/cache/backends/locmem.py

    old new  
    66except ImportError: 
    77    import pickle 
    88 
    9 from django.core.cache.backends.simple import CacheClass as SimpleCacheClass 
     9from django.core.cache.backends.base import BaseCache 
    1010from django.utils.synch import RWLock 
    1111 
    12 class CacheClass(SimpleCacheClass): 
    13     def __init__(self, host, params): 
    14         SimpleCacheClass.__init__(self, host, params) 
     12class CacheClass(BaseCache): 
     13    def __init__(self, _, params): 
     14        BaseCache.__init__(self, params) 
     15        self._cache = {} 
     16        self._expire_info = {} 
     17 
     18        max_entries = params.get('max_entries', 300) 
     19        try: 
     20            self._max_entries = int(max_entries) 
     21        except (ValueError, TypeError): 
     22            self._max_entries = 300 
     23 
     24        cull_frequency = params.get('cull_frequency', 3) 
     25        try: 
     26            self._cull_frequency = int(cull_frequency) 
     27        except (ValueError, TypeError): 
     28            self._cull_frequency = 3 
     29 
    1530        self._lock = RWLock() 
    1631 
     32    def _add(self, key, value, timeout=None): 
     33        if len(self._cache) >= self._max_entries: 
     34            self._cull() 
     35        if timeout is None: 
     36            timeout = self.default_timeout 
     37        if key not in self._cache.keys(): 
     38            self._cache[key] = value 
     39            self._expire_info[key] = time.time() + timeout 
     40 
    1741    def add(self, key, value, timeout=None): 
    1842        self._lock.writer_enters() 
    1943        # Python 2.3 and 2.4 don't allow combined try-except-finally blocks. 
    2044        try: 
    2145            try: 
    22                 super(CacheClass, self).add(key, pickle.dumps(value), timeout) 
     46                self._add(key, pickle.dumps(value), timeout) 
    2347            except pickle.PickleError: 
    2448                pass 
    2549        finally: 
    …… 
    5175            finally: 
    5276                self._lock.writer_leaves() 
    5377 
     78    def _set(self, key, value, timeout=None): 
     79        if len(self._cache) >= self._max_entries: 
     80            self._cull() 
     81        if timeout is None: 
     82            timeout = self.default_timeout 
     83        self._cache[key] = value 
     84        self._expire_info[key] = time.time() + timeout 
     85 
    5486    def set(self, key, value, timeout=None): 
    5587        self._lock.writer_enters() 
    5688        # Python 2.3 and 2.4 don't allow combined try-except-finally blocks. 
    5789        try: 
    5890            try: 
    59                 super(CacheClass, self).set(key, pickle.dumps(value), timeout) 
     91                self._set(key, pickle.dumps(value), timeout) 
    6092            except pickle.PickleError: 
    6193                pass 
    6294        finally: 
    6395            self._lock.writer_leaves() 
    6496 
     97    def has_key(self, key): 
     98        return key in self._cache 
     99 
     100    def _cull(self): 
     101        if self._cull_frequency == 0: 
     102            self._cache.clear() 
     103            self._expire_info.clear() 
     104        else: 
     105            doomed = [k for (i, k) in enumerate(self._cache) if i % self._cull_frequency == 0] 
     106            for k in doomed: 
     107                self.delete(k) 
     108 
     109    def _delete(self, key): 
     110        try: 
     111            del self._cache[key] 
     112        except KeyError: 
     113            pass 
     114        try: 
     115            del self._expire_info[key] 
     116        except KeyError: 
     117            pass 
     118 
    65119    def delete(self, key): 
    66120        self._lock.writer_enters() 
    67121        try: 
    68             SimpleCacheClass.delete(self, key) 
     122            self._delete(key) 
    69123        finally: 
    70124            self._lock.writer_leaves() 

  • django/core/cache/backends/filebased.py

    old new  
    11"File-based cache backend" 
    22 
    3 from django.core.cache.backends.simple import CacheClass as SimpleCacheClass 
    4 from django.utils.http import urlquote_plus 
    53import os, time 
    64try: 
    75    import cPickle as pickle 
    86except ImportError: 
    97    import pickle 
     8from django.core.cache.backends.base import BaseCache 
     9from django.utils.http import urlquote_plus 
    1010 
    11 class CacheClass(SimpleCacheClass): 
     11class CacheClass(BaseCache): 
    1212    def __init__(self, dir, params): 
     13        BaseCache.__init__(self, params) 
     14         
     15        max_entries = params.get('max_entries', 300) 
     16        try: 
     17            self._max_entries = int(max_entries) 
     18        except (ValueError, TypeError): 
     19            self._max_entries = 300 
     20             
     21        cull_frequency = params.get('cull_frequency', 3) 
     22        try: 
     23            self._cull_frequency = int(cull_frequency) 
     24        except (ValueError, TypeError): 
     25            self._cull_frequency = 3 
     26             
    1327        self._dir = dir 
    1428        if not os.path.exists(self._dir): 
    1529            self._createdir() 
    16         SimpleCacheClass.__init__(self, dir, params) 
    17         del self._cache 
    18         del self._expire_info 
    1930 
    2031    def add(self, key, value, timeout=None): 
    2132        fname = self._key_to_file(key)