Question

我目前正在玩aiohttp，看看它如何作为带有websocket连接的移动应用的服务器应用程序。

这是简单的＆＃34; Hello world＆＃34;示例（as gist here）：

import asyncio
import aiohttp
from aiohttp import web


class WebsocketEchoHandler:

    @asyncio.coroutine
    def __call__(self, request):
        ws = web.WebSocketResponse()
        ws.start(request)

        print('Connection opened')
        try:
            while True:
                msg = yield from ws.receive()
                ws.send_str(msg.data + '/answer')
        except:
            pass
        finally:
            print('Connection closed')
        return ws


if __name__ == "__main__":
    app = aiohttp.web.Application()
    app.router.add_route('GET', '/ws', WebsocketEchoHandler())

    loop = asyncio.get_event_loop()
    handler = app.make_handler()

    f = loop.create_server(
        handler,
        '127.0.0.1',
        8080,
    )

    srv = loop.run_until_complete(f)
    print("Server started at {sock[0]}:{sock[1]}".format(
        sock=srv.sockets[0].getsockname()
    ))
    try:
        loop.run_forever()
    except KeyboardInterrupt:
        pass
    finally:
        loop.run_until_complete(handler.finish_connections(1.0))
        srv.close()
        loop.run_until_complete(srv.wait_closed())
        loop.run_until_complete(app.finish())
    loop.close()

问题

现在我想使用下面描述的结构（node server = python aiohttp）。更具体地说，使用Redis Pub/Sub机制和asyncio-redis来读取和写入websocket连接和我的 WebsocketEchoHandler 中的Redis。

WebsocketEchoHandler 是一个简单的循环，所以我不确定应该怎么做。使用Tornado和brükva我只会使用回调。

额外（可能是offtopic）问题

由于我已经使用Redis，我应采取以下哪种方法：

喜欢＆＃34; classic＆＃34;网络应用程序，拥有所有内容的控制器/视图，仅使用Redis进行消息传递等。
Web应用程序应该只是客户端和Redis之间的一个层，也用作任务队列（最简单的Python RQ）。每个请求都应该委托给员工。

修改

来自http://goldfirestudios.com/blog/136/Horizontally-Scaling-Node.js-and-WebSockets-with-Redis的图片

编辑2

似乎我需要澄清一下。

仅限Websocket处理程序如上所示

Redis Pub / Sub处理程序可能如下所示：

class WebsocketEchoHandler:

    @asyncio.coroutine
    def __call__(self, request):
        ws = web.WebSocketResponse()
        ws.start(request)

        connection = yield from asyncio_redis.Connection.create(host='127.0.0.1', port=6379)
        subscriber = yield from connection.start_subscribe()
        yield from subscriber.subscribe(['ch1', 'ch2'])

        print('Connection opened')
        try:
            while True:
                msg = yield from subscriber.next_published()
                ws.send_str(msg.value + '/answer')
        except:
            pass
        finally:
            print('Connection closed')
        return ws

此处理程序只订阅Redis频道 ch1 和 ch2 ，并将从这些频道收到的每条消息发送到websocket。

我想要这个处理程序：

class WebsocketEchoHandler:

    @asyncio.coroutine
    def __call__(self, request):
        ws = web.WebSocketResponse()
        ws.start(request)

        connection = yield from asyncio_redis.Connection.create(host='127.0.0.1', port=6379)
        subscriber = yield from connection.start_subscribe()
        yield from subscriber.subscribe(['ch1', 'ch2'])

        print('Connection opened')
        try:
            while True:
                # If message recived from redis OR from websocket
                msg_ws = yield from ws.receive()
                msg_redis = yield from subscriber.next_published()
                if msg_ws:
                    # push to redis / do something else
                    self.on_msg_from_ws(msg_ws)
                if msg_redis:
                    self.on_msg_from_redis(msg_redis)
        except:
            pass
        finally:
            print('Connection closed')
        return ws

但是下面的代码总是按顺序调用，所以读取来自Redis的websocket块：

msg_ws = yield from ws.receive()
msg_redis = yield from subscriber.next_published()

我想在事件 事件上完成阅读事件是从两个来源之一收到的消息。

Answer 1

你应该使用两个while循环 - 一个处理来自websocket的消息，一个处理来自redis的消息。你的主处理程序可以启动两个协程，一个处理每个循环，然后等待两个：

class WebsocketEchoHandler:
    @asyncio.coroutine
    def __call__(self, request):
        ws = web.WebSocketResponse()
        ws.start(request)

        connection = yield from asyncio_redis.Connection.create(host='127.0.0.1', port=6379)
        subscriber = yield from connection.start_subscribe()
        yield from subscriber.subscribe(['ch1', 'ch2'])

        print('Connection opened')
        try:
            # Kick off both coroutines in parallel, and then block
            # until both are completed.
            yield from asyncio.gather(self.handle_ws(ws), self.handle_redis(subscriber))
        except Exception as e:  # Don't do except: pass
            import traceback
            traceback.print_exc()
        finally:
            print('Connection closed')
        return ws

    @asyncio.coroutine
    def handle_ws(self, ws):
        while True:
            msg_ws = yield from ws.receive()
            if msg_ws:
                self.on_msg_from_ws(msg_ws)

    @asyncio.coroutine
    def handle_redis(self, subscriber):
        while True:
            msg_redis = yield from subscriber.next_published()
            if msg_redis:
                self.on_msg_from_redis(msg_redis)

通过这种方式，您可以从两个潜在来源中的任何一个进行阅读，而无需关心另一个。

Answer 2

最近我们可以在python 3.5及更高版本中使用async await ..

async def task1(ws):
    async for msg in ws:
        if msg.type == WSMsgType.TEXT:
            data = msg.data
            print(data)
            if data:
                await ws.send_str('pong')
## ch is a redis channel
async def task2(ch):
    async for msg in ch1.iter(encoding="utf-8", decoder=json.loads):
        print("receving", msg)
        user_token = msg['token']
        if user_token in r_cons.keys():
            _ws = r_cons[user_token]
            await  _ws.send_json(msg)

coroutines = list()
coroutines.append(task1(ws))
coroutines.append(task2(ch1))

await asyncio.gather(*coroutines)

这就是我的工作。当websockets需要等待来自mutli源的消息时。

这里的要点是使用asyncio.gather一起运行两个corotine @dano提到。

Asyncio + aiohttp - redis Pub / Sub和websocket在单个处理程序中读/写

问题

额外（可能是offtopic）问题

修改

编辑2

2 个答案: