Gecko [ emad.team ]

Name	Size	Permission	Date
__init__.py	0 B	-rw-r--r--	2008-02-29 00:32
__init__.pyc	142 B	-rw-r--r--	2014-09-17 18:36
__init__.pyo	142 B	-rw-r--r--	2014-09-17 18:36
database.py	5.86 KB	-rw-r--r--	2010-02-24 02:09
database.pyc	6.55 KB	-rw-r--r--	2014-09-17 18:36
database.pyo	6.55 KB	-rw-r--r--	2014-09-17 18:36
google.py	3.92 KB	-rw-r--r--	2010-03-02 22:36
google.pyc	4.94 KB	-rw-r--r--	2014-09-17 18:36
google.pyo	4.94 KB	-rw-r--r--	2014-09-17 18:36
memcached.py	2.79 KB	-rw-r--r--	2010-02-24 02:09
memcached.pyc	4.36 KB	-rw-r--r--	2014-09-17 18:36
memcached.pyo	4.36 KB	-rw-r--r--	2014-09-17 18:36
sqla.py	4.51 KB	-rw-r--r--	2010-02-24 02:09
sqla.pyc	6.12 KB	-rw-r--r--	2014-09-17 18:36
sqla.pyo	6.12 KB	-rw-r--r--	2014-09-17 18:36

Rename

from beaker.container import NamespaceManager, Container
from beaker.exceptions import InvalidCacheBackendError, MissingCacheParameter
from beaker.synchronization import file_synchronizer, null_synchronizer
from beaker.util import verify_directory, SyncDict
import warnings

memcache = None

class MemcachedNamespaceManager(NamespaceManager):
    clients = SyncDict()
    
    @classmethod
    def _init_dependencies(cls):
        global memcache
        if memcache is not None:
            return
        try:
            import pylibmc as memcache
        except ImportError:
            try:
                import cmemcache as memcache
                warnings.warn("cmemcache is known to have serious "
                            "concurrency issues; consider using 'memcache' or 'pylibmc'")
            except ImportError:
                try:
                    import memcache
                except ImportError:
                    raise InvalidCacheBackendError("Memcached cache backend requires either "
                                                        "the 'memcache' or 'cmemcache' library")
        
    def __init__(self, namespace, url=None, data_dir=None, lock_dir=None, **params):
        NamespaceManager.__init__(self, namespace)
       
        if not url:
            raise MissingCacheParameter("url is required") 
        
        if lock_dir:
            self.lock_dir = lock_dir
        elif data_dir:
            self.lock_dir = data_dir + "/container_mcd_lock"
        if self.lock_dir:
            verify_directory(self.lock_dir)            
        
        self.mc = MemcachedNamespaceManager.clients.get(url, memcache.Client, url.split(';'))

def get_creation_lock(self, key):
        return file_synchronizer(
            identifier="memcachedcontainer/funclock/%s" % self.namespace,lock_dir = self.lock_dir)

def _format_key(self, key):
        return self.namespace + '_' + key.replace(' ', '\302\267')

def __getitem__(self, key):
        return self.mc.get(self._format_key(key))

def __contains__(self, key):
        value = self.mc.get(self._format_key(key))
        return value is not None

def has_key(self, key):
        return key in self

def set_value(self, key, value, expiretime=None):
        if expiretime:
            self.mc.set(self._format_key(key), value, time=expiretime)
        else:
            self.mc.set(self._format_key(key), value)

def __setitem__(self, key, value):
        self.set_value(key, value)
        
    def __delitem__(self, key):
        self.mc.delete(self._format_key(key))

def do_remove(self):
        self.mc.flush_all()
    
    def keys(self):
        raise NotImplementedError("Memcache caching does not support iteration of all cache keys")

class MemcachedContainer(Container):
    namespace_class = MemcachedNamespaceManager