9.13. TCP-сокети#

TCP-сокети бувають двох видів, що мають різний вигляд, але спільний базовий тип: клієнтські сокети, які виконують connect() до віддаленого сервера, та серверні сокети, які виконують bind(), listen() і accept() вхідних з’єднань. Обидві ролі використовують той самий клас socket, описаний на Об’єкти сокетів; різняться лише методи, які на них викликаються.

9.13.1. TCP-клієнт#

Найпростіший клієнт відкриває з’єднання, надсилає запит, зчитує відповідь і закриває:

import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("192.168.1.20", 9000))

s.send(b"hello\n")
reply = s.recv(1024)
print("reply:", reply)

s.close()

connect() виконує триходове рукостискання, описане на TCP – надійний потік байтів, і повертається, коли з’єднання встановлено. send() записує байти до з’єднання; recv() зчитує з нього до заданої кількості байтів. Після завершення роботи застосунку close() закриває з’єднання.

Той самий скрипт, загорнутий в ідіому with-statement зі сторінки Об’єкти сокетів, щоб сокет закривався навіть у разі виникнення помилки:

import socket

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect(("192.168.1.20", 9000))
    s.send(b"hello\n")
    print(s.recv(1024))

9.13.1.1. Читання до завершення#

Один виклик recv() повертає до запитаної кількості байтів – він може повернути менше, оскільки TCP є потоком, а не послідовністю повідомлень. Застосунок повинен продовжувати читати, доки не отримає повну відповідь:

chunks = []
while True:
    chunk = s.recv(1024)
    if not chunk:                  # empty bytes -> other side closed
        break
    chunks.append(chunk)
reply = b"".join(chunks)

Цикл завершується, коли recv() повертає порожній bytes. Це відбувається, коли інша сторона коректно закрила свою половину з’єднання; у цьому стилі протоколу застосунок сприймає «кінець потоку» як «кінець повідомлення».

9.13.1.2. Надсилання до завершення#

Зворотне застереження стосується send(): він може надіслати менше байтів, ніж запитано, повертаючи кількість фактично записаних байтів. Для великих даних слід повторювати надсилання нерозісланого залишку:

payload = some_big_bytes
while payload:
    n = s.send(payload)
    payload = payload[n:]

sendall() виконує цей цикл внутрішньо, тому більшість коду може просто викликати його та уникнути ручного повторення:

s.sendall(some_big_bytes)

9.13.2. TCP-сервер#

Серверна сторона складається з чотирьох кроків: зайняти порт, перевести сокет у режим прослуховування, по черзі приймати з’єднання, спілкуватися через кожен прийнятий сокет. Мінімальний сервер-відлунювач:

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("0.0.0.0", 9000))
server.listen(1)
print("listening on port 9000")

while True:
    conn, addr = server.accept()
    print("connection from", addr)

    while True:
        data = conn.recv(1024)
        if not data:
            break
        conn.send(data)            # echo back

    conn.close()

Крок за кроком:

bind() зайнятиме хост і порт на камері. "0.0.0.0" приймає на будь-якому інтерфейсі; заміна на конкретну IP-адресу обмежить прослуховувач цим інтерфейсом.
listen() переводить сокет зі звичайного в режим прослуховування. Аргумент – це черга – скільки очікуючих з’єднань MicroPython буде ставити в чергу, поки застосунок зайнятий. Вибирайте мале число; 1 підходить для більшості випадків.
accept() блокується до підключення клієнта, потім повертає (conn, addr): новий сокет для цього конкретного з’єднання та адресу клієнта. Прослуховуючий сокет залишається відкритим для прийняття нових з’єднань.
Усі байти розмови проходять через conn – новий сокет. Читання та запис використовують ті самі виклики recv() / send(), що й на стороні клієнта.
Коли клієнт закривається, recv() повертає b"": внутрішній цикл завершується, і сервер закриває свій кінець за допомогою close().

Зовнішній while True повертається до accept(), щоб очікувати наступного клієнта. У такому вигляді сервер обробляє одного клієнта за раз; для паралельної роботи з кількома клієнтами потрібні або потоки, або asyncio. Останнє є темою наступної сторінки.

9.13.3. Поширені підводні камені#

Очікування, що recv() поводиться як повідомлення. Це не так. Два виклики send(b"hi") можуть прийти як один recv(4) з b"hihi" або як два recv(2)s. Якщо межі повідомлень мають значення, застосунок повинен додати обрамлення – символ нового рядка, префікс довжини тощо.
Забування повторного надсилання при коротких відправках. Використовуйте sendall() для будь-чого, що перевищує кілька сотень байтів.
Забування закрити прийнятий сокет. Кожен conn є окремим сокетом; закриття прослуховуючого сокета не закриває прийняті. Блоки with на обох роблять цю помилку практично неможливою:
```
while True:
    with server.accept()[0] as conn:
        # ... talk on conn ...
```
Повторне прив’язування до порту, що ще перебуває в стані TIME_WAIT. Якщо сервер перезапускається через кілька секунд після закриття, bind() може завершитися помилкою «address in use», оскільки MicroPython ще утримує порт для попереднього з’єднання. Виклик server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) перед bind() усуває цю проблему.

9.13.4. Що далі#

Блокування на accept() означає, що сервер може обслуговувати лише одного клієнта за раз. Блокування на recv() означає, що один повільний клієнт зупиняє весь цикл. Стандартним рішенням на камері є asyncio – запускати кожне з’єднання як окреме завдання, дозволяючи циклу подій розподіляти роботу між ними. Наступна сторінка охоплює версії asyncio для всього, що описано на цій.