Tcp socket recv python
Странно, что в гугле не находятся статьи про сокеты для конкретно третьего питона. Разбирающиеся, может, и со второго питона всё портируют, а новички запутаются в типах.
«Со́кеты (англ. socket — разъём) — название программного интерфейса для обеспечения обмена данными между процессами. Процессы при таком обмене могут исполняться как на одной ЭВМ, так и на различных ЭВМ, связанных между собой сетью. Сокет — абстрактный объект, представляющий конечную точку соединения.» © Википедия
Суть работы: на одном компьютере программа открывает сокет, слушает какой-то порт (в случае с TCP и UDP), другая программа на другом (или том же) компьютере, указав IP и этот самый порт, подключается к слушающей порт программе, и дальше они обмениваются какими надо данными, после чего закрывают соединение.
Для работы с сокетами нам нужно импортировать соответствующий модуль.
Теперь у нас есть сокет в переменной sock, и мы можем работать с ним дальше.
Сервер TCP
Суть TCP-соединения: одна программа устанавливает соединение с другой, и они обмениваются данными, причём их потери не происходит. После завершения работы соединение должно быть закрыто.
Данные в TCP — это поток байтов. Разделять его на отдельные сообщения придётся самой программе.
Сокет для TCP-соединения создаётся как обычно. Для создания сервера нужно связать сокет с одним или всеми из имеющихся у компьютера хостов (IP-адресов) и каким-либо свободным портом. Если не указать хост или указать «0.0.0.0», сокет будет прослушивать все хосты. Если указать «127.0.0.1», то подключиться можно будет только с этого же компьютера.
Для привязки используется функция bind сокета, которая принимает массив, содержащий два элемента: хост и порт.
Теперь можно заняться прослушкой, это можно сделать с помощью функции listen. Она принимает в качестве аргумента максимальное число соединений, которые будут находиться в очереди соединений до вызова вами функции accept; она не ограничивает максимальное число активных соединений в целом.
Теперь принимаем соединения с помощью функции accept. Она ждёт появление входящего соединения и возвращает связанный с ним сокет и адрес подключившегося. Адрес — массив, состоящий из IP-адреса и порта.
В объекте conn теперь у нас сокет, через который мы можем обмениваться данными с клиентом, в addr[0] — IP-адрес подключившегося клиента. Чтобы получить следующего клиента, нужно вызвать функцию accept ещё раз, при этом необязательно закрывать соединение с предыдущим клиентом: соединений может быть условно неограниченное количество.
Для чтения данных используется функция recv, которой первым параметром нужно передать количество получаемых байт данных. Если столько байт, сколько указано, не пришло, а какие-то данные уже появились, она всё равно возвращает всё, что имеется, поэтому надо контролировать размер полученных данных.
Тип возвращаемых данных — bytes. У этого типа есть почти все методы, что и у строк, но для того, чтобы использовать из него текстовые данные с другими строками (складывать, например, или искать строку в данных, или печатать), придётся декодировать данные (или их часть, если вы обработали байты и выделили строку) и использовать уже полученную строку. (Здесь и далее используется кодировка utf-8, если вы вдруг по какой-то глупости используете другую кодировку — указывайте свою.)
udata = data.decode("utf-8")
print("Data: " + udata)
>>> print("Data: "+data)
Traceback (most recent call last):
File "", line 1, in module>
TypeError: Can't convert 'bytes' object to str implicitly
Для отправки данных в сокет используется функция send. Принимает она тоже bytes, поэтому для отправки строки вам придётся её закодировать.
conn.send(b"Hello!\n")
conn.send(b"Your data: " + udata.encode("utf-8"))
Вот так с помощью функций recv и send и осуществляется весь обмен данными в TCP-соединении.
После всего и клиенту, и серверу необходимо закрыть сокет с помощью функции close.
Теперь этот сокет использовать нельзя.
В случае, если другая сторона сторона закроет сокет, функция recv вернёт пустой объект bytes.
Если данных приходится ждать слишком долго, можно перед использованием функции recv задать (однократно) таймаут с помощью функции settimeout.
conn, addr = sock.accept() # старая строка получения сокета
conn.settimeout(60) # установка таймаута
data = conn.recv(16384) # получение данных, про это рассказано выше
Теперь, если за 60 секунд не придут никакие данные, функция recv вернёт пустой объект bytes, как и при закрытом соединении.
if not data:
print("No data")
conn.close()
Для примера и закрепления всего прочитанного привожу простенький HTTP-сервер, возвращающий текущие дату и время.
Запустите его и наберите в браузере адрес http://localhost:8080/time.html
#!/usr/bin/env python3
import time
import socket
def send_answer(conn, status="200 OK", typ="text/plain; charset=utf-8", data=""):
data = data.encode("utf-8")
conn.send(b"HTTP/1.1 " + status.encode("utf-8") + b"\r\n")
conn.send(b"Server: simplehttp\r\n")
conn.send(b"Connection: close\r\n")
conn.send(b"Content-Type: " + typ.encode("utf-8") + b"\r\n")
conn.send(b"Content-Length: " + bytes(len(data)) + b"\r\n")
conn.send(b"\r\n")# после пустой строки в HTTP начинаются данные
conn.send(data)
def parse(conn, addr):# обработка соединения в отдельной функции
data = b""
while not b"\r\n" in data: # ждём первую строку
tmp = conn.recv(1024)
if not tmp: # сокет закрыли, пустой объект
break
else:
data += tmp
if not data: # данные не пришли
return # не обрабатываем
udata = data.decode("utf-8")
# берём только первую строку
udata = udata.split("\r\n", 1)[0]
# разбиваем по пробелам нашу строку
method, address, protocol = udata.split(" ", 2)
if method != "GET" or address != "/time.html":
send_answer(conn, "404 Not Found", data="Не найдено")
return
answer = """"""
answer += """"""
answer += time.strftime("%H:%M:%S %d.%m.%Y")
answer += """"""
send_answer(conn, typ="text/html; charset=utf-8", data=answer)
sock = socket.socket()
sock.bind( ("", 8080) )
sock.listen(5)
try:
while 1: # работаем постоянно
conn, addr = sock.accept()
print("New connection from " + addr[0])
try:
parse(conn, addr)
except:
send_answer(conn, "500 Internal Server Error", data="Ошибка")
finally:
# так при любой ошибке
# сокет закроем корректно
conn.close()
finally: sock.close()
# так при возникновении любой ошибки сокет
# всегда закроется корректно и будет всё хорошо
TCP-клиент
HTTP-сервер с браузером это, конечно, хорошо, но вы же тут все хотите онлайн-игры делать ;D Поэтому придётся научиться делать программу клиентом. Сокет создаётся точно так же:
А вот дальше появляется отличие. Вместо прослушивания порта мы подключаемся к другому хосту с помощью функции connect, которая принимает этот самый хост (IP-адрес или можно сразу обычный адрес буквами написать) и порт.
А дальше всё как обычно: для установки таймаута используется settimeout, для обмена данными send и recv, для закрытия close.
conn.send(b"Hello! \n")
data = b""
tmp = conn.recv(1024)
while tmp:
data += tmp
tmp = conn.recv(1024)
print( data.decode("utf-8") )
conn.close()
Те, кто собрался делать крутые онлайн-игры в Blender Game Engine, столкнутся с тем, что функции accept и recv ждут соединения и данных, и в результате игра виснет на время ожидания, что плохо. Блокировку с recv поможет снять функция setblocking(0). Тогда в случае отсутствия данных функция не будет ждать, а выкинет исключение socket.error, которое можно будет поймать в блоке try-except, после чего спокойно завершить скрипт, не вешая игру.
# при открытии соединения:
conn = socket.socket()
conn.connect( ("yandex.ru", 80) )
conn.setblocking(0)
# в скрипте, читающем данные:
try: data = conn.recv(1024)
except socket.error: # данных нет
pass # тут ставим код выхода
else: # данные есть
print(data)
# если в блоке except вы выходите,
# ставить else и отступ не нужно
# скрипт, читающий данные, запускаем на каждом кадре
Аналогично с функцией accept.
# при создании сервера:
conn = socket.socket()
conn.bind( ("", 8989) )
conn.listen(5)
conn.setblocking(0)
# в скрипте, который получает клиентов:
try: client, addr = conn.accept()
except socket.error: # данных нет
pass # тут ставим код выхода
else: # данные есть
client.setblocking(0) # снимаем блокировку и тут тоже
parse(client, addr)
# если в блоке except вы выходите,
# ставить else и отступ не нужно
# скрипт, получающий клиентов, запускаем на каждом кадре
Но, конечно, для сервера обрабатывать, например, под сотню клиентов, у каждого просить recv и прочее это издевательство, и тут будет лучше использовать асинхронный сервер на базе asyncio или gevent, а тяжёлые CPU-bound задачи выносить в отдельные потоки (хотя в контексте Blender Game Engine это не обязательно). Но это уже темы для других постов.
Для обработки текстовых данных ознакомьтесь с функцями для работы со строками, с помощью них уже можно будет составить простой текстовый протокол и, закодироав координаты кубика с помощью str, соединив через join, отправив закодированное по сокету и разбив присланное на другом компьютере, двигать кубик по сети. (Но лучше, конечно, какой-нибудь pickle использовать, а для серьёзной игры свой бинарный протокол, чтобы трафик впустую не тратился.)