dogpile.cache-fork / dogpile / cache / backends /

File Backends

Provides backends that deal with local filesystem access.


from dogpile.cache.api import CacheBackend, NO_VALUE
from contextlib import contextmanager
from dogpile.cache import util
import os
import fcntl

__all__ = 'DBMBackend', 'FileLock'

class DBMBackend(CacheBackend):
    """A file-backend using a dbm file to store keys.

    Basic usage::

        from dogpile.cache import make_region

        region = make_region().configure(
            expiration_time = 3600,
            arguments = {

    DBM access is provided using the Python ``anydbm`` module,
    which selects a platform-specific dbm module to use.
    This may be made to be more configurable in a future 
    Note that different dbm modules have different behaviors.
    Some dbm implementations handle their own locking, while 
    others don't.  The :class:`.DBMBackend` uses a read/write
    lockfile by default, which is compatible even with those
    DBM implementations for which this is unnecessary,
    though the behavior can be disabled.

    The DBM backend by default makes use of two lockfiles.
    One is in order to protect the DBM file itself from 
    concurrent writes, the other is to coordinate
    value creation (i.e. the dogpile lock).  By default,
    these lockfiles use the ``flock()`` system call 
    for locking; this is only available on Unix 
    Currently, the dogpile lock is against the entire
    DBM file, not per key.   This means there can
    only be one "creator" job running at a time
    per dbm file.
    A future improvement might be to have the dogpile lock 
    using a filename that's based on a modulus of the key. 
    Locking on a filename that uniquely corresponds to the 
    key is problematic, since it's not generally safe to
    delete lockfiles as the application runs, implying an 
    unlimited number of key-based files would need to be 
    created and never deleted.
    Parameters to the ``arguments`` dictionary are 

    :param filename: path of the filename in which to 
     create the DBM file.  Note that some dbm backends
     will change this name to have additional suffixes.
    :param rw_lockfile: the name of the file to use for
     read/write locking.  If omitted, a default name
     is used by appending the suffix ".rw.lock" to the 
     DBM filename.  If False, then no lock is used.
    :param dogpile_lockfile: the name of the file to use
     for value creation, i.e. the dogpile lock.  If 
     omitted, a default name is used by appending the 
     suffix ".dogpile.lock" to the DBM filename. If 
     False, then dogpile.cache uses the default dogpile
     lock, a plain thread-based mutex.

    def __init__(self, arguments):
        self.filename = os.path.abspath(
        dir_, filename = os.path.split(self.filename)

        self._rw_lock = self._init_lock(
                                ".rw.lock", dir_, filename)
        self._dogpile_lock = self._init_lock(
                                dir_, filename)

        # TODO: make this configurable
        if util.py3k:
            import dbm
            import anydbm as dbm
        self.dbmmodule = dbm

    def _init_lock(self, argument, suffix, basedir, basefile):
        if argument is None:
            return FileLock(os.path.join(basedir, basefile + suffix))
        elif argument is not False:
            return FileLock(
            return None

    def _init_dbm_file(self):
        exists = os.access(self.filename, os.F_OK)
        if not exists:
            for ext in ('db', 'dat', 'pag', 'dir'):
                if os.access(self.filename + os.extsep + ext, os.F_OK):
                    exists = True
        if not exists:
            fh =, 'c')

    def get_mutex(self, key):
        # using one dogpile for the whole file.   Other ways
        # to do this might be using a set of files keyed to a 
        # hash/modulus of the key.   the issue is it's never
        # really safe to delete a lockfile as this can 
        # break other processes trying to get at the file
        # at the same time - so handling unlimited keys
        # can't imply unlimited filenames
        return self._dogpile_lock

    def _use_rw_lock(self, write):
        if self._rw_lock is None:
        elif write:
            with self._rw_lock.write():

    def _dbm_file(self, write):
        with self._use_rw_lock(write):
            dbm =, 
                                "w" if write else "r")
            yield dbm

    def get(self, key):
        with self._dbm_file('r') as dbm:
            value = dbm.get(key, NO_VALUE)
            if value is not NO_VALUE:
                value = util.pickle.loads(value)
            return value

    def set(self, key, value):
        with self._dbm_file('w') as dbm:
            dbm[key] = util.pickle.dumps(value)

    def delete(self, key):
        with self._dbm_file('w') as dbm:
                del dbm[key]
            except KeyError:

class FileLock(object):
    """Use lockfiles to coordinate read/write access to a file.
    Only works on Unix systems, using 
    `fcntl.flock() <>`_.

    def __init__(self, filename):
        self._filedescriptor = util.threading.local()
        self.filename = filename

    def acquire(self, wait=True):
        return self.acquire_write_lock(wait)

    def release(self):

    def is_open(self):
        return hasattr(self._filedescriptor, 'fileno')

    def read(self):

    def write(self):

    def acquire_read_lock(self, wait):
        return self._acquire(wait, os.O_RDONLY, fcntl.LOCK_SH)

    def acquire_write_lock(self, wait):
        return self._acquire(wait, os.O_WRONLY, fcntl.LOCK_EX)

    def release_read_lock(self):

    def release_write_lock(self):

    def _acquire(self, wait, wrflag, lockflag):
        wrflag |= os.O_CREAT
        fileno =, wrflag)
            if not wait:
                lockflag |= fcntl.LOCK_NB
            fcntl.flock(fileno, lockflag)
        except IOError:
            if not wait:
                # this is typically 
                # "[Errno 35] Resource temporarily unavailable",
                # because of LOCK_NB
                return False
            self._filedescriptor.fileno = fileno
            return True

    def _release(self):
            fileno = self._filedescriptor.fileno
        except AttributeError:
            fcntl.flock(fileno, fcntl.LOCK_UN)
            del self._filedescriptor.fileno
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.