读取所有套接字异步

Question

Server await 1024 bytes:

import asyncio


async def handle_client(reader, writer):
    data = await reader.read(1024)
    writer.write("hello from server".encode())
    await writer.drain()
    writer.close()


loop = asyncio.get_event_loop()
loop.create_task(asyncio.start_server(handle_client, 'localhost', 4782))
loop.run_forever()

Client Gen 2048 bytes and send on server:

import socket
sock = socket.socket()
sock.connect(('localhost', 4782))
sock.sendall(("".join([str(i)[-1:] for i in range(2048)])).encode())
data = sock.recv(1024)
sock.close()

trouble: if buff=1020 Client sent 3000bytes server stop client and freeze him

Answer 1

This question is something that I think a lot of beginners get confused because they don't fully understand how to read sockets until completion. The answer is simple, but likely unsatisfactory:

It depends on the protocol you are using.

If you look at a standard like HTTP/1.1 the way client and servers know when the message is done (simplified for explanation - there is more to it, but for the general gist) is via the Content-Length header and a double \r\n escape characters. So when the client sends something over to the server, he/she would send:

GET / HTTP/1.1\r\n
Host: www.example.com\r\n
Connection: close\r\n\r\n

In this case the client is requesting the root directory / via a GET request using the HTTP/1.1 protocol.

Notice the double \r\n - that is the completion of the header and message, and the server will not read the socket beyond this since there is no Content-Length header present. Then the server would reply with:

HTTP/1.1 200 OK\r\n
Content-Length: 18\r\n\r\n
{"hello": "world"}

This a dumb-down explanation how both client and server know how long to read a socket for when using HTTP/1.1. You can easily find more information about the protocol online, and there are a few libraries out there that will help you creating your own raw HTTP requests.

If you want to write your own version of this - I would not recommend to use your own protocol in production unless you really know what you are doing - you could be a bit more simple and simply read the socket until a symbol (example) \0 is reached, which indicates the end of either the client or server message.

In short: the protocol matters, and if you are not using a standard protocol you need to figure out how to tell the client and server until when they should read their socket for.