def testFlushAll(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "31337")
self.assertEquals(c.get("key1")[0], "31337")
c.flush_all()
self.assertEquals(c.get("key1"), None)
def testStats(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
d = c.stats()
self.assertTrue(d.has_key("uptime"))
self.assertTrue(d.has_key("bytes"))
def testTupleRefCrashFix(self):
client = Client(MEMCACHED_ADDRESS)
for i in range(1000):
try:
client.connect()
except:
pass
def testStats(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
d = c.stats()
self.assertTrue (d.has_key("uptime"))
self.assertTrue (d.has_key("bytes"))
def testTupleRefCrashFix(self):
client = Client(MEMCACHED_ADDRESS)
for i in range(1000):
try:
client.connect()
except:
pass
def testVersion(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
v = c.version()
l = v.split('.')
self.assertEquals(3, len(l))
def testVersion(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
v = c.version()
l = v.split('.');
self.assertEquals(3, len(l))
def _create_connector(self):
if self.max_item_size is not None:
self._client = OriginalClient(self.address, self.max_item_size)
else:
self._client = OriginalClient(self.address)
self.funcs = [func for func in dir(self._client)
if not func.startswith('_')]
def _create_connector(self):
if self.max_item_size is not None:
self._client = OriginalClient(self.address, self.max_item_size)
else:
self._client = OriginalClient(self.address)
self.funcs = [func for func in dir(self._client)
if not func.startswith('_')]
def testCas(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key1", "a")
value, flags, cas = c.gets("key1")
self.assertEquals("STORED", c.cas("key1", "b", cas))
c.set("key1", "a")
self.assertEquals("EXISTS", c.cas("key1", "b", cas))
def testOversizedKey(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
data = "A" * (1000 * 1000 * 2)
try:
r = c.set("test", data)
assert False
except (RuntimeError):
pass
def testOversizedKey(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
data = "A" * (1000 * 1000 * 2)
try:
r = c.set("test", data)
assert False
except(RuntimeError):
pass
def testConnectFails(self):
c = Client("130.244.1.1:31337");
try:
c.connect();
assert False
except:
pass
c.disconnect();
pass
def testConnectDNSFails(self):
c = Client("flensost:12111");
try:
c.connect();
assert False
except:
pass
c.disconnect();
pass
def testFlushAll(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key1", "31337")
self.assertEquals(c.get("key1")[0], "31337")
c.flush_all()
self.assertEquals(c.get("key1"), None)
class Client(object):
"""On connection errors, tries to reconnect
"""
def __init__(self,
address,
max_item_size=None,
max_connect_retries=5,
reconnect_delay=.5):
self.address = address
self.max_item_size = max_item_size
self._client = None
self.funcs = []
self._create_client()
self.max_connect_retries = max_connect_retries
self.reconnect_delay = reconnect_delay
def _create_connector(self):
if self.max_item_size is not None:
self._client = OriginalClient(self.address, self.max_item_size)
else:
self._client = OriginalClient(self.address)
self.funcs = [
func for func in dir(self._client) if not func.startswith('_')
]
def _create_client(self):
reconnect = self._client is not None
if reconnect:
try:
self._client.close()
except Exception:
pass
self._create_connector()
if reconnect:
retries = 0
delay = self.reconnect_delay
while retries < self.max_connect_retries:
try:
return self._client.connect()
except socket.error, exc:
if exc.errno == EISCONN:
return # we're good
if exc.errno == EINVAL:
# we're doomed, retry
self._create_connector()
time.sleep(delay)
retries += 1
delay *= 2 # growing the delay
raise exc
def testDel(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "a")
c.delete("key1")
self.assertEquals(None, c.get("key1"))
pass
def testConnectFails(self):
c = Client("130.244.1.1:31337");
c.sock.settimeout(2)
try:
c.connect();
assert False
except:
pass
c.disconnect();
pass
def testPipelineDoesNotAllowReads(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.begin_pipeline()
self.assertRaises(MemcachedError, c.get, "foo")
self.assertRaises(MemcachedError, c.gets, "foo")
self.assertRaises(MemcachedError, c.get_multi, ["foo"])
self.assertRaises(MemcachedError, c.gets_multi, ["foo"])
self.assertRaises(MemcachedError, c.version)
self.assertRaises(MemcachedError, c.stats)
def testGets(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key", "value")
self.assertEquals("value", c.gets("key")[0])
self.assertEquals(None, c.gets("key23123"))
r = c.gets("key")
self.assertEquals(3, len(r))
pass
class Client(object):
"""On connection errors, tries to reconnect
"""
def __init__(self, address, max_item_size=None, max_connect_retries=5,
reconnect_delay=.5):
self.address = address
self.max_item_size = max_item_size
self._client = None
self.funcs = []
self._create_client()
self.max_connect_retries = max_connect_retries
self.reconnect_delay = reconnect_delay
def _create_connector(self):
if self.max_item_size is not None:
self._client = OriginalClient(self.address, self.max_item_size)
else:
self._client = OriginalClient(self.address)
self.funcs = [func for func in dir(self._client)
if not func.startswith('_')]
def _create_client(self):
reconnect = self._client is not None
if reconnect:
try:
self._client.close()
except Exception:
pass
self._create_connector()
if reconnect:
retries = 0
delay = self.reconnect_delay
while retries < self.max_connect_retries:
try:
self._client.connect()
except socket.error, exc:
if exc.errno == EISCONN:
return # we're good
if exc.errno == EINVAL:
# we're doomed, retry
self._create_connector()
time.sleep(delay)
retries += 1
delay *= 2 # growing the delay
raise exc
def testDel(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key1", "a")
c.delete("key1")
self.assertEquals(None, c.get("key1"))
pass
def testPrepend(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "a")
self.assertEquals("STORED", c.prepend("key1", "b"))
self.assertEquals("ba", c.get("key1")[0])
pass
def testGets(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key", "value")
self.assertEquals("value", c.gets("key")[0])
self.assertEquals(None, c.gets("key23123"))
r = c.gets("key")
self.assertEquals(3, len(r))
pass
def testConnectTwice(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.disconnect()
self.assertEquals(False, c.is_connected())
try:
c.connect()
assert False
except (RuntimeError):
pass
pass
def testPrepend(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key1", "a")
self.assertEquals("STORED", c.prepend("key1", "b"))
self.assertEquals("ba", c.get("key1")[0])
pass
def testGet_multi(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "value1")
c.set("key2", "value2")
c.set("key3", "value3")
r = c.get_multi(["key1", "key2", "key3", "key4"])
self.assertEquals(("value1", 0), r["key1"])
self.assertEquals(("value2", 0), r["key2"])
self.assertEquals(("value3", 0), r["key3"])
self.assertEquals(None, r.get("key4"))
pass
def testAppend(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "a")
self.assertEquals("STORED", c.append("key1", "b"))
self.assertEquals("ab", c.get("key1")[0])
pass
def testReplace(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "value1")
self.assertEquals("STORED", c.replace("key1", "value"))
pass
pass
def testReadOnly(self):
# make sure once a Client class is created
# host, port and sock are readonly
c = Client(MEMCACHED_ADDRESS)
self.assertEquals(c.host, MEMCACHED_HOST)
self.assertEquals(c.port, MEMCACHED_PORT)
self.assertTrue(isinstance(c.sock, socket.socket))
for attr in ('sock', 'host', 'port'):
self.assertRaises(TypeError, setattr, c, attr, 'booo')
def testConnectCloseQuery(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.disconnect()
try:
r = c.set("jonas", "kaka", 0, False)
assert False
except:
pass
def testConnectTwice(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.disconnect();
self.assertEquals(False, c.is_connected());
try:
c.connect();
assert False
except (RuntimeError):
pass
pass
def testBigDataFail(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
data = "31337" * 10000
for x in xrange(0, 10):
v = c.get("kaka" + str(x))
c.set(
"fsdafbdsakjfjdkfjadklsafdsafdsaffdsafdasfdsafdasfsdafdsafdsafasdas"
+ str(x), data, 604830, 17, True)
def testSockAccess(self):
# accessing the members before connect() is called
c = Client(MEMCACHED_ADDRESS)
self.assertEquals(c.host, MEMCACHED_HOST)
self.assertEquals(c.port, MEMCACHED_PORT)
self.assertTrue(isinstance(c.sock, socket.socket))
c.sock.settimeout(2)
c.connect()
c.set("key1", "31337")
self.assertEquals(c.get("key1")[0], "31337")
def testGet_multi(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key1", "value1")
c.set("key2", "value2")
c.set("key3", "value3")
r = c.get_multi(["key1", "key2", "key3", "key4"])
self.assertEquals(("value1", 0), r["key1"])
self.assertEquals(("value2", 0), r["key2"])
self.assertEquals(("value3", 0), r["key3"])
self.assertEquals(None, r.get("key4"))
pass
def testBigDataFail(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
data = "31337" * 10000
for x in xrange(0, 10):
v = c.get("kaka" + str(x))
c.set("fsdafbdsakjfjdkfjadklsafdsafdsaffdsafdasfdsafdasfsdafdsafdsafasdas" + str(x), data, 604830, 17, True)
def testReplace(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key1", "value1")
self.assertEquals("STORED", c.replace("key1", "value"))
pass
pass
def testConnectCloseQuery(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.disconnect();
try:
r = c.set("jonas", "kaka", 0, False)
assert False
except:
pass
def testConnectDNSFails(self):
c = Client("flensost:12111")
try:
c.connect()
assert False
except:
pass
c.disconnect()
pass
def testConnectFails(self):
c = Client("130.244.1.1:31337")
try:
c.connect()
assert False
except:
pass
c.disconnect()
pass
def testSockAccess(self):
# accessing the members before connect() is called
c = Client(MEMCACHED_ADDRESS)
self.assertEquals(c.host, MEMCACHED_HOST)
self.assertEquals(c.port, MEMCACHED_PORT)
self.assertTrue(isinstance(c.sock, socket.socket))
c.sock.settimeout(2)
c.connect()
c.set("key1", "31337")
self.assertEquals(c.get("key1")[0], "31337")
def testPipelineDoesNotAllowReads(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.begin_pipeline()
self.assertRaises(MemcachedError, c.get, "foo")
self.assertRaises(MemcachedError, c.gets, "foo")
self.assertRaises(MemcachedError, c.get_multi, ["foo"])
self.assertRaises(MemcachedError, c.gets_multi, ["foo"])
self.assertRaises(MemcachedError, c.version)
self.assertRaises(MemcachedError, c.stats)
def testRandomData(self):
def random_bytes(size):
return "".join(chr(random.randrange(0, 256)) for i in xrange(size))
def random_str(size):
return "".join(chr(random.randrange(33, 64)) for i in xrange(size))
c = Client(MEMCACHED_ADDRESS)
c.connect()
count = 0
for x in xrange(0, 10):
key = random_str(random.randrange(1, 33))
value = random_bytes(random.randrange(1, 5000))
c.set(key, value, 0, 0, True)
v2 = c.get(key)[0]
count += 1
if len(value) != len(v2):
print "%d %d != %d" % (count, len(value), len(v2))
def testRandomData(self):
def random_bytes(size):
return "".join(chr(random.randrange(0, 256)) for i in xrange(size))
def random_str(size):
return "".join(chr(random.randrange(33, 64)) for i in xrange(size))
c = Client(MEMCACHED_ADDRESS)
c.connect()
count = 0
for x in xrange(0, 10):
key = random_str(random.randrange(1, 33))
value = random_bytes(random.randrange(1, 5000))
c.set(key, value, 0, 0, True)
v2 = c.get(key)[0]
count += 1
if len(value) != len(v2):
print "%d %d != %d" % (count, len(value), len(v2))
def testAdd(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "value1")
self.assertEquals("NOT_STORED", c.add("key1", "value"))
pass
def testIncr(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key1", "0")
c.incr("key1", 313370)
self.assertEquals("313370", c.get("key1")[0])
def testMaxSize(self):
c = Client(MEMCACHED_ADDRESS, 1)
c.connect()
self.assertRaises(RuntimeError, c.set, 'key1', 'xx')
c.set("key1", "3")
self.assertEquals(c.get("key1")[0], "3")
def testIncrDecrString(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("test", "hej")
self.assertRaises(Exception, c.incr, "test", 1)
self.assertRaises(Exception, c.decr, "test", 5)
def testMaxSize(self):
c = Client(MEMCACHED_ADDRESS, 1)
c.connect()
self.assertRaises(RuntimeError, c.set, 'key1', 'xx')
c.set("key1", "3")
self.assertEquals(c.get("key1")[0], "3")
def testConnectDNSOK(self):
c = Client("localhost:11211")
c.connect()
c.disconnect()
pass
def testAdd(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key1", "value1")
self.assertEquals("NOT_STORED", c.add("key1", "value"))
pass
def testSet(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key", "my new value")
self.assertEquals("my new value", c.get("key")[0])
pass
def testSet(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key", "my new value")
self.assertEquals("my new value", c.get("key")[0])
pass
def testConnectDNSOK(self):
c = Client("localhost:11211");
c.connect();
c.disconnect();
pass
def testDecr(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "31337")
c.decr("key1", 31337)
self.assertEquals(0, long(c.get("key1")[0]))
def testIncr(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "0")
c.incr("key1", 313370)
self.assertEquals("313370", c.get("key1")[0])
def testCasGetsMulti(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "a")
c.set("key2", "a")
results = c.gets_multi(("key1", "key2"))
cas1 = results["key1"][2]
cas2 = results["key2"][2]
self.assertEquals("STORED", c.cas("key1", "b", cas1))
self.assertEquals("STORED", c.cas("key2", "b", cas2))
results = c.gets_multi(("key1", "key2"))
cas1 = results["key1"][2]
cas2 = results["key2"][2]
c.set("key1", "a")
self.assertEquals("EXISTS", c.cas("key1", "b", cas1))
self.assertEquals("STORED", c.cas("key2", "b", cas2))
def testCas(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("key1", "a")
value, flags, cas = c.gets("key1")
self.assertEquals("STORED", c.cas("key1", "b", cas))
c.set("key1", "a")
self.assertEquals("EXISTS", c.cas("key1", "b", cas))
def testIncrDecrString(self):
c = Client(MEMCACHED_ADDRESS)
c.connect()
c.set("test", "hej")
self.assertRaises(Exception, c.incr, "test", 1)
self.assertRaises(Exception, c.decr, "test", 5)
def testDecr(self):
c = Client(MEMCACHED_ADDRESS);
c.connect();
c.set("key1", "31337")
c.decr("key1", 31337)
self.assertEquals(0, long(c.get("key1")[0]))
