Turn pylibmc into a shallow package
This commit is contained in:
lericson
parent
a3605ca55f
commit
9d4b01ff4d
307
pylibmc.py
307
pylibmc.py
@ -1,307 +0,0 @@
|
|||||||
"""Snappy libmemcached wrapper
|
|
||||||
|
|
||||||
pylibmc is a Python wrapper around TangentOrg's libmemcached library.
|
|
||||||
|
|
||||||
The interface is intentionally made as close to python-memcached as possible,
|
|
||||||
so that applications can drop-in replace it.
|
|
||||||
|
|
||||||
Example usage
|
|
||||||
=============
|
|
||||||
|
|
||||||
Create a connection and configure it::
|
|
||||||
|
|
||||||
>>> import pylibmc
|
|
||||||
>>> mc = pylibmc.Client(["127.0.0.1"], binary=True)
|
|
||||||
>>> mc.behaviors = {"tcp_nodelay": True, "ketama": True}
|
|
||||||
|
|
||||||
Basic operation::
|
|
||||||
|
|
||||||
>>> mc.set("some_key", "Some value")
|
|
||||||
True
|
|
||||||
>>> value = mc.get("some_key")
|
|
||||||
>>> value
|
|
||||||
'Some value'
|
|
||||||
>>> mc.set("another_key", 3)
|
|
||||||
True
|
|
||||||
>>> mc.delete("another_key")
|
|
||||||
True
|
|
||||||
>>> mc.set("key", "1") # str or int is fine
|
|
||||||
True
|
|
||||||
|
|
||||||
Atomic increments and decrements::
|
|
||||||
|
|
||||||
>>> mc.incr("key")
|
|
||||||
2L
|
|
||||||
>>> mc.decr("key")
|
|
||||||
1L
|
|
||||||
|
|
||||||
Batch operation::
|
|
||||||
|
|
||||||
>>> mc.get_multi(["key", "another_key"])
|
|
||||||
{'key': '1'}
|
|
||||||
>>> mc.set_multi({"cats": ["on acid", "furry"], "dogs": True})
|
|
||||||
[]
|
|
||||||
>>> mc.get_multi(["cats", "dogs"])
|
|
||||||
{'cats': ['on acid', 'furry'], 'dogs': True}
|
|
||||||
>>> mc.delete_multi(["cats", "dogs", "nonextant"])
|
|
||||||
False
|
|
||||||
>>> mc.add_multi({"cats": ["on acid", "furry"], "dogs": True})
|
|
||||||
[]
|
|
||||||
>>> mc.get_multi(["cats", "dogs"])
|
|
||||||
{'cats': ['on acid', 'furry'], 'dogs': True}
|
|
||||||
>>> mc.add_multi({"cats": "not set", "dogs": "definitely not set", "bacon": "yummy"})
|
|
||||||
['cats', 'dogs']
|
|
||||||
>>> mc.get_multi(["cats", "dogs", "bacon"])
|
|
||||||
{'cats': ['on acid', 'furry'], 'bacon': 'yummy', 'dogs': True}
|
|
||||||
>>> mc.delete_multi(["cats", "dogs", "bacon"])
|
|
||||||
True
|
|
||||||
|
|
||||||
Further Reading
|
|
||||||
===============
|
|
||||||
|
|
||||||
See http://sendapatch.se/projects/pylibmc/
|
|
||||||
"""
|
|
||||||
|
|
||||||
from __future__ import with_statement
|
|
||||||
|
|
||||||
import _pylibmc
|
|
||||||
from Queue import Queue
|
|
||||||
|
|
||||||
__all__ = ["hashers", "distributions", "Client"]
|
|
||||||
__version__ = _pylibmc.__version__
|
|
||||||
support_compression = _pylibmc.support_compression
|
|
||||||
|
|
||||||
errors = tuple(e for (n, e) in _pylibmc.exceptions)
|
|
||||||
# *Cough* Uhm, not the prettiest of things but this unpacks all exception
|
|
||||||
# objects and sets them on the very module object currently constructed.
|
|
||||||
import sys
|
|
||||||
modself = sys.modules[__name__]
|
|
||||||
for name, exc in _pylibmc.exceptions:
|
|
||||||
setattr(modself, name, exc)
|
|
||||||
|
|
||||||
hashers, hashers_rvs = {}, {}
|
|
||||||
distributions, distributions_rvs = {}, {}
|
|
||||||
# Not the prettiest way of doing things, but works well.
|
|
||||||
for name in dir(_pylibmc):
|
|
||||||
if name.startswith("hash_"):
|
|
||||||
key, value = name[5:], getattr(_pylibmc, name)
|
|
||||||
hashers[key] = value
|
|
||||||
hashers_rvs[value] = key
|
|
||||||
elif name.startswith("distribution_"):
|
|
||||||
key, value = name[13:].replace("_", " "), getattr(_pylibmc, name)
|
|
||||||
distributions[key] = value
|
|
||||||
distributions_rvs[value] = key
|
|
||||||
|
|
||||||
class BehaviorDict(dict):
|
|
||||||
def __init__(self, client, *args, **kwds):
|
|
||||||
super(BehaviorDict, self).__init__(*args, **kwds)
|
|
||||||
self.client = client
|
|
||||||
|
|
||||||
def __setitem__(self, name, value):
|
|
||||||
super(BehaviorDict, self).__setitem__(name, value)
|
|
||||||
self.client.set_behaviors({name: value})
|
|
||||||
|
|
||||||
def update(self, d):
|
|
||||||
super(BehaviorDict, self).update(d)
|
|
||||||
self.client.set_behaviors(d.copy())
|
|
||||||
|
|
||||||
class Client(_pylibmc.client):
|
|
||||||
def __init__(self, servers, binary=False):
|
|
||||||
"""Initialize a memcached client instance.
|
|
||||||
|
|
||||||
This connects to the servers in *servers*, which will default to being
|
|
||||||
TCP servers. If it looks like a filesystem path, a UNIX socket. If
|
|
||||||
prefixed with `udp:`, a UDP connection.
|
|
||||||
|
|
||||||
If *binary* is True, the binary memcached protocol is used.
|
|
||||||
"""
|
|
||||||
self.binary = binary
|
|
||||||
self.addresses = list(servers)
|
|
||||||
addr_tups = []
|
|
||||||
for server in servers:
|
|
||||||
addr = server
|
|
||||||
port = 11211
|
|
||||||
if server.startswith("udp:"):
|
|
||||||
stype = _pylibmc.server_type_udp
|
|
||||||
addr = addr[4:]
|
|
||||||
if ":" in server:
|
|
||||||
(addr, port) = addr.split(":", 1)
|
|
||||||
port = int(port)
|
|
||||||
elif ":" in server:
|
|
||||||
stype = _pylibmc.server_type_tcp
|
|
||||||
(addr, port) = server.split(":", 1)
|
|
||||||
port = int(port)
|
|
||||||
elif "/" in server:
|
|
||||||
stype = _pylibmc.server_type_unix
|
|
||||||
port = 0
|
|
||||||
else:
|
|
||||||
stype = _pylibmc.server_type_tcp
|
|
||||||
addr_tups.append((stype, addr, port))
|
|
||||||
super(Client, self).__init__(servers=addr_tups, binary=binary)
|
|
||||||
|
|
||||||
def __repr__(self):
|
|
||||||
return "%s(%r, binary=%r)" % (self.__class__.__name__,
|
|
||||||
self.addresses, self.binary)
|
|
||||||
|
|
||||||
def __str__(self):
|
|
||||||
addrs = ", ".join(map(str, self.addresses))
|
|
||||||
return "<%s for %s, binary=%r>" % (self.__class__.__name__,
|
|
||||||
addrs, self.binary)
|
|
||||||
|
|
||||||
def get_behaviors(self):
|
|
||||||
"""Gets the behaviors from the underlying C client instance.
|
|
||||||
|
|
||||||
Reverses the integer constants for `hash` and `distribution` into more
|
|
||||||
understandable string values. See *set_behaviors* for info.
|
|
||||||
"""
|
|
||||||
bvrs = super(Client, self).get_behaviors()
|
|
||||||
bvrs["hash"] = hashers_rvs[bvrs["hash"]]
|
|
||||||
bvrs["distribution"] = distributions_rvs[bvrs["distribution"]]
|
|
||||||
return BehaviorDict(self, bvrs)
|
|
||||||
|
|
||||||
def set_behaviors(self, behaviors):
|
|
||||||
"""Sets the behaviors on the underlying C client instance.
|
|
||||||
|
|
||||||
Takes care of morphing the `hash` key, if specified, into the
|
|
||||||
corresponding integer constant (which the C client expects.) If,
|
|
||||||
however, an unknown value is specified, it's passed on to the C client
|
|
||||||
(where it most surely will error out.)
|
|
||||||
|
|
||||||
This also happens for `distribution`.
|
|
||||||
"""
|
|
||||||
behaviors = behaviors.copy()
|
|
||||||
if behaviors.get("hash") is not None:
|
|
||||||
behaviors["hash"] = hashers[behaviors["hash"]]
|
|
||||||
if behaviors.get("ketama_hash") is not None:
|
|
||||||
behaviors["ketama_hash"] = hashers[behaviors["ketama_hash"]]
|
|
||||||
if behaviors.get("distribution") is not None:
|
|
||||||
behaviors["distribution"] = distributions[behaviors["distribution"]]
|
|
||||||
return super(Client, self).set_behaviors(behaviors)
|
|
||||||
|
|
||||||
behaviors = property(get_behaviors, set_behaviors)
|
|
||||||
@property
|
|
||||||
def behaviours(self):
|
|
||||||
raise AttributeError("nobody uses british spellings")
|
|
||||||
|
|
||||||
def clone(self):
|
|
||||||
obj = super(Client, self).clone()
|
|
||||||
obj.addresses = list(self.addresses)
|
|
||||||
obj.binary = self.binary
|
|
||||||
return obj
|
|
||||||
|
|
||||||
|
|
||||||
from contextlib import contextmanager
|
|
||||||
|
|
||||||
class ClientPool(Queue):
|
|
||||||
"""Client pooling helper.
|
|
||||||
|
|
||||||
This is mostly useful in threaded environments, because a client isn't
|
|
||||||
thread-safe at all. Instead, what you want to do is have each thread use
|
|
||||||
its own client, but you don't want to reconnect these all the time.
|
|
||||||
|
|
||||||
The solution is a pool, and this class is a helper for that.
|
|
||||||
|
|
||||||
>>> mc = Client(["127.0.0.1"])
|
|
||||||
>>> pool = ClientPool()
|
|
||||||
>>> pool.fill(mc, 4)
|
|
||||||
>>> with pool.reserve() as mc:
|
|
||||||
... mc.set("hi", "ho")
|
|
||||||
... mc.delete("hi")
|
|
||||||
...
|
|
||||||
True
|
|
||||||
True
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __init__(self, mc=None, n_slots=None):
|
|
||||||
Queue.__init__(self, n_slots)
|
|
||||||
if mc is not None:
|
|
||||||
self.fill(mc, n_slots)
|
|
||||||
|
|
||||||
@contextmanager
|
|
||||||
def reserve(self, timeout=None):
|
|
||||||
"""Context manager for reserving a client from the pool.
|
|
||||||
|
|
||||||
If *timeout* is given, it specifiecs how long to wait for a client to
|
|
||||||
become available.
|
|
||||||
"""
|
|
||||||
mc = self.get(True, timeout=timeout)
|
|
||||||
try:
|
|
||||||
yield mc
|
|
||||||
finally:
|
|
||||||
self.put(mc)
|
|
||||||
|
|
||||||
def fill(self, mc, n_slots):
|
|
||||||
"""Fill *n_slots* of the pool with clones of *mc*."""
|
|
||||||
for i in xrange(n_slots):
|
|
||||||
self.put(mc.clone())
|
|
||||||
|
|
||||||
class ThreadMappedPool(dict):
|
|
||||||
"""Much like the *ClientPool*, helps you with pooling.
|
|
||||||
|
|
||||||
In a threaded environment, you'd most likely want to have a client per
|
|
||||||
thread. And there'd be no harm in one thread keeping the same client at all
|
|
||||||
times. So, why not map threads to clients? That's what this class does.
|
|
||||||
|
|
||||||
If a client is reserved, this class checks for a key based on the current
|
|
||||||
thread, and if none exists, clones the master client and inserts that key.
|
|
||||||
|
|
||||||
>>> mc = Client(["127.0.0.1"])
|
|
||||||
>>> pool = ThreadMappedPool(mc)
|
|
||||||
>>> with pool.reserve() as mc:
|
|
||||||
... mc.set("hi", "ho")
|
|
||||||
... mc.delete("hi")
|
|
||||||
...
|
|
||||||
True
|
|
||||||
True
|
|
||||||
"""
|
|
||||||
|
|
||||||
def __new__(cls, master):
|
|
||||||
return super(ThreadMappedPool, cls).__new__(cls)
|
|
||||||
|
|
||||||
def __init__(self, master):
|
|
||||||
self.master = master
|
|
||||||
|
|
||||||
@contextmanager
|
|
||||||
def reserve(self):
|
|
||||||
"""Reserve a client.
|
|
||||||
|
|
||||||
Creates a new client based on the master client if none exists for the
|
|
||||||
current thread.
|
|
||||||
"""
|
|
||||||
key = thread.get_ident()
|
|
||||||
mc = self.pop(key, None)
|
|
||||||
if mc is None:
|
|
||||||
mc = self.master.clone()
|
|
||||||
try:
|
|
||||||
yield mc
|
|
||||||
finally:
|
|
||||||
self[key] = mc
|
|
||||||
|
|
||||||
# This makes sure ThreadMappedPool doesn't exist with non-thread Pythons.
|
|
||||||
try:
|
|
||||||
import thread
|
|
||||||
except ImportError:
|
|
||||||
del ThreadMappedPool
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
import sys
|
|
||||||
import code
|
|
||||||
|
|
||||||
svr_addrs = []
|
|
||||||
|
|
||||||
sys.stderr.write("pylibmc interactive shell\n\n")
|
|
||||||
sys.stderr.write("Input list of servers, end by a blank line\n")
|
|
||||||
|
|
||||||
binary = False
|
|
||||||
if sys.argv[1:] == ["--binary"]:
|
|
||||||
binary = True
|
|
||||||
|
|
||||||
while True:
|
|
||||||
in_addr = raw_input("Address: ")
|
|
||||||
if not in_addr:
|
|
||||||
break
|
|
||||||
if not svr_addrs:
|
|
||||||
svr_addrs.append("127.0.0.1")
|
|
||||||
|
|
||||||
mc = Client(svr_addrs, binary=binary)
|
|
||||||
code.interact(banner="\nmc client available as `mc`", local={"mc": mc})
|
|
||||||
73
pylibmc/__init__.py
Normal file
73
pylibmc/__init__.py
Normal file
@ -0,0 +1,73 @@
|
|||||||
|
"""Snappy libmemcached wrapper
|
||||||
|
|
||||||
|
pylibmc is a Python wrapper around TangentOrg's libmemcached library.
|
||||||
|
|
||||||
|
The interface is intentionally made as close to python-memcached as possible,
|
||||||
|
so that applications can drop-in replace it.
|
||||||
|
|
||||||
|
Example usage
|
||||||
|
=============
|
||||||
|
|
||||||
|
Create a connection and configure it::
|
||||||
|
|
||||||
|
>>> import pylibmc
|
||||||
|
>>> mc = pylibmc.Client(["127.0.0.1"], binary=True)
|
||||||
|
>>> mc.behaviors = {"tcp_nodelay": True, "ketama": True}
|
||||||
|
|
||||||
|
Basic operation::
|
||||||
|
|
||||||
|
>>> mc.set("some_key", "Some value")
|
||||||
|
True
|
||||||
|
>>> value = mc.get("some_key")
|
||||||
|
>>> value
|
||||||
|
'Some value'
|
||||||
|
>>> mc.set("another_key", 3)
|
||||||
|
True
|
||||||
|
>>> mc.delete("another_key")
|
||||||
|
True
|
||||||
|
>>> mc.set("key", "1") # str or int is fine
|
||||||
|
True
|
||||||
|
|
||||||
|
Atomic increments and decrements::
|
||||||
|
|
||||||
|
>>> mc.incr("key")
|
||||||
|
2L
|
||||||
|
>>> mc.decr("key")
|
||||||
|
1L
|
||||||
|
|
||||||
|
Batch operation::
|
||||||
|
|
||||||
|
>>> mc.get_multi(["key", "another_key"])
|
||||||
|
{'key': '1'}
|
||||||
|
>>> mc.set_multi({"cats": ["on acid", "furry"], "dogs": True})
|
||||||
|
[]
|
||||||
|
>>> mc.get_multi(["cats", "dogs"])
|
||||||
|
{'cats': ['on acid', 'furry'], 'dogs': True}
|
||||||
|
>>> mc.delete_multi(["cats", "dogs", "nonextant"])
|
||||||
|
False
|
||||||
|
>>> mc.add_multi({"cats": ["on acid", "furry"], "dogs": True})
|
||||||
|
[]
|
||||||
|
>>> mc.get_multi(["cats", "dogs"])
|
||||||
|
{'cats': ['on acid', 'furry'], 'dogs': True}
|
||||||
|
>>> mc.add_multi({"cats": "not set", "dogs": "definitely not set", "bacon": "yummy"})
|
||||||
|
['cats', 'dogs']
|
||||||
|
>>> mc.get_multi(["cats", "dogs", "bacon"])
|
||||||
|
{'cats': ['on acid', 'furry'], 'bacon': 'yummy', 'dogs': True}
|
||||||
|
>>> mc.delete_multi(["cats", "dogs", "bacon"])
|
||||||
|
True
|
||||||
|
|
||||||
|
Further Reading
|
||||||
|
===============
|
||||||
|
|
||||||
|
See http://sendapatch.se/projects/pylibmc/
|
||||||
|
"""
|
||||||
|
|
||||||
|
import _pylibmc
|
||||||
|
from .consts import hashers, distributions
|
||||||
|
from .client import Client
|
||||||
|
from .pools import ClientPool, ThreadMappedPool
|
||||||
|
|
||||||
|
support_compression = _pylibmc.support_compression
|
||||||
|
__version__ = _pylibmc.__version__
|
||||||
|
__all__ = ["hashers", "distributions", "Client",
|
||||||
|
"ClientPool", "ThreadMappedPool"]
|
||||||
48
pylibmc/__main__.py
Normal file
48
pylibmc/__main__.py
Normal file
@ -0,0 +1,48 @@
|
|||||||
|
"""Interactive shell"""
|
||||||
|
|
||||||
|
import sys
|
||||||
|
import code
|
||||||
|
import random
|
||||||
|
import pylibmc
|
||||||
|
|
||||||
|
tips = [
|
||||||
|
"Want to use 127.0.0.1? Just hit Enter immediately.",
|
||||||
|
"This was supposed to be a list of tips but I...",
|
||||||
|
"I don't really know what to write here.",
|
||||||
|
"Really, hit Enter immediately and you'll connect to 127.0.0.1.",
|
||||||
|
"Did you know there's a --binary flag? Try it!",
|
||||||
|
"Want to use binary mode? Pass --binary as a sole argument."
|
||||||
|
]
|
||||||
|
|
||||||
|
def print_header(outf=sys.stdout):
|
||||||
|
outf.write("pylibmc interactive shell\n\n")
|
||||||
|
outf.write("Input list of servers, terminating by a blank line.\n")
|
||||||
|
outf.write(random.choice(tips) + "\n")
|
||||||
|
|
||||||
|
def collect_servers():
|
||||||
|
in_addr = raw_input("Address [127.0.0.1]: ")
|
||||||
|
while in_addr:
|
||||||
|
in_addr = raw_input("Address [<stop>]: ")
|
||||||
|
if in_addr:
|
||||||
|
yield in_addr
|
||||||
|
else:
|
||||||
|
yield "127.0.0.1"
|
||||||
|
|
||||||
|
banner = ("\nmc client available as `mc`\n"
|
||||||
|
"memface available as mf")
|
||||||
|
def interact(servers, banner=banner, binary=False):
|
||||||
|
mc = pylibmc.Client(servers, binary=binary)
|
||||||
|
mf = pylibmc.Memface(servers, binary=binary)
|
||||||
|
local = {"pylibmc": pylibmc,
|
||||||
|
"mf": mf, "mc": mc}
|
||||||
|
code.interact(banner=banner, local=local)
|
||||||
|
|
||||||
|
def main():
|
||||||
|
binary = False
|
||||||
|
if sys.argv[1:] == ["--binary"]:
|
||||||
|
binary = True
|
||||||
|
print_header()
|
||||||
|
interact(list(collect_servers()), binary=binary)
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
90
pylibmc/client.py
Normal file
90
pylibmc/client.py
Normal file
@ -0,0 +1,90 @@
|
|||||||
|
"""Python-level wrapper client"""
|
||||||
|
|
||||||
|
import _pylibmc
|
||||||
|
from .consts import (hashers, distributions,
|
||||||
|
hashers_rvs, distributions_rvs,
|
||||||
|
BehaviorDict)
|
||||||
|
|
||||||
|
class Client(_pylibmc.client):
|
||||||
|
def __init__(self, servers, binary=False):
|
||||||
|
"""Initialize a memcached client instance.
|
||||||
|
|
||||||
|
This connects to the servers in *servers*, which will default to being
|
||||||
|
TCP servers. If it looks like a filesystem path, a UNIX socket. If
|
||||||
|
prefixed with `udp:`, a UDP connection.
|
||||||
|
|
||||||
|
If *binary* is True, the binary memcached protocol is used.
|
||||||
|
"""
|
||||||
|
self.binary = binary
|
||||||
|
self.addresses = list(servers)
|
||||||
|
addr_tups = []
|
||||||
|
for server in servers:
|
||||||
|
addr = server
|
||||||
|
port = 11211
|
||||||
|
if server.startswith("udp:"):
|
||||||
|
stype = _pylibmc.server_type_udp
|
||||||
|
addr = addr[4:]
|
||||||
|
if ":" in server:
|
||||||
|
(addr, port) = addr.split(":", 1)
|
||||||
|
port = int(port)
|
||||||
|
elif ":" in server:
|
||||||
|
stype = _pylibmc.server_type_tcp
|
||||||
|
(addr, port) = server.split(":", 1)
|
||||||
|
port = int(port)
|
||||||
|
elif "/" in server:
|
||||||
|
stype = _pylibmc.server_type_unix
|
||||||
|
port = 0
|
||||||
|
else:
|
||||||
|
stype = _pylibmc.server_type_tcp
|
||||||
|
addr_tups.append((stype, addr, port))
|
||||||
|
super(Client, self).__init__(servers=addr_tups, binary=binary)
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return "%s(%r, binary=%r)" % (self.__class__.__name__,
|
||||||
|
self.addresses, self.binary)
|
||||||
|
|
||||||
|
def __str__(self):
|
||||||
|
addrs = ", ".join(map(str, self.addresses))
|
||||||
|
return "<%s for %s, binary=%r>" % (self.__class__.__name__,
|
||||||
|
addrs, self.binary)
|
||||||
|
|
||||||
|
def get_behaviors(self):
|
||||||
|
"""Gets the behaviors from the underlying C client instance.
|
||||||
|
|
||||||
|
Reverses the integer constants for `hash` and `distribution` into more
|
||||||
|
understandable string values. See *set_behaviors* for info.
|
||||||
|
"""
|
||||||
|
bvrs = super(Client, self).get_behaviors()
|
||||||
|
bvrs["hash"] = hashers_rvs[bvrs["hash"]]
|
||||||
|
bvrs["distribution"] = distributions_rvs[bvrs["distribution"]]
|
||||||
|
return BehaviorDict(self, bvrs)
|
||||||
|
|
||||||
|
def set_behaviors(self, behaviors):
|
||||||
|
"""Sets the behaviors on the underlying C client instance.
|
||||||
|
|
||||||
|
Takes care of morphing the `hash` key, if specified, into the
|
||||||
|
corresponding integer constant (which the C client expects.) If,
|
||||||
|
however, an unknown value is specified, it's passed on to the C client
|
||||||
|
(where it most surely will error out.)
|
||||||
|
|
||||||
|
This also happens for `distribution`.
|
||||||
|
"""
|
||||||
|
behaviors = behaviors.copy()
|
||||||
|
if behaviors.get("hash") is not None:
|
||||||
|
behaviors["hash"] = hashers[behaviors["hash"]]
|
||||||
|
if behaviors.get("ketama_hash") is not None:
|
||||||
|
behaviors["ketama_hash"] = hashers[behaviors["ketama_hash"]]
|
||||||
|
if behaviors.get("distribution") is not None:
|
||||||
|
behaviors["distribution"] = distributions[behaviors["distribution"]]
|
||||||
|
return super(Client, self).set_behaviors(behaviors)
|
||||||
|
|
||||||
|
behaviors = property(get_behaviors, set_behaviors)
|
||||||
|
@property
|
||||||
|
def behaviours(self):
|
||||||
|
raise AttributeError("nobody uses british spellings")
|
||||||
|
|
||||||
|
def clone(self):
|
||||||
|
obj = super(Client, self).clone()
|
||||||
|
obj.addresses = list(self.addresses)
|
||||||
|
obj.binary = self.binary
|
||||||
|
return obj
|
||||||
40
pylibmc/consts.py
Normal file
40
pylibmc/consts.py
Normal file
@ -0,0 +1,40 @@
|
|||||||
|
"""Constants and functionality related to them"""
|
||||||
|
|
||||||
|
import _pylibmc
|
||||||
|
|
||||||
|
#: Mapping of
|
||||||
|
errors = tuple(e for (n, e) in _pylibmc.exceptions)
|
||||||
|
# *Cough* Uhm, not the prettiest of things but this unpacks all exception
|
||||||
|
# objects and sets them on the package module object currently constructed.
|
||||||
|
import sys
|
||||||
|
modpkg = sys.modules[__package__]
|
||||||
|
modself = sys.modules[__package__]
|
||||||
|
for name, exc in _pylibmc.exceptions:
|
||||||
|
setattr(modself, name, exc)
|
||||||
|
setattr(modpkg, name, exc)
|
||||||
|
|
||||||
|
hashers, hashers_rvs = {}, {}
|
||||||
|
distributions, distributions_rvs = {}, {}
|
||||||
|
# Not the prettiest way of doing things, but works well.
|
||||||
|
for name in dir(_pylibmc):
|
||||||
|
if name.startswith("hash_"):
|
||||||
|
key, value = name[5:], getattr(_pylibmc, name)
|
||||||
|
hashers[key] = value
|
||||||
|
hashers_rvs[value] = key
|
||||||
|
elif name.startswith("distribution_"):
|
||||||
|
key, value = name[13:].replace("_", " "), getattr(_pylibmc, name)
|
||||||
|
distributions[key] = value
|
||||||
|
distributions_rvs[value] = key
|
||||||
|
|
||||||
|
class BehaviorDict(dict):
|
||||||
|
def __init__(self, client, *args, **kwds):
|
||||||
|
super(BehaviorDict, self).__init__(*args, **kwds)
|
||||||
|
self.client = client
|
||||||
|
|
||||||
|
def __setitem__(self, name, value):
|
||||||
|
super(BehaviorDict, self).__setitem__(name, value)
|
||||||
|
self.client.set_behaviors({name: value})
|
||||||
|
|
||||||
|
def update(self, d):
|
||||||
|
super(BehaviorDict, self).update(d)
|
||||||
|
self.client.set_behaviors(d.copy())
|
||||||
97
pylibmc/pools.py
Normal file
97
pylibmc/pools.py
Normal file
@ -0,0 +1,97 @@
|
|||||||
|
"""Pooling"""
|
||||||
|
|
||||||
|
from __future__ import with_statement
|
||||||
|
|
||||||
|
from contextlib import contextmanager
|
||||||
|
from Queue import Queue
|
||||||
|
|
||||||
|
class ClientPool(Queue):
|
||||||
|
"""Client pooling helper.
|
||||||
|
|
||||||
|
This is mostly useful in threaded environments, because a client isn't
|
||||||
|
thread-safe at all. Instead, what you want to do is have each thread use
|
||||||
|
its own client, but you don't want to reconnect these all the time.
|
||||||
|
|
||||||
|
The solution is a pool, and this class is a helper for that.
|
||||||
|
|
||||||
|
>>> mc = Client(["127.0.0.1"])
|
||||||
|
>>> pool = ClientPool()
|
||||||
|
>>> pool.fill(mc, 4)
|
||||||
|
>>> with pool.reserve() as mc:
|
||||||
|
... mc.set("hi", "ho")
|
||||||
|
... mc.delete("hi")
|
||||||
|
...
|
||||||
|
True
|
||||||
|
True
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self, mc=None, n_slots=None):
|
||||||
|
Queue.__init__(self, n_slots)
|
||||||
|
if mc is not None:
|
||||||
|
self.fill(mc, n_slots)
|
||||||
|
|
||||||
|
@contextmanager
|
||||||
|
def reserve(self, timeout=None):
|
||||||
|
"""Context manager for reserving a client from the pool.
|
||||||
|
|
||||||
|
If *timeout* is given, it specifiecs how long to wait for a client to
|
||||||
|
become available.
|
||||||
|
"""
|
||||||
|
mc = self.get(True, timeout=timeout)
|
||||||
|
try:
|
||||||
|
yield mc
|
||||||
|
finally:
|
||||||
|
self.put(mc)
|
||||||
|
|
||||||
|
def fill(self, mc, n_slots):
|
||||||
|
"""Fill *n_slots* of the pool with clones of *mc*."""
|
||||||
|
for i in xrange(n_slots):
|
||||||
|
self.put(mc.clone())
|
||||||
|
|
||||||
|
class ThreadMappedPool(dict):
|
||||||
|
"""Much like the *ClientPool*, helps you with pooling.
|
||||||
|
|
||||||
|
In a threaded environment, you'd most likely want to have a client per
|
||||||
|
thread. And there'd be no harm in one thread keeping the same client at all
|
||||||
|
times. So, why not map threads to clients? That's what this class does.
|
||||||
|
|
||||||
|
If a client is reserved, this class checks for a key based on the current
|
||||||
|
thread, and if none exists, clones the master client and inserts that key.
|
||||||
|
|
||||||
|
>>> mc = Client(["127.0.0.1"])
|
||||||
|
>>> pool = ThreadMappedPool(mc)
|
||||||
|
>>> with pool.reserve() as mc:
|
||||||
|
... mc.set("hi", "ho")
|
||||||
|
... mc.delete("hi")
|
||||||
|
...
|
||||||
|
True
|
||||||
|
True
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __new__(cls, master):
|
||||||
|
return super(ThreadMappedPool, cls).__new__(cls)
|
||||||
|
|
||||||
|
def __init__(self, master):
|
||||||
|
self.master = master
|
||||||
|
|
||||||
|
@contextmanager
|
||||||
|
def reserve(self):
|
||||||
|
"""Reserve a client.
|
||||||
|
|
||||||
|
Creates a new client based on the master client if none exists for the
|
||||||
|
current thread.
|
||||||
|
"""
|
||||||
|
key = thread.get_ident()
|
||||||
|
mc = self.pop(key, None)
|
||||||
|
if mc is None:
|
||||||
|
mc = self.master.clone()
|
||||||
|
try:
|
||||||
|
yield mc
|
||||||
|
finally:
|
||||||
|
self[key] = mc
|
||||||
|
|
||||||
|
# This makes sure ThreadMappedPool doesn't exist with non-thread Pythons.
|
||||||
|
try:
|
||||||
|
import thread
|
||||||
|
except ImportError:
|
||||||
|
ThreadMappedPool = None
|
||||||
2
setup.py
2
setup.py
@ -74,4 +74,4 @@ setup(name="pylibmc", version=version,
|
|||||||
license="3-clause BSD <http://www.opensource.org/licenses/bsd-license.php>",
|
license="3-clause BSD <http://www.opensource.org/licenses/bsd-license.php>",
|
||||||
description="Quick and small memcached client for Python",
|
description="Quick and small memcached client for Python",
|
||||||
long_description=readme_text,
|
long_description=readme_text,
|
||||||
ext_modules=[pylibmc_ext], py_modules=["pylibmc"])
|
ext_modules=[pylibmc_ext], packages=["pylibmc"])
|
||||||
|
|||||||
Reference in New Issue
Block a user