Django

Code

Ticket #6086: 6086_combined_patch.diff

File 6086_combined_patch.diff, 9.6 kB (added by mcroydon, 1 year ago)

Updating combined diff to include rm_simple.diff (patch with -p1)

  • a/django/conf/global_settings.py

    old new  
    293293 
    294294# The cache backend to use.  See the docstring in django.core.cache for the 
    295295# possible values. 
    296 CACHE_BACKEND = 'simple://' 
     296CACHE_BACKEND = 'locmem://' 
    297297CACHE_MIDDLEWARE_KEY_PREFIX = '' 
    298298CACHE_MIDDLEWARE_SECONDS = 600 
    299299 

  • a/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 

  • a/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) 

  • a/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() 

  • a/django/core/cache/backends/simple.py

    old new  
    1 "Single-process in-memory cache backend." 
    2  
    3 from django.core.cache.backends.base import BaseCache 
    4 import time 
    5  
    6 class CacheClass(BaseCache): 
    7     def __init__(self, host, params): 
    8         BaseCache.__init__(self, params) 
    9         self._cache = {} 
    10         self._expire_info = {} 
    11  
    12         max_entries = params.get('max_entries', 300) 
    13         try: 
    14             self._max_entries = int(max_entries) 
    15         except (ValueError, TypeError): 
    16             self._max_entries = 300 
    17  
    18         cull_frequency = params.get('cull_frequency', 3) 
    19         try: 
    20             self._cull_frequency = int(cull_frequency) 
    21         except (ValueError, TypeError): 
    22             self._cull_frequency = 3 
    23  
    24     def add(self, key, value, timeout=None): 
    25         if len(self._cache) >= self._max_entries: 
    26             self._cull() 
    27         if timeout is None: 
    28             timeout = self.default_timeout 
    29         if key not in self._cache.keys(): 
    30             self._cache[key] = value 
    31             self._expire_info[key] = time.time() + timeout 
    32  
    33     def get(self, key, default=None): 
    34         now = time.time() 
    35         exp = self._expire_info.get(key) 
    36         if exp is None: 
    37             return default 
    38         elif exp < now: 
    39             del self._cache[key] 
    40             del self._expire_info[key] 
    41             return default 
    42         else: 
    43             return self._cache[key] 
    44  
    45     def set(self, key, value, timeout=None): 
    46         if len(self._cache) >= self._max_entries: 
    47             self._cull() 
    48         if timeout is None: 
    49             timeout = self.default_timeout 
    50         self._cache[key] = value 
    51         self._expire_info[key] = time.time() + timeout 
    52  
    53     def delete(self, key): 
    54         try: 
    55             del self._cache[key] 
    56         except KeyError: 
    57             pass 
    58         try: 
    59             del self._expire_info[key] 
    60         except KeyError: 
    61             pass 
    62  
    63     def has_key(self, key): 
    64         return key in self._cache 
    65  
    66     def _cull(self): 
    67         if self._cull_frequency == 0: 
    68             self._cache.clear() 
    69             self._expire_info.clear() 
    70         else: 
    71             doomed = [k for (i, k) in enumerate(self._cache) if i % self._cull_frequency == 0] 
    72             for k in doomed: 
    73                 self.delete(k) 

  • a/tests/regressiontests/cache/tests.py

    old new  
    7272            'function'  : f, 
    7373            'class'     : C, 
    7474        } 
     75        cache.set("stuff", stuff) 
     76        self.assertEqual(cache.get("stuff"), stuff) 
    7577 
    7678    def test_expiration(self): 
    7779        # expiration