def init_process(self) -> None: # pragma: no cover import tokio # Setup tokio policy, so that every # asyncio.get_event_loop() will create an instance # of tokio event loop. asyncio.set_event_loop_policy(tokio.EventLoopPolicy()) super().init_process()
def init_process(self): # pragma: no cover import tokio # Close any existing event loop before setting a # new policy. asyncio.get_event_loop().close() # Setup tokio policy, so that every # asyncio.get_event_loop() will create an instance # of tokio event loop. asyncio.set_event_loop_policy(tokio.EventLoopPolicy()) super().init_process()
def _init_process(self): # load event loop if self._loop_type == 'default': # use default event loop pass elif self._loop_type == 'uvloop': try: import uvloop except ImportError: raise utils.ConfigurationError('uvloop is not available') # Setup uvloop policy, so that every # asyncio.get_event_loop() will create an instance # of uvloop event loop. asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) elif self._loop_type == 'tokio': try: import tokio except ImportError: raise utils.ConfigurationError('tokio is not available') # Setup tokio policy, so that every # asyncio.get_event_loop() will create an instance # of uvloop event loop. asyncio.set_event_loop_policy(tokio.EventLoopPolicy()) else: raise utils.ConfigurationError('Unknown loop type: %s' % self._loop_type) # create new event_loop after fork asyncio.get_event_loop().close() loop = asyncio.new_event_loop() if self._args.debug: loop.set_debug(True) self._loop = loop # read/write queues to master self._read_queue = asyncio.Queue(loop=loop) self._write_queue = asyncio.Queue(loop=loop) # convert callbacks to coroutine self._on_msg = [asyncio.coroutine(cb) for cb in self._on_msg] self._on_shutdown = [asyncio.coroutine(cb) for cb in self._on_shutdown] for sock in self._sockets.values(): sock.set_nonblocking() asyncio.set_event_loop(loop) super()._init_process()
def set_loop_policy(event_loop): log = structlog.get_logger() if event_loop == 'uvloop': try: import uvloop asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) log.info("Using uvloop event loop policy") except ImportError: log.warning("uvloop is not available.") elif event_loop == 'tokio': try: import tokio asyncio.set_event_loop_policy(tokio.EventLoopPolicy()) log.info("Using tokio event loop policy") except ImportError: log.warning("tokio is not available.") else: # set default policy asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--uvloop', default=False, action='store_true') parser.add_argument('--tokio', default=False, action='store_true') parser.add_argument('--addr', default='127.0.0.1:25000', type=str) parser.add_argument('--print', default=False, action='store_true') args = parser.parse_args() if args.uvloop: import uvloop loop = uvloop.new_event_loop() print('using UVLoop') elif args.tokio: import tokio policy = tokio.EventLoopPolicy() asyncio.set_event_loop_policy(policy) loop = tokio.new_event_loop() print('using tokio loop') else: loop = asyncio.new_event_loop() print('using asyncio loop') asyncio.set_event_loop(loop) loop.set_debug(False) if args.print: PRINT = 1 if hasattr(loop, 'print_debug_info'): loop.create_task(print_debug(loop))
def function39(self): import tokio asyncio.get_event_loop().function639() asyncio.set_event_loop_policy(tokio.EventLoopPolicy()) super().function39()