Class CacheSuite

Caching proxy for object retrieval and caching.

Object factories for other classes are registered in the
`Cache` object and used to e.g. retrieve requested objects from network.
They are called only when the requested object is not in the cache
or is not fresh enough.

Objects are addressed using their class and a class dependant address.
Eg. `pyxmpp.jabber.disco.DiscoInfo` objects are addressed using
(`pyxmpp.jabber.disco.DiscoInfo`,(jid, node)) tuple.

Additionaly a state (freshness level) name may be provided when requesting
an object. When the cached item state is "less fresh" then requested, then
new object will be retrieved.

Following states are defined:

  - 'new': always a new object should be retrieved.
  - 'fresh': a fresh object (not older than freshness time)
  - 'old': object not fresh, but most probably still valid.
  - 'stale': object known to be expired.

:Ivariables:
    - `default_freshness_period`: default freshness period (in seconds).
    - `default_expiration_period`: default expiration period (in seconds).
    - `default_purge_period`: default purge period (in seconds). When
      0 then items are never purged because of their age.
    - `max_items`: maximum number of obejects of one class to store.
    - `_caches`: dictionary of per-class caches.
    - `_lock`: lock for thread safety.
:Types:
    - `default_freshness_period`: timedelta
    - `default_expiration_period`: timedelta
    - `default_purge_period`: timedelta
    - `max_items`: `int`
    - `_caches`: `dict` of (`classobj`, addr) -> `Cache`
    - `_lock`: `threading.RLock`

Initialize a `Cache` object.

:Parameters:
    - `default_freshness_period`: default freshness period (in seconds).
    - `default_expiration_period`: default expiration period (in seconds).
    - `default_purge_period`: default purge period (in seconds). When
      0 then items are never purged because of their age.
    - `max_items`: maximum number of items to store.
:Types:
    - `default_freshness_period`: number
    - `default_expiration_period`: number
    - `default_purge_period`: number
    - `max_items`: number

Register a fetcher class for an object class.

:Parameters:
    - `object_class`: class to be retrieved by the fetcher.
    - `fetcher_class`: the fetcher class.
:Types:
    - `object_class`: `classobj`
    - `fetcher_class`: `CacheFetcher` based class

Request an object of given class, with given address and state not
worse than `state`. The object will be taken from cache if available,
and created/fetched otherwise. The request is asynchronous -- this
metod doesn't return the object directly, but the `object_handler` is
called as soon as the object is available (this may be before
`request_object` returns and may happen in other thread). On error the
`error_handler` will be called, and on timeout -- the
`timeout_handler`.

:Parameters:
    - `object_class`: class (type) of the object requested.
    - `address`: address of the object requested.
    - `state`: the worst acceptable object state. When 'new' then always
      a new object will be created/fetched. 'stale' will select any
      item available in cache.
    - `object_handler`: function to be called when object is available.
      It will be called with the following arguments: address, object
      and its state.
    - `error_handler`: function to be called on object retrieval error.
      It will be called with two arguments: requested address and
      additional error information (fetcher-specific, may be
      StanzaError for XMPP objects).  If not given, then the object
      handler will be called with object set to `None` and state
      "error".
    - `timeout_handler`: function to be called on object retrieval
      timeout.  It will be called with only one argument: the requested
      address. If not given, then the `error_handler` will be called
      instead, with error details set to `None`.
    - `backup_state`: when set and object in state `state` is not
      available in the cache and object retrieval failed then object
      with this state will also be looked-up in the cache and provided
      if available.
    - `timeout`: time interval after which retrieval of the object
      should be given up.
    - `freshness_period`: time interval after which the item created
      should become 'old'.
    - `expiration_period`: time interval after which the item created
      should become 'stale'.
    - `purge_period`: time interval after which the item created
      shuld be removed from the cache.
:Types:
    - `object_class`: `classobj`
    - `address`: any hashable
    - `state`: "new", "fresh", "old" or "stale"
    - `object_handler`: callable(address, value, state)
    - `error_handler`: callable(address, error_data)
    - `timeout_handler`: callable(address)
    - `backup_state`: "new", "fresh", "old" or "stale"
    - `timeout`: `timedelta`
    - `freshness_period`: `timedelta`
    - `expiration_period`: `timedelta`
    - `purge_period`: `timedelta`

Do the regular cache maintenance.

Must be called from time to time for timeouts and cache old items
purging to work.

Unregister a fetcher class for an object class.

:Parameters:
    - `object_class`: class retrieved by the fetcher.
:Types:
    - `object_class`: `classobj`