beaker – Caching

Beaker

Cache

Cache object

The Cache object is used to manage a set of cache files and their associated backend. The backends can be rotated on the fly by specifying an alternate type when used.

Advanced users can add new backends in beaker.backends

class beaker.cache.Cache(namespace, type='memory', expiretime=None, starttime=None, expire=None, **nsargs)

Front-end to the containment API implementing a data cache.

namespace
the namespace of this Cache
type
type of cache to use
expire
seconds to keep cached data
expiretime
seconds to keep cached data (legacy support)
starttime
time when cache was cache was
clear()
Clear all the values from the namespace
get(key, **kw)
Retrieve a cached value from the container
get_value(key, **kw)
Retrieve a cached value from the container
class beaker.cache.CacheManager(**kwargs)
cache(*args, **kwargs)

Decorate a function to cache itself with supplied parameters

args
used to make the key unique for this function, as in region() above.
kwargs
parameters to be passed to get_cache(), will override defaults

Example:

# Assuming a cache object is available like:
cache = CacheManager(dict_of_config_options)


def populate_things():
    
    @cache.cache('mycache', expire=15)
    def load(search_term, limit, offset):
        return load_the_data(search_term, limit, offset)
    
    return load('rabbits', 20, 0)

Note

The function being decorated must only be called with positional arguments.

region(region, *args)

Decorate a function to cache itself using a cache region

The region decorator requires arguments if there are more than 2 of the same named function, in the same module. This is because the namespace used for the functions cache is based on the functions name and the module.

Example:

# Assuming a cache object is available like:
cache = CacheManager(dict_of_config_options)


def populate_things():
    
    @cache.region('short_term', 'some_data')
    def load(search_term, limit, offset):
        return load_the_data(search_term, limit, offset)
    
    return load('rabbits', 20, 0)

Note

The function being decorated must only be called with positional arguments.

Container

Container and Namespace classes

beaker.container.ContainerContext
alias of dict
class beaker.container.Container
class beaker.container.MemoryContainer
class beaker.container.DBMContainer
class beaker.container.NamespaceManager(namespace)

Handles dictionary operations and locking for a namespace of values.

The implementation for setting and retrieving the namespace data is handled by subclasses.

NamespaceManager may be used alone, or may be privately accessed by one or more Container objects. Container objects provide per-key services like expiration times and automatic recreation of values.

Multiple NamespaceManagers created with a particular name will all share access to the same underlying datasource and will attempt to synchronize against a common mutex object. The scope of this sharing may be within a single process or across multiple processes, depending on the type of NamespaceManager used.

The NamespaceManager itself is generally threadsafe, except in the case of the DBMNamespaceManager in conjunction with the gdbm dbm implementation.

class beaker.container.MemoryNamespaceManager(namespace, **kwargs)
class beaker.container.DBMNamespaceManager(namespace, dbmmodule=None, data_dir=None, dbm_dir=None, lock_dir=None, digest_filenames=True, **kwargs)
class beaker.container.FileContainer
class beaker.container.FileNamespaceManager(namespace, data_dir=None, file_dir=None, lock_dir=None, digest_filenames=True, **kwargs)
class beaker.container.CreationAbortedError
deprecated.

Database

class beaker.ext.database.DatabaseNamespaceManager(namespace, url=None, sa_opts=None, optimistic=False, table_name='beaker_cache', data_dir=None, lock_dir=None, **params)
class beaker.ext.database.DatabaseContainer

Memcached

Middleware

class beaker.middleware.CacheMiddleware(app, config=None, environ_key='beaker.cache', **kwargs)
class beaker.middleware.SessionMiddleware(wrap_app, config=None, environ_key='beaker.session', **kwargs)

Session

class beaker.session.SignedCookie(secret, input=None)
Extends python cookie to give digital signature support
class beaker.session.Session(request, id=None, invalidate_corrupt=False, use_cookies=True, type=None, data_dir=None, key='beaker.session.id', timeout=None, cookie_expires=True, cookie_domain=None, secret=None, secure=False, namespace_class=None, **namespace_args)
Session object that uses container package for storage
class beaker.session.SessionObject(environ, **params)

Session proxy/lazy creator

This object proxies access to the actual session object, so that in the case that the session hasn’t been used before, it will be setup. This avoid creating and loading the session from persistent storage unless its actually used during the request.

Synchronization

Synchronization functions.

File- and mutex-based mutual exclusion synchronizers are provided, as well as a name-based mutex which locks within an application based on a string name.

class beaker.synchronization.NameLock(identifier=None, reentrant=False)

a proxy for an RLock object that is stored in a name based registry.

Multiple threads can get a reference to the same RLock based on the name alone, and synchronize operations related to that name.

class beaker.synchronization.SynchronizerImpl
class beaker.synchronization.FileSynchronizer(identifier, lock_dir)

a synchronizer which locks using flock().

Adapted for Python/multithreads from Apache::Session::Lock::File, http://search.cpan.org/src/CWEST/Apache-Session-1.81/Session/Lock/File.pm

This module does not unlink temporary files, because it interferes with proper locking. This can cause problems on certain systems (Linux) whose file systems (ext2) do not perform well with lots of files in one directory. To prevent this you should use a script to clean out old files from your lock directory.

class beaker.synchronization.ConditionSynchronizer(identifier)
a synchronizer using a Condition.

Util

Beaker utilities

class beaker.util.SyncDict

An efficient/threadsafe singleton map algorithm, a.k.a. “get a value based on this key, and create if not found or not valid” paradigm:

exists && isvalid ? get : create

Works with weakref dictionaries and the LRUCache to handle items asynchronously disappearing from the dictionary.

Use python 2.3.3 or greater ! a major bug was just fixed in Nov. 2003 that was driving me nuts with garbage collection/weakrefs in this section.

class beaker.util.WeakValuedRegistry
class beaker.util.ThreadLocal
stores a value on a per-thread basis
beaker.util.b64decode(s, altchars=None)

Decode a Base64 encoded string.

s is the string to decode. Optional altchars must be a string of at least length 2 (additional characters are ignored) which specifies the alternative alphabet used instead of the ‘+’ and ‘/’ characters.

The decoded string is returned. A TypeError is raised if s were incorrectly padded or if there are non-alphabet characters present in the string.

beaker.util.b64encode(s, altchars=None)

Encode a string using Base64.

s is the string to encode. Optional altchars must be a string of at least length 2 (additional characters are ignored) which specifies an alternative alphabet for the ‘+’ and ‘/’ characters. This allows an application to e.g. generate url or filesystem safe Base64 strings.

The encoded string is returned.

beaker.util.verify_directory(dir)
verifies and creates a directory. tries to ignore collisions with other threads and processes.
beaker.util.encoded_path(root, identifiers, extension='.enc', depth=3, digest_filenames=True)
Generate a unique file-accessible path from the given list of identifiers starting at the given root directory.
beaker.util.verify_options(opt, types, error)
beaker.util.verify_rules(params, ruleset)
beaker.util.coerce_session_params(params)
beaker.util.coerce_cache_params(params)

Table Of Contents

This Page