其他-Setting the call order of mutliple asyncio.Protocol.data_received

user4815162342 2020-12-02 04:34:02

First, I would recommend using the higher-level streams API instead of the transport/protocols. Then if you need to maintain the order observed when connections were made, you can enforce it yourself using a series of asyncio.Events. For example:

import asyncio, itertools

class Comm:
    def __init__(self):
        self.extra = bytearray()
        self.preceding_evt = None

    async def serve(self, r, w):
        preceding_evt = self.preceding_evt
        self.preceding_evt = this_evt = asyncio.Event()
        while True:
            request = await r.read(4096)
            # wait for the preceding connection to receive and store data
            # before we store ours
            if preceding_evt is not None:
                await preceding_evt.wait()
                preceding_evt.clear()
            # self.extra now contains data from previous connections
            self.extra.extend(request)
            # inform the subsequent connection that we got data
            this_evt.set()
        w.close()

async def main():
    comm = Comm()
    server = await asyncio.start_server(comm.serve, '127.0.0.1', 8888)
    async with server:
        await server.serve_forever()

asyncio.run(main())

Daniel 2020-12-01 22:57:41

What does Comm() return? And how can I include functionality that I did within eof_received before, in the higher-level streams API/in this solution?

user4815162342 2020-12-01 23:00:54

@Daniel Since Comm is a class, Comm() returns its instance. The instance created in main() will be shared among all the connections, just like your AIO class in the code in the question. The equivalent of eof_received() is reading an empty bytes object from r.read().

user4815162342 2020-12-01 23:02:44

@Daniel Also, note that r.read(4096) will read as much data as provided by the kernel, but no more than 4096 bytes. There is no guarantee that one whole request will be read in one read, so you might want to take steps to ensure that the whole response was read. (The approach will depend on what the request looks like.)

Daniel 2020-12-01 23:08:02

But why would you want to read the request in steps? Couldn't the whole response be read with r.read()?

user4815162342 2020-12-01 23:26:29

@Daniel r.read() will return all data sent by the peer until they've closed their side of the socket, i.e. until end-of-file. The consequence is that after r.read() nothing else can be read, so it doesn't allow the peer to continue communicating with you over the same connection. If that works for you, great, and you get to eliminate the while loop as well. If not, you have to design a way to detect where your request ends. Another downside of r.read() is that an untrusted peer can DOS you by feeding you with infinite data which will cause your server to run out of memory.

Setting the call order of mutliple asyncio.Protocol.data_received

热门帖子

热门github