| | |
- thread._local(__builtin__.object)
-
- Client
class Client(thread._local) |
| |
Object representing a pool of memcache servers.
See L{memcache} for an overview.
In all cases where a key is used, the key can be either:
1. A simple hashable type (string, integer, etc.).
2. A tuple of C{(hashvalue, key)}. This is useful if you want
to avoid making this module calculate a hash value. You may
prefer, for example, to keep all of a given user's objects on
the same memcache server, so you could use the user's unique
id as the hash value.
@group Setup: __init__, set_servers, forget_dead_hosts,
disconnect_all, debuglog
@group Insertion: set, add, replace, set_multi
@group Retrieval: get, get_multi
@group Integers: incr, decr
@group Removal: delete, delete_multi
@sort: __init__, set_servers, forget_dead_hosts, disconnect_all,
debuglog,\ set, set_multi, add, replace, get, get_multi,
incr, decr, delete, delete_multi
|
| |
- Method resolution order:
- Client
- thread._local
- __builtin__.object
Methods defined here:
- __init__(self, servers, debug=0, pickleProtocol=0, pickler=<class pickle.Pickler>, unpickler=<class pickle.Unpickler>, compressor=<built-in function compress>, decompressor=<built-in function decompress>, pload=None, pid=None, server_max_key_length=None, server_max_value_length=None, dead_retry=30, socket_timeout=3, cache_cas=False, flush_on_reconnect=0, check_keys=True)
- Create a new Client object with the given list of servers.
@param servers: C{servers} is passed to L{set_servers}.
@param debug: whether to display error messages when a server
can't be contacted.
@param pickleProtocol: number to mandate protocol used by
(c)Pickle.
@param pickler: optional override of default Pickler to allow
subclassing.
@param unpickler: optional override of default Unpickler to
allow subclassing.
@param pload: optional persistent_load function to call on
pickle loading. Useful for cPickle since subclassing isn't
allowed.
@param pid: optional persistent_id function to call on pickle
storing. Useful for cPickle since subclassing isn't allowed.
@param dead_retry: number of seconds before retrying a
blacklisted server. Default to 30 s.
@param socket_timeout: timeout in seconds for all calls to a
server. Defaults to 3 seconds.
@param cache_cas: (default False) If true, cas operations will
be cached. WARNING: This cache is not expired internally, if
you have a long-running process you will need to expire it
manually via client.reset_cas(), or the cache can grow
unlimited.
@param server_max_key_length: (default SERVER_MAX_KEY_LENGTH)
Data that is larger than this will not be sent to the server.
@param server_max_value_length: (default
SERVER_MAX_VALUE_LENGTH) Data that is larger than this will
not be sent to the server.
@param flush_on_reconnect: optional flag which prevents a
scenario that can cause stale data to be read: If there's more
than one memcached server and the connection to one is
interrupted, keys that mapped to that server will get
reassigned to another. If the first server comes back, those
keys will map to it again. If it still has its data, get()s
can read stale data that was overwritten on another
server. This flag is off by default for backwards
compatibility.
@param check_keys: (default True) If True, the key is checked
to ensure it is the correct length and composed of the right
characters.
- add(self, key, val, time=0, min_compress_len=0, noreply=False)
- Add new key with value.
Like L{set}, but only stores in memcache if the key doesn't
already exist.
@return: Nonzero on success.
@rtype: int
- append(self, key, val, time=0, min_compress_len=0, noreply=False)
- Append the value to the end of the existing key's value.
Only stores in memcache if key already exists.
Also see L{prepend}.
@return: Nonzero on success.
@rtype: int
- cas(self, key, val, time=0, min_compress_len=0, noreply=False)
- Check and set (CAS)
Sets a key to a given value in the memcache if it hasn't been
altered since last fetched. (See L{gets}).
The C{key} can optionally be an tuple, with the first element
being the server hash value and the second being the key. If
you want to avoid making this module calculate a hash value.
You may prefer, for example, to keep all of a given user's
objects on the same memcache server, so you could use the
user's unique id as the hash value.
@return: Nonzero on success.
@rtype: int
@param time: Tells memcached the time which this value should
expire, either as a delta number of seconds, or an absolute
unix time-since-the-epoch value. See the memcached protocol
docs section "Storage Commands" for more info on <exptime>. We
default to 0 == cache forever.
@param min_compress_len: The threshold length to kick in
auto-compression of the value using the compressor
routine. If the value being cached is a string, then the
length of the string is measured, else if the value is an
object, then the length of the pickle result is measured. If
the resulting attempt at compression yeilds a larger string
than the input, then it is discarded. For backwards
compatability, this parameter defaults to 0, indicating don't
ever try to compress.
@param noreply: optional parameter instructs the server to not
send the reply.
- check_key(self, key, key_extra_len=0)
- Checks sanity of key.
Fails if:
Key length is > SERVER_MAX_KEY_LENGTH (Raises MemcachedKeyLength).
Contains control characters (Raises MemcachedKeyCharacterError).
Is not a string (Raises MemcachedStringEncodingError)
Is an unicode string (Raises MemcachedStringEncodingError)
Is not a string (Raises MemcachedKeyError)
Is None (Raises MemcachedKeyError)
- debuglog(self, str)
- decr(self, key, delta=1, noreply=False)
- Decrement value for C{key} by C{delta}
Like L{incr}, but decrements. Unlike L{incr}, underflow is
checked and new values are capped at 0. If server value is 1,
a decrement of 2 returns 0, not -1.
@param delta: Integer amount to decrement by (should be zero
or greater).
@param noreply: optional parameter instructs the server to not send the
reply.
@return: New value after decrementing, or None for noreply or error.
@rtype: int
- delete(self, key, time=0, noreply=False)
- Deletes a key from the memcache.
@return: Nonzero on success.
@param time: number of seconds any subsequent set / update commands
should fail. Defaults to None for no delay.
@param noreply: optional parameter instructs the server to not send the
reply.
@rtype: int
- delete_multi(self, keys, time=0, key_prefix='', noreply=False)
- Delete multiple keys in the memcache doing just one query.
>>> notset_keys = mc.set_multi({'a1' : 'val1', 'a2' : 'val2'})
>>> mc.get_multi(['a1', 'a2']) == {'a1' : 'val1','a2' : 'val2'}
1
>>> mc.delete_multi(['key1', 'key2'])
1
>>> mc.get_multi(['key1', 'key2']) == {}
1
This method is recommended over iterated regular L{delete}s as
it reduces total latency, since your app doesn't have to wait
for each round-trip of L{delete} before sending the next one.
@param keys: An iterable of keys to clear
@param time: number of seconds any subsequent set / update
commands should fail. Defaults to 0 for no delay.
@param key_prefix: Optional string to prepend to each key when
sending to memcache. See docs for L{get_multi} and
L{set_multi}.
@param noreply: optional parameter instructs the server to not send the
reply.
@return: 1 if no failure in communication with any memcacheds.
@rtype: int
- disconnect_all(self)
- flush_all(self)
- Expire all data in memcache servers that are reachable.
- forget_dead_hosts(self)
- Reset every host in the pool to an "alive" state.
- get(self, key)
- Retrieves a key from the memcache.
@return: The value or None.
- get_multi(self, keys, key_prefix='')
- Retrieves multiple keys from the memcache doing just one query.
>>> success = mc.set("foo", "bar")
>>> success = mc.set("baz", 42)
>>> mc.get_multi(["foo", "baz", "foobar"]) == {
... "foo": "bar", "baz": 42
... }
1
>>> mc.set_multi({'k1' : 1, 'k2' : 2}, key_prefix='pfx_') == []
1
This looks up keys 'pfx_k1', 'pfx_k2', ... . Returned dict
will just have unprefixed keys 'k1', 'k2'.
>>> mc.get_multi(['k1', 'k2', 'nonexist'],
... key_prefix='pfx_') == {'k1' : 1, 'k2' : 2}
1
get_mult [ and L{set_multi} ] can take str()-ables like ints /
longs as keys too. Such as your db pri key fields. They're
rotored through str() before being passed off to memcache,
with or without the use of a key_prefix. In this mode, the
key_prefix could be a table name, and the key itself a db
primary key number.
>>> mc.set_multi({42: 'douglass adams',
... 46: 'and 2 just ahead of me'},
... key_prefix='numkeys_') == []
1
>>> mc.get_multi([46, 42], key_prefix='numkeys_') == {
... 42: 'douglass adams',
... 46: 'and 2 just ahead of me'
... }
1
This method is recommended over regular L{get} as it lowers
the number of total packets flying around your network,
reducing total latency, since your app doesn't have to wait
for each round-trip of L{get} before sending the next one.
See also L{set_multi}.
@param keys: An array of keys.
@param key_prefix: A string to prefix each key when we
communicate with memcache. Facilitates pseudo-namespaces
within memcache. Returned dictionary keys will not have this
prefix.
@return: A dictionary of key/value pairs that were
available. If key_prefix was provided, the keys in the retured
dictionary will not have it present.
- get_slabs(self)
- get_stats(self, stat_args=None)
- Get statistics from each of the servers.
@param stat_args: Additional arguments to pass to the memcache
"stats" command.
@return: A list of tuples ( server_identifier,
stats_dictionary ). The dictionary contains a number of
name/value pairs specifying the name of the status field
and the string value associated with it. The values are
not converted from strings.
- gets(self, key)
- Retrieves a key from the memcache. Used in conjunction with 'cas'.
@return: The value or None.
- incr(self, key, delta=1, noreply=False)
- Increment value for C{key} by C{delta}
Sends a command to the server to atomically increment the
value for C{key} by C{delta}, or by 1 if C{delta} is
unspecified. Returns None if C{key} doesn't exist on server,
otherwise it returns the new value after incrementing.
Note that the value for C{key} must already exist in the
memcache, and it must be the string representation of an
integer.
>>> mc.set("counter", "20") # returns 1, indicating success
1
>>> mc.incr("counter")
21
>>> mc.incr("counter")
22
Overflow on server is not checked. Be aware of values
approaching 2**32. See L{decr}.
@param delta: Integer amount to increment by (should be zero
or greater).
@param noreply: optional parameter instructs the server to not send the
reply.
@return: New value after incrementing, no None for noreply or error.
@rtype: int
- prepend(self, key, val, time=0, min_compress_len=0, noreply=False)
- Prepend the value to the beginning of the existing key's value.
Only stores in memcache if key already exists.
Also see L{append}.
@return: Nonzero on success.
@rtype: int
- replace(self, key, val, time=0, min_compress_len=0, noreply=False)
- Replace existing key with value.
Like L{set}, but only stores in memcache if the key already exists.
The opposite of L{add}.
@return: Nonzero on success.
@rtype: int
- reset_cas(self)
- Reset the cas cache.
This is only used if the Client() object was created with
"cache_cas=True". If used, this cache does not expire
internally, so it can grow unbounded if you do not clear it
yourself.
- set(self, key, val, time=0, min_compress_len=0, noreply=False)
- Unconditionally sets a key to a given value in the memcache.
The C{key} can optionally be an tuple, with the first element
being the server hash value and the second being the key. If
you want to avoid making this module calculate a hash value.
You may prefer, for example, to keep all of a given user's
objects on the same memcache server, so you could use the
user's unique id as the hash value.
@return: Nonzero on success.
@rtype: int
@param time: Tells memcached the time which this value should
expire, either as a delta number of seconds, or an absolute
unix time-since-the-epoch value. See the memcached protocol
docs section "Storage Commands" for more info on <exptime>. We
default to 0 == cache forever.
@param min_compress_len: The threshold length to kick in
auto-compression of the value using the compressor
routine. If the value being cached is a string, then the
length of the string is measured, else if the value is an
object, then the length of the pickle result is measured. If
the resulting attempt at compression yeilds a larger string
than the input, then it is discarded. For backwards
compatability, this parameter defaults to 0, indicating don't
ever try to compress.
@param noreply: optional parameter instructs the server to not
send the reply.
- set_multi(self, mapping, time=0, key_prefix='', min_compress_len=0, noreply=False)
- Sets multiple keys in the memcache doing just one query.
>>> notset_keys = mc.set_multi({'key1' : 'val1', 'key2' : 'val2'})
>>> mc.get_multi(['key1', 'key2']) == {'key1' : 'val1',
... 'key2' : 'val2'}
1
This method is recommended over regular L{set} as it lowers
the number of total packets flying around your network,
reducing total latency, since your app doesn't have to wait
for each round-trip of L{set} before sending the next one.
@param mapping: A dict of key/value pairs to set.
@param time: Tells memcached the time which this value should
expire, either as a delta number of seconds, or an
absolute unix time-since-the-epoch value. See the
memcached protocol docs section "Storage Commands" for
more info on <exptime>. We default to 0 == cache forever.
@param key_prefix: Optional string to prepend to each key when
sending to memcache. Allows you to efficiently stuff these
keys into a pseudo-namespace in memcache:
>>> notset_keys = mc.set_multi(
... {'key1' : 'val1', 'key2' : 'val2'},
... key_prefix='subspace_')
>>> len(notset_keys) == 0
True
>>> mc.get_multi(['subspace_key1',
... 'subspace_key2']) == {'subspace_key1': 'val1',
... 'subspace_key2' : 'val2'}
True
Causes key 'subspace_key1' and 'subspace_key2' to be
set. Useful in conjunction with a higher-level layer which
applies namespaces to data in memcache. In this case, the
return result would be the list of notset original keys,
prefix not applied.
@param min_compress_len: The threshold length to kick in
auto-compression of the value using the compressor
routine. If the value being cached is a string, then the
length of the string is measured, else if the value is an
object, then the length of the pickle result is
measured. If the resulting attempt at compression yeilds a
larger string than the input, then it is discarded. For
backwards compatability, this parameter defaults to 0,
indicating don't ever try to compress.
@param noreply: optional parameter instructs the server to not
send the reply.
@return: List of keys which failed to be stored [ memcache out
of memory, etc. ].
@rtype: list
- set_servers(self, servers)
- Set the pool of servers used by this client.
@param servers: an array of servers.
Servers can be passed in two forms:
1. Strings of the form C{"host:port"}, which implies a
default weight of 1.
2. Tuples of the form C{("host:port", weight)}, where
C{weight} is an integer weight value.
- touch(self, key, time=0, noreply=False)
- Updates the expiration time of a key in memcache.
@return: Nonzero on success.
@param time: Tells memcached the time which this value should
expire, either as a delta number of seconds, or an absolute
unix time-since-the-epoch value. See the memcached protocol
docs section "Storage Commands" for more info on <exptime>. We
default to 0 == cache forever.
@param noreply: optional parameter instructs the server to not send the
reply.
@rtype: int
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
Data and other attributes defined here:
- MemcachedKeyCharacterError = <class 'memcache.MemcachedKeyCharacterError'>
- MemcachedKeyError = <class 'memcache.MemcachedKeyError'>
- MemcachedKeyLengthError = <class 'memcache.MemcachedKeyLengthError'>
- MemcachedKeyNoneError = <class 'memcache.MemcachedKeyNoneError'>
- MemcachedKeyTypeError = <class 'memcache.MemcachedKeyTypeError'>
- MemcachedStringEncodingError = <class 'memcache.MemcachedStringEncodingError'>
Methods inherited from thread._local:
- __delattr__(...)
- x.__delattr__('name') <==> del x.name
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __setattr__(...)
- x.__setattr__('name', value) <==> x.name = value
Data and other attributes inherited from thread._local:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
| |