Парсинг на Rust: полное руководство от простого к сложному

[package]
name = "parser-demo"
version = "0.1.0"
edition = "2021"

[dependencies]
reqwest = { version = "0.13", features = ["json", "gzip", "brotli"] }
tokio = { version = "1", features = ["full"] }
scraper = "0.27"
encoding_rs = "0.8"
anyhow = "1"          # удобная обработка ошибок

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let body = reqwest::get("https://example.com")
        .await?      // ждём ответа
        .text()      // читаем тело как строку
        .await?;
    println!("{body}");
    Ok(())
}

use std::time::Duration;
use reqwest::Client;

fn build_client() -> anyhow::Result<Client> {
    let client = Client::builder()
        // притворяемся обычным браузером
        .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) \
                     AppleWebKit/537.36 (KHTML, like Gecko) \
                     Chrome/124.0 Safari/537.36")
        .timeout(Duration::from_secs(30))          // общий таймаут запроса
        .connect_timeout(Duration::from_secs(10))  // таймаут установки соединения
        .gzip(true)                                // авто-распаковка gzip
        .brotli(true)                              // авто-распаковка brotli
        .build()?;
    Ok(client)
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = build_client()?;
    let resp = client
        .get("https://example.com")
        .header("Accept-Language", "ru-RU,ru;q=0.9")
        .send()
        .await?;

    println!("Статус: {}", resp.status());
    let html = resp.text().await?;
    println!("Длина HTML: {}", html.len());
    Ok(())
}

reqwest = { version = "0.13", features = ["blocking"] }

fn main() -> anyhow::Result<()> {
    let body = reqwest::blocking::get("https://example.com")?.text()?;
    println!("{body}");
    Ok(())
}

use scraper::{Html, Selector};

fn parse_articles(html: &str) -> anyhow::Result<()> {
    let document = Html::parse_document(html);

    // Селекторы лучше скомпилировать один раз (вне цикла).
    let item_sel  = Selector::parse("article.post").unwrap();
    let title_sel = Selector::parse("h2.title > a").unwrap();
    let date_sel  = Selector::parse("time.published").unwrap();

    for item in document.select(&item_sel) {
        let title = item
            .select(&title_sel)
            .next()
            .map(|e| e.text().collect::<String>().trim().to_string())
            .unwrap_or_default();

        // ссылка из атрибута href
        let link = item
            .select(&title_sel)
            .next()
            .and_then(|e| e.value().attr("href"))
            .unwrap_or("");

        // дата из атрибута datetime
        let date = item
            .select(&date_sel)
            .next()
            .and_then(|e| e.value().attr("datetime"))
            .unwrap_or("");

        println!("{title} | {date} | {link}");
    }
    Ok(())
}

use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Product {
    id: u64,
    name: String,
    price: f64,
}

async fn fetch_products(client: &reqwest::Client) -> anyhow::Result<Vec<Product>> {
    let products = client
        .get("https://shop.example.com/api/products")
        .send()
        .await?
        .json::<Vec<Product>>()   // десериализация прямо в структуры
        .await?;
    Ok(products)
}

use encoding_rs::{Encoding, WINDOWS_1251, UTF_8};

async fn get_text_cp1251(client: &reqwest::Client, url: &str) -> anyhow::Result<String> {
    let resp = client.get(url).send().await?;
    let bytes = resp.bytes().await?;

    // Декодируем как Windows-1251.
    let (text, _enc, had_errors) = WINDOWS_1251.decode(&bytes);
    if had_errors {
        eprintln!("Внимание: при декодировании были ошибки");
    }
    Ok(text.into_owned())
}

use encoding_rs::Encoding;
use reqwest::header::CONTENT_TYPE;

async fn get_text_smart(client: &reqwest::Client, url: &str) -> anyhow::Result<String> {
    let resp = client.get(url).send().await?;

    // 1) пробуем взять charset из заголовка
    let header_charset = resp
        .headers()
        .get(CONTENT_TYPE)
        .and_then(|v| v.to_str().ok())
        .and_then(|ct| ct.split("charset=").nth(1))
        .map(|s| s.trim().to_string());

    let bytes = resp.bytes().await?;

    // 2) если в заголовке нет — ищем в <meta> (упрощённо: первые 1024 байта)
    let charset = header_charset.or_else(|| {
        let head = String::from_utf8_lossy(&bytes[..bytes.len().min(1024)]);
        head.to_lowercase()
            .split("charset=")
            .nth(1)
            .map(|s| s.trim_matches(|c: char| !c.is_ascii_alphanumeric() && c != '-')
                      .to_string())
    });

    // 3) выбираем энкодинг (по умолчанию UTF-8)
    let enc = charset
        .as_deref()
        .and_then(|name| Encoding::for_label(name.as_bytes()))
        .unwrap_or(encoding_rs::UTF_8);

    let (text, _, _) = enc.decode(&bytes);
    Ok(text.into_owned())
}

use futures::stream::{self, StreamExt};

async fn crawl_many(client: &reqwest::Client, urls: Vec<String>) {
    let concurrency = 20; // не больше 20 запросов одновременно

    let results = stream::iter(urls)
        .map(|url| {
            let client = client.clone(); // клон дешёвый (Arc внутри)
            async move {
                match client.get(&url).send().await {
                    Ok(resp) => {
                        let status = resp.status();
                        let body = resp.text().await.unwrap_or_default();
                        (url, status.as_u16(), body.len())
                    }
                    Err(e) => {
                        eprintln!("Ошибка {url}: {e}");
                        (url, 0, 0)
                    }
                }
            }
        })
        .buffer_unordered(concurrency)
        .collect::<Vec<_>>()
        .await;

    for (url, status, len) in results {
        println!("{status} {len:>8} {url}");
    }
}

use std::sync::Arc;
use tokio::sync::Semaphore;

async fn crawl_with_semaphore(client: reqwest::Client, urls: Vec<String>) {
    let sem = Arc::new(Semaphore::new(20)); // максимум 20 «в полёте»
    let mut handles = Vec::new();

    for url in urls {
        let client = client.clone();
        let sem = sem.clone();
        handles.push(tokio::spawn(async move {
            let _permit = sem.acquire().await.unwrap(); // ждём свободный слот
            let _ = client.get(&url).send().await;
            // permit освобождается при выходе из скоупа
        }));
    }

    for h in handles {
        let _ = h.await;
    }
}

use rayon::prelude::*;

fn parse_all(pages: Vec<String>) -> Vec<usize> {
    pages
        .par_iter()                      // параллельный итератор
        .map(|html| {
            let doc = scraper::Html::parse_document(html);
            doc.select(&scraper::Selector::parse("a").unwrap()).count()
        })
        .collect()
}

reqwest = { version = "0.13", features = ["socks"] }

use reqwest::{Client, Proxy};

fn client_with_proxy() -> anyhow::Result<Client> {
    let proxy = Proxy::all("http://proxy.example.com:8080")?
        .basic_auth("user", "password"); // если нужна авторизация

    let client = Client::builder()
        .proxy(proxy)
        .build()?;
    Ok(client)
}

let proxy = reqwest::Proxy::all("socks5://127.0.0.1:1080")?;

use std::sync::atomic::{AtomicUsize, Ordering};
use reqwest::{Client, Proxy};

struct ProxyPool {
    clients: Vec<Client>,
    idx: AtomicUsize,
}

impl ProxyPool {
    fn new(proxies: &[&str]) -> anyhow::Result<Self> {
        let clients = proxies
            .iter()
            .map(|p| {
                Client::builder()
                    .proxy(Proxy::all(*p)?)
                    .build()
                    .map_err(Into::into)
            })
            .collect::<anyhow::Result<Vec<_>>>()?;
        Ok(Self { clients, idx: AtomicUsize::new(0) })
    }

    /// Возвращает следующий клиент по кругу.
    fn next(&self) -> &Client {
        let i = self.idx.fetch_add(1, Ordering::Relaxed) % self.clients.len();
        &self.clients[i]
    }
}

use reqwest::{Client, Proxy};

fn tor_client() -> anyhow::Result<Client> {
    // ВАЖНО: socks5h (с буквой h), а не socks5.
    // 'h' = резолвинг DNS на стороне прокси (внутри TOR),
    // иначе будет утечка DNS и .onion не заработает.
    let proxy = Proxy::all("socks5h://127.0.0.1:9050")?;
    let client = Client::builder()
        .proxy(proxy)
        .build()?;
    Ok(client)
}

async fn check_tor(client: &reqwest::Client) -> anyhow::Result<()> {
    let txt = client
        .get("https://check.torproject.org/api/ip")
        .send().await?
        .text().await?;
    println!("{txt}"); // {"IsTor":true,"IP":"..."}
    Ok(())
}

arti-client = "..."   # уточните актуальную версию: cargo add arti-client
tor-rtcompat = "..."

use arti_client::{TorClient, TorClientConfig};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let config = TorClientConfig::default();
    // Поднимаем встроенный TOR-клиент и дожидаемся bootstrap.
    let tor = TorClient::create_bootstrapped(config).await?;

    // Дальше можно открывать анонимные TCP-стримы (AsyncRead/AsyncWrite)
    // и поверх них слать HTTP вручную или через hyper.
    let mut stream = tor.connect(("example.com", 80)).await?;
    // ... отправка HTTP-запроса по stream ...
    Ok(())
}

# rustls (по умолчанию) — кроссплатформенно, не нужен OpenSSL
reqwest = { version = "0.13" }

# либо системный TLS (schannel на Windows, Secure Transport на macOS, OpenSSL на Linux)
reqwest = { version = "0.13", default-features = false, features = ["native-tls"] }

# либо OpenSSL, вкомпилированный статически (удобно для сборки бинарника)
reqwest = { version = "0.13", default-features = false, features = ["native-tls-vendored"] }

let client = reqwest::Client::builder()
    .danger_accept_invalid_certs(true) // ⚠ небезопасно
    .build()?;

use reqwest::{Certificate, Identity};

// Добавить корпоративный/самоподписанный CA:
let ca = Certificate::from_pem(&std::fs::read("my-ca.pem")?)?;

// Клиентский сертификат (mTLS):
let id = Identity::from_pem(&std::fs::read("client.pem")?)?;

let client = reqwest::Client::builder()
    .add_root_certificate(ca)
    .identity(id)
    .build()?;

reqwest = { version = "0.13", features = ["cookies"] }

let client = reqwest::Client::builder()
    .cookie_store(true) // включить автоматическое хранение cookie
    .build()?;

// 1) логинимся — сервер вернёт Set-Cookie, клиент их запомнит
client.post("https://site.example/login")
    .form(&[("user", "alice"), ("pass", "secret")])
    .send().await?;

// 2) последующие запросы автоматически уйдут с этими cookie
let dashboard = client.get("https://site.example/dashboard")
    .send().await?
    .text().await?;

use std::sync::Arc;
use reqwest::cookie::{Jar, CookieStore};
use reqwest::Url;

let jar = Arc::new(Jar::default());

// Заранее положить cookie вручную:
let url: Url = "https://site.example/".parse()?;
jar.add_cookie_str("session=abc123; Domain=site.example; Path=/", &url);

let client = reqwest::Client::builder()
    .cookie_provider(jar.clone()) // используем наш jar
    .build()?;

// после запросов можно прочитать накопленные cookie из jar

let resp = client.get(url)
    .header(reqwest::header::COOKIE, "session=abc123; lang=ru")
    .send().await?;

use reqwest::StatusCode;
use reqwest::header::{CONTENT_TYPE, CONTENT_LENGTH, LOCATION, RETRY_AFTER};

async fn fetch(client: &reqwest::Client, url: &str) -> anyhow::Result<Option<String>> {
    let resp = client.get(url).send().await?;

    let status = resp.status();
    println!("HTTP {} ({})", status.as_u16(), status.canonical_reason().unwrap_or(""));

    // Удобные проверки категорий статуса:
    if status.is_success() {            // 2xx
        // читаем нужные заголовки
        let headers = resp.headers();

        if let Some(ct) = headers.get(CONTENT_TYPE).and_then(|v| v.to_str().ok()) {
            println!("Content-Type: {ct}");
            // парсим только HTML, картинки пропускаем
            if !ct.contains("text/html") {
                return Ok(None);
            }
        }
        if let Some(len) = headers.get(CONTENT_LENGTH) {
            println!("Content-Length: {len:?}");
        }

        let body = resp.text().await?;
        return Ok(Some(body));
    }

    if status.is_redirection() {        // 3xx
        if let Some(loc) = resp.headers().get(LOCATION).and_then(|v| v.to_str().ok()) {
            println!("Редирект на: {loc}");
        }
    }

    if status == StatusCode::TOO_MANY_REQUESTS {  // 429
        // сервер просит подождать
        if let Some(ra) = resp.headers().get(RETRY_AFTER).and_then(|v| v.to_str().ok()) {
            println!("Нас тормозят. Retry-After: {ra} сек");
        }
    }

    Ok(None)
}

use std::collections::{VecDeque, HashSet};

struct Frontier {
    queue: VecDeque<String>,
    seen: HashSet<String>,
}

impl Frontier {
    fn new() -> Self {
        Self { queue: VecDeque::new(), seen: HashSet::new() }
    }
    /// Добавить URL, если ещё не видели.
    fn push(&mut self, url: String) {
        if self.seen.insert(url.clone()) {  // insert вернёт false, если уже был
            self.queue.push_back(url);
        }
    }
    fn pop(&mut self) -> Option<String> {
        self.queue.pop_front()
    }
}

use std::num::NonZeroU32;
use governor::{Quota, RateLimiter};

// не больше 5 запросов в секунду
let limiter = RateLimiter::direct(Quota::per_second(NonZeroU32::new(5).unwrap()));

// перед каждым запросом:
limiter.until_ready().await;
// client.get(...).send().await?;

reqwest-middleware = "0.5"
reqwest-retry = "0.9"

use reqwest_middleware::ClientBuilder;
use reqwest_retry::{RetryTransientMiddleware, policies::ExponentialBackoff};

let retry_policy = ExponentialBackoff::builder().build_with_max_retries(3);
let client = ClientBuilder::new(reqwest::Client::new())
    .with(RetryTransientMiddleware::new_with_policy(retry_policy))
    .build();
// дальше client.get(...).send().await — ретраи произойдут автоматически

use anyhow::Context;

let html = client.get(url).send().await
    .with_context(|| format!("не удалось скачать {url}"))?
    .text().await
    .context("не удалось прочитать тело")?;