def Loop():
loop = asyncio.get_event_loop_policy().new_event_loop()
asyncio.set_event_loop(loop)
try:
yield loop
finally:
loop.close()
def test_log_slow_callbacks(self, m_logger):
def stop_loop_cb(loop):
loop.stop()
@asyncio.coroutine
def stop_loop_coro(loop):
yield From(None)
loop.stop()
asyncio.set_event_loop(self.loop)
self.loop.set_debug(True)
self.loop.slow_callback_duration = 0.0
# slow callback
self.loop.call_soon(stop_loop_cb, self.loop)
self.loop.run_forever()
fmt = m_logger.warning.call_args[0][0]
args = m_logger.warning.call_args[0][1:]
self.assertRegex(
fmt % tuple(args), "^Executing <Handle.*stop_loop_cb.*> "
"took .* seconds$")
# slow task
asyncio. async (stop_loop_coro(self.loop), loop=self.loop)
self.loop.run_forever()
fmt = m_logger.warning.call_args[0][0]
args = m_logger.warning.call_args[0][1:]
self.assertRegex(
fmt % tuple(args), "^Executing <Task.*stop_loop_coro.*> "
"took .* seconds$")
def asyloop(loop, sock, camera):
asyncio.set_event_loop(loop)
tasks = [
# asyncio.async(video()),
asyncio. async (slackServer(sock, camera)),
]
loop.run_until_complete(asyncio.wait(tasks))
def test_default_exc_handler_coro(self):
self.loop._process_events = mock.Mock()
self.loop.set_debug(True)
asyncio.set_event_loop(self.loop)
@asyncio.coroutine
def zero_error_coro():
yield From(asyncio.sleep(0.01, loop=self.loop))
1 / 0
# Test Future.__del__
with mock.patch('trollius.base_events.logger') as log:
fut = asyncio. async (zero_error_coro(), loop=self.loop)
fut.add_done_callback(lambda *args: self.loop.stop())
self.loop.run_forever()
fut = None # Trigger Future.__del__ or futures._TracebackLogger
support.gc_collect()
if PY34:
# Future.__del__ in Python 3.4 logs error with
# an actual exception context
log.error.assert_called_with(
test_utils.MockPattern('.*exception was never retrieved'),
exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY))
else:
# futures._TracebackLogger logs only textual traceback
log.error.assert_called_with(test_utils.MockPattern(
'.*exception was never retrieved.*ZeroDiv'),
exc_info=False)
def run(driver, time_out):
loop = new_event_loop()
set_event_loop(loop)
ensure_future(control_loop(driver, time_out, loop))
loop.run_forever()
loop.close()
return (distance_to_goal, left_velocity, right_velocity)
def run_main_loop(G):
'''
This runs the stopingibition/visual/audio part of the paradigm using
asyncio-replacement trollius. Before and after, we can still present
other stimuli.
'''
# something like this:
# mainClock=clock.Clock()
# mainClockContainer[0]=mainClock # put it into my list, that double-serves
# as a pointer
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
#tasks = [
# asyncio.async(handleVisual()),
# asyncio.async(handleGonogo()),
# asyncio.async(handleEscape()),
# ]
tasks_dbg = [
# asyncio.async(handle_exception(test_it,G,loop)),
asyncio. async (handle_exception(handle_audio, G, loop)),
asyncio. async (handle_exception(handle_visual, G, loop)),
asyncio. async (handle_exception(handle_gonogo, G, loop)),
#asyncio.async(handle_exception(handle_visual,loop)),
]
tasks = [
# asyncio.async(test_it(G)),
# asyncio.async(handle_audio(G))
]
# so to debug, just run tasks_dbg instead of tasks.
loop.run_until_complete(asyncio.wait(tasks_dbg))
loop.close()
def test_default_exc_handler_coro(self):
self.loop._process_events = mock.Mock()
self.loop.set_debug(True)
asyncio.set_event_loop(self.loop)
@asyncio.coroutine
def zero_error_coro():
yield From(asyncio.sleep(0.01, loop=self.loop))
1 / 0
# Test Future.__del__
with mock.patch("trollius.base_events.logger") as log:
fut = asyncio.async(zero_error_coro(), loop=self.loop)
fut.add_done_callback(lambda *args: self.loop.stop())
self.loop.run_forever()
fut = None # Trigger Future.__del__ or futures._TracebackLogger
support.gc_collect()
if PY34:
# Future.__del__ in Python 3.4 logs error with
# an actual exception context
log.error.assert_called_with(
test_utils.MockPattern(".*exception was never retrieved"),
exc_info=(ZeroDivisionError, MOCK_ANY, MOCK_ANY),
)
else:
# futures._TracebackLogger logs only textual traceback
log.error.assert_called_with(
test_utils.MockPattern(".*exception was never retrieved.*ZeroDiv"), exc_info=False
)
def setUp(self):
trollius.set_event_loop(None)
self.loop = trollius.new_event_loop()
self.loop.set_debug(True)
self.cluster = Cluster()
self.session = self.cluster.connect()
aiosession(self.session, loop=self.loop)
def run(driver, time_out):
loop = new_event_loop()
set_event_loop(loop)
ensure_future(control_loop(driver, time_out, loop))
loop.run_forever()
loop.close()
return (distance_to_goal, left_velocity, right_velocity)
def run(self, driver, time_out):
self.loop = new_event_loop()
set_event_loop(self.loop)
ensure_future(self.control_loop(driver, time_out))
self.loop.run_forever()
self.loop.close()
return (self.distance_to_goal, self.left_velocity, self.right_velocity)
def main():
asyncio.set_event_loop(None)
if args.iocp:
from trollius.windows_events import ProactorEventLoop
loop = ProactorEventLoop()
else:
loop = asyncio.new_event_loop()
sslctx = None
if args.tls:
import ssl
# TODO: take cert/key from args as well.
here = os.path.join(os.path.dirname(__file__), '..', 'tests')
sslctx = asyncio.SSLContext(ssl.PROTOCOL_SSLv23)
sslctx.options |= ssl.OP_NO_SSLv2
sslctx.load_cert_chain(
certfile=os.path.join(here, 'ssl_cert.pem'),
keyfile=os.path.join(here, 'ssl_key.pem'))
cache = Cache(loop)
task = asyncio.streams.start_server(cache.handle_client,
args.host, args.port,
ssl=sslctx, loop=loop)
svr = loop.run_until_complete(task)
for sock in svr.sockets:
logging.info('socket %s', sock.getsockname())
try:
loop.run_forever()
finally:
loop.close()
def main():
asyncio.set_event_loop(None)
if args.iocp:
from trollius.windows_events import ProactorEventLoop
loop = ProactorEventLoop()
else:
loop = asyncio.new_event_loop()
sslctx = None
if args.tls:
import ssl
# TODO: take cert/key from args as well.
here = os.path.join(os.path.dirname(__file__), '..', 'tests')
sslctx = asyncio.SSLContext(ssl.PROTOCOL_SSLv23)
sslctx.options |= ssl.OP_NO_SSLv2
sslctx.load_cert_chain(certfile=os.path.join(here, 'ssl_cert.pem'),
keyfile=os.path.join(here, 'ssl_key.pem'))
cache = Cache(loop)
task = asyncio.streams.start_server(cache.handle_client,
args.host,
args.port,
ssl=sslctx,
loop=loop)
svr = loop.run_until_complete(task)
for sock in svr.sockets:
logging.info('socket %s', sock.getsockname())
try:
loop.run_forever()
finally:
loop.close()
def test_log_slow_callbacks(self, m_logger):
def stop_loop_cb(loop):
loop.stop()
@asyncio.coroutine
def stop_loop_coro(loop):
yield From(None)
loop.stop()
asyncio.set_event_loop(self.loop)
self.loop.set_debug(True)
self.loop.slow_callback_duration = 0.0
# slow callback
self.loop.call_soon(stop_loop_cb, self.loop)
self.loop.run_forever()
fmt = m_logger.warning.call_args[0][0]
args = m_logger.warning.call_args[0][1:]
self.assertRegex(fmt % tuple(args), "^Executing <Handle.*stop_loop_cb.*> " "took .* seconds$")
# slow task
asyncio.async(stop_loop_coro(self.loop), loop=self.loop)
self.loop.run_forever()
fmt = m_logger.warning.call_args[0][0]
args = m_logger.warning.call_args[0][1:]
self.assertRegex(fmt % tuple(args), "^Executing <Task.*stop_loop_coro.*> " "took .* seconds$")
def run(self, command, *args, **kwargs):
self_ = self
class SubprocessProtocol(asyncio.SubprocessProtocol):
def pipe_data_received(self, fd, data):
self_._write(fd, re.sub(r'(\r?\n)+', r'\1', data))
def connection_lost(self, exc):
loop.stop() # end loop.run_forever()
if os.name == 'nt':
# For subprocess' pipes on Windows
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
try:
if kwargs.pop('shell', False):
proc = loop.subprocess_shell(SubprocessProtocol, command)
else:
proc = loop.subprocess_exec(SubprocessProtocol, *command)
def _refresh_gui():
refresh_gui()
loop.call_soon(_refresh_gui)
loop.call_soon(_refresh_gui)
transport, protocol = loop.run_until_complete(proc)
loop.run_forever()
except Exception, exception:
self._write(2, str(exception))
def run(self, driver, time_out):
self.loop = new_event_loop()
set_event_loop(self.loop)
ensure_future(self.control_loop(driver, time_out))
self.loop.run_forever()
self.loop.close()
return (self.distance_to_goal, self.left_velocity, self.right_velocity)
def handler(event, contest):
logger.info("Start!")
executor = ThreadPoolExecutor(max_workers=1000)
main_loop = asyncio.new_event_loop()
main_loop.set_default_executor(executor)
asyncio.set_event_loop(main_loop)
poll = Poll(main_loop)
cal = poll.cal
update_and_delete = UpdateAndDelete(main_loop, executor)
table = event['table']
queue_url = event['queueUrl']
message_count = event['messageCount']
poll.messages(sqs, queue_url, message_count)
logger.info("Receive API count: {}".format(poll.fetch_count))
logger.info("Fetched messages: {}".format(poll.message_count))
update_and_delete.execute(sqs_client, db, queue_url, table, cal.stats)
logger.info("Update API count: {}".format(update_and_delete.update_count))
logger.info("Delete API count: {}".format(update_and_delete.delete_count))
logger.info("Delete Message count: {}".format(
update_and_delete.deleted_message_count))
main_loop.close()
executor.shutdown()
return "Lambda job finished successfully."
def handler(event, contest):
logger.info("Start!")
executor = ThreadPoolExecutor(max_workers=1000)
main_loop = asyncio.new_event_loop()
main_loop.set_default_executor(executor)
asyncio.set_event_loop(main_loop)
poll = Poll(main_loop)
cal = poll.cal
update_and_delete = UpdateAndDelete(main_loop, executor)
table = event['table']
queue_url = event['queueUrl']
message_count = event['messageCount']
poll.messages(sqs, queue_url, message_count)
logger.info("Receive API count: {}".format(poll.fetch_count))
logger.info("Fetched messages: {}".format(poll.message_count))
update_and_delete.execute(sqs_client, db, queue_url, table, cal.stats)
logger.info("Update API count: {}".format(update_and_delete.update_count))
logger.info("Delete API count: {}".format(update_and_delete.delete_count))
logger.info("Delete Message count: {}".format(
update_and_delete.deleted_message_count))
main_loop.close()
executor.shutdown()
return "Lambda job finished successfully."
def set_event_loop(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.events = asyncio.Queue(loop=self.loop)
self.set_exception_handler()
if self.loglevel is not None and self.loglevel <= logging.DEBUG:
self.loop.set_debug(True)
return self.loop
def test_streamreader_constructor(self):
self.addCleanup(asyncio.set_event_loop, None)
asyncio.set_event_loop(self.loop)
# Tulip issue #184: Ensure that StreamReaderProtocol constructor
# retrieves the current loop if the loop parameter is not set
reader = asyncio.StreamReader()
self.assertIs(reader._loop, self.loop)
def set_event_loop(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.events = asyncio.Queue(loop=self.loop)
self.set_exception_handler()
if self.loglevel is not None and self.loglevel <= logging.DEBUG:
self.loop.set_debug(True)
return self.loop
def test_streamreader_constructor(self):
self.addCleanup(asyncio.set_event_loop, None)
asyncio.set_event_loop(self.loop)
# asyncio issue #184: Ensure that StreamReaderProtocol constructor
# retrieves the current loop if the loop parameter is not set
reader = asyncio.StreamReader()
self.assertIs(reader._loop, self.loop)
def test_tb_logger_exception_unretrieved(self, m_log):
self.loop.set_debug(True)
asyncio.set_event_loop(self.loop)
fut = asyncio.Future(loop=self.loop)
fut.set_exception(RuntimeError('boom'))
del fut
test_utils.run_briefly(self.loop)
support.gc_collect()
self.assertTrue(m_log.error.called)
def test_streamreaderprotocol_constructor(self):
self.addCleanup(asyncio.set_event_loop, None)
asyncio.set_event_loop(self.loop)
# Tulip issue #184: Ensure that StreamReaderProtocol constructor
# retrieves the current loop if the loop parameter is not set
reader = mock.Mock()
protocol = asyncio.StreamReaderProtocol(reader)
self.assertIs(protocol._loop, self.loop)
def main():
if os.name == 'nt':
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
loop.run_until_complete(start(
'sleep 2; wc', input=[b'foo bar baz\n'*300 for i in range(100)]))
loop.close()
def test_tb_logger_exception_unretrieved(self, m_log):
self.loop.set_debug(True)
asyncio.set_event_loop(self.loop)
fut = asyncio.Future(loop=self.loop)
fut.set_exception(RuntimeError("boom"))
del fut
test_utils.run_briefly(self.loop)
support.gc_collect()
self.assertTrue(m_log.error.called)
def execute(self, sqs, queue_url, ids):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.set_default_executor(self.executor)
id_groups = group_by_10(ids)
tasks = []
for id_group in id_groups:
tasks.append(self._one_request(loop, sqs, queue_url, id_group))
loop.run_until_complete(asyncio.wait(tasks))
def execute(self, sqs, queue_url, ids):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.set_default_executor(self.executor)
id_groups = group_by_10(ids)
tasks = []
for id_group in id_groups:
tasks.append(self._one_request(loop, sqs, queue_url, id_group))
loop.run_until_complete(asyncio.wait(tasks))
def add_task(self, key, task, no_cache=False):
if not no_cache:
task_cache = self._get_cache(key)
if task_cache is not None:
return TaskGetter(task_cache)
self._tasks[key] = task
aio.set_event_loop(self.loop)
self.loop.call_soon_threadsafe(aio.async, self.queue.put(task))
return TaskGetter(task)
def __init__(self, instances=4):
logging.warn('init dymola builder')
DymolaBuilder._initial_paths()
self.dymola_instances = [start_dymola() for _ in range(instances)]
self.loop = aio.get_event_loop()
aio.set_event_loop(self.loop)
self.queue = aio.Queue(maxsize=0, loop=self.loop)
arguments = (self.queue, self.loop, self.dymola_instances)
self.main = Thread(target=main_event_loop, args=arguments)
self.main.start()
logging.warn('started thread loop asyncio')
def _basetest_open_connection_no_loop_ssl(self, open_connection_fut):
try:
reader, writer = self.loop.run_until_complete(open_connection_fut)
finally:
asyncio.set_event_loop(None)
writer.write(b'GET / HTTP/1.0\r\n\r\n')
f = reader.read()
data = self.loop.run_until_complete(f)
self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
writer.close()
def _basetest_open_connection_no_loop_ssl(self, open_connection_fut):
try:
reader, writer = self.loop.run_until_complete(open_connection_fut)
finally:
asyncio.set_event_loop(None)
writer.write(b'GET / HTTP/1.0\r\n\r\n')
f = reader.read()
data = self.loop.run_until_complete(f)
self.assertTrue(data.endswith(b'\r\n\r\nTest message'))
writer.close()
def thread_target(self, loop):
trollius.set_event_loop(loop)
retry = True
update = True
sz = None
sh = None
while retry:
try:
[szTime, shTime] = self.sina.get_ticktime()
if (szTime > self.szTime) & (len(self.szSymbols) > 0):
self.szTime = szTime
szUpdate = True
else:
szUpdate = False
if (shTime > self.shTime) & (len(self.shSymbols) > 0):
self.shTime = shTime
shUpdate = True
else:
shUpdate = False
if szUpdate and shUpdate:
[sz,
sh] = self.sina.get_realtime_quotes(symbols=self.symbols,
dataframe=False,
loop=loop,
split=True)
elif szUpdate:
sz = self.sina.get_realtime_quotes(symbols=self.szSymbols,
dataframe=False,
loop=loop,
split=False)
elif shUpdate:
sh = self.sina.get_realtime_quotes(symbols=self.shSymbols,
dataframe=False,
loop=loop,
split=False)
retry = False
except Exception as e:
print(e)
# print( time.time() - start )
if sz:
eventSZ = Event(event_type='SinaFreeQuote', data=sz)
eventSZ.time = szTime
eventSZ.localtime = time.time()
eventSZ.exchange = 'SZ'
for q in self._subscriber:
q.put(eventSZ)
if sh:
eventSH = Event(event_type='SinaFreeQuote', data=sh)
eventSH.time = shTime
eventSH.localtime = time.time()
eventSH.exchange = 'SH'
for q in self._subscriber:
q.put(eventSH)
def run_executor(executor):
# create an event loop in the executor thread
loop = trollius.new_event_loop()
trollius.set_event_loop(loop)
eventlet.spawn(run_loop, loop)
# run the executor
executor.start()
executor.wait()
# stop the event loop: run_loop() will close it
loop.stop()
def start(self):
self.isStopped = False
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.face = ThreadsafeFace(self.loop, '')
k = KeyChain()
self.face.setCommandSigningInfo(k, k.getDefaultCertificateName())
self.face.stopWhen(lambda:self.isStopped)
try:
self.loop.run_until_complete(self.sendNextInsertRequest())
finally:
self.face.shutdown()
def test_run_from_running_loop():
@asyncio.coroutine
def foo():
return bnra.available_devices()
loop = bnra.new_file_event_loop()
original_loop = asyncio.get_event_loop()
asyncio.set_event_loop(loop)
print(loop.run_until_complete(foo()))
loop.stop()
asyncio.set_event_loop(original_loop)
def run_executor(executor):
# create an event loop in the executor thread
loop = trollius.new_event_loop()
trollius.set_event_loop(loop)
eventlet.spawn(run_loop, loop)
# run the executor
executor.start()
executor.wait()
# stop the event loop: run_loop() will close it
loop.stop()
def _run_async_loop(loop):
LOG.debug("run_async_loop")
threading.current_thread().name = "AsyncLoopThread"
pythoncom.CoInitialize()
trollius.set_event_loop(loop)
try:
loop.run_forever()
except Exception as ex:
LOG.exception(ex)
finally:
loop.close()
def get_stock_data(self):
threads = []
for index in range(self.request_num):
threads.append(self.get_stocks_by_range(index))
log.debug("url:%s len:%s" % (self.sina_stock_api, len(self.stock_list[index])))
try:
loop = asyncio.get_event_loop()
except RuntimeError:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(asyncio.wait(threads))
log.debug("get_stock_data_loop")
return self.format_response_data()
def setup_eventloop(self):
"""
Sets up a new eventloop as the current one according to the OS.
"""
if os.name == 'nt':
self.eventloop = asyncio.ProactorEventLoop()
if sys.version_info <= (3, 0):
# FIXME: There appears to be a bug in the 2.7 version of trollius, wherein the selector retrieves an
# object of value 0 and attempts to look for it in the weakref set, which raises an exception.
# This hack sidesteps this issue, but does not solve it. If a proper fix is found, apply it!
self.eventloop._selector._stopped_serving = set()
else:
self.eventloop = asyncio.new_event_loop()
asyncio.set_event_loop(self.eventloop)
def setup_eventloop(self):
"""
Sets up a new eventloop as the current one according to the OS.
"""
if os.name == 'nt':
self.eventloop = asyncio.ProactorEventLoop()
if sys.version_info <= (3, 0):
# FIXME: There appears to be a bug in the 2.7 version of trollius, wherein the selector retrieves an
# object of value 0 and attempts to look for it in the weakref set, which raises an exception.
# This hack sidesteps this issue, but does not solve it. If a proper fix is found, apply it!
self.eventloop._selector._stopped_serving = set()
else:
self.eventloop = asyncio.new_event_loop()
asyncio.set_event_loop(self.eventloop)
def run(self):
def childEventLoopSigHandler(sig, func):
raise NotImplementedError
assert not self.__session
asyncio.set_event_loop(self.__loop)
#hack so that autobahn doesn't try to bind SIGTERM to the thread's event loop (which would generate an exception)
self.__loop.add_signal_handler = childEventLoopSigHandler
runner = ApplicationRunner(WEBSOCKET_HOST,
WEBSOCKET_REALM,
extra={'client': self})
runner.run(WebSocketClientSession)
def token_renewer(self):
while True:
loop = trollius.new_event_loop()
trollius.set_event_loop(loop)
tasks = list()
for symbol in self.websockets.keys():
ws = self.websockets[symbol]["ws"]
if ws.open:
if (datetime.now() - self.websockets[symbol]["renewed"]
).total_seconds() > 180:
tasks.append(self.renew_token(symbol))
if len(tasks) > 0:
loop.run_until_complete(trollius.wait(tasks))
loop.close()
time.sleep(1)
def test_default_exc_handler_broken(self):
contexts = []
class Loop(base_events.BaseEventLoop):
_selector = mock.Mock()
_process_events = mock.Mock()
def default_exception_handler(self, context):
contexts.append(context)
# Simulates custom buggy "default_exception_handler"
raise ValueError('spam')
loop = Loop()
self.addCleanup(loop.close)
asyncio.set_event_loop(loop)
def run_loop():
def zero_error():
1 / 0
loop.call_soon(zero_error)
loop._run_once()
with mock.patch('trollius.base_events.logger') as log:
run_loop()
log.error.assert_called_with(
'Exception in default exception handler', exc_info=True)
def custom_handler(loop, context):
raise ValueError('ham')
del contexts[:]
loop.set_exception_handler(custom_handler)
with mock.patch('trollius.base_events.logger') as log:
run_loop()
log.error.assert_called_with(test_utils.MockPattern(
'Exception in default exception.*'
'while handling.*in custom'),
exc_info=True)
# Check that original context was passed to default
# exception handler.
context = contexts[0]
self.assertIn('context', context)
self.assertIs(type(context['context']['exception']),
ZeroDivisionError)
def test_asyncserial_timeout_error():
'''
Verify serial device AsyncSerial instance is still tied up after closing.
In Windows, it turns out that the serial port is tied up by an AsyncSerial
instance until the corresponding event loop is closed. This test tests
that this is true.
'''
ports = serial.tools.list_ports.comports()
if not ports:
raise RuntimeError('No comports available.')
kwargs = {'port': ports[0].device}
@asyncio.coroutine
def _open_asyncserial():
with asyncserial.AsyncSerial(**kwargs) as async_device:
yield asyncio.From(asyncio.sleep(5))
raise asyncio.Return(None)
def _open_serial(retries=1):
for i in range(retries):
try:
with serial.Serial(**kwargs):
pass
break
except serial.SerialException as exception:
pass
else:
raise exception
_open_serial()
try:
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
loop.run_until_complete(asyncio.wait_for(_open_asyncserial(),
timeout=2))
except asyncio.TimeoutError:
pass
try:
_open_serial()
except serial.SerialException:
raises(serial.SerialException)(_open_serial)()
def main(loop, mode, host, port):
asyncio.set_event_loop(loop)
if not (mode == "server" or mode == "client"):
raise Exception("Mode must be 'server' or 'client': " + str(mode))
setup_logging()
if mode == "server":
server = start_server(loop, (host, port))
else:
start_client(loop, (host, port))
try:
loop.run_forever()
finally:
if mode == "server":
server.close()
loop.close()
def test_default_exc_handler_broken(self):
contexts = []
class Loop(base_events.BaseEventLoop):
_selector = mock.Mock()
_process_events = mock.Mock()
def default_exception_handler(self, context):
contexts.append(context)
# Simulates custom buggy "default_exception_handler"
raise ValueError('spam')
loop = Loop()
asyncio.set_event_loop(loop)
def run_loop():
def zero_error():
1/0
loop.call_soon(zero_error)
loop._run_once()
with mock.patch('trollius.base_events.logger') as log:
run_loop()
log.error.assert_called_with(
'Exception in default exception handler',
exc_info=True)
def custom_handler(loop, context):
raise ValueError('ham')
del contexts[:]
loop.set_exception_handler(custom_handler)
with mock.patch('trollius.base_events.logger') as log:
run_loop()
log.error.assert_called_with(
test_utils.MockPattern('Exception in default exception.*'
'while handling.*in custom'),
exc_info=True)
# Check that original context was passed to default
# exception handler.
context = contexts[0]
self.assertIn('context', context)
self.assertIs(type(context['context']['exception']),
ZeroDivisionError)
def test_asyncserial_timeout_workaround():
'''
Test closing event loop to free up device AsyncSerial instance.
'''
ports = serial.tools.list_ports.comports()
if not ports:
raise RuntimeError('No comports available.')
kwargs = {'port': ports[0].device}
@asyncio.coroutine
def _open_asyncserial():
with asyncserial.AsyncSerial(**kwargs) as async_device:
yield asyncio.From(asyncio.sleep(5))
raise asyncio.Return(None)
def _open_serial(retries=1):
for i in range(retries):
try:
with serial.Serial(**kwargs):
pass
break
except serial.SerialException as exception:
pass
else:
raise exception
_open_serial()
try:
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
loop.run_until_complete(asyncio.wait_for(_open_asyncserial(),
timeout=2))
except asyncio.TimeoutError:
pass
finally:
# Close event loop.
loop.close()
try:
_open_serial()
except serial.SerialException:
_open_serial()
def main():
asyncio.set_event_loop(None)
if args.iocp:
from trollius.windows_events import ProactorEventLoop
loop = ProactorEventLoop()
else:
loop = asyncio.new_event_loop()
sslctx = None
if args.tls:
sslctx = test_utils.dummy_ssl_context()
cache = CacheClient(args.host, args.port, sslctx=sslctx, loop=loop)
try:
loop.run_until_complete(
asyncio.gather(
*[testing(i, cache, loop) for i in range(args.ntasks)],
loop=loop))
finally:
loop.close()
def run(self):
try:
asyncio.set_event_loop(asyncio.new_event_loop())
indexPath = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'templates')
app = tornado.web.Application([
(r"/stream", ImageStreamHandler, {}),
(r"/(.*)", tornado.web.StaticFileHandler, {
'path': indexPath,
'default_filename': 'index.html'
})
])
app.listen(self.port)
print('ImageServer::Started.')
tornado.ioloop.IOLoop.instance().start()
except Exception as e:
print('ImageServer::exited run loop. Exception - ' + str(e))
def check_in_thread(loop, event, debug, create_loop, fut):
# wait until the event loop is running
event.wait()
try:
if create_loop:
loop2 = base_events.BaseEventLoop()
try:
asyncio.set_event_loop(loop2)
self.check_thread(loop, debug)
finally:
asyncio.set_event_loop(None)
loop2.close()
else:
self.check_thread(loop, debug)
except Exception as exc:
loop.call_soon_threadsafe(fut.set_exception, exc)
else:
loop.call_soon_threadsafe(fut.set_result, None)
def get_stock_data(self, retry_count=3, pause=0.01):
threads = []
for index in range(self.request_num):
threads.append(self.get_stocks_by_range(index))
log.debug("url len:%s" % (len(self.stock_list[index])))
if self.request_num == 0:
threads.append(self.get_stocks_by_range(0))
for _ in range(retry_count):
time.sleep(pause)
try:
loop = asyncio.get_event_loop()
except RuntimeError:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(asyncio.wait(threads))
log.debug('get_stock_data_loop')
return self.format_response_data()
raise IOError(ct.NETWORK_URL_ERROR_MSG)
def check_in_thread(loop, event, debug, create_loop, fut):
# wait until the event loop is running
event.wait()
try:
if create_loop:
loop2 = base_events.BaseEventLoop()
try:
asyncio.set_event_loop(loop2)
self.check_thread(loop, debug)
finally:
asyncio.set_event_loop(None)
loop2.close()
else:
self.check_thread(loop, debug)
except Exception as exc:
loop.call_soon_threadsafe(fut.set_exception, exc)
else:
loop.call_soon_threadsafe(fut.set_result, None)
def to_asyncio_run(urllist, cmd):
results = []
# print "asyncio",
@asyncio.coroutine
def get_loop_cmd(cmd, url_s):
loop = asyncio.get_event_loop()
result = yield From(loop.run_in_executor(None, cmd, url_s))
results.append(result)
threads = []
for url_s in urllist:
threads.append(get_loop_cmd(cmd, url_s))
try:
loop = asyncio.get_event_loop()
except RuntimeError:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(asyncio.wait(threads))
return results
def handler(event, contest):
logger.info("Start!")
executor = ThreadPoolExecutor(max_workers=1000)
main_loop = asyncio.new_event_loop()
main_loop.set_default_executor(executor)
asyncio.set_event_loop(main_loop)
poll = Poll(main_loop)
queue_url = event['queueUrl']
message_count = event['messageCount']
poll.messages(sqs, queue_url, message_count)
logger.info("Receive API count: {}".format(poll.fetch_count))
logger.info("Fetched messages: {}".format(poll.message_count))
main_loop.close()
executor.shutdown()
def main():
"""Main program.
Parse arguments, set up event loop, run crawler, print report.
"""
args = ARGS.parse_args()
if not args.roots:
print('Use --help for command line help')
return
log = Logger(args.level)
if args.iocp:
from trollius.windows_events import ProactorEventLoop
loop = ProactorEventLoop()
asyncio.set_event_loop(loop)
elif args.select:
loop = asyncio.SelectorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
roots = {fix_url(root) for root in args.roots}
crawler = Crawler(log,
roots, exclude=args.exclude,
strict=args.strict,
max_redirect=args.max_redirect,
max_tries=args.max_tries,
max_tasks=args.max_tasks,
max_pool=args.max_pool,
)
try:
loop.run_until_complete(crawler.crawl()) # Crawler gonna crawl.
except KeyboardInterrupt:
sys.stderr.flush()
print('\nInterrupted\n')
finally:
crawler.report()
crawler.close()
loop.close()
def test_assert_is_current_event_loop(self):
def cb():
pass
other_loop = base_events.BaseEventLoop()
other_loop._selector = mock.Mock()
asyncio.set_event_loop(other_loop)
# raise RuntimeError if the event loop is different in debug mode
self.loop.set_debug(True)
with self.assertRaises(RuntimeError):
self.loop.call_soon(cb)
with self.assertRaises(RuntimeError):
self.loop.call_later(60, cb)
with self.assertRaises(RuntimeError):
self.loop.call_at(self.loop.time() + 60, cb)
# check disabled if debug mode is disabled
self.loop.set_debug(False)
self.loop.call_soon(cb)
self.loop.call_later(60, cb)
self.loop.call_at(self.loop.time() + 60, cb)
def platform_setup(driver):
driver.loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(driver.loop)
driver.kbd_h = GetStdHandle(STD_INPUT_HANDLE)
def main_event_loop(queue, loop, dymola_instances):
aio.set_event_loop(loop)
for d_instance in dymola_instances:
aio.async(dymola_builder(queue, d_instance))
loop.run_forever()
def run_loop(loop):
loop.run_forever()
loop.close()
trollius.set_event_loop(None)