Changeset 686

Timestamp:

09/25/05 15:01:35 (3 years ago)

Author:

jacob

Message:

Added "locmem" and "file" cache backends. "locmem" is a thread-safe local-memory cache, and "file" is a file-based cache.
This refs #515; much thanks to Eugene Lazutkin!

Files:

• django/trunk/django/core/cache.py (modified) (6 diffs)
• django/trunk/django/utils/synch.py (added)

django/trunk/django/core/cache.py

@@ -16 +16 @@
-                                    on localhost port 11211.
-
-
-
-
-
-
+
+
+
+
+
+
+
-
-    simple:///                      A simple single-process memory cache; you
@@ -26 +28 @@
-                                    testing. Note that this cache backend is
-                                    NOT threadsafe!
+                                        
+    locmem:///                      A more sophisticaed local memory cache;
+                                    this is multi-process- and thread-safe.
-
-All caches may take arguments; these are given in query-string style.  Valid
@@ -51 +56 @@
-
-    memcached://127.0.0.1:11211/?timeout=60
-pg
+
-
-Invalid arguments are silently ignored, as are invalid values of known
-arguments.
-
-So far, only the memcached and simple backend have been implemented; backends
-using postgres, and file-system storage are planned.
-"""
-
@@ -182 +184 @@
-    def get(self, key, default=None):
-        now = time.time()
-
-
+
+
+
+
-            del self._cache[key]
-            del self._expire_info[key]
-            return default
-        else:
-.get(key, default)
+[key]
-
-    def set(self, key, value, timeout=None):
@@ -220 +224 @@
-                self.delete(k)
-
+###############################
+# Thread-safe in-memory cache #
+###############################
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+from django.utils.synch import RWLock
+
+class _LocMemCache(_SimpleCache):
+    """Thread-safe in-memory cache"""
+    
+    def __init__(self, host, params):
+        _SimpleCache.__init__(self, host, params)
+        self._lock = RWLock()
+
+    def get(self, key, default=None):
+        should_delete = False
+        self._lock.reader_enters()
+        try:
+            now = time.time()
+            exp = self._expire_info.get(key)
+            if exp is None:
+                return default
+            elif exp < now:
+                should_delete = True
+            else:
+                return self._cache[key]
+        finally:
+            self._lock.reader_leaves()
+        if should_delete:
+            self._lock.writer_enters()
+            try:
+                del self._cache[key]
+                del self._expire_info[key]
+                return default
+            finally:
+                self._lock.writer_leaves()
+                
+    def set(self, key, value, timeout=None):
+        self._lock.writer_enters()
+        try:
+            _SimpleCache.set(self, key, value, timeout)
+        finally:
+            self._lock.writer_leaves()
+            
+    def delete(self, key):
+        self._lock.writer_enters()
+        try:
+            _SimpleCache.delete(self, key)
+        finally:
+            self._lock.writer_leaves()
+
+####################
+# File-based cache #
+####################
+
+import os
+import urllib
+
+class _FileCache(_SimpleCache):
+    """File-based cache"""
+    
+    def __init__(self, dir, params):
+        self._dir = dir
+        if not os.path.exists(self._dir):
+            try:
+                os.makedirs(self._dir)
+            except OSError:
+                raise EnvironmentError, "Cache directory '%s' does not exist and could not be created'" % self._dir
+        _SimpleCache.__init__(self, dir, params)
+        del self._cache
+        del self._expire_info
+        
+    def get(self, key, default=None):
+        fname = self._key_to_file(key)
+        try:
+            f = open(fname, 'rb')
+            exp = pickle.load(f)
+            now = time.time()
+            if exp < now:
+                f.close()
+                os.remove(fname)
+            else:
+                return pickle.load(f)
+        except (IOError, pickle.PickleError):
+            pass
+        return default
+        
+    def set(self, key, value, timeout=None):
+        fname = self._key_to_file(key)
+        if timeout is None:
+            timeout = self.default_timeout
+        filelist = os.listdir(self._dir)
+        if len(filelist) > self._max_entries:
+            self._cull(filelist)
+        try:
+            f = open(fname, 'wb')
+            now = time.time()
+            pickle.dump(now + timeout, f, 2)
+            pickle.dump(value, f, 2)
+        except (IOError, OSError):
+            raise
+            
+    def delete(self, key):
+        try:
+            os.remove(self._key_to_file(key))
+        except (IOError, OSError):
+            pass
+            
+    def has_key(self, key):
+        return os.path.exists(self._key_to_file(key))
+        
+    def _cull(self, filelist):
+        if self.cull_frequency == 0:
+            doomed = filelist
+        else:
+            doomed = [k for (i, k) in enumerate(filelist) if i % self._cull_frequency == 0]
+        for fname in doomed:
+            try:
+                os.remove(os.path.join(self._dir, fname))
+            except (IOError, OSError):
+                pass
+      
+    def _key_to_file(self, key):
+        return os.path.join(self._dir, urllib.quote_plus(key))
+    
-##########################################
-# Read settings and load a cache backend #
@@ -229 +361 @@
-    'memcached' : _MemcachedCache,
-    'simple'    : _SimpleCache,
+    'locmem'    : _LocMemCache,
+    'file'      : _FileCache,
-}
-