target socket is occupied rust что это

Как не копировать код в Rust

Первое правило хорошего тона в программировании (или одно из первых) гласит: «Не копируй код». Используй функции и наследование.

Если с функциями все понятно, то с наследованием посложнее. Вы, наверное, знаете, что в Rust нет прямого наследования, но есть способы добиться чего-то на него похожего. О них я и расскажу.

impl dyn Trait

Представим, что вы пишете иерархию классов для игры в жанре RPG. Так вот, вместо того, чтобы в каждом новом классе писать один и тот же код, например, получения урона, можно сделать единый интерфейс, который подставит нужный код там, где вы этого попросите:

TL;DR сделали 2 структуры и реализовали для них трейт Character, в котором 6 required методов и 1 provided метод.

Но внимательный читатель совершенно справедливо спросит: «Так мы ведь всё равно скопировали код?» Верно, из-за того, что в трейтах нельзя объявлять поля, нам пришлось городить required методы для получения нужных данных. Сейчас-то, конечно, их всего 6, но потом у нас могут добавиться передвижения, анимации, левел-апы и проч. Конечно, целый один метод у нас единый на все имплементации, но код-то мы все равно копируем?

Deref

Тут нам на помощь приходит трейт Deref. Честно говоря, не знаю, насколько это хорошая практика использовать его с такой целью, но, например, в image есть такое: ImageBuffer реализует Deref для [P::Subpixel] и, соответственно, имеет все методы массива, которые есть в стандартной библиотеке. Давайте перепишем наш пример под Deref и посмотрим, сколько места нам удалось сэкономить.

Неплохо, несколько строчек мы сэкономили. Ну и, конечно, надо понимать, что расширять такую иерархию проще, чем интерфейс, ведь в том случае при добавлении методов, нужно затаскивать их и в имплементации, а в данном случае достаточно лишь реализовать метод в «родителе», и мы уже получим его во всех «наследниках».

Но у такого подхода тоже есть минус. Если нам нужны другие данные, помимо «родительских», тогда нам придётся создавать дополнительные структуры, чтобы хранить уже свои, независимые от «родительских», данные. Тогда нам придется писать код вроде:

И, согласитесь, сигнатура этого метода не очень удобочитаемая. А если у нас будет несколько внутренних структур, то остаётся только пожелать здоровья людям, которые будут это ревьюить и/или поддерживать.

Заключение

В заключение хочу сказать, что в расте не помешало бы явное наследование структур. Всё-таки, как ни крути, в других языках оно позволяет писать с одной стороны хорошо читаемый, с другой стороны лаконичный код (если, конечно, это не множественное наследование). Подходы в Rust, конечно, позволяют экономить какое-то количество места, но хотелось бы чего-то более явного. Да и интерфейсы Deref, DerefMut вообще не предназначены для того, для чего мы их использовали в данной статье. Они, как следует из названия, нужны чтобы разыменовывать умные указатели. А если вы объединяете несколько структур данных, то вам придется использовать синтаксис self.1, который далеко не очевидный. В общем, как и всегда, есть и плюсы и минусы.

Вот, собственно, и все, что я хотел сказать на эту тему. Может, я что-то упустил? Напишите в комментариях, если вас тоже волнует эта тема, хочется знать, что не мне одному не хватает наследования в Rust.

Источник

Target socket is occupied rust что это

I’ve been having a major problem whenever I try to administrate one of my vending machines.

Does anyone know how to fix this? Is it something in my settings or the servers settings?

I usually run a lot of shops in a weekly wipe so I get a lot sulfur. So can’t really imagine not doing this for a while. I wanna fix this before tonight’s wipe.

If anyone can help me, I appreciate it a lot.

This is usually down to a server DDOS, I’ve had it before, interacting with all items is very laggy, resulting in ‘Packet Flooding: Player Tick’

This is usually down to a server DDOS, I’ve had it before, interacting with all items is very laggy, resulting in ‘Packet Flooding: Player Tick’

Ошибка в раст

Билет на владение приложением
Эта часть билета подписана Steam и действительна в течение более длительного периода времени, обычно пару недель. Это доказывает, что у вас есть игра, для которой вы пытаетесь пройти аутентификацию. Его можно многократно использовать с разными токенами GC.

Он содержит такие вещи, как ваш SteamID, идентификатор приложения, для которого он был назначен, ваши внешние и внутренние IP-адреса, время, когда был сгенерирован тикет, и когда он истекает, ваши лицензии, которые предоставляют вам эту игру, любой DLC, которым вы владеете и подпись.

Поскольку эта часть заявки подписана, имеет срок действия и может быть повторно использована, нет необходимости отправлять ее в Steam для проверки, поэтому она проверяется

Заключение

В заключение хочу сказать, что в расте не помешало бы явное наследование структур. Всё-таки, как ни крути, в других языках оно позволяет писать с одной стороны хорошо читаемый, с другой стороны лаконичный код (если, конечно, это не множественное наследование). Подходы в Rust, конечно, позволяют экономить какое-то количество места, но хотелось бы чего-то более явного. Да и интерфейсы Deref, DerefMut вообще не предназначены для того, для чего мы их использовали в данной статье. Они, как следует из названия, нужны чтобы разыменовывать умные указатели. А если вы объединяете несколько структур данных, то вам придется использовать синтаксис self.1, который далеко не очевидный. В общем, как и всегда, есть и плюсы и минусы.

Вот, собственно, и все, что я хотел сказать на эту тему. Может, я что-то упустил? Напишите в комментариях, если вас тоже волнует эта тема, хочется знать, что не мне одному не хватает наследования в Rust.

Disconnected: Packet Flooding: Player Tick

New comments cannot be posted and votes cannot be cast

Something very similar to this actually just happened to me.

24 hours before this there were rumors of this particular server getting DDOS attacked. So I signed in to reset decay on the 10x server I play just for raid-fun, and I hear people rocketing my shit to death.

Now, when I opened my door after hearing what I thought to be people rocketing directly through my base, they had went straight for the loot, ignored loot rooms and 4 people were all standing in the one missing foundation looting stashes. Because of this, I actually killed all 4 of them and got a chance to see their bodys.

Rockets. Rockets. Rockets. Rockets. The rockets which stacked to 10, they had stacks, and stacks, of rockets. I know its a 10x server but were talking 150 rockets on Each person

They blew a direct line to the foundation, blew down, and left after that. No TC, no loot rooms.

Deref

Тут нам на помощь приходит трейт Deref. Честно говоря, не знаю, насколько это хорошая практика использовать его с такой целью, но, например, в image есть такое: ImageBuffer реализует Deref для [P::Subpixel] и, соответственно, имеет все методы массива, которые есть в стандартной библиотеке. Давайте перепишем наш пример под Deref и посмотрим, сколько места нам удалось сэкономить.

Неплохо, несколько строчек мы сэкономили. Ну и, конечно, надо понимать, что расширять такую иерархию проще, чем интерфейс, ведь в том случае при добавлении методов, нужно затаскивать их и в имплементации, а в данном случае достаточно лишь реализовать метод в «родителе», и мы уже получим его во всех «наследниках».

Но у такого подхода тоже есть минус. Если нам нужны другие данные, помимо «родительских», тогда нам придётся создавать дополнительные структуры, чтобы хранить уже свои, независимые от «родительских», данные. Тогда нам придется писать код вроде:

И, согласитесь, сигнатура этого метода не очень удобочитаемая. А если у нас будет несколько внутренних структур, то остаётся только пожелать здоровья людям, которые будут это ревьюить и/или поддерживать.

Target socket is occupied rust что это

Эта публикация удалена, так как она нарушает рекомендации по поведению и контенту в Steam. Её можете видеть только вы. Если вы уверены, что публикацию удалили по ошибке, свяжитесь со службой поддержки Steam.

Этот предмет несовместим с Rust. Пожалуйста, прочитайте справочную статью, почему этот предмет может не работать в Rust.

Этот предмет виден только вам, администраторам и тем, кто будет отмечен как создатель.

В результатах поиска этот предмет сможете видеть только вы, ваши друзья и администраторы.

Вылетает игра при запуске, на стадии Bootstrap Warmup
Вылетает игра при запуске, на стадии Bootstrap Systems
Вылетает игра при запуске, на стадии Running self check
Вылетает игра при вводе IP в консоль.
При вводе IP в консоль появляется ошибка No Token Data.

Вылетает игра при запуске, на стадии Bootstrap Shaders

Обновите драйвера для видеокарты, также установите полный пакет Microsoft Visual C++ и Net framework 4.5.2 затем запускайте игру с максимальными настройками графики.

При подключении к серверу Wrong connection protocol: Client update required!

У вас старая версия, скачайте актуальную версию клиента.

Загрузка карты зависла, ошибка Oops! «The game crashed» или в консоли Out of memory

Игре не хватило оперативной памяти. Для нормальной игры нужно, как рекомендуют разработчики 64-разрядную Windows и не менее 4-6 гб ОЗУ. Также возможны вылеты на рабочий стол без каких либо ошибкок ( возможно из-за нехватки оперативной памяти)

При подключении к серверу ошибка EAC: unconnected.

Запускайте игру через RustClient.exe, если не помогло, то переустановите EAC.

Эта ошибка происходит, если EAC уже запущен. Откройте диспетчер задач и закройте процессы игры, а также EasyAntiCheat.exe. Перезагрузитесь.

По какой-то причине не удалось получить ip
Очистите локальный кэш DNS. Для очистки выполните следующие команды в командной строке: ipconfig /flushdns

Видекарта не может обработать данные ( попробуйте обновить драйвера)

скорее всего у вас 32-х битная система, для игры требуется x64

Rust просто не запускается или пишет прекращена работа программы

Проверьте наличие установленного программного по. такого как Net framework 4.5.2+Microsoft visual c++ 2005, 2008, 2010, 2012 и тд.

Проследите, чтобы игру не блокировал ваш антивирус и firewall windows, а также возможно вы подписаны на бета программы. Для того что бы решить эту проблему нужно просто от них отписаться, сделать это можно по следующему алгоритму:
Выйти из игры.
Зайти в библиотеку Steam.
Находим ярлык игры Rust, щелкаем по нему ПКМ и выбираем Свойства.
Находим вкладку «Бета» (BETAS) в окне.
И в ней выбираем: «NONE — Opt out of all beta programs».

Ошибка steam Auth:K_EAuthSessionResponseVACCheckTimedOut

Вылет происходит из-за слабых видеокарт, которые не могут обработать данные. Попробуйте обновить драйвер до последней версии, если не поможет, то игру вы не запустите.

Бывает такое, что при загрузке на сервер мы получаем такую надпись You are already connected

Просто ждать, если перевести данные слова, то в них сказано будто вы уже присоединились и находитесь на этом сервере. Пройдет со временем. Можно также попробовать очистить кэш игры.

Установить Microsoft visual c++ 2013 версии x86 и x 64 ( запускать игру на diretrix 9.0)

Вылетает на Loading level Prosedural Map или Loading level HAPISISLAND

Можно попробовать обновить драйвер на видеокарту
Запускайте игру на DiretcX 9.0

Возникает на слабых видеокартах. Ждем когда будет новый патч, который исправит данную проблему.

При заходе на сервер пишет Disconnected: EAC Network: Disconnected

Что-то блокирует связь с серверами EAC. Попробуйте выключить антивирус и firewall windows

При заходе на сервер вылезает окошко с надписью «ops the game crashed», оперативной памяти более 8 гигабайт и система 64 разрядная

]На ноутбуках может быть то, что игра по умолчанию будет использовать интегрированную видеокарту и нужно переключиться на дискетную.
Для этого запускаем панель управления nvidia > управления параметрами 3D > выбираем вкладку программные настройки и в списке ищем Rust, после во втором пункте предпочтение выбираем высокопроизводительный процессор Nvidia.

Данная ошибка может возникать из-за несовместимости с системой, а именно windows xp, vista, а также на некоторых mac os. На них игра не запустится, так как отсутствуют некоторые библиотеки.

EasyAntyCheat disconnect и ничего не помогает, все программное по установлено

Служба не может быть запущена, поскольку она либо отключена либо он не имеет связанного с ней устройства
Написать в командной строке (cmd) sc delete easyanticheat
если не поможет добавить в исключение антивируса файл EasyAntiCheat.sys

Чаще всего бывает из-за нехватки оперативной памяти, блокировке соединения антивирусом

Заходим в папку с игрой и ставим совместимость на раст клиент с windows vista 1 ( убираем галочку выполнять от администратора) если не заходит то оставляем ее

Антивирус блокирует соединение Eac, нет соединения с серверами античита, отключить антивирус, переустановить античит

Это не ошибка, а простое уведомление о том, что подключение не удалось. Почему оно не удалось неизвестно. Но может быть причина в интернет соединении
Если вы пользуетесь модемом, то пробуйте его перезагрузить. Иногда может возникать из-за потери пакетов игры.

Отключить и если не поможет, то удалить антивирус и переустановить Eac

Удалить антивирус, прописать в командной строке (cmd) sc delete easyanticheat

Rust launcher error launch failure error validating easyanticheat code signing certificate

Античиту игры мешает программа КриптоПро, ее удаление поможет решить проблему. Также все подобные ошибки 19, 20, 21 и тд. с такой надписью, ошибка античита. Переустановить античит, при этом удалив антивирус и прочие программы, которые могут блокировать файлы

Данная проблема может появиться при блокировке файлов античит системы EAC, антивирусом или брандмауэром windows, а также другими защитными средствами. Даже в выключенном состоянии антивирус способен блокировать неугодные ему файлы.

Не забывайте оценивать и делиться руководством с другими пользователями!
Список ошибок и их решений будет пополняться.

Как не копировать код в Rust

Первое правило хорошего тона в программировании (или одно из первых) гласит: «Не копируй код». Используй функции и наследование.

Если с функциями все понятно, то с наследованием посложнее. Вы, наверное, знаете, что в Rust нет прямого наследования, но есть способы добиться чего-то на него похожего. О них я и расскажу.

impl dyn Trait

Представим, что вы пишете иерархию классов для игры в жанре RPG. Так вот, вместо того, чтобы в каждом новом классе писать один и тот же код, например, получения урона, можно сделать единый интерфейс, который подставит нужный код там, где вы этого попросите:

TL;DR сделали 2 структуры и реализовали для них трейт Character, в котором 6 required методов и 1 provided метод.

Но внимательный читатель совершенно справедливо спросит: «Так мы ведь всё равно скопировали код?» Верно, из-за того, что в трейтах нельзя объявлять поля, нам пришлось городить required методы для получения нужных данных. Сейчас-то, конечно, их всего 6, но потом у нас могут добавиться передвижения, анимации, левел-апы и проч. Конечно, целый один метод у нас единый на все имплементации, но код-то мы все равно копируем?

Источник

Rust в деталях: пишем масштабируемый чат с нуля, часть 1

Часть 1: Реализуем WebSocket. Введение.

В этом цикле статей мы рассмотрим процесс создания масштабируемого чата, который будет работать в реальном времени.
Целью данного обзора является пошаговое изучение основ быстро набирающего популярность языка программирования Rust на практике, с попутным охватом системных интерфейсов.

В первой части мы рассмотрим начальную настройку окружения и реализацию простейшего WebSocket-сервера. Чтобы понять технические детали статьи вам не потребуется опыта работы с языком Rust, хотя знание основ системных API (POSIX) и C/C++ лишним не будет. Прежде чем начинать чтение, заготовьте немного времени (и кофе) — статья описывает все максимально подробно и поэтому довольно длинная.

1 Rust — причина выбора

Я заинтересовался языком программирования Rust из-за давнего увлечения системным программированием, которое дело хоть и занимательное, но и весьма сложное — все потому что и новичков, и опытных разработчиков поджидает большое количество совершенно неочевидных моментов и каверзных проблем.

И, пожалуй, наиболее сложной проблемой тут можно назвать безопасную работу с памятью. Именно некорректная работа с памятью является причиной множества багов: переполнения буфера, утечки памяти, двойных освобождений памяти, висячих ссылок, разыменований указателей на уже освобожденную память, и т.п. И подобные ошибки порой влекут за собой серьезные проблемы в безопасности — например, причиной не так давно нашумевшего бага в OpenSSL, Heartbleed, является ни что иное как небрежное обращение с памятью. И это только верхушка айсберга — никому неизвестно, сколько подобных брешей таится в программном обеспечении которым мы пользуемся ежедневно.

То есть, на уровне языка нет обязательного условия применять подобные практики — вместо этого считается, что “хорошие разработчики” их всегда используют сами и никогда не делают ошибок. Однако я же считаю, что наличие подобных критических проблем в коде никак не связано с уровнем разработчиков, потому что люди не могут досконально проверять вручную большие объемы кода — это задача компьютера. В какой-то степени здесь помогают инструменты статического анализа — но, опять же, их используют далеко не все и не всегда.

У языка Rust другой подход к проблеме — можно сказать, золотая середина — автоматическое освобождение памяти и ресурсов без дополнительного потребления памяти или процессорного времени и без необходимости самостоятельного отслеживания каждого шага. Достигается это за счет применения концепций владения и заимствования.

В основе языка лежит утверждение, что у каждого значения может быть исключительно один владелец — то есть, может существовать только одна изменяемая переменная указывающая на определенную область памяти:

У такого подхода есть интересные последствия: поскольку значение связано исключительно с одной переменной, ресурсы связанные с этим значением (память, файловые дескрипторы, сокеты, и т.п.) автоматически освобождаются при выходе переменной из области видимости (которая задается блоками кода внутри фигурных скобок, < и >).

Такие искусственные ограничения могут выглядеть ненужными и излишне переусложненными, но если хорошо подумать, то, по большому счету, это и есть “киллер-фича” Rust, которая появилась исключительно из практических соображений. Именно такой подход позволяет Rust выглядеть языком высокого уровня при сохранении эффективности низкоуровневого кода, написанного на C/C++.

2 Цели

Я предпочитаю изучать новые языки и концепции разрабатывая относительно простые проекты с применением в реальном мире. Таким образом, возможности языка изучаются именно тогда, когда они становятся нужными. В качестве проекта для изучения Rust’а я выбрал сервис анонимных чатов наподобие Chat Roulette и многих других. На мой взгляд, это подходящий выбор по той причине, что чаты, как правило, требовательны к низкому времени отклика от сервера и подразумевают наличие большого количества одновременных подключений. Мы будем рассчитывать на несколько тысяч — так мы сможем посмотреть на потребление памяти и производительность программ написанных на Rust’е в реальном окружении.

Конечным результатом должен стать бинарный файл программы со скриптами для развертывания нашего сервера на различных облачных хостингах.

Но прежде чем мы начнем писать код, нужно сделать небольшое отступление для пояснения некоторых моментов с вводом-выводом, так как правильная работа с ним — ключевой момент при разработке сетевых сервисов.

3 Варианты работы с вводом-выводом

Для выполнения поставленных задач нашему сервису необходимо отправлять и получать данные через сетевые сокеты.

На первый взгляд, задача простая, но на самом деле существует множество возможных способов ее решения различной сложности и различной эффективности. Основное различие между ними кроется в подходе к блокировкам: стандартной практикой тут является прекращение работы процессора во время ожидания поступления новых данных в сокет.

Поэтому смасштабировать многопоточную программу до большого количества подключений может быть довольно сложно, и в нашем случае это вообще вряд ли разумно — ведь мы планируем несколько тысяч одновременно подключенных пользователей. В конце концов, надо быть готовыми к Хабраэффекту!

4 Цикл обработки событий

Оба этих API устроены довольно похожим образом, и общая идея проста: мы, вместо того чтобы ждать, когда в сокеты через сеть поступят новые данные, просим сокеты оповещать нас о пришедших байтах.

Оповещения в форме событий поступают в общий цикл, который в данном случае и выступает блокировщиком. То есть, вместо того, чтобы постоянно проверять тысячи сокетов на наличие в них новых данных, мы просто ждем, когда сокеты сами нам об этом сообщат — и разница довольно существенна, поскольку довольно часто подключенные пользователи находятся в режиме ожидания, ничего не отправляя и не получая. Особенно это характерно для приложений, использующих WebSocket. К тому же, используя асинхронный ввод-вывод мы практически не имеем накладных расходов — все, что требуется хранить в памяти — это файловый дескриптор сокета и состояние клиента (в случае чата это несколько сотен байт на одно подключение).

Любопытной особенностью такого подхода является возможность использовать асинхронный ввод-вывод не только для сетевых подключений, но и, например, для чтения файлов с диска — цикл обработки событий принимает любые типы файловых дескрипторов (а сокеты в мире *NIX именно ими и являются).

5 Начинаем проект

Дальнейший текст подразумевает, что у вас уже установлен Rust. Если еще нет — то следуйте документации на официальном сайте.

Именно это нам и нужно в данный момент, так что давайте попробуем открыть терминал и набрать такую команду:

В результате у нас появятся два файла:

Cargo.toml содержит описание и ссылки на зависимости проекта (схоже с package.json в JavaScript).
src/main.rs — главный исходный файл и точка входа в нашу программу.

6 Обработка событий в Rust

Перейдем от теории к практике. Давайте попробуем запустить простейший цикл событий, который будет ожидать появления новых сообщений. Для этого нам не нужно вручную подключать различные системные API — достаточно воспользоваться уже существующей библиотекой для работы с асинхронным I/O под названием “Metal IO” или mio.

Как вы помните, зависимостями занимается программа Cargo. Она загружает библиотеки из репозитория crates.io, но помимо того позволяет получать их и из Git-репозиториев напрямую — такая возможность бывает полезна в тех случаях, когда нам нужно использовать последнюю версию библиотеки, которая еще не была загружена в репозиторий пакетов.

На момент написания статьи у mio в репозитории доступна только уже устаревшая версия 0.3 — в находящейся в разработке версии 0.4 появилось много полезных изменений, к тому же, несовместимых со старыми версиями. Поэтому подключим ее напрямую через GitHub, добавив такие строки в Cargo.toml :

После того, как мы определили зависимость в описании проекта, добавим импорт в main.rs :

Хотя в языке Rust нет поддержки “традиционного” объектно-ориентированного программирования, структуры во многом аналогичны классам, и они похожим на классический ООП образом могут имплементировать интерфейсы, которые регламентируются в языке через типажи.

Давайте определим новую структуру:

И реализуем типаж Handler для нее:

Теперь запустим цикл событий:

Здесь нам впервые встречается применение заимствований (borrows): обратите внимание на &mut на последней строчке. Это обозначает, что мы временно передаем “право владения” значением, связывая его с другой переменной с возможностью изменения (mutation) данных.

Проще говоря, можно представить себе принцип работы заимствований следующим образом (псевдокод):

Вышеприведенный код эквивалентен этому:

На каждую область видимости у переменной может быть только одно изменяемое заимствование (mutable borrow), и даже владелец значения не может его читать или изменять до тех пор, пока заимствование не выйдет из области видимости.

Ничего страшного, если такое описание показалось вам недостаточно понятным — рано или поздно наступит интуитивное понимание, поскольку заимствования в Rust используются повсеместно, и по ходу чтения статьи вы найдете больше практических примеров.

Теперь давайте вернемся к нашему проекту. Запускайте команду “ cargo run ” и Cargo скачает все необходимые зависимости, скомпилирует программу (с некоторыми предупреждениями, которые мы можем пока проигнорировать), и запустит ее.

В итоге мы увидим окно терминала с мигающим курсором. Не очень интересный результат, но он, по крайней мере, показывает, что программа выполняется корректно — мы успешно запустили цикл событий, хоть он пока ничего полезного и не делает. Давайте это положение дел исправим.

Чтобы прервать выполнение программы, воспользуйтесь комбинацией клавиш Ctrl+C.

7 TCP-сервер

Давайте рассмотрим его построчно.

Распарсим строку «0.0.0.0:10000» в структуру, описывающую адрес и привяжем к этому адресу сокет:

Создаем слушающий сокет и запускаем прослушивание:

Вы также могли заметить, что мы почти везде вызываем unwrap для результата выполнения функции — это паттерн обработки ошибок в Rust, и мы скоро вернемся к этой теме.

Теперь давайте добавим созданный сокет в цикл событий:

Вызов register посложнее — функция принимает следующие аргументы:

Разница между двумя подходами, названия которых позаимствованы из электроники, заключается в моменте, когда сокет оповещает нас о произошедшем событии — например, при событии поступления данных (т.е. если мы подписаны на событие readable() ) в случае срабатывания по уровню мы получаем оповещение, если в буфере сокета есть доступные для чтения данные. В случае же сигнала по фронту оповещение мы получим в тот момент, когда в сокет поступят новые данные — т.е., если при обработке события мы не прочитали все содержимое буфера, то мы не получим новых оповещений до тех пор, пока не поступят новые данные. Более подробное описание (на английском) есть в ответе на Stack Overflow.

8 Принимаем соединения

Все соединения по протоколу WebSocket начинаются с подтверждения установления связи (т.н. handshake) — специальной последовательности запросов и ответов, передаваемых по HTTP. Это означает, что прежде чем приступить к реализации ВебСокета мы должны научить наш сервер общаться по базовому протоколу, HTTP/1.1.

Заголовки запроса на соединение по протоколу WebSocket.

Но прежде чем мы начнем реализовать HTTP, нам необходимо написать код для установления соединений с клиентами и подписки на поступающие от них события.

Рассмотрим базовую реализацию:

Кода получилось много, поэтому давайте рассмотрим его детальнее — шаг за шагом.

В первую очередь нам нужно добавить состояние в серверную структуру WebSocketServer — она будет хранить серверный сокет и сокеты подключенных клиентов.

Для хранения клиентских сокетов используем структуру данных HashMap из стандартной библиотеки коллекций, std::collections — это стандартная реализация для хеш-таблиц (также известных как словари и ассоциативные массивы). В качестве ключа мы будем использовать уже знакомые нам токены, которые должны быть уникальными для каждого подключения.

Далее нам снова пригождается типаж Handler из библиотеки mio :

Слушающий сокет генерирует события типа readable в тот момент, когда новый клиент поступил в очередь ожидающих соединения. Но прежде, чем мы начнем соединяться, нам нужно убедиться в том, что источник события — именно слушающий сокет. Мы легко можем это проверить используя сопоставление с образцом:

Что это значит? Синтаксис match напоминает стандартную конструкцию switch из “традиционных” императивных языков программирования, но дает намного больше возможностей. Например, в Java конструкция switch ограничена определенным набором типов и работает только для чисел, строк, и перечислений enum. В Rust же match позволяет делать сопоставление практически для любого типа, включая множественные значения, структуры, и т.п. Помимо сопоставления match также позволяет захватывать содержимое или части образцов, схожим с регулярными выражениями образом.

В вышеприведенном примере мы сопоставляем токен с образцом Token(0) — как вы помните, он связан со слушающим сокетом. И чтобы наши намерения были более понятными при чтении кода, мы определили этот токен в виде константы SERVER_TOKEN :

Теперь, когда мы уверены, что имеем дело с серверным сокетом, мы можем установить соединение с клиентом:

Так что давайте распакуем возвращенный accept() ‘ом результат:

Продолжаем сопоставлять результаты с образцами:

Полученный сокет мы сохраняем в хеш-таблице, не забывая увеличить счетчик токенов:

Наконец, нам нужно подписаться на события от сокета, с которым мы только что установили соединение — давайте зарегистрируем его в цикле событий. Делается это точно таким же образом, как и с регистрацией серверного сокета, только теперь мы в качестве параметров предоставим другой токен, и, конечно же, другой сокет:

Ну и, наконец, из-за того, что наша структура WebSocketServer усложнилась, нам нужно поменять код регистрации сервера в цикле событий. Изменения достаточно простые и в основном касаются инициализации новой структуры:

9 Парсим HTTP

Теперь, когда мы установили соединение с клиентом, согласно протоколу нам нужно распарсить входящий HTTP-запрос и “переключить” (upgrade) соединение на протокол WebSocket.

Поскольку это довольно скучное занятие, мы не будем все это делать вручную — вместо этого воспользуемся библиотекой http-muncher для парсинга HTTP, добавив ее в список зависимостей. Библиотека адаптирует для Rust парсер HTTP из Node.js (он же по совместительству парсер в nginx), который позволяет обрабатывать запросы в потоковом режиме, что как раз будет очень полезным для TCP-соединений.

Давайте добавим зависимость в Cargo.toml :

Не будем рассматривать API библиотеки в деталях, и сразу перейдем к написанию парсера:

И еще нам нужно внести некоторые изменения в реализацию функции ready в структуре WebSocketServer :

Давайте опять попробуем рассмотреть новый код построчно.

Первым делом мы импортируем библиотеку и добавляем контролирующую структуру для парсера:

Однако, тут есть одна деталь: парсер HTTP имеет свое состояние, а это значит, что нам нужно будет создавать новый экземпляр структуры HttpParser для каждого нового клиента. Учитывая, что каждый клиент будет хранить у себя состояние парсера, давайте создадим новую структуру, описывающую отдельного клиента:

Так как теперь мы можем там же хранить и клиентский сокет, можно заменить определение HashMap на HashMap в структуре сервера.

Этой функции не нужно принимать никаких параметров — у нас уже есть вне необходимое состояние внутри самой структуры.

Теперь мы можем начать читать поступающие от клиента данные:

Вызов try_read может завершиться ошибкой, поэтому мы проводим сопоставление с образцом по типу Result :

Затем мы провереяем, остались ли еще байты для чтения в буфере TCP-сокета:

try_read возвращает результат Ok(None) в том случае, если мы прочитали все доступные данные, поступившие от клиента. Когда это происходит, мы прерываем бесконечный цикл и продолжаем ждать новых событий.

И, наконец, вот обработка случая, когда вызов try_read записал данные в наш буфер:

Здесь мы отправляем полученные данные парсеру и сразу же проверяем имеющиеся HTTP-заголовки на наличие запроса на “переключение” соединения в режим WebSocket (точнее говоря, мы ожидаем заголовок Connection: Upgrade ).

Есть еще пара деталей. Обратите внимание, что мы не используем ключевое слово return в явном виде — Rust позволяет автоматически возвращать последнее выражение функции в качестве ее результата.

И эта строчка требует пояснения:

Теперь, когда мы разобрались с клиентами, мы можем вернуться к серверному коду, в котором в обработчике ready мы вносим такие изменения:

В конце мы должны перерегистрировать клиента в цикле событий (из-за oneshot() ):

Вот и все — теперь мы знаем, когда клиент хочет установить соединение по протоколу WebSocket, и теперь мы можем подумать над тем, как отвечать на подобные запросы.

10 Подтверждение соединения

По сути, мы могли бы отправить в ответ такой простой набор заголовков:

В стандартной библиотеке Rust нет функций для работы с SHA-1 и base64, но все нужные библиотеки есть в репозитории crates.io, так что давайте их добавим в наш Cargo.toml :

Функция, которая генерирует ответный ключ довольно-таки простая:

Сам по себе этот код достаточно простой, но тут мы сталкиваемся с новой важной концепцией — совместным владением.

Правда, тут есть нюанс — значение, которое содержит Rc неизменяемое, и из-за ограничений компилятора мы не можем на него как-то повлиять. По сути, это всего лишь следствие правила Rust насчет изменяемости данных — можно иметь сколько угодно заимствований переменной, но изменять ее можно только если владелец один.

И тут опять наступает противоречие — ведь нам нужно добавлять новые заголовки в список, при том, что мы уверены, что мы изменяем эту переменную только в одном месте, так что формально правил Rust мы не нарушаем. Только компилятор с нами на этот счет не соглаится — при попытке изменить содержимое Rc произойдет ошибка компиляции.

Давайте рассмотрим эти строки из обработчика HttpParser :

Но так как мы не можем просто так отправлять данные в неблокирующие сокеты, нужно для начала попросить цикл событий о том, чтобы он нас оповестил о доступности сокета для записи. Сделать это просто — нужно поменять набор флагов EventSet на EventSet::writable() в момент перерегистрации сокета.

Помните эту строку?

Мы можем хранить набор интересующих нас событий в состоянии клиента — изменим структуру WebSocketClient :

Теперь изменим процедуру перерегистрации соответствующим образом:

Нам осталось только менять значение interest в нужных местах. Чтобы упростить этот процесс, давайте формализуем его с помощью состояний подключения:

Добавим переменную состояния в клиентскую структуру:

И добавим начальные значения новых переменных в конструктор:

Поменяем заглушку в блоке условия is_upgrade() на код смены состояния соединения:

Осталась самая малость — нам нужно собрать по частям и отправить ответную строку:

Давайте попробуем подключиться к нашему серверу. Откройте консоль разработки в вашем любимом браузере (нажав F12, например), и введите следующий код:

Похоже, что все работает — мы соединились с сервером!

Заключение

Наше увлекательное путешествие по возможностям и непривычным концепциям языка Rust подошло к концу, но мы затронули только самое начало — серия статей будет продолжена (разумеется, продолжения будут такими же длинными и скучными! :)). Нам нужно рассмотреть еще много других интересных вопросов: безопасные подключения по TLS, многопоточные циклы событий, нагрузочное тестирование и оптимизация, и, конечно, самое главное — нам еще нужно закончить реализацию протокола WebSocket и написать само приложение чата.

Но перед тем, как мы дойдем до приложения, нужно будет заняться небольшим рефакторингом и отделением библиотечного кода от кода приложения. Скорее всего, мы также рассмотрим публкацию своей библиотеки на crates.io.

Весь текущий код доступен на Гитхабе, вы можете форкнуть репозиторий и попробовать что-нибудь в нем поменять.

Чтобы следить за появлением следующих частей статьи предлагаю подписаться на меня в твиттере.

Заметки

[1] Стоит отметить, что Rust по сути использует умные указатели на уровне языка — идея заимствований во многом схожа с типами unique_ptr и shared_ptr из C++.

[3] Простые алгоритмы сборки мусора применять довольно легко, однако более сложные варианты вроде многопоточной сборки могут потребовать немалых усилий в реализации. Например, в языке Go многопоточная сборка мусора появилась только к версии 1.5, которая вышла почти спустя 3 года после первой.

[4] Вообще говоря многие реализации функций malloc() и free() имеют ту же проблему из-за фрагментации памяти.

[5] “Грейдон Хоар […] начал работу над новым языком программирования под названием Rust в 2006 г.” — InfoQ: “Interview On Rust”

[6] В странице man pthread_create(3) говорится о 2 МБ на 32-битной системе Linux.

[7] Для сравнения epoll с другими системными API рекомендую ознакомиться с публикацией “Comparing and Evaluating epoll, select, and poll Event Mechanisms”, Университет Ватерлоо, 2004 (англ.)

Выражаю признательность за помощь:
podust за иллюстрации и вычитку.
VgaCich за чтение черновиков и корректирование.

Источник