djblets.cache.synchronizer¶

class GenerationSynchronizer(cache_key, normalize_cache_key=True)[source]¶

Bases: object

Manages the synchronization of generation state across processes.

This is a utility class that makes it easy for consumers to synchronize a generation ID between processes and servers. This ID can be used to check whether a process has the latest version of some data, updating if the version it has is expired.

Callers should create a GenerationSynchronizer with a stable cache key, which will be used for communication between processes/servers. The initial generation number will be fetched, or created if one does not already exist.

When the caller has updated something in the state, it must call mark_updated(). This will bump the synchronization generation number, which will invalidate other processes.

Other callers, upon noticing that their state is expired (through is_expired()) can re-fetch or re-compute the data needed and then call refresh() to refresh the instance’s counter from the cache.

sync_gen¶

The synchronization generation number last fetched or set by this instance.

Type:

int

cache_key¶

The synchronization cache key.

Type:

unicode

__init__(cache_key, normalize_cache_key=True)[source]¶

Initialize the synchronizer.

Parameters:

• cache_key (unicode) – The base cache key used for all synchronization. This will be normalized by make_cache_key().

• normalize_cache_key (bool, optional) – Whether to normalize the cache key. Normalizing it will ensure it can fit within the key length constraints, and reduces changes of colliding with keys from other services. This is enabled by default.

is_expired()[source]¶

Return whether the current state has expired.

Returns:

True if the state has expired. False if this has the latest cached generation.

Return type:

bool

refresh()[source]¶

Refresh the generation ID from cache.

This should be called after having updated to the latest state.

clear()[source]¶

Clear the cached generation ID.

This will expire all existing caches and force all processes to re-fetch and store the cache state.

mark_updated()[source]¶

Mark the synchronized state as having been updated.

All other processes will find their state expired, and will need to re-update.