Создание однопоточного веб-сервера
Мы начнём с того, что заставим работать однопоточный веб-сервер. Прежде чем начать, давайте кратко рассмотрим протоколы, участвующие в создании веб-серверов. Детали этих протоколов выходят за рамки этой книги, но краткий обзор даст вам необходимую информацию.
Два основных протокола, участвующих в веб-серверах, — это протокол передачи гипертекста (HTTP) и протокол управления передачей (TCP). Оба протокола являются протоколами запрос-ответ, что означает, что клиент инициирует запросы, а сервер слушает запросы и предоставляет ответ клиенту. Содержимое этих запросов и ответов определяется протоколами.
TCP — это протокол более низкого уровня, который описывает детали того, как информация передаётся от одного сервера к другому, но не определяет, что это за информация. HTTP строится поверх TCP, определяя содержимое запросов и ответов. Технически возможно использовать HTTP с другими протоколами, но в подавляющем большинстве случаев HTTP отправляет свои данные через TCP. Мы будем работать с необработанными байтами TCP- и HTTP-запросов и ответов.
Прослушивание TCP-соединения
Нашему веб-серверу нужно прослушивать TCP-соединение, поэтому это первая часть, над которой мы будем работать. Стандартная библиотека предлагает модуль std::net, который позволяет нам это делать. Давайте создадим новый проект обычным образом:
$ cargo new hello
Created binary (application) `hello` project
$ cd hello
Теперь введите код из листинга 21-1 в src/main.rs для начала. Этот код будет слушать локальный адрес 127.0.0.1:7878 на предмет входящих TCP-потоков. Когда он получает входящий поток, он печатает Connection established!.
use std::net::TcpListener;
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
println!("Connection established!");
}
}
Используя TcpListener, мы можем прослушивать TCP-соединения по адресу 127.0.0.1:7878. В адресе часть перед двоеточием — это IP-адрес, представляющий ваш компьютер (это одинаково на каждом компьютере и не представляет конкретно компьютер авторов), а 7878 — это порт. Мы выбрали этот порт по двум причинам: HTTP обычно не принимается на этом порту, поэтому наш сервер вряд ли будет конфликтовать с любым другим веб-сервером, который может быть запущен на вашей машине, и 7878 — это rust, набранный на телефоне.
Функция bind в этом сценарии работает как функция new в том смысле, что она возвращает новый экземпляр TcpListener. Функция называется bind, потому что в сетевых технологиях подключение к порту для прослушивания известно как «привязка к порту».
Функция bind возвращает Result<T, E>, что указывает на возможность неудачной привязки, например, если мы запустили два экземпляра нашей программы и, таким образом, имели две программы, прослушивающие один и тот же порт. Поскольку мы пишем базовый сервер только в учебных целях, мы не будем беспокоиться об обработке подобных ошибок; вместо этого мы используем unwrap, чтобы остановить программу в случае ошибок.
Метод incoming на TcpListener возвращает итератор, который даёт нам последовательность потоков (точнее, потоков типа TcpStream). Один поток представляет открытое соединение между клиентом и сервером. Соединение — это название полного процесса запроса и ответа, в котором клиент подключается к серверу, сервер генерирует ответ, и сервер закрывает соединение. Таким образом, мы будем читать из TcpStream, чтобы увидеть, что отправил клиент, а затем записывать наш ответ в поток, чтобы отправить данные обратно клиенту. В целом, этот цикл for будет обрабатывать каждое соединение по очереди и создавать серию потоков для нас для обработки.
На данный момент наша обработка потока состоит из вызова unwrap, чтобы завершить нашу программу, если поток содержит какие-либо ошибки; если ошибок нет, программа печатает сообщение. Мы добавим больше функциональности для случая успеха в следующем листинге. Причина, по которой мы можем получать ошибки от метода incoming, когда клиент подключается к серверу, заключается в том, что мы на самом деле не перебираем соединения. Вместо этого мы перебираем попытки соединения. Соединение может быть неуспешным по ряду причин, многие из которых зависят от операционной системы. Например, многие операционные системы имеют ограничение на количество одновременно открытых соединений, которые они могут поддерживать; новые попытки соединения сверх этого числа будут производить ошибку до тех пор, пока некоторые из открытых соединений не будут закрыты.
Давайте попробуем запустить этот код! Вызовите cargo run в терминале, а затем загрузите 127.0.0.1:7878 в веб-браузере. Браузер должен показать сообщение об ошибке, такое как «Connection reset», потому что сервер в настоящее время не отправляет никаких данных. Но когда вы посмотрите на свой терминал, вы должны увидеть несколько сообщений, которые были напечатаны, когда браузер подключился к серверу!
Running `target/debug/hello`
Connection established!
Connection established!
Connection established!
Иногда вы увидите несколько сообщений, напечатанных для одного запроса браузера; причина может быть в том, что браузер делает запрос страницы, а также запрос других ресурсов, таких как значок favicon.ico, который появляется на вкладке браузера.
Также может быть, что браузер пытается подключиться к серверу несколько раз, потому что сервер не отвечает никакими данными. Когда stream выходит из области видимости и отбрасывается в конце цикла, соединение закрывается в рамках реализации drop. Браузеры иногда справляются с закрытыми соединениями, повторяя попытки, потому что проблема может быть временной.
Браузеры также иногда открывают несколько соединений к серверу, не отправляя никаких запросов, чтобы, если они действительно позже отправят запросы, эти запросы могли происходить быстрее. Когда это происходит, наш сервер увидит каждое соединение, независимо от того, есть ли какие-либо запросы по этому соединению. Многие версии браузеров на основе Chrome делают это, например; вы можете отключить эту оптимизацию, используя режим приватного просмотра или другой браузер.
Важным фактором является то, что мы успешно получили дескриптор TCP-соединения!
Не забудьте остановить программу, нажав ctrl-C, когда вы закончите запускать конкретную версию кода. Затем перезапустите программу, вызвав команду cargo run после того, как вы внесли каждый набор изменений в код, чтобы убедиться, что вы запускаете самую новую версию кода.
Чтение запроса
Давайте реализуем функциональность чтения запроса от браузера! Чтобы разделить заботы о первом получении соединения и затем выполнении какого-либо действия с соединением, мы начнём новую функцию для обработки соединений. В этой новой функции handle_connection мы будем читать данные из TCP-потока и печатать их, чтобы мы могли видеть данные, отправляемые от браузера. Измените код так, чтобы он выглядел как в листинге 21-2.
use std::{
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let http_request: Vec<_> = buf_reader
.lines()
.map(|result| result.unwrap())
.take_while(|line| !line.is_empty())
.collect();
println!("Request: {http_request:#?}");
}
TcpStream и печать данныхМы вводим в область видимости std::io::BufReader и std::io::prelude, чтобы получить доступ к трейтам и типам, которые позволяют нам читать из потока и писать в него. В цикле for в функции main вместо печати сообщения о том, что мы установили соединение, мы теперь вызываем новую функцию handle_connection и передаём ей stream.
В функции handle_connection мы создаём новый экземпляр BufReader, который оборачивает ссылку на stream. BufReader добавляет буферизацию, управляя вызовами методов трейта std::io::Read за нас.
Мы создаём переменную с именем http_request для сбора строк запроса, который браузер отправляет нашему серверу. Мы указываем, что хотим собрать эти строки в вектор, добавив аннотацию типа Vec<_>.
BufReader реализует трейт std::io::BufRead, который предоставляет метод lines. Метод lines возвращает итератор из Result<String, std::io::Error>, разбивая поток данных каждый раз, когда он видит байт новой строки. Чтобы получить каждую String, мы применяем map и unwrap к каждому Result. Result может быть ошибкой, если данные не являются допустимым UTF-8 или если была проблема при чтении из потока. Опять же, производственная программа должна обрабатывать эти ошибки более изящно, но мы выбираем остановку программы в случае ошибки для простоты.
Браузер сигнализирует об окончании HTTP-запроса, отправляя два символа новой строки подряд, поэтому чтобы получить один запрос из потока, мы берём строки, пока не получим строку, которая является пустой строкой. Как только мы собрали строки в вектор, мы печатаем их с использованием красивого отладочного форматирования, чтобы мы могли взглянуть на инструкции, которые веб-браузер отправляет нашему серверу.
Давайте попробуем этот код! Запустите программу и снова сделайте запрос в веб-браузере. Обратите внимание, что мы по-прежнему получим страницу с ошибкой в браузере, но вывод нашей программы в терминале теперь будет выглядеть примерно так:
$ cargo run
Compiling hello v0.1.0 (file:///projects/hello)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
Running `target/debug/hello`
Request: [
"GET / HTTP/1.1",
"Host: 127.0.0.1:7878",
"User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:99.0) Gecko/20100101 Firefox/99.0",
"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
"Accept-Language: en-US,en;q=0.5",
"Accept-Encoding: gzip, deflate, br",
"DNT: 1",
"Connection: keep-alive",
"Upgrade-Insecure-Requests: 1",
"Sec-Fetch-Dest: document",
"Sec-Fetch-Mode: navigate",
"Sec-Fetch-Site: none",
"Sec-Fetch-User: ?1",
"Cache-Control: max-age=0",
]
В зависимости от вашего браузера вы можете получить несколько иной вывод. Теперь, когда мы печатаем данные запроса, мы можем увидеть, почему мы получаем несколько соединений от одного запроса браузера, посмотрев на путь после GET в первой строке запроса. Если повторные соединения все запрашивают /, мы знаем, что браузер пытается получить / повторно, потому что он не получает ответа от нашей программы.
Давайте разберём эти данные запроса, чтобы понять, что браузер просит у нашей программы.
Более подробный взгляд на HTTP-запрос
HTTP — это текстовый протокол, и запрос имеет следующий формат:
Метод Request-URI HTTP-Version CRLF
заголовки CRLF
тело-сообщения
Первая строка — это строка запроса, которая содержит информацию о том, что запрашивает клиент. Первая часть строки запроса указывает используемый метод, такой как GET или POST, который описывает, как клиент делает этот запрос. Наш клиент использовал запрос GET, что означает, что он запрашивает информацию.
Следующая часть строки запроса — это /, которая указывает универсальный идентификатор ресурса (URI), который запрашивает клиент: URI почти, но не совсем, совпадает с универсальным локатором ресурса (URL). Различие между URI и URL не важно для наших целей в этой главе, но спецификация HTTP использует термин URI, поэтому мы можем мысленно заменить URL на URI здесь.
Последняя часть — это версия HTTP, которую использует клиент, и затем строка запроса заканчивается последовательностью CRLF. (CRLF означает возврат каретки и перевод строки, которые являются терминами из дней пишущих машинок!) Последовательность CRLF также может быть записана как \r\n, где \r — это возврат каретки, а \n — это перевод строки. Последовательность CRLF отделяет строку запроса от остальных данных запроса. Обратите внимание, что когда CRLF печатается, мы видим начало новой строки, а не \r\n.
Глядя на данные строки запроса, которые мы получили при запуске нашей программы, мы видим, что GET — это метод, / — это URI запроса, а HTTP/1.1 — это версия.
После строки запроса остальные строки, начинающиеся с Host: и далее, — это заголовки. Запросы GET не имеют тела.
Попробуйте сделать запрос из другого браузера или запросить другой адрес, например 127.0.0.1:7878/test, чтобы увидеть, как изменяются данные запроса.
Теперь, когда мы знаем, что запрашивает браузер, давайте отправим обратно некоторые данные!
Запись ответа
Мы собираемся реализовать отправку данных в ответ на запрос клиента. Ответы имеют следующий формат:
HTTP-Version Status-Code Reason-Phrase CRLF
заголовки CRLF
тело-сообщения
Первая строка — это строка статуса, которая содержит версию HTTP, используемую в ответе, числовой код состояния, который обобщает результат запроса, и фразу причины, которая обеспечивает текстовое описание кода состояния. После последовательности CRLF идут любые заголовки, ещё одна последовательность CRLF и тело ответа.
Вот пример ответа, который использует версию HTTP 1.1 и имеет код состояния 200, фразу причины OK, без заголовков и без тела:
HTTP/1.1 200 OK\r\n\r\n
Код состояния 200 — это стандартный успешный ответ. Текст — это крошечный успешный HTTP-ответ. Давайте запишем это в поток как наш ответ на успешный запрос! Из функции handle_connection удалите println!, который печатал данные запроса, и замените его кодом из листинга 21-3.
use std::{
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let http_request: Vec<_> = buf_reader
.lines()
.map(|result| result.unwrap())
.take_while(|line| !line.is_empty())
.collect();
let response = "HTTP/1.1 200 OK\r\n\r\n";
stream.write_all(response.as_bytes()).unwrap();
}
Первая новая строка определяет переменную response, которая содержит данные сообщения об успехе. Затем мы вызываем as_bytes для нашего response, чтобы преобразовать строковые данные в байты. Метод write_all на stream принимает &[u8] и отправляет эти байты напрямую по соединению. Поскольку операция write_all может завершиться неудачно, мы используем unwrap для любого результата ошибки, как и раньше. Опять же, в реальном приложении вы бы добавили здесь обработку ошибок.
С этими изменениями давайте запустим наш код и сделаем запрос. Мы больше не печатаем никаких данных в терминал, поэтому мы не увидим никакого вывода, кроме вывода от Cargo. Когда вы загрузите 127.0.0.1:7878 в веб-браузере, вы должны получить пустую страницу вместо ошибки. Вы только что вручную закодировали получение HTTP-запроса и отправку ответа!
Возврат настоящего HTML
Давайте реализуем функциональность возврата чего-то большего, чем пустая страница. Создайте новый файл hello.html в корне каталога вашего проекта, а не в каталоге src. Вы можете ввести любой HTML, который захотите; листинг 21-4 показывает одну из возможностей.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Hello!</title>
</head>
<body>
<h1>Hello!</h1>
<p>Hi from Rust</p>
</body>
</html>
Это минимальный HTML5-документ с заголовком и некоторым текстом. Чтобы возвращать это с сервера при получении запроса, мы изменим handle_connection, как показано в листинге 21-5, чтобы прочитать HTML-файл, добавить его в ответ как тело и отправить.
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
// --snip--
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let http_request: Vec<_> = buf_reader
.lines()
.map(|result| result.unwrap())
.take_while(|line| !line.is_empty())
.collect();
let status_line = "HTTP/1.1 200 OK";
let contents = fs::read_to_string("hello.html").unwrap();
let length = contents.len();
let response =
format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
stream.write_all(response.as_bytes()).unwrap();
}
Мы добавили fs в выражение use, чтобы ввести в область видимости модуль файловой системы стандартной библиотеки. Код для чтения содержимого файла в строку должен выглядеть знакомо; мы использовали его, когда читали содержимое файла для нашего проекта ввода-вывода в листинге 12-4.
Затем мы используем format!, чтобы добавить содержимое файла в качестве тела успешного ответа. Чтобы обеспечить действительный HTTP-ответ, мы добавляем заголовок Content-Length, который устанавливается равным размеру нашего тела ответа — в данном случае размеру hello.html.
Запустите этот код с помощью cargo run и загрузите 127.0.0.1:7878 в браузере; вы должны увидеть ваш HTML отрендеренным!
В настоящее время мы игнорируем данные запроса в http_request и просто безоговорочно отправляем обратно содержимое HTML-файла. Это означает, что если вы попытаетесь запросить 127.0.0.1:7878/something-else в браузере, вы всё равно получите обратно тот же самый HTML-ответ. На данный момент наш сервер очень ограничен и не делает того, что делают большинство веб-серверов. Мы хотим настроить наши ответы в зависимости от запроса и отправлять обратно HTML-файл только для правильно сформированного запроса к /.
Проверка запроса и выборочный ответ
Прямо сейчас наш веб-сервер будет возвращать HTML в файле независимо от того, что запросил клиент. Давайте добавим функциональность, чтобы проверить, что браузер запрашивает /, перед возвратом HTML-файла, и возвращать ошибку, если браузер запрашивает что-либо другое. Для этого нам нужно изменить handle_connection, как показано в листинге 21-6. Этот новый код проверяет содержимое полученного запроса на соответствие тому, что, как мы знаем, выглядит запрос к /, и добавляет блоки if и else для разной обработки запросов.
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
// --snip--
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
if request_line == "GET / HTTP/1.1" {
let status_line = "HTTP/1.1 200 OK";
let contents = fs::read_to_string("hello.html").unwrap();
let length = contents.len();
let response = format!(
"{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
);
stream.write_all(response.as_bytes()).unwrap();
} else {
// какой-то другой запрос
}
}
Мы собираемся смотреть только на первую строку HTTP-запроса, поэтому вместо того, чтобы читать весь запрос в вектор, мы вызываем next, чтобы получить первый элемент из итератора. Первый unwrap заботится об Option и останавливает программу, если в итераторе нет элементов. Второй unwrap обрабатывает Result и имеет тот же эффект, что и unwrap, который был в map, добавленном в листинге 21-2.
Затем мы проверяем request_line, чтобы увидеть, равна ли она строке запроса GET-запроса к пути /. Если равна, блок if возвращает содержимое нашего HTML-файла.
Если request_line не равна GET-запросу к пути /, это означает, что мы получили какой-то другой запрос. Мы добавим код в блок else через мгновение, чтобы ответить на все другие запросы.
Запустите этот код сейчас и запросите 127.0.0.1:7878; вы должны получить HTML из hello.html. Если вы сделаете любой другой запрос, например 127.0.0.1:7878/something-else, вы получите ошибку соединения, подобную тем, которые вы видели при запуске кода в листинге 21-1 и листинге 21-2.
Теперь давайте добавим код из листинга 21-7 в блок else, чтобы вернуть ответ с кодом состояния 404, который сигнализирует, что содержимое для запроса не найдено. Мы также вернём немного HTML для страницы, которая будет отображена в браузере, указывая ответ конечному пользователю.
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
if request_line == "GET / HTTP/1.1" {
let status_line = "HTTP/1.1 200 OK";
let contents = fs::read_to_string("hello.html").unwrap();
let length = contents.len();
let response = format!(
"{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
);
stream.write_all(response.as_bytes()).unwrap();
// --snip--
} else {
let status_line = "HTTP/1.1 404 NOT FOUND";
let contents = fs::read_to_string("404.html").unwrap();
let length = contents.len();
let response = format!(
"{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
);
stream.write_all(response.as_bytes()).unwrap();
}
}
Здесь наш ответ имеет строку статуса с кодом состояния 404 и фразой причины NOT FOUND. Тело ответа будет HTML в файле 404.html. Вам нужно будет создать файл 404.html рядом с hello.html для страницы ошибки; опять же, не стесняйтесь использовать любой HTML, который захотите, или используйте пример HTML в листинге 21-8.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Hello!</title>
</head>
<body>
<h1>Oops!</h1>
<p>Sorry, I don't know what you're asking for.</p>
</body>
</html>
С этими изменениями снова запустите ваш сервер. Запрос 127.0.0.1:7878 должен вернуть содержимое hello.html, а любой другой запрос, например 127.0.0.1:7878/foo, должен вернуть HTML ошибки из 404.html.
Рефакторинг
На данный момент блоки if и else имеют много повторений: они оба читают файлы и записывают содержимое файлов в поток. Единственные различия — это строка статуса и имя файла. Давайте сделаем код более кратким, вынеся эти различия в отдельные строки if и else, которые будут присваивать значения строки статуса и имени файла переменным; затем мы можем использовать эти переменные безусловно в коде для чтения файла и записи ответа. Листинг 21-9 показывает результирующий код после замены больших блоков if и else.
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
// --snip--
fn handle_connection(mut stream: TcpStream) {
// --snip--
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
let (status_line, filename) = if request_line == "GET / HTTP/1.1" {
("HTTP/1.1 200 OK", "hello.html")
} else {
("HTTP/1.1 404 NOT FOUND", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let length = contents.len();
let response =
format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
stream.write_all(response.as_bytes()).unwrap();
}
if и else, чтобы они содержали только код, отличающийся в этих двух случаяхТеперь блоки if и else возвращают только соответствующие значения для строки статуса и имени файла в кортеже; затем мы используем деструктуризацию, чтобы присвоить эти два значения status_line и filename с помощью шаблона в инструкции let, как обсуждалось в главе 19.
Ранее дублированный код теперь находится вне блоков if и else и использует переменные status_line и filename. Это облегчает понимание разницы между двумя случаями, а также означает, что у нас есть только одно место для обновления кода, если мы хотим изменить способ чтения файлов и записи ответов. Поведение кода в листинге 21-9 будет таким же, как в листинге 21-7.
Отлично! Теперь у нас есть простой веб-сервер примерно в 40 строках кода на Rust, который отвечает на один запрос страницей контента и отвечает на все другие запросы 404-ответом.
В настоящее время наш сервер работает в одном потоке, что означает, что он может обслуживать только один запрос за раз. Давайте рассмотрим, как это может быть проблемой, смоделировав несколько медленных запросов. Затем мы исправим это, чтобы наш сервер мог обрабатывать несколько запросов одновременно.