В сетевом программировании всё просто — клиент отправляет запрос, сервер его получает. Для реализации такого клиент-серверного взаимодействия используется, в том числе, Python, который имеет на борту средства для взаимодействия между вычислительными устройствами, объединенными в сеть. Самую главную роль в этом играет как раз сокет.
Сокет — это программные объекты (интерфейсы), определяющие конечную точку соединения. Сокет — это некий абстрактный файл, через который обеспечивает сетевую связность программное приложение. Программа с помощью сокета может установить входящие и исходящие соединения, а также принимать данные. Сокет работает на уровне операционной системы и имеет два параметра: порт и IP-адрес
Непонятно? Попробуем проще. Вы зашли в МакДональдс. Есть свободные кассы (порты), а есть кассы с кассирами — тоже порты, но за ними висит какое-либо приложение (это приложение постоянно прослушивает порт — нет ли новых «клиентов»).
Если вы попробуете обратиться к конкретному кассиру (приложению), то он установит с вами соединение через сокет именно своего порта. Вас же обслуживают на той кассе, к которой вы подошли, верно?
Что такое веб-сокеты за 4 минуты
Протоколы
Протокол — это арбитр, который определяет правила обмена данными между сервером и клиентом — упаковка, передача, распаковка и так далее. В рамках знакомства с сокетом в Python мы будем ориентироваться на протокол TCP (Transmission Control Protocol).
Он определяет правила выполнения большинства сетевых задач: подключения к базам данных, обеспечения сетевого взаимодействия, работы с веб-сервисами. Протокол UDP не требует подтверждения от принимающей стороны и вообще не гарантирует стабильную передачу, в то время как пакеты по TCP будут гарантировано доставляться и соблюдать очередность.
Если клиент хочет соединиться с сервером, то он отправляет свои данные через «окно» (оно же — сокет). Эти данные летят в протокол TCP, запущенный у клиента. Данные проходят через буфер и отправляются в сторону сервера, где, в свою очередь, данные также попадают через буфер в сокет.
Сокеты в питоне
В Python для работы с сокетами применяется модуль socket, в котором реализованы функции, отвечающие за создание нового сокета, установление и закрытие соединения, отправку данных по сети и их получение.
Процедура установки соединения через TCP будет выглядеть так:
Какие будут использованы функции?
Общие для клиента и сервера:
- socket() — создать сокет (функция возвращает объект сокета, методы которого реализуют различные системные вызовы сокетов)
- send() — передать данные
- recv() — получить данные
- close() — закрыть соединение
Клиентские:
- connect() — установить соединение
Серверные:
- bind() — привязать сокет к IP-адресу и порту машины
- listen() — просигнализировать о готовности принимать соединения
- accept() — принять запрос на установку соединения
Пример использования сокета
Представим простую ситуацию, клиент хочет получить от сервера текущую дату и время. Что нам нужно? Нужно настроить соединение посредством протокола TCP. Через сокет, конечно же.
Все про WebSockets (веб-сокеты) простыми словами
Серверный код:
from socket import * import time s = socket(AF_INET, SOCK_STREAM) s.bind((», 7777)) s.listen(5) while True: client, addr = s.accept() print(client) print(«Получен запрос на соединение от %s» % str(addr)) timestr = time.ctime(time.time()) + «n» client.send(timestr.encode(‘utf-8’)) client.close()
s = socket(AF_INET, SOCK_STREAM) — запускаем функцию socket() с двумя параметрами — communication domain и type of socket. В качестве коммуникационного домена, как правило, передается значение AF_INET — оно указывает, что создаваемый сокет будет сетевым. Тип сокета мы указали SOCK_STREAM, как понятно из названия — сокет у нас будет потоковый, то есть реализующий последовательный, надежный двусторонний поток байтов по протоколу TCP.
В результате функции socket() создается конечная точка соединения и возвращается файловый дескриптор (некоторый целочисленный идентификатор, однозначно определяющий файл в текущем процессе), который позволяет работать с сокетом, как с файлом — записывать и считывать данные в/из него.
s.bind((», 7777)) — присваиваем сокету 7777 порт
s.listen(5) — режим ожидания. Одновременно можем работать с 5 запросами. Слушающий процесс обычно находится в цикле ожидания, то есть просыпается при появлении нового соединения
timestr.encode(‘utf-8’) — в сетевых протоколах обмен данными должен выполняться в байтовом формате. Поэтому надо кодировать строки, передаваемые через сеть. Именно по этой причине в программе сервера к отправляемым данным применяется метод encode.
Результат подключения клиента в IDEшке:
Клиентский код:
from socket import * s = socket(AF_INET, SOCK_STREAM) s.connect((‘localhost’, 7777)) tm = s.recv(1024) s.close() print(«Текущее время: %s» % tm.decode(‘utf-8’))
s = socket(AF_INET,SOCK_STREAM) — создаем сокет
s.connect((‘localhost’, 7777)) — запускаем функцию коннект, где указываем сервер и порт
tm = s.recv(1024) — принимаем не более 1024 байта данных
tm.decode(‘utf-8’) — прежде чем работать с данными, их необходимо декодировать. Для этого в программе клиента к принимаемым данным применяется метод decode(‘utf-8’).
Немного про буфер
Немаловажный фактор при работе с сокетом — это размер буфера. Здесь можно разжиться проблемами на пустом месте. Маленький размер буфера будет обеспечивать скоростную передачу данных, но их объем будет слишком мал.
Большой буфер может пропустить через себя огромный поток данных, но при этом будет жрать ресурсы и работать достаточно медленно.
Для установки размера буфера используется метод socket.setsockopt(level, optname, None, optlen: int). Этот метод получает три аргумента: уровень, имя и числовая переменная (сам размер буфера непосредственно)
socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 8192) # Размер буфера 8192 # или s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024)
Немного про тайм-аут
Для сокета можно задать таймаут для активности (времени прослушивания) в течение которой он ожидает отправку или получения данных — socket.settimeout(value).Тайм-аут применяется к одному вызову операции чтения/записи сокета.
Аргумент value определяется в секундах. После установленного времени сокет блокируется для операций с ним. Если задан ноль, сокет переводится в неблокирующий режим, в котором операции должны быть выполнены немедленно.
s = socket.create_connection((«kite.com», 80)) s.settimeout(0.00001) try: message = «GET /text HTTP/2.0rnrn».encode() s.send(message) print(s.recv(1024)) except socket.timeout as e: print(e) # здесь сработает тайм-айут на выходе
- Отправить в ВК
- Отправить в Telegram
- Отправить в Viber
Источник: devrockets.ru
Сеть: Что такое сокет?
Вы постоянно слышите разговоры о каких-то «сокетах» и, наверно, вам интересно, что же это такое. В общем, изначально сокеты — это способ общения программ друг с другом, используя файловые дескрипторы Unix.
Ок — возможно, вы слышали от какого-нибуть Unix-хакера фразу типа «господи, всё, что есть в Unix — файлы!» Этот человек, возможно, имел в виду, что программы в Unix при абсолютно любом вводе-выводе читают или пишут в файловый дескриптор. Дескриптор файла — это простое целое число, связанное операционной системой с открытым файлов. Но (и в этом заключается ловушка) файлом может быть и сетевое подключение, и FIFO, и пайпы, и терминал, и реальный файл на диске, и просто что угодно другое. Всё в UNIX — это файл! Итак, просто поверьте, что собираясь общаться с другой программой через интернет, вам придется делать это через дескриптор файла.
«Эй, умник, а откуда мне взять этот дескриптор файла для работы в сети?» Отвечу.
Вы совершаете системный вызов socket(). Он возвращает дескриптор сокета, и вы общаетесь через него с помощью системных вызовов send() и recv() (man send, man recv).
«Но, эй!» могли бы вы воскликнуть. «Если это дескриптор файла, почему я не могу использовать простые функции read() и write(), чтобы общаться через него?». Ответ прост: «Вы можете!». Немного развернутый ответ: «Вы можете, но send() и recv() предлагают гораздо больший контроль над передачей ваших данных.»
Что дальше? Как насчет этого: бывают разные виды сокетов. Есть DARPA инернет-адреса (Сокеты интернет), CCITT X.25 адреса (X.25 сокеты, которые вам не нужны), и, вероятно, многие другие в зависимости от особенностей вашей ОС. Этот документ описывает только первые, Интернет-Сокеты.
Два типа интернет-сокетов
Что? Есть два типа интернет сокетов? Да. Ну ладно, нет, я вру. Есть больше, но я не хочу вас пугать.
Есть ещё raw-сокеты, очень мощная штука, вам стоит взглянуть на них.
Ну ладно. Какие два типа? Один из них — «потоковый сокет», второй — «сокет дейтаграмм», в дальнейшем они будут называться «SOCK_STREAM» и «SOCK_DGRAM» соответственно. Дейтаграммные сокеты иногда называют «сокетами без соединения» (хотя они могут и connect()`иться, если вам этого действительно захочется. См. connect() ниже.)
Потоковые сокеты обеспечивают надёжность своей двусторонней системой коммуникации. Если вы отправите в сокет два элемента в порядке «1, 2», они и «собеседнику» придут в том же порядке — «1, 2». Кроме того, обеспечивается защита от ошибок.
Что использует потоковые сокеты? Ну, вы наверно слышали о программе Telnet, да? Телнет использует потоковый сокет. Все символы, которые вы печатаете, должны прибыть на другой конец в том же порядке, верно? Кроме того, браузеры используют протокол HTTP, который в свою очередь использует потоковые сокеты для получения страниц. Если вы зайдёте телнетом на любой сайт, на порт 80 и наберёте что-то вроде «GET / HTTP/1.0» и нажмете ввод два раза, на вас свалится куча HTML
Как потоковые сокеты достигают высокого уровня качества передачи данных? Они используют протокол под названием «The Transmission Control Protocol», иначе — «TCP». TCP гарантирует, что ваши данные передаются последовательно и без ошибок. Возможно, ранее вы слышали о TCP как о половине от «TCP/IP», где IP — это «Internet Protocol». IP имеет дело в первую очередь с маршрутизацей в Интернете и сам по себе не отвечает за целостность данных.
Круто. А что насчёт дейтаграммных сокетов? Почему они называются без-соединительными? В чем тут дело? Почему они ненадежны?
Ну, вот некоторые факты: если вы посылаете дейтаграмму, она может дойти. А может и не дойти. Но если уж приходит, то данные внутри пакета будут без ошибок.
Дейтаграммные сокеты также используют IP для роутинга, но не используют TCP; они используют «User Datagram Protocol», или «UDP».
Почему UDP не устанавливает соединения? Потому что вам не нужно держать открытое соединение с потоковыми сокетами. Вы просто строите пакет, формируете IP-заголовок с информацией о получателе, и посылаете пакет наружу. Устанавливать соединение нет необходимости.
UDP как правило используется либо там, где стек TCP недоступен, либо там, где один-другой пропущеный пакет не приводит к концу света. Примеры приложений: TFTP (trivial file transfer protocol, младшый брат FTP), dhcpcd (DHCP клиент), сетевые игры, потоковое аудио, видео конференции и т.д.
«Подождите минутку! TFTP и DHCPcd используются для передачи бинарных данных с одного хоста на другой! Данные не могут быть потеряны, если вы хотите нормально с ними работать! Что это за темная магия?»
Нуу, мой человеческий друг, TFTP и подобные программы обычно строят свой собственный протокол поверх UDP. Например, TFTP протокол гласит, что для каждого принятого пакета получатель должен отправить обратно пакет, говорящий «я получил его!» («ACK»-пакет). Если отправитель исходного пакета не получает ответ, скажем, в течение 5 секунд, он отправит пакет повторно, пока, наконец, не получит ACK. Подобные процедуры очень важны для реализации надёжных приложений, использующих SOCK_DGRAM.
Для приложений, не требующих такой надёжности — игры, аудио или видео, вы просто игнорируете потерянные пакеты или, возможно, пытаетесь как-то их компенсировать. (Игроки в quake обычно называют это явление «проклятый лаг», и «проклятый» — это ещё крайне мягкое высказывание).
Зачем вам может понадобиться использовать ненадежный базовый протокол? По двум причинам: скорость и скорость. Этот способ гораздо быстрее, выстрелил-и-забыл, чем постоянное слежение за тем, всё ли благополучно прибыло получателю. Если вы отправляете сообщение в чате, TCP великолепен, но если вы шлёте 40 позиционных обновлений персонажа в секунду, может быть, не так и важно, если один или два из них потеряются, и UDP тут будет неплохим выбором.
Теория сетей и низкие уровни
Поскольку я только что упоминал слои протоколов, пришло время поговорить о том, как на самом деле работает сеть, и показать примеры того, как построены пакеты SOCK_DGRAM. На самом деле вы можете пропустить этот раздел, но он является неплохим теоретическим подспорьем.
Эй, детишки, настало время поговорить об инкапсуляции данных! Это очень-очень важная вещь. Это настолько важно, что вам стоит выучить это наизусть.
В основном суть такова: пакет родился; пакет завёрнут («инкапсулирован») в заголовок первым протоколом (скажем, протоколом TFTP), затем всё это (включая хидер TFTP) инкапсулируется вновь следующим протоколом (скажем, UDP), затем снова — следующим (например, IP), и наконец финальным, физическим протоколом (скажем, Ethernet).
Когда другой компьютер получает пакет, оборудование (сетевая карта) исключает Ethernet-заголовок (разворачивает пакет), ядро ОС исключает заголовки IP и UDP, программа TFTP исключает заголовок TFTP, и наконец мы получаем голые данные.
Теперь наконец можно поговорить о печально известной модели OSI — многоуровневой модели сети. Эта модель описывает систему сетевой функциональности, которая имеет много преимуществ по сравнению с другими моделями. Например, вы можете написать в своей программе как сокеты, которые шлют данные не заботясь о том, как физически передаются данные (серийный порт, эзернет, модем и т.д.), так как программы на более низких уровнях (ОС, драйверы) делают за вас всю работу, и представляют её прозрачно для программиста.
Собственно, вот все уровни полномасштабной модели:
- Прикладной
- Представительский
- Сеансовый
- Транспортный
- Сетевой
- Канальный
- Аппаратный (физический)
Физический уровень — это оборудование; ком-порт, сетевая карта, модем и т.д. Прикладной слой — дальше всех отстоит от физического. Это то место, где пользователь взаимодействует с сетью.
Для нас эта модель слишком общая и обширная. Сетевая модель, которую можем использовать мы, может выглядеть так:
- Уровень приложений (Telnet, FTP и т.д.)
- Транспортный протокол хост-хост (TCP, UDP)
- Интернет-уровень (IP и маршрутизация)
- Уровень доступа к сети (Ethernet, Wi-Fi или что угодно)
Теперь вы можете четко видеть, как эти слои соответствуют инкапсуляции исходных данных.
Видите, как много работы заключается в создании одного простого пакета? Офигеть! И все эти заголовки пакетов вы должны самостоятельно набирать в блокноте! Шучу. Всё, что вам нужно сделать в случае потоковых сокетов — это послать (send()) данные наружу. Ядро ОС построит TCP и IP хидеры, а оборудование возьмет на себя уровень доступа к сети.
Ах, я люблю современные технологии.
На этом наш краткий экскурс в теорию сетей завершен. Ах да, я забыл вам сказать: всё, что я хотел вам сказать о маршрутизации: ничего! Да-да, я ничего не буду говорить об этом. О таблице маршрутизации за вас позаботятся ОС и IP-протокол. Если вам действительно интересно, почитайте документацию в интернете, её море.
Источник: masandilov.ru
Основы программирования TCP-сокетов на Java
Клиент-серверная архитектура — наиболее распространенная структура приложений в Интернете. В этой архитектуре клиенты (т.е. персональные компьютеры, устройства Интернета вещей и т. д.) сначала запрашивают ресурсы с сервера. Затем сервер отправляет обратно соответствующие ответы на запросы клиентов. Чтобы это произошло, должен быть какой-то механизм, реализованный как на стороне клиента, так и на стороне сервера, который поддерживает эту сетевую транзакцию. Этот механизм называется коммуникацией посредством сокетов.
Почти каждое приложение, которое полагается на сетевые операции, такие как извлечение данных с удаленных серверов и загрузка файлов на сервер, широко использует сокеты “под капотом”. Несколько примеров таких приложений — браузеры, чат-приложения и одноранговые сетевые приложения.
В этой статье мы более подробно рассмотрим сокеты и простую клиент-серверную реализацию с использованием сокетов в Java.
Примечание: существует два типа сокетов: TCP и UDP. Поскольку большинство сетевых приложений используют TCP, здесь я буду говорить только о TCP-сокетах и их реализации.
Что такое сокет?
Сокет — это программная (логическая) конечная точка, устанавливающая двунаправленную коммуникацию между сервером и одной или несколькими клиентскими программами. Сокет — это нечто “программное”. Другими словами, сокет не существует на физическом уровне. Прикладное программное обеспечение определяет сокет так, чтобы он использовал порты на основном компьютере для его реализации. Это позволяет программистам комфортно работать с низкоуровневыми деталями сетевых коммуникаций, такими как порты, маршрутизация и т. д., внутри прикладного кода.
Как работают сокеты?
TCP-сокет устанавливает связь между клиентом и сервером в несколько этапов.
- Socket() — на сервере создается конечная точка для коммуникации.
- Bind() — сокету присваивается уникальный номер и для него резервируется уникальная комбинации IP-адреса и порта.
- Listen() — после создания сокета сервер ожидает подключения клиента.
- Accept() — сервер получает запрос на подключение от клиентского сокета.
- Connect() — клиент и сервер соединены друг с другом.
- Send()/Recieve() — обмен данными между клиентом и сервером.
- Close() — после обмена данными сервер и клиент разрывают соединение.
На каждой из перечисленных выше стадий коммуникации сокетов “под капотом» происходит много всего сложного. Однако этих знаний вполне достаточно для понимания и демонстрации того, как работает коммуникация посредством TCP-сокетов.
К настоящему времени мы уже достаточно знаем о TCP-сокетах. Давайте теперь посмотрим на них в действии.
Реализация коммуникации посредством TCP-сокетов в Java
Давайте посмотрим, как мы можем реализовать коммуникацию сокетов в Java. Мы сейчас напишем две Java-программы. Одной будет программа, запущенная на сервере, а другой — клиентская программа, которая будет взаимодействовать с сервером.
Реализация серверного сокета
import java.io.DataOutputStream; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class SocketServer < public static final int SERVER_PORT = 50001; public static void main (String[] args)< try < ServerSocket server = new ServerSocket(SERVER_PORT); Socket clientConn = server.accept(); DataOutputStream serverOutput = new DataOutputStream(clientConn.getOutputStream()); serverOutput.writeBytes(«Java revisitedn»); clientConn.close(); >catch (IOException e) < e.printStackTrace(); >> >
В приведенной выше программе сервер открывает сокет с порта 50001 на серверной машине и ожидает клиента на server.accept() . После подключения клиента создается экземпляр выходного потока. Это может быть использовано для отправки данных с сервера на подключенный клиент. Именно это и делает serverOutput.writeBytes() . После отправки данных соединение с клиентом завершается.
Теперь давайте создадим клиент для взаимодействия с серверным сокетом, созданным выше.
Реализация клиентского сокета
import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.net.Socket; public class SocketClient < public static void main(String[] args)< try < Socket clientSocket = new Socket («localhost»,50001); InputStream is = clientSocket.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(is)); String receivedData = br.readLine(); System.out.println(«Received Data: «+receivedData); >catch (Exception e) < e.printStackTrace(); >> >
Показанная выше программа действует как клиент, создавая соединение с серверным сокетом. После подключения клиент получает отправленные сервером данные. Входной поток соединяется с буфером, используя BufferedReader для хранения полученных данных, так как мы не можем быть уверены, что данные будут использоваться сразу же после получения. Затем мы считываем данные из буфера и выводим их в консоль.
Запуск программ
Сначала запустите серверную Java-программу, а затем клиентскую Java-программу (потому что сервер уже должен работать для подключения клиента). Вы увидите Received data: Java Revisited в терминале, где работает клиентская программа. Вот что здесь произошло: серверная программа отправила данные клиенту по запросу, а клиентская программа вывела их на терминал.
В этой статье мы обсудили, что такое сокеты и Java-реализация связи TCP-сокетов.
Спасибо за чтение.
- Кто на свете всех сильнее — Java, Go и Rust в сравнении
- Java-Lombok: нужны ли геттеры и сеттеры?
- Топ — 9 фреймворков Java в 2020 году
Источник: nuancesprog.ru