Python - Running Autobahn|Python asyncio websocket server in a separate subprocess or thread

Question

I have a tkinter based GUI program running in Python 3.4.1. I have several threads running in the program to get JSON data from various urls. I am wanting to add some WebSocket functionality to be able to allow program to act as a server and allow several clients to connect to it over a WebSocket and exchange other JSON data.

I am attempting to use the Autobahn|Python WebSocket server for asyncio.

I first tried to run the asyncio event loop in a separate thread under the GUI program. However, every attempt gives 'AssertionError: There is no current event loop in thread 'Thread-1'.

I then tried spawning a process with the standard library multiprocessing package that ran the asyncio event loop in another Process. When I try this I don't get any exception but the WebSocket server doesn't start either.

Is it even possible to run an asyncio event loop in a subprocess from another Python program?

Is there even a way to integrate an asyncio event loop into a currently multithreaded/tkinter program?

UPDATE Below is the actual code I am trying to run for an initial test.

from autobahn.asyncio.websocket import WebSocketServerProtocol from autobahn.asyncio.websocket import WebSocketServerFactory import asyncio from multiprocessing import Process  class MyServerProtocol(WebSocketServerProtocol):     def onConnect(self, request):       print("Client connecting: {0}".format(request.peer))     def onOpen(self):       print("WebSocket connection open.")     def onMessage(self, payload, isBinary):       if isBinary:          print("Binary message received: {0} bytes".format(len(payload)))        else:          print("Text message received: {0}".format(payload.decode('utf8')))        ## echo back message verbatim       self.sendMessage(payload, isBinary)     def onClose(self, wasClean, code, reason):       print("WebSocket connection closed: {0}".format(reason))  def start_server():    factory = WebSocketServerFactory("ws://10.241.142.27:6900", debug = False)    factory.protocol = MyServerProtocol    loop = asyncio.get_event_loop()    coro = loop.create_server(factory, '10.241.142.27', 6900)    server = loop.run_until_complete(coro)    loop.run_forever()    server.close()    loop.close()   websocket_server_process = Process(target = start_server) websocket_server_process.start() 

Most of it is straight from the Autobahn|Python example code for asyncio. If I try to run it as a Process it doesn't do anything, no client can connect to it, if I run netstat -a there is no port 6900 being used. If just use start_server() in the main program it creates the WebSocket Server.

Answer 1

First, you're getting AssertionError: There is no current event loop in thread 'Thread-1'. because asyncio requires each thread in your program to have its own event loop, but it will only automatically create an event loop for you in the main thread. So if you call asyncio.get_event_loop once in the main thread it will automatically create a loop object and set it as the default for you, but if you call it again in a child thread, you'll get that error. Instead, you need to explicitly create/set the event loop when the thread starts:

loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) 

Once you've done that, you should be able to use get_event_loop() in that specific thread.

It is possible to start an asyncio event loop in a subprocess started via multiprocessing:

import asyncio from multiprocessing import Process   @asyncio.coroutine def coro():     print("hi")  def worker():     loop = asyncio.get_event_loop()     loop.run_until_complete(coro())  if __name__ == "__main__":     p = Process(target=worker)     p.start()     p.join() 

Output:

hi 

The only caveat is that if you start an event loop in the parent process as well as the child, you need to explicitly create/set a new event loop in the child if you're on a Unix platform (due to a bug in Python). It should work fine on Windows, or if you use the 'spawn' multiprocessing context.

I think it should be possible to start an asyncio event loop in a background thread (or process) of your Tkinter application and have both the tkinter and asyncio event loop run side-by-side. You'll only run into issues if you try to update the GUI from the background thread/process.