def testConnectionManager(self):
try:
cm = MemcacheConnectionManager()
protocol = MemcacheProtocol.create("text")
connections = []
def connector():
connections.append(cm.get_connection((MEMCACHE_IP, 11212), protocol))
Tasklet.new(connector)()
Tasklet.new(connector)()
Tasklet.new(connector)()
Tasklet.join_children()
Tasklet.new(connector)()
Tasklet.join_children()
self.assertEquals(4, len(connections))
self.assertEquals(1, len(cm._connections))
finally:
cm.close_all()
def testMultiClientMultiServer(self):
N = 40 * 100
keys = ['test%d' % i for i in range(N)]
mc = Memcache()
mc.set_servers([
((MEMCACHE_IP, 11211), 100), ((MEMCACHE_IP, 11212), 100),
((MEMCACHE_IP, 11213), 100), ((MEMCACHE_IP, 11214), 100)
])
with unittest.timer() as tmr:
for i in range(N):
self.assertEquals(MemcacheResult.STORED,
mc.set(keys[i], 'hello world %d' % i))
print 'single client multi server single set keys/sec', tmr.sec(N)
stride = 40
def fetcher():
for i in range(0, N, stride):
result, values = mc.get_multi(keys[i:i + stride])
self.assertEquals(MemcacheResult.OK, result)
self.assertEquals(stride, len(values))
for nr_clients in [2, 4, 8, 16]: #,32,64,128]:
with unittest.timer() as tmr:
for i in range(nr_clients):
Tasklet.new(fetcher)()
Tasklet.join_children()
print 'multi client (%d), multi server multi get (%d) keys/sec' % (
nr_clients, stride), tmr.sec(N * nr_clients)
def testMultiClientMultiServer(self):
N = 40 * 100
keys = ['test%d' % i for i in range(N)]
mc = Memcache()
mc.set_servers([((MEMCACHE_IP, 11212), 100),
((MEMCACHE_IP, 11213), 100),
((MEMCACHE_IP, 11214), 100),
((MEMCACHE_IP, 11215), 100)])
with unittest.timer() as tmr:
for i in range(N):
self.assertEquals(MemcacheResult.STORED, mc.set(keys[i], 'hello world %d' % i))
print 'single client multi server single set keys/sec', tmr.sec(N)
stride = 40
def fetcher():
for i in range(0, N, stride):
result, values = mc.get_multi(keys[i:i+stride])
self.assertEquals(MemcacheResult.OK, result)
self.assertEquals(stride, len(values))
for nr_clients in [2,4,8,16]:#,32,64,128]:
with unittest.timer() as tmr:
for i in range(nr_clients):
Tasklet.new(fetcher)()
Tasklet.join_children()
print 'multi client (%d), multi server multi get (%d) keys/sec' % (nr_clients, stride), tmr.sec(N * nr_clients)
def testConnectionManager(self):
try:
cm = MemcacheConnectionManager()
protocol = MemcacheProtocol.create("text")
connections = []
def connector():
connections.append(
cm.get_connection((MEMCACHE_IP, 11211), protocol))
Tasklet.new(connector)()
Tasklet.new(connector)()
Tasklet.new(connector)()
Tasklet.join_children()
Tasklet.new(connector)()
Tasklet.join_children()
self.assertEquals(4, len(connections))
self.assertEquals(1, len(cm._connections))
finally:
cm.close_all()
def testLock(self):
lock = Lock()
self.assertEquals(True, lock.acquire())
self.assertEquals(True, lock.is_locked())
self.assertEquals(None, lock.release())
xs = []
def t(x):
try:
with lock:
Tasklet.sleep(1.0)
xs.append(x)
return x
except TimeoutError:
pass
start = time.time()
for i in range(5):
Tasklet.new(t)(i)
join_result = Tasklet.join_children()
self.assertEquals(5, len(join_result))
self.assertEquals(10, sum(xs))
end = time.time()
self.assertAlmostEqual(5.0, end - start, places = 1)
def main():
options = parse_options()
options.dbargs = {'host': options.host,
'port': options.port,
'user': options.user,
'passwd': options.passwd,
'db': options.db}
if options.use_pool:
options.pool = Pool(client, options.dbargs, options.use_pool)
for i in range(options.sessions):
session = Session(options)
Tasklet.new(session.run)()
try:
query_count = options.query_count
start = time.time()
query_count_done = sum(Tasklet.join_children())
end = time.time()
print end - start, query_count_done, query_count_done / (end - start)
except Exception:
logging.exception("must be an error in one of the sessions")
quit()
def testJoinChildren(self):
def t():
return 1
for i in range(4):
Tasklet.new(t)()
self.assertEquals(4, len(Tasklet.current().children()))
result = Tasklet.join_children()
self.assertEquals([1, 1, 1, 1], result)
def testJoinChildren(self):
def t():
return 1
for i in range(4):
Tasklet.new(t)()
self.assertEquals(4, len(Tasklet.current().children()))
result = Tasklet.join_children()
self.assertEquals([1,1,1,1], result)
def testSemaphore(self):
sema = Semaphore(4)
self.assertEquals(True, sema.acquire())
self.assertEquals(3, sema.count)
self.assertEquals(True, sema.acquire())
self.assertEquals(2, sema.count)
self.assertEquals(True, sema.acquire())
self.assertEquals(1, sema.count)
self.assertEquals(True, sema.acquire())
self.assertEquals(0, sema.count)
self.assertEquals(False, sema.acquire(False))
self.assertEquals(0, sema.count)
self.assertEquals(None, sema.release())
self.assertEquals(1, sema.count)
self.assertEquals(None, sema.release())
self.assertEquals(2, sema.count)
self.assertEquals(None, sema.release())
self.assertEquals(3, sema.count)
self.assertEquals(None, sema.release())
self.assertEquals(4, sema.count)
self.assertEquals(None, sema.release())
self.assertEquals(5, sema.count) #possible to go beyond initial count... is this ok?
sema = Semaphore(4)
xs = []
def t(x):
try:
with sema:
Tasklet.sleep(1.0)
xs.append(x)
return x
except TimeoutError:
pass
start = time.time()
for i in range(8):
Tasklet.new(t)(i)
join_result = Tasklet.join_children()
self.assertEquals(8, len(join_result))
self.assertEquals(28, sum(xs))
end = time.time()
self.assertAlmostEqual(2.0, end - start, places = 1)
def testTimeout(self):
mc = Memcache()
mc.set_servers([((MEMCACHE_IP, 11212), 100)])
self.memcachedPause()
def clientTimeout():
with Timeout.push(0.5):
self.assertEquals(MemcacheResult.TIMEOUT,
mc.set('blaat', 'aap'))
def clientError():
with Timeout.push(0.5):
self.assertEquals(MemcacheResult.ERROR, mc.set('blaat', 'aap'))
# Send some requests
for i in xrange(0, 1000):
Tasklet.new(clientTimeout)()
Tasklet.join_children()
with Timeout.push(0.5):
self.assertEquals(MemcacheResult.TIMEOUT, mc.set('foo', 'bar'))
print 'done (timeout)'
self.memcachedResume()
self.assertEquals(mc.get('blaat'), 'aap')
self.assertEquals(mc.get('foo'), 'bar')
self.memcachedPause()
# Send some requests
for i in xrange(0, 1000):
Tasklet.new(clientTimeout)()
Tasklet.join_children()
self.memcachedKill()
# Send some requests expected
for i in xrange(0, 1000):
Tasklet.new(clientError)()
Tasklet.join_children()
self.memcachedRun()
self.assertEquals(MemcacheResult.STORED, mc.set("bar", "baz"))
self.assertEquals(None, mc.get("blaat"))
self.assertEquals(None, mc.get("foo"))
self.assertEquals("baz", mc.get("bar"))
def testTimeout(self):
mc = Memcache()
mc.set_servers([((MEMCACHE_IP, 11212), 100)])
self.memcachedPause()
def clientTimeout():
with Timeout.push(0.5):
self.assertEquals(MemcacheResult.TIMEOUT, mc.set('blaat', 'aap'))
def clientError():
with Timeout.push(0.5):
self.assertEquals(MemcacheResult.ERROR, mc.set('blaat', 'aap'))
# Send some requests
for i in xrange(0, 1000):
Tasklet.new(clientTimeout)()
Tasklet.join_children()
with Timeout.push(0.5):
self.assertEquals(MemcacheResult.TIMEOUT, mc.set('foo', 'bar'))
print 'done (timeout)'
self.memcachedResume()
self.assertEquals(mc.get('blaat'), 'aap')
self.assertEquals(mc.get('foo'), 'bar')
self.memcachedPause()
# Send some requests
for i in xrange(0, 1000):
Tasklet.new(clientTimeout)()
Tasklet.join_children()
self.memcachedKill()
# Send some requests expected
for i in xrange(0, 1000):
Tasklet.new(clientError)()
Tasklet.join_children()
self.memcachedRun()
self.assertEquals(MemcacheResult.STORED, mc.set("bar", "baz"))
self.assertEquals(None, mc.get("blaat"))
self.assertEquals(None, mc.get("foo"))
self.assertEquals("baz", mc.get("bar"))
def testRemote(self):
client_results = []
server_results = []
def server():
server_endpoint = None
try:
remote_server = RemoteServer()
server_endpoint = remote_server.serve(('localhost', 9081))
remote_server.register('testing123')
for msg, args, kwargs in Tasklet.receive():
if msg.match(MSG_SUM):
server_results.append('s')
msg.reply(sum(args))
elif msg.match(MSG_TEST):
server_results.append('t')
elif msg.match(MSG_QUIT):
server_results.append('q')
break
elif msg.match(MSG_SLEEP):
server_results.append('sl')
Tasklet.sleep(args[0])
msg.reply(True)
except Exception:
logging.exception("")
self.fail("")
finally:
if server_endpoint is not None:
server_endpoint.close()
def client():
try:
remote_client = RemoteClient()
remote_client.connect(('localhost', 9081))
remote_task = remote_client.lookup('testing123')
self.assertFalse(remote_task is None)
MSG_TEST.send(remote_task)(20, 30)
MSG_TEST.send(remote_task)(30, 40)
client_results.append(MSG_SUM.call(remote_task)(10, 20, 30))
client_results.append(MSG_SUM.call(remote_task)(10, 20, 30))
MSG_TEST.send(remote_task)(20, 30)
MSG_TEST.send(remote_task)(30, 40)
MSG_SLEEP.call(remote_task)(1)
try:
MSG_SLEEP.call(remote_task, timeout = 1)(2)
self.fail("expected timeout")
except TimeoutError:
pass #expected
MSG_QUIT.send(remote_task)()
Tasklet.sleep(2)
remote_client.close()
except Exception:
logging.exception("")
self.fail("")
server_task = Tasklet.new(server)()
client_task = Tasklet.new(client)()
Tasklet.join_children()
self.assertEquals([60,60], client_results)
self.assertEquals(['t', 't', 's', 's', 't', 't', 'sl', 'sl', 'q'], server_results)
def testRemote(self):
client_results = []
server_results = []
def server():
server_endpoint = None
try:
remote_server = RemoteServer()
server_endpoint = remote_server.serve(('localhost', 9081))
remote_server.register('testing123')
for msg, args, kwargs in Tasklet.receive():
if msg.match(MSG_SUM):
server_results.append('s')
msg.reply(sum(args))
elif msg.match(MSG_TEST):
server_results.append('t')
elif msg.match(MSG_QUIT):
server_results.append('q')
break
elif msg.match(MSG_SLEEP):
server_results.append('sl')
Tasklet.sleep(args[0])
msg.reply(True)
except Exception:
logging.exception("")
self.fail("")
finally:
if server_endpoint is not None:
server_endpoint.close()
def client():
try:
remote_client = RemoteClient()
remote_client.connect(('localhost', 9081))
remote_task = remote_client.lookup('testing123')
self.assertFalse(remote_task is None)
MSG_TEST.send(remote_task)(20, 30)
MSG_TEST.send(remote_task)(30, 40)
client_results.append(MSG_SUM.call(remote_task)(10, 20, 30))
client_results.append(MSG_SUM.call(remote_task)(10, 20, 30))
MSG_TEST.send(remote_task)(20, 30)
MSG_TEST.send(remote_task)(30, 40)
MSG_SLEEP.call(remote_task)(1)
try:
MSG_SLEEP.call(remote_task, timeout = 1)(2)
self.fail("expected timeout")
except TimeoutError:
pass #expected
MSG_QUIT.send(remote_task)()
Tasklet.sleep(2)
remote_client.close()
except Exception:
logging.exception("")
self.fail("")
server_task = Tasklet.new(server)()
client_task = Tasklet.new(client)()
Tasklet.join_children()
self.assertEquals([60,60], client_results)
self.assertEquals(['t', 't', 's', 's', 't', 't', 'sl', 'sl', 'q'], server_results)
