使用 websockets 和 asyncio 监听多个套接字

Question

我正在尝试在 python 中创建一个脚本，该脚本使用 websockets 和 asyncio 侦听多个套接字，问题是无论我做什么，它都只侦听我调用的第一个套接字。 我认为这是无限循环，我有什么选择来解决这个问题？ 为每个套接字使用线程？

  async def start_socket(self, event):
    payload = json.dumps(event)
    loop = asyncio.get_event_loop()

    self.tasks.append(loop.create_task(
        self.subscribe(event)))

    # this should not block the rest of the code
    await asyncio.gather(*tasks)


  def test(self):
    # I want to be able to add corotines at a different time
    self.start_socket(event1)
    # some code
    self.start_socket(event2)

Answer 1

这就是我最终所做的，这样它就不会阻塞主线程并且所有订阅都并行工作。

def subscribe(self, payload):
    ws = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE})
    ws.connect(url)
    ws.send(payload)
    while True:
        result = ws.recv()
        print("Received '%s'" % result)

    def start_thread(self, loop):
    asyncio.set_event_loop(loop)
    loop.run_forever()

def start_socket(self, **kwargs):
    worker_loop = asyncio.new_event_loop()
    worker = Thread(target=self.start_thread, args=(worker_loop,))
    worker.start()

    worker_loop.call_soon_threadsafe(self.subscribe, payload)


def listen(self):
    self.start_socket(payload1)
    # code
    self.start_socket(payload2)
    # code
    self.start_socket(payload3)

Answer 2

您的代码似乎不完整，但您显示的内容有两个问题。 一个是run_until_complete接受一个协程对象（或其他类型的未来），而不是一个协程函数。 所以应该是：

# note parentheses after your_async_function()
asyncio.get_event_loop().run_until_complete(your_async_function())

问题是无论我做什么，它都只听我调用的第一个套接字。 我认为这是无限循环，我有什么选择来解决这个问题？ 为每个套接字使用线程？

无限循环不是问题，asyncio 旨在支持这种“无限循环”。 问题是您试图在一个协程中完成所有事情，而您应该为每个 websocket 创建一个协程。 这不是问题，因为协程非常轻量级。

例如（未经测试）：

async def subscribe_all(self, payload):
    loop = asyncio.get_event_loop()
    # create a task for each URL
    for url in url_list:
        tasks.append(loop.create_task(self.subscribe_one(url, payload)))
    # run all tasks in parallel
    await asyncio.gather(*tasks)

async def subsribe_one(self, url, payload):
    async with websockets.connect(url) as websocket:
        await websocket.send(payload)
        while True:
            msg = await websocket.recv()
            print(msg)

Answer 3

一种从 websocket 服务器有效侦听多个 websocket 连接的方法是保留已连接客户端的列表，并基本上并行处理多个对话。

例如，一个简单的服务器每隔几秒向每个连接的客户端发送随机#：

import os
import asyncio
import websockets
import random 

websocket_clients = set()

async def handle_socket_connection(websocket, path):
    """Handles the whole lifecycle of each client's websocket connection."""
    websocket_clients.add(websocket)
    print(f'New connection from: {websocket.remote_address} ({len(websocket_clients)} total)')
    try:
        # This loop will keep listening on the socket until its closed. 
        async for raw_message in websocket:
            print(f'Got: [{raw_message}] from socket [{id(websocket)}]')
    except websockets.exceptions.ConnectionClosedError as cce:
        pass
    finally:
        print(f'Disconnected from socket [{id(websocket)}]...')
        websocket_clients.remove(websocket)

async def broadcast_random_number(loop):
    """Keeps sending a random # to each connected websocket client"""
    while True:
        for c in websocket_clients:
            num = str(random.randint(10, 99))
            print(f'Sending [{num}] to socket [{id(c)}]')
            await c.send(num)
        await asyncio.sleep(2)

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    try:
        socket_server = websockets.serve(handle_socket_connection, 'localhost', 6789)
        print(f'Started socket server: {socket_server} ...')
        loop.run_until_complete(socket_server)
        loop.run_until_complete(broadcast_random_number(loop))
        loop.run_forever()
    finally:
        loop.close()
        print(f"Successfully shutdown [{loop}].")

一个连接到服务器并侦听数字的简单客户端：

import asyncio
import random
import websockets

async def handle_message():
    uri = "ws://localhost:6789"
    async with websockets.connect(uri) as websocket:
        msg = 'Please send me a number...'
        print(f'Sending [{msg}] to [{websocket}]')
        await websocket.send(msg)
        while True:
            got_back = await websocket.recv()
            print(f"Got: {got_back}")

asyncio.get_event_loop().run_until_complete(handle_message())

混合线程和asyncio比它的价值更麻烦，您仍然有代码会阻塞最浪费的步骤，例如网络 IO（这是使用asyncio的基本好处）。

你需要在一个事件循环异步运行的每个协同程序，调用任何阻塞调用await及定义方法与用任何awaitable互动交互async

看到一个工作例如： https : //github.com/adnantium/websocket_client_server