def testMaxAge(self):
pool = Pool(client,
DB_ARGS,
max_connections=2,
connect_timeout=2,
max_connection_age=2,
max_connection_age_reaper_interval=1)
new, cnn1 = pool.connect()
new, cnn2 = pool.connect()
pool.disconnect(cnn1)
self.assertTrue(cnn1.is_connected())
self.assertTrue(cnn2.is_connected())
Tasklet.sleep(3)
#cnn1 was idle, should be disconnected now by old age reaper
self.assertFalse(cnn1.is_connected())
self.assertTrue(cnn2.is_connected())
pool.disconnect(cnn2)
#cnn2 should be closed on old age
self.assertFalse(cnn1.is_connected())
self.assertFalse(cnn2.is_connected())
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("")
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 main():
try:
dispatcher = Dispatcher()
host = Host(dispatcher, "/dev/ttyUSB0")
dispatcher.add_host(host)
Tasklet.new(dispatcher.loop)()
print "Calibration: %s" % host.calibrate_baudrate()
print "Available: %s" % host.available()
dev = RadioDevice(dispatcher, 2)
print "Protocol version: %s" % dev.protocol_version
# Running HTTP server
application = django.core.handlers.wsgi.WSGIHandler()
def app_wrapper(*args, **kwargs):
try:
return application(*args, **kwargs)
except Exception as e:
print e
server = WSGIServer(application)
server.serve(('localhost', 8080))
while True:
print "ADC data: %s, supply voltage: %.2f" % (dev.adc_data(), dev.supply_voltage())
Tasklet.sleep(1)
os._exit(0)
except Exception as e:
logging.exception(e)
os._exit(1)
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 callback(socket, count, event, args, kwargs):
print count, event, Tasklet.current()
if (count, event) == (1, "write"):
pass
elif (count, event) == (2, "read"):
Tasklet.sleep(1.0)
return "OK\r\n"
def accept_iter(self):
while True:
try:
yield self.accept()
except Exception:
self.log.exception("in accept_iter")
Tasklet.sleep(1.0) #prevent hogging
def testPushPop(self):
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places=1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places=1)
Tasklet.sleep(1.0)
self.assertAlmostEqual(29, Timeout.current(), places=1)
#push a temporary short timeout
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places=1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places=1)
#try to push a new longer timeout than the parent timeout
#this should fail, e.g. it will keep the parent timeout
Timeout.push(60)
self.assertAlmostEqual(29, Timeout.current(), places=1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places=1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
def accept_iter(self):
while True:
try:
yield self.accept()
except Exception:
self.log.exception("in accept_iter")
Tasklet.sleep(1.0) #prevent hogging
def callback(socket, count, event, args, kwargs):
print count, event, Tasklet.current()
if (count, event) == (1, "write"):
pass
elif (count, event) == (2, "read"):
Tasklet.sleep(1.0)
return "OK\r\n"
def query_services(self, service_type, url, timeout=10, call_int=False, delay=0, *args, **kwargs):
inst = self.app().inst
daemons = inst.int_app.obj(DBCluster, "daemons", silent=True)
tasklets = []
for dmnid, dmninfo in daemons.data.items():
services = dmninfo.get("services", {})
for svcid, svcinfo in services.items():
if svcinfo.get("type") != service_type:
continue
if call_int:
found = False
for sid, sinfo in services.items():
if sinfo.get("type") != "int":
continue
found = True
svcid = sid
svcinfo = sinfo
break
if not found:
continue
if "addr" not in svcinfo:
continue
if "port" not in svcinfo:
continue
task = Tasklet.new(self.do_query_service_exc)
tasklets.append(task)
task(svcid, svcinfo, url, timeout, *args, **kwargs)
if delay > 0:
Tasklet.sleep(delay)
Tasklet.join_all(tasklets)
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("")
def testPushPop(self):
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places = 1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places = 1)
Tasklet.sleep(1.0)
self.assertAlmostEqual(29, Timeout.current(), places = 1)
#push a temporary short timeout
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places = 1)
#try to push a new longer timeout than the parent timeout
#this should fail, e.g. it will keep the parent timeout
Timeout.push(60)
self.assertAlmostEqual(29, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places = 1)
Timeout.pop()
self.assertEquals(TIMEOUT_NEVER, Timeout.current())
def a():
while True:
#for i in xrange(0, 3):
# try:
# print "Line %d ReadROM: %s" % (i + 1, dispatcher.request(MicroLANReadROM(i)))
# except MicroLANError as e:
# print "Line %d ReadROM: %s" % (i + 1, type(e).__name__)
devs = {}
for i in xrange(0, 3):
try:
req = MicroLANListAll(dispatcher, i)
devices = req.execute()
except MicroLANError as e:
print "Line %d SearchROM: %s" % (i + 1, type(e).__name__)
else:
#print "Line %d SearchROM: %s" % (i + 1, devices)
if devices:
try:
dispatcher.request(MicroLANConvertTemperature(i))
except MicroLANError as e:
print "Line %d ConvertTemperature: %s" % (i + 1, type(e).__name__)
else:
devs[i] = devices
Tasklet.sleep(1)
print "---"
for i in xrange(0, 3):
devices = devs.get(i)
if devices:
print "Line %d" % (i + 1)
for dev in devices:
try:
print "ReadTemperature of %s: %.1f" % (dev, dispatcher.request(MicroLANReadTemperature(i, dev)))
except MicroLANError as e:
print "ReadTemperature of %s: %s" % (dev, type(e).__name__)
Tasklet.sleep(2)
def ping(self):
while True:
if self._calibrated:
pkt = [0xf2]
for i in xrange(0, 8):
pkt.append(random.randint(0, 255))
self.send(pkt)
Tasklet.sleep(7)
def ping(self):
while True:
if self._calibrated:
pkt = [0xf2]
for i in xrange(0, 8):
pkt.append(random.randint(0, 255))
self.send(pkt)
Tasklet.sleep(7)
def t(x):
try:
with sema:
Tasklet.sleep(1.0)
xs.append(x)
return x
except TimeoutError:
pass
def tearDown(self):
MemcacheConnectionManager.create("default").close_all()
cmd = 'killall %s' % MEMCACHED_BIN
self.log.debug(cmd)
os.system(cmd)
Tasklet.sleep(1.0) #should be enough for memcached to go down
def tearDown(self):
MemcacheConnectionManager.create("default").close_all()
cmd = 'killall %s' % MEMCACHED_BIN
self.log.debug(cmd)
os.system(cmd)
Tasklet.sleep(1.0) #should be enough for memcached to go down
def sendall(self, data, flags=0):
# WARNING: this will busy wait until all data is sent
# It should be possible to do away with the busy wait with
# the use of a channel.
self.sendBuffer += data
while self.sendBuffer:
Tasklet.sleep(0.01)
return len(data)
def c():
for msg, args, kwargs in Tasklet.receive():
if msg.match(MSG_TEST_SUM):
msg.reply(sum(args))
elif msg.match(MSG_TEST_MAX):
msg.reply(max(args))
elif msg.match(MSG_TEST_SLEEP):
Tasklet.sleep(args[0])
msg.reply(True)
def c():
for msg, args, kwargs in Tasklet.receive():
if msg.match(MSG_TEST_SUM):
msg.reply(sum(args))
elif msg.match(MSG_TEST_MAX):
msg.reply(max(args))
elif msg.match(MSG_TEST_SLEEP):
Tasklet.sleep(args[0])
msg.reply(True)
def memcachedRun(self):
self.log.debug("using memcached daemon: %s", MEMCACHED_BIN)
for i in range(4):
cmd = '%s -m 10 -p %d -u nobody -l 127.0.0.1&' % (MEMCACHED_BIN, 11212 + i)
self.log.debug(cmd)
os.system(cmd)
Tasklet.sleep(1.0) #should be enough for memcached to get up and running
def ManageSockets():
global managerRunning
while len(asyncore.socket_map):
# Check the sockets for activity.
asyncore.poll(0.05)
# Yield to give other tasklets a chance to be scheduled.
Tasklet.sleep(0.01)
managerRunning = False
def testBlock2(self):
d = Deque()
Tasklet.later(0.5, d.append)(10)
Tasklet.later(1.0, d.append)(20)
Tasklet.sleep(1.5)
s = time.time()
#should not block
self.assertEquals(20, d.pop(True))
self.assertEquals(10, d.pop(True))
e = time.time()
self.assertAlmostEqual(0.0, (e - s), places = 1)
def setUp(self):
self.log.debug("using memcached daemon: %s", MEMCACHED_BIN)
for i in range(4):
cmd = '%s -m 10 -p %d -u nobody -l 127.0.0.1&' % (MEMCACHED_BIN,
11211 + i)
self.log.debug(cmd)
os.system(cmd)
Tasklet.sleep(
1.0) #should be enough for memcached to get up and running
def __enter__(self):
if self.mc is None:
return
start = None
while True:
locked = []
try:
success = True
badlock = None
for key in self.keys:
if self.mc.add(key, self.value,
self.ttl) != MemcacheResult.NOT_STORED:
locked.append(key)
else:
for k in locked:
self.mc.delete(k)
success = False
badlock = (key, self.mc.get(key))
break
if success:
if DEBUG:
logging.getLogger(
"mg.core.memcached.MemcachedLock").debug(
"[%s] Locked keys %s", self.value, locked)
self.locked = time.time()
self.onlocked()
return
Tasklet.sleep(self.delay)
if start is None:
start = time.time()
elif time.time() > start + self.patience:
logging.getLogger("mg.core.memcached.MemcachedLock").error(
"[%s] Timeout waiting lock %s (locked by %s)",
self.value, badlock[0], badlock[1])
logging.getLogger("mg.core.memcached.MemcachedLock").error(
traceback.format_stack())
for key in self.keys:
self.mc.set(key, self.value, self.ttl)
logging.getLogger(
"mg.core.memcached.MemcachedLock").warning(
"[%s] Locked keys %s because of timeout",
self.value, locked)
self.locked = time.time()
self.onlocked()
return
except Exception:
logging.getLogger("mg.core.memcached.MemcachedLock").error(
"[%s] Exception during locking. Unlock everything immediately",
self.value)
for k in locked:
self.mc.delete(k)
raise
def run_daemon_loop(self):
inst = self.app().inst
next_update = self.now()
while True:
try:
if self.now() >= next_update:
next_update = self.now(10)
with self.cluster_lock:
self.store_daemon()
self.call("core.fastidle")
except Exception as e:
self.exception(e)
Tasklet.sleep(1)
def main():
try:
setupLogging()
server = WSGIServer(app_wrapper)
addr = conf('web', 'addr', '0.0.0.0')
port = confInt('web', 'port', 8080)
server.serve((addr, port))
logging.getLogger("hautowebsrv").info("Serving HTTP at %s:%s", addr, port)
while True:
Tasklet.sleep(1)
except Exception as e:
logging.exception(e)
os._exit(1)
def getter():
while len(clients) < N:
Tasklet.sleep(1.0)
while True:
#get
with timer() as tmr:
bts = 0
for i in range(B):
#print i
stream = random.choice(clients)
bts += get(stream, 'fooblaatpiet%d' % random.randint(0, KN))
print 'getter', tmr.sec(B), '/sec', tmr.sec(bts / 1024.0 / 1024.0), 'Mb/sec'
Tasklet.sleep(1.0)
def run_daemon_loop(self):
inst = self.app().inst
next_update = self.now()
while True:
try:
if self.now() >= next_update:
next_update = self.now(10)
with self.cluster_lock:
self.store_daemon()
self.call("core.fastidle")
except Exception as e:
self.exception(e)
Tasklet.sleep(1)
def main():
try:
setupLogging()
server = WSGIServer(app_wrapper)
addr = conf('web', 'addr', '0.0.0.0')
port = confInt('web', 'port', 8080)
server.serve((addr, port))
logging.getLogger("hautowebsrv").info("Serving HTTP at %s:%s", addr,
port)
while True:
Tasklet.sleep(1)
except Exception as e:
logging.exception(e)
os._exit(1)
def getter():
while len(clients) < N:
Tasklet.sleep(1.0)
while True:
#get
with timer() as tmr:
bts = 0
for i in range(B):
#print i
stream = random.choice(clients)
bts += get(stream, 'fooblaatpiet%d' % random.randint(0, KN))
print 'getter', tmr.sec(B), '/sec', tmr.sec(bts / 1024.0 /
1024.0), 'Mb/sec'
Tasklet.sleep(1.0)
def dispense(self):
if self.options.count == -1:
#run forever
while True:
self.dispenser.send(True)
if self.options.delay > 0.0:
Tasklet.sleep(self.options.delay)
else:
#a fixed number of total requests
for i in range(self.options.count):
self.dispenser.send(True)
if self.options.delay > 0.0:
Tasklet.sleep(self.options.delay)
for i in range(self.options.sessions):
self.dispenser.send(None)
def testDeferredQueue(self):
d = DeferredQueue()
def f(i):
pass
for i in range(10):
d.defer(f, i)
Tasklet.sleep(1)
for i in range(10):
d.defer(f, i)
Tasklet.sleep(1)
def __init__(self,
app,
combat_id,
fqn="mg.mmorpg.combats.daemons.CombatInterface"):
mg.constructor.ConstructorModule.__init__(self, app, fqn)
# access RunningCombat object
if not re_valid_uuid.match(combat_id):
raise CombatUnavailable(self._("Invalid combat idenfifier"))
self.combat_id = combat_id
try:
cobj = self.obj(DBRunningCombat, combat_id)
except mg.ObjectNotFoundException:
raise CombatUnavailable(self._("Combat not found"))
self.cobj = cobj
try:
# restart combat if needed
attempts = 3
while not cobj.get("host"):
# wait for combat to run
if cobj.get("started") > self.now(-10):
Tasklet.sleep(1)
try:
cobj.load()
except mg.ObjectNotFoundException:
raise CombatUnavailable(self._("Combat disappeared"))
continue
# restart failed combat
attempts -= 1
if attempts < 0:
raise CombatUnavailable(
self._("Failed to start combat server"))
with self.lock(["Combat-%s" % combat_id]):
try:
cobj.load()
except mg.ObjectNotFoundException:
raise CombatUnavailable(self._("Combat disappeared"))
if not cobj.get("host"):
self.debug("Relaunching combat %s", cobj.uuid)
self.call("combat-run.daemon", cobj)
# find connection
self.api_host = cobj.get("host")
self.api_port = cobj.get("port")
#self.debug("Remote combat API URI: %s:%s", self.api_host, self.api_port)
except CombatUnavailable as e:
self.cancel_combat(e)
raise
def try_getresponse(cnn, times=1, sleep_time_dict=sleep_time_dict):
"""
async https request need read response multiple times until timeout.
"""
# must sleep, or throw exception:
# _ssl.c:1354: The operation did not complete
try:
response = cnn.getresponse()
except SSLError:
sleep_time = sleep_time_dict.get(times, None)
if sleep_time is None:
assert False, 'request timeout'
Tasklet.sleep(sleep_time)
response = try_getresponse(cnn, times=times + 1)
except:
raise
return response
def testStatisticExtra(self):
timer = StatisticExtra(g = 0.1) #low g for fast convergence
for i in range(10):
with timer.time():
Tasklet.sleep(0.1)
self.assertEquals(10, timer.count)
self.assertAlmostEqual(0.1, timer.avg, places = 1)
timer = StatisticExtra(g = 0.1) #low g for fast convergence
for i in range(11):
with timer.time():
Tasklet.sleep(0.2)
self.assertEquals(11, timer.count)
self.assertAlmostEqual(0.2, timer.avg, places = 1)
def server():
"""accepts connections on a socket, and dispatches
new tasks for handling the incoming requests"""
#parent process opens socket and listens:
server_socket = Socket.server(('localhost', HTTP_PORT), backlog=2048)
#fork some worker processes
for i in range(HTTP_WORKERS):
pid = os.fork()
if pid == 0:
#i am a worker, accept and handle connections
try:
for client_socket in server_socket.accept_iter():
Tasklet.defer(handle, client_socket)
finally:
return
#i am the parent
while True:
Tasklet.sleep(1.0)
def testStatisticExtra(self):
timer = StatisticExtra(g=0.1) #low g for fast convergence
for i in range(10):
with timer.time():
Tasklet.sleep(0.1)
self.assertEquals(10, timer.count)
self.assertAlmostEqual(0.1, timer.avg, places=1)
timer = StatisticExtra(g=0.1) #low g for fast convergence
for i in range(11):
with timer.time():
Tasklet.sleep(0.2)
self.assertEquals(11, timer.count)
self.assertAlmostEqual(0.2, timer.avg, places=1)
def testTimeout(self):
mc = Memcache()
mc.set_servers([((MEMCACHE_IP, 11211), 100)])
def callback(socket, count, event, args, kwargs):
print count, event, Tasklet.current()
if (count, event) == (1, "write"):
pass
elif (count, event) == (2, "read"):
Tasklet.sleep(1.0)
return "OK\r\n"
unittest.TestSocket.install((MEMCACHE_IP, 11211), callback)
with Timeout.push(0.5):
self.assertEquals(MemcacheResult.TIMEOUT, mc.set('blaat', 'aap'))
print 'done (timeout)'
Tasklet.sleep(4.0)
def testTimeout(self):
mc = Memcache()
mc.set_servers([((MEMCACHE_IP, 11211), 100)])
def callback(socket, count, event, args, kwargs):
print count, event, Tasklet.current()
if (count, event) == (1, "write"):
pass
elif (count, event) == (2, "read"):
Tasklet.sleep(1.0)
return "OK\r\n"
unittest.TestSocket.install((MEMCACHE_IP, 11211), callback)
with Timeout.push(0.5):
self.assertEquals(MemcacheResult.TIMEOUT, mc.set('blaat', 'aap'))
print 'done (timeout)'
Tasklet.sleep(4.0)
def a():
while True:
#for i in xrange(0, 3):
# try:
# print "Line %d ReadROM: %s" % (i + 1, dispatcher.request(MicroLANReadROM(i)))
# except MicroLANError as e:
# print "Line %d ReadROM: %s" % (i + 1, type(e).__name__)
devs = {}
for i in xrange(0, 3):
try:
req = MicroLANListAll(dispatcher, i)
devices = req.execute()
except MicroLANError as e:
print "Line %d SearchROM: %s" % (i + 1,
type(e).__name__)
else:
#print "Line %d SearchROM: %s" % (i + 1, devices)
if devices:
try:
dispatcher.request(
MicroLANConvertTemperature(i))
except MicroLANError as e:
print "Line %d ConvertTemperature: %s" % (
i + 1, type(e).__name__)
else:
devs[i] = devices
Tasklet.sleep(1)
print "---"
for i in xrange(0, 3):
devices = devs.get(i)
if devices:
print "Line %d" % (i + 1)
for dev in devices:
try:
print "ReadTemperature of %s: %.1f" % (
dev,
dispatcher.request(
MicroLANReadTemperature(i, dev)))
except MicroLANError as e:
print "ReadTemperature of %s: %s" % (
dev, type(e).__name__)
Tasklet.sleep(2)
def __init__(self, app, combat_id, fqn="mg.mmorpg.combats.daemons.CombatInterface"):
mg.constructor.ConstructorModule.__init__(self, app, fqn)
# access RunningCombat object
if not re_valid_uuid.match(combat_id):
raise CombatUnavailable(self._("Invalid combat idenfifier"))
self.combat_id = combat_id
try:
cobj = self.obj(DBRunningCombat, combat_id)
except mg.ObjectNotFoundException:
raise CombatUnavailable(self._("Combat not found"))
self.cobj = cobj
try:
# restart combat if needed
attempts = 3
while not cobj.get("host"):
# wait for combat to run
if cobj.get("started") > self.now(-10):
Tasklet.sleep(1)
try:
cobj.load()
except mg.ObjectNotFoundException:
raise CombatUnavailable(self._("Combat disappeared"))
continue
# restart failed combat
attempts -= 1
if attempts < 0:
raise CombatUnavailable(self._("Failed to start combat server"))
with self.lock(["Combat-%s" % combat_id]):
try:
cobj.load()
except mg.ObjectNotFoundException:
raise CombatUnavailable(self._("Combat disappeared"))
if not cobj.get("host"):
self.debug("Relaunching combat %s", cobj.uuid)
self.call("combat-run.daemon", cobj)
# find connection
self.api_host = cobj.get("host")
self.api_port = cobj.get("port")
#self.debug("Remote combat API URI: %s:%s", self.api_host, self.api_port)
except CombatUnavailable as e:
self.cancel_combat(e)
raise
def testHasSender(self):
test_channel = Channel()
def sender():
test_channel.send(True)
self.assertEquals(False, test_channel.has_sender())
r = Tasklet.new(sender)()
Tasklet.sleep(1.0)
self.assertEquals(True, test_channel.has_sender())
r.kill()
Tasklet.sleep(1.0)
self.assertEquals(False, test_channel.has_sender())
def testTree(self):
def child(prefix, level, i):
if level < 2:
for j in range(2):
name = prefix + str(j)
Tasklet.new(child, name = name)(name, level + 1, j)
Tasklet.sleep(2)
Tasklet.new(child, 'child')('child', 0, 0)
Tasklet.sleep(1)
#for task, level in Tasklet.current().tree():
# print '\t' * level, task.name, level
flattened = set([(task.name, level) for (task, level) in Tasklet.current().tree()][1:])
self.assertEquals(set([('child', 1), ('child0', 2), ('child00', 3), ('child01', 3),
('child1', 2), ('child10', 3), ('child11', 3)]), flattened)
def testHasReceiver(self):
test_channel = Channel()
def receiver():
test_channel.receive()
self.assertEquals(False, test_channel.has_receiver())
r = Tasklet.new(receiver)()
Tasklet.sleep(1.0)
self.assertEquals(True, test_channel.has_receiver())
r.kill()
Tasklet.sleep(1.0)
self.assertEquals(False, test_channel.has_receiver())
def testTree(self):
def child(prefix, level, i):
if level < 2:
for j in range(2):
name = prefix + str(j)
Tasklet.new(child, name = name)(name, level + 1, j)
Tasklet.sleep(2)
Tasklet.new(child, 'child')('child', 0, 0)
Tasklet.sleep(1)
#for task, level in Tasklet.current().tree():
# print '\t' * level, task.name, level
flattened = set([(task.name, level) for (task, level) in Tasklet.current().tree()][1:])
self.assertEquals(set([('child', 1), ('child0', 2), ('child00', 3), ('child01', 3),
('child1', 2), ('child10', 3), ('child11', 3)]), flattened)
def testHasSender(self):
test_channel = Channel()
def sender():
test_channel.send(True)
self.assertEquals(False, test_channel.has_sender())
r = Tasklet.new(sender)()
Tasklet.sleep(1.0)
self.assertEquals(True, test_channel.has_sender())
r.kill()
Tasklet.sleep(1.0)
self.assertEquals(False, test_channel.has_sender())
def xtestIdleDisconnect(self):
pool = Pool(client, DB_ARGS, max_connections=2, connect_timeout=2)
def qry():
new, cnn = pool.connect()
rs = cnn.query("SELECT 1")
l = list(rs)
rs.close()
self.assertEquals([('1', )], l)
#return it so it becomes idle
closed = pool.disconnect(cnn)
self.assertFalse(closed)
self.assertEquals(1, pool.idle_connection_count)
qry()
Tasklet.sleep(20)
qry()
def testHasReceiver(self):
test_channel = Channel()
def receiver():
test_channel.receive()
self.assertEquals(False, test_channel.has_receiver())
r = Tasklet.new(receiver)()
Tasklet.sleep(1.0)
self.assertEquals(True, test_channel.has_receiver())
r.kill()
Tasklet.sleep(1.0)
self.assertEquals(False, test_channel.has_receiver())
def xtestIdleDisconnect(self):
pool = Pool(client, DB_ARGS, max_connections = 2, connect_timeout = 2)
def qry():
new, cnn = pool.connect()
rs = cnn.query("SELECT 1")
l = list(rs)
rs.close()
self.assertEquals([('1',)], l)
#return it so it becomes idle
closed = pool.disconnect(cnn)
self.assertFalse(closed)
self.assertEquals(1, pool.idle_connection_count)
qry()
Tasklet.sleep(20)
qry()
def error(self, exc=None, delay_on_error=0.1):
"Notify Pool that currently selected connection is bad"
if exc is None:
if delay_on_error > 0:
Tasklet.sleep(delay_on_error)
conn = self.new_connection()
self.cput(conn)
return
while True:
bad_host = self.hosts.pop(0)
self.hosts.append(bad_host)
self.close_all()
self.debug("MySQL server %s failed: %s. Trying %s", bad_host, exc, self.hosts[0])
Tasklet.sleep(1)
try:
self.success_counter = 0
conn = self.new_connection()
self.cput(conn)
return
except Exception as e:
exc = e
def setter():
while len(clients) < N:
Tasklet.sleep(1.0)
avg_bts_sec = 0.0
avg_b_sec = 0.0
while True:
#set
with timer() as tmr:
bts = 0
for i in range(B):
stream = random.choice(clients)
n = random.randint(0, KV)
bts += n
set(stream, 'fooblaatpiet%d' % random.randint(0, KN), 'b' * n)
bts_sec = tmr.sec(bts)
#print avg_bts_sec, bts_sec
avg_bts_sec = gamma_filter(avg_bts_sec, bts_sec, 0.90)
#print avg_bts_sec, bts_sec
b_sec = tmr.sec(B)
avg_b_sec = gamma_filter(avg_b_sec, b_sec, 0.90)
print 'setter', b_sec, '/sec', avg_b_sec, '/sec', bts_sec / 1024.0 / 1024.0, 'Mb/sec', avg_bts_sec / 1024.0 / 1024.0, 'Mb/sec'
Tasklet.sleep(1.0)
def setter():
while len(clients) < N:
Tasklet.sleep(1.0)
avg_bts_sec = 0.0
avg_b_sec = 0.0
while True:
#set
with timer() as tmr:
bts = 0
for i in range(B):
stream = random.choice(clients)
n = random.randint(0, KV)
bts += n
set(stream, 'fooblaatpiet%d' % random.randint(0, KN), 'b' * n)
bts_sec = tmr.sec(bts)
#print avg_bts_sec, bts_sec
avg_bts_sec = gamma_filter(avg_bts_sec, bts_sec, 0.90)
#print avg_bts_sec, bts_sec
b_sec = tmr.sec(B)
avg_b_sec = gamma_filter(avg_b_sec, b_sec, 0.90)
print 'setter', b_sec, '/sec', avg_b_sec, '/sec', bts_sec / 1024.0 / 1024.0, 'Mb/sec', avg_bts_sec / 1024.0 / 1024.0, 'Mb/sec'
Tasklet.sleep(1.0)
def error(self, exc=None, delay_on_error=0.1):
"Notify Pool that currently selected connection is bad"
if exc is None:
if delay_on_error > 0:
Tasklet.sleep(delay_on_error)
conn = self.new_connection()
self.cput(conn)
return
while True:
bad_host = self.hosts.pop(0)
self.hosts.append(bad_host)
self.close_all()
self.debug("MySQL server %s failed: %s. Trying %s", bad_host, exc,
self.hosts[0])
Tasklet.sleep(1)
try:
self.success_counter = 0
conn = self.new_connection()
self.cput(conn)
return
except Exception as e:
exc = e
