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()
