Ticket #437: filecache.diff

django/utils/filecache.py

@@ +1 @@
+# -*- coding: utf-8 -*-
+# vim:enc=utf8:fenc=utf8:sts=4:sw=4:sta:et:nofen:si:ai:nowrap
+
+# (C) Djordjevic Nebojsa <nesh@studioquattro.co.yu> 2005
+# You're welcome to redistribute this software under the
+# terms of the GNU Library General Public Licence version 2.0
+# or, at your option, any higher version.
+#
+# You can read the complete GNU LGPL in the file COPYING
+# which should come along with this software, or visit
+# the Free Software Foundation's WEB site http://www.fsf.org
+#
+
+
+""" In memory file cache. It will automatically reload a file if it
+    has changed. This includes its modification time being
+    set backwards in time.
+
+    based on vampire TemplateCache
+"""
+
+##################################################
+## DEPENDENCIES ##
+
+import os
+import time
+
+try:
+  from threading import Lock
+except:
+    class Lock:
+        def acquire(self): pass
+        def release(self): pass
+    # Lock
+#
+
+##################################################
+## GLOBALS AND CONSTANTS ##
+
+_cache = {}
+
+##################################################
+## CLASSES ##
+
+class _FileInfo(object):
+    __slots__ = ('path', 'mtime', 'atime', 'hits', 'content')
+
+    def __init__(self, path, mtime, content):
+        super(_FileInfo, self).__init__()
+        self.path = path
+        self.mtime = mtime
+        self.atime = time.time()
+        self.hits = 0
+        self.content = content
+    # __init__
+# _FileInfo
+
+class FileCache(object):
+    """ dict based cache  """
+
+    __slots__ = ('_lock', '_frozen', '_cache')
+
+    def __init__(self):
+        super(FileCache, self).__init__()
+
+        self._lock = Lock()
+        self._frozen = False
+        self._cache = {}
+    # __init__
+
+    def files(self):
+        self._lock.acquire()
+        try:
+            return self._cache.keys()
+        finally:
+            self._lock.release()
+    # keys
+
+    def info(self, path):
+        self._lock.acquire()
+        try:
+            path = os.path.normpath(path)
+            return self._cache[path]
+        finally:
+            self._lock.release()
+    # info
+
+    def unload(self, path):
+        self._lock.acquire()
+        try:
+            path = os.path.normpath(path)
+            if path in self._cache:
+                del self._cache[path]
+        finally:
+            self._lock.release()
+    # unload
+
+    def freeze(self):
+        self._frozen = True
+    # freeze
+
+    def load(self, path, mode='r'):
+        self._lock.acquire()
+        try:
+            record = None
+            # ensure the path is normalised
+            path = os.path.normpath(path)
+            # is page template already loaded
+            if path in self._cache:
+                record = self._cache[path]
+                # check if reloads have been disabled
+                if not self._frozen:
+                    # has page template been changed
+                    try:
+                        mtime = os.path.getmtime(path)
+                    except:
+                        # page template must not exist
+                        del self._cache[path]
+                        raise
+                    else:
+                        if record.mtime != mtime:
+                            # force reloading of page template
+                            del self._cache[path]
+                            record = None
+                        # if
+                    # try
+                # if
+            # if
+            # need to load the page template
+            if record is None:
+                content = self.do_load(path, mode)
+                mtime = os.path.getmtime(path)
+                record = _FileInfo(path, mtime, content)
+                self._cache[path] = record
+                return self.make_content(content)
+            else:
+                content = record.content
+                record.hits += 1
+                record.atime = time.time()
+                return self.make_content(content)
+            # if
+        finally:
+            self._lock.release()
+        # try
+    # load
+
+    def make_content(self, content):
+        """ return content
+            derived classes can override this
+            to do some proccesing before returning data
+        """
+        return content
+    # make_content
+
+    def do_load(self, path, mode):
+        """ load file 
+            derived classes can override this
+            to do some proccesing before storing data
+            i.e. parse template and store parsed version in
+            the cache
+        """
+        fhandle = file(path, mode)
+        content = fhandle.read()
+        fhandle.close()
+        return content
+    # do_load
+# FileCache
+
+##################################################
+## FUNCTIONS ##
+
+def get_cache(cache_name, cache_object=FileCache):
+    """ return cache named cache_name 
+        using FileCache object cache_object (default FileCache)
+    """
+
+    global _cache
+
+    if cache_name not in _cache:
+        _cache[cache_name] = cache_object()
+    return _cache[cache_name]
+# get_cache
+
+def delete_cache(cache_name):
+    """ delete cache cache_name,
+        if cache does not exists, do nothing
+    """
+
+    global _cache
+
+    if cache_name in _cache:
+        del _cache[cache_name]
+# delete_cache