13.05.2024 08:01
aio350 0 2400 Источник



Hello world!


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



Содержание



Обратите внимание:: для запуска примеров Книги вам потребуется такой файл Cargo.toml:


[package]
name = "rust_cookbook"
version = "0.1.0"
edition = "2021"

[dependencies]
chrono = "0.4.31"
crossbeam = "0.8.3"
crossbeam-channel = "0.5.10"
csv = "1.3.0"
env_logger = "0.11.3"
error-chain = "0.12.4"
glob = "0.3.1"
image = "0.25.0"
lazy_static = "1.4.0"
log = "0.4.20"
mime = "0.3.17"
num = "0.4.1"
num_cpus = "1.16.0"
postgres = "0.19.7"
rand = "0.8.5"
rayon = "1.8.0"
regex = "1.10.2"
reqwest = {version = "0.11.23", features = ["blocking", "json"]}
same-file = "1.0.6"
select = "0.6.0"
serde = {version = "1.0.193", features = ["derive"]}
serde_json = "1.0.110"
threadpool = "1.8.1"
tokio = { version = "1.35.1", features = ["full"] }
unicode-segmentation = "1.10.1"
url = "2.5.0"
walkdir = "2.4.0"
dotenv = "0.15.0"
tempfile = "3.9.0"
data-encoding = "2.5.0"
ring = "0.17.7"
clap = "4.5.2"
ansi_term = "0.12.1"
flate2 = "1.0.28"
tar = "0.4.40"
semver = "1.0.22"
percent-encoding = "2.3.1"
base64 = "0.22.0"
toml = "0.8.12"
memmap = "0.7.0"

[dependencies.rusqlite]
version = "0.31.0"
features = ["bundled"]

Также обратите внимание, что некоторые примеры работают только на Linux.



10. Кодирование


10.1. Наборы символов


Процентное кодирование строки


Пример процентного кодирования строки с помощью функции uft8_percent_encode из крейта percent-encoding. Декодирование строки выполняется в помощью функции percent_decode.


use percent_encoding::{utf8_percent_encode, percent_decode, AsciiSet, CONTROLS};
use std::str::Utf8Error;

/// https://url.spec.whatwg.org/#fragment-percent-encode-set
const FRAGMENT: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');

fn main() -> Result<(), Utf8Error> {
    let input = "confident, productive systems programming";

    // Кодируем и собираем строку
    let iter = utf8_percent_encode(input, FRAGMENT);
    let encoded: String = iter.collect();
    assert_eq!(encoded, "confident,%20productive%20systems%20programming");

    // Декодируем строку
    let iter = percent_decode(encoded.as_bytes());
    let decoded = iter.decode_utf8()?;
    assert_eq!(decoded, "confident, productive systems programming");

    Ok(())
}

Набор кодировок (FRAGMENT) определяет, какие байты (помимо байтов, отличных от ASCII, и элементов управления (controls)) должны кодироваться. Состав этого набора зависит от контекста. Например, url кодирует ? в пути (path) URL, но не в строке запроса (query string).


utf8_percent_encode возвращает итератор срезов &str, которые собираются (collect) в String.


Кодирование строки в application/x-www-form-urlencoded


Пример кодирования строки в application/x-www-form-urlencoded с помощью метода form_urlencoded::byte_serialize. Декодирование выполняется с помощью метода form_urlencoded::parse. Обе функции возвращают итераторы, которые собираются (collect) в String.


use url::form_urlencoded::{byte_serialize, parse};

fn main() {
    // Кодируем строку
    let urlencoded: String = byte_serialize("What is ❤?".as_bytes()).collect();
    assert_eq!(urlencoded, "What+is+%E2%9D%A4%3F");

    // Декодируем строку
    let decoded: String = parse(urlencoded.as_bytes())
        .map(|(key, val)| [key, val].concat())
        .collect();
    assert_eq!(decoded, "What is ❤?");
}

Шестнадцатеричное кодирование и декодирование


Крейт data_encoding предоставляет метод HEXUPPER::encode, который принимает &[u8] и возвращает String, содержащую шестнадцатеричное представление данных.


Этот крейт также предоставляет метод HEXUPPER::decode, который принимает &[u8] и возвращает Vec<u8> при успешном декодировании данных.


use data_encoding::{DecodeError, HEXUPPER};

fn main() -> Result<(), DecodeError> {
    let original = b"The quick brown fox jumps over the lazy dog.";
    let expected = "54686520717569636B2062726F776E20666F78206A756D7073206F76\
        657220746865206C617A7920646F672E";

    // Кодируем данные
    let encoded = HEXUPPER.encode(original);
    assert_eq!(encoded, expected);

    // Декодируем данные
    let decoded = HEXUPPER.decode(&encoded.into_bytes())?;
    assert_eq!(decoded, original);

    Ok(())
}

base64 кодирование и декодирование


Крейт base64 предоставляет методы encode и decode для кодирования и декодирования байтовых срезов в base64:


use error_chain::error_chain;

use base64::{engine::general_purpose::STANDARD, Engine as _};
use std::str;

error_chain! {
    foreign_links {
        Base64(base64::DecodeError);
        Utf8Error(str::Utf8Error);
    }
}

fn main() -> Result<()> {
    let hello = b"hello rustaceans";
    let encoded = STANDARD.encode(hello);
    let decoded = STANDARD.decode(&encoded)?;

    println!("origin: {}", str::from_utf8(hello)?);
    println!("base64 encoded: {}", encoded);
    println!("back to origin: {}", str::from_utf8(&decoded)?);

    Ok(())
}

10.2. Обработка CSV


Чтение записей CSV


Пример чтения стандартных записей CSV в структуру csv::StringRecord — слаботипизированное представление данных, которое ожидает валидные строки UTF-8. В качестве альтернативы можно использовать структуру ByteRecord, которая не проверяет строки.


use csv::Error;

fn main() -> Result<(), Error> {
    let csv = "year,make,model,description
1948,Porsche,356,Luxury sports car
1967,Ford,Mustang fastback 1967,American car";

    let mut reader = csv::Reader::from_reader(csv.as_bytes());
    for record in reader.records() {
        let record = record?;
        println!(
            "In {}, {} built the {} model. It is a {}.",
            &record[0], &record[1], &record[2], &record[3]
        );
    }

    Ok(())
}

Метод csv::Reader::deserialize десериализует данные в строготипизированные структуры. Обратите внимание на явную типизацию десериализуемой записи.


use serde::Deserialize;

#[derive(Deserialize)]
struct Record {
    year: u16,
    make: String,
    model: String,
    description: String,
}

fn main() -> Result<(), csv::Error> {
    let csv = "year,make,model,description
1948,Porsche,356,Luxury sports car
1967,Ford,Mustang fastback 1967,American car";

    let mut reader = csv::Reader::from_reader(csv.as_bytes());

    for record in reader.deserialize() {
        // Типизация записи
        let record: Record = record?;
        println!(
            "In {}, {} built the {} model. It is a {}.",
            record.year,
            record.make,
            record.model,
            record.description
        );
    }

    Ok(())
}

Чтение записей CSV с другим разделителем


Пример чтения записей CSV, разделителем которых является таб:


use csv::Error;
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Record {
    name: String,
    place: String,
    #[serde(deserialize_with = "csv::invalid_option")]
    id: Option<u64>,
}

use csv::ReaderBuilder;

fn main() -> Result<(), Error> {
    let data = "name\tplace\tid
Mark\tMelbourne\t46
Ashley\tZurich\t92";

    let mut reader = ReaderBuilder::new()
        // указываем разделитель
        .delimiter(b'\t')
        .from_reader(data.as_bytes());
    // Другой способ типизации записи
    for result in reader.deserialize::<Record>() {
        println!("{:?}", result?);
    }

    Ok(())
}

Фильтрация записей CSV, совпадающих с предикатом


В следующем примере возвращаются только те строки data, которые совпадают с query:


use error_chain::error_chain;

use std::io;

error_chain! {
    foreign_links {
        Io(std::io::Error);
        CsvError(csv::Error);
    }
}

fn main() -> Result<()> {
    let query = "CA";
    let data = "\
City,State,Population,Latitude,Longitude
Kenai,AK,7610,60.5544444,-151.2583333
Oakman,AL,,33.7133333,-87.3886111
Sandfort,AL,,32.3380556,-85.2233333
West Hollywood,CA,37031,34.0900000,-118.3608333";

    // Средство чтения CSV
    let mut rdr = csv::ReaderBuilder::new().from_reader(data.as_bytes());
    // Средство записи данных в stdout (терминал)
    let mut wtr = csv::Writer::from_writer(io::stdout());

    // Пишем в терминал заголовки CSV
    wtr.write_record(rdr.headers()?)?;

    for result in rdr.records() {
        let record = result?;
        // Пишем в терминал запись, содержащую поле, совпадающее с `query` (`CA`)
        if record.iter().any(|field| field == query) {
            wtr.write_record(&record)?;
        }
    }

    // `writer` использует внутренний буфер, см. ниже
    wtr.flush()?;
    Ok(())
}

Обработка невалидных данных с помощью serde


Файлы CSV часто содержат невалидные данные. Для таких случаяв крейт csv предоставляет кастомный десериализатор, csv::invalid_option, который автоматически преобразует невалидные данные в значения None:


use csv::Error;
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Record {
    name: String,
    place: String,
    #[serde(deserialize_with = "csv::invalid_option")]
    id: Option<u64>,
}

fn main() -> Result<(), Error> {
    // Последняя запись содержит невалидный ID
    let data = "name,place,id
mark,sydney,46.5
ashley,zurich,92
akshat,delhi,37
alisha,colombo,xyz";

    let mut rdr = csv::Reader::from_reader(data.as_bytes());
    for result in rdr.deserialize() {
        let record: Record = result?;
        // Результат десериализации последней записи выглядит как
        // `Record { name: "alisha", place: "colombo", id: None }`
        println!("{:?}", record);
    }

    Ok(())
}

Сериализация записей в CSV


Пример сериализации кортежей Rust. Структура csv::writer поддерживает автоматическую сериализацию типов Rust в записи CSV. Метод write_record предназначен для работы с простыми записями, содержащими только строковые данные. Для работы с данными, содержащими более сложные значения, такие как целые числа, числа с плавающей точкой и опциональные значения, используются метод serialize. Поскольку в средстве записи (writer) используется внутренний буфер, необходимо явно вызывать метод flush для его очистки.


use error_chain::error_chain;

use std::io;

error_chain! {
    foreign_links {
        CSVError(csv::Error);
        IOError(std::io::Error);
   }
}

fn main() -> Result<()> {
    let mut wtr = csv::Writer::from_writer(io::stdout());

    wtr.write_record(&["Name", "Place", "ID"])?;

    wtr.serialize(("Mark", "Sydney", 87))?;
    wtr.serialize(("Ashley", "Dublin", 32))?;
    wtr.serialize(("Akshat", "Delhi", 11))?;

    wtr.flush()?;
    Ok(())
}

Сериализация записей в CSV с помощью serde


Пример сериализации кастомной структуры в запись CSV с помощью крейта serde:


use error_chain::error_chain;
use serde::Serialize;
use std::io;

error_chain! {
   foreign_links {
       IOError(std::io::Error);
       CSVError(csv::Error);
   }
}

#[derive(Serialize)]
struct Record<'a> {
    name: &'a str,
    place: &'a str,
    id: u64,
}

fn main() -> Result<()> {
    let mut wtr = csv::Writer::from_writer(io::stdout());

    let rec1 = Record {
        name: "Mark",
        place: "Melbourne",
        id: 56,
    };
    let rec2 = Record {
        name: "Ashley",
        place: "Sydney",
        id: 64,
    };
    let rec3 = Record {
        name: "Akshat",
        place: "Delhi",
        id: 98,
    };

    wtr.serialize(rec1)?;
    wtr.serialize(rec2)?;
    wtr.serialize(rec3)?;

    wtr.flush()?;

    Ok(())
}

10.3. Структурированные данные


Сериализация и десериализация неструктурированного JSON


Крейт serde_json предоставляет функцию from_str для разбора &str в формате JSON.


Неструктурированный JSON разбирается в универсальный тип serde_json::Value, который может представлять любой валидный JSON.


Следующим пример демонстрирует разбор &str JSON. Макрос json! используется для определения ожидаемого значения.


use serde_json::json;
use serde_json::{Value, Error};

fn main() -> Result<(), Error> {
    let j = r#"{
                 "userid": 103609,
                 "verified": true,
                 "access_privileges": [
                   "user",
                   "admin"
                 ]
               }"#;

    let parsed: Value = serde_json::from_str(j)?;

    let expected = json!({
        "userid": 103609,
        "verified": true,
        "access_privileges": [
            "user",
            "admin"
        ]
    });

    assert_eq!(parsed, expected);

    Ok(())
}

Десериализация TOML


Пример разбора TOML в универсальное toml::Value, которое может представлять любые валидные данные в формате TOML:


use toml::{Value, de::Error};

fn main() -> Result<(), Error> {
    let toml_content = r#"
          [package]
          name = "your_package"
          version = "0.1.0"
          authors = ["You! <you@example.org>"]

          [dependencies]
          serde = "1.0"
          "#;

    let package_info: Value = toml::from_str(toml_content)?;

    assert_eq!(package_info["dependencies"]["serde"].as_str(), Some("1.0"));
    assert_eq!(package_info["package"]["name"].as_str(),
               Some("your_package"));

    Ok(())
}

Крейт serde позволяет разбирать TOML в кастомные структуры:


use serde::Deserialize;
use std::collections::HashMap;
use toml::de::Error;

#[derive(Deserialize)]
struct Config {
    package: Package,
    dependencies: HashMap<String, String>,
}

#[derive(Deserialize)]
struct Package {
    name: String,
    version: String,
    authors: Vec<String>,
}

fn main() -> Result<(), Error> {
    let toml_content = r#"
          [package]
          name = "your_package"
          version = "0.1.0"
          authors = ["You! <you@example.org>"]

          [dependencies]
          serde = "1.0"
          "#;

    let package_info: Config = toml::from_str(toml_content)?;

    assert_eq!(package_info.package.name, "your_package");
    assert_eq!(package_info.package.version, "0.1.0");
    assert_eq!(package_info.package.authors, vec!["You! <you@example.org>"]);
    assert_eq!(package_info.dependencies["serde"], "1.0");

    Ok(())
}

11. Обработка ошибок


Правильная обработка ошибок в main


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


Io(std::io::Error) внутри foreign_links автоматически преобразует структуру std::io::Error в тип, определенный макросом error_chain! и реализующий трейт Error.


В следующем примере мы пытаемся выяснить, сколько времени работает система путем открытия файла Unix /proc/uptime и разбора его содержимого для извлечения первого числа. Функция read_uptime возвращает время безотказной работы или ошибку.


use error_chain::error_chain;

use std::fs::File;
use std::io::Read;

error_chain!{
    foreign_links {
        Io(std::io::Error);
        ParseInt(std::num::ParseIntError);
    }
}

fn read_uptime() -> Result<u64> {
    let mut uptime = String::new();
    File::open("/proc/uptime")?.read_to_string(&mut uptime)?;

    Ok(uptime
        .split('.')
        .next()
        .ok_or("Невозможно разобрать данные")?
        .parse()?)
}

fn main() {
    match read_uptime() {
        Ok(uptime) => println!("Время безотказной работы: {} секунд", uptime),
        Err(err) => eprintln!("Ошибка: {}", err),
    };
}

Обработка всех возможных ошибок


Крейт error-chain делает возможным и относительно компактным сопоставление разных типов ошибок, возвращаемых функцией. Тип ошибки определяется перечислением ErrorKind.


Используем reqwest::blocking для получения произвольного целого числа из веб-сервиса. Преобразуем строку из ответа в целое число. Стандартная библиотека Rust, reqwest и веб-сервис могут генерировать ошибки. Мы определяем ошибки с помощью foreign_links. Дополнительный вариант ErrorKind для веб-сервиса использует блок errors макроса error_chain!.


use error_chain::error_chain;

error_chain! {
    foreign_links {
        Io(std::io::Error);
        Reqwest(reqwest::Error);
        ParseIntError(std::num::ParseIntError);
    }
    errors { RandomResponseError(t: String) }
}

fn parse_response(response: reqwest::blocking::Response) -> Result<u32> {
    let mut body = response.text()?;
    body.pop();
    body.parse::<u32>()
        .chain_err(|| ErrorKind::RandomResponseError(body))
}

fn run() -> Result<()> {
    let url =
        format!("https://www.random.org/integers/?num=1&min=0&max=10&col=1&base=10&format=plain");
    let response = reqwest::blocking::get(&url)?;
    let random_value: u32 = parse_response(response)?;
    println!("Произвольное целое число между 0 и 10: {}", random_value);
    Ok(())
}

fn main() {
    if let Err(error) = run() {
        match *error.kind() {
            ErrorKind::Io(_) => println!("Стандартная ошибка ввода/вывода: {:?}", error),
            ErrorKind::Reqwest(_) => println!("Ошибка Reqwest: {:?}", error),
            ErrorKind::ParseIntError(_) => {
                println!("Стандартная ошибка разбора целого числа: {:?}", error)
            }
            ErrorKind::RandomResponseError(_) => println!("Кастомная ошибка: {:?}", error),
            _ => println!("Другая ошибка: {:?}", error),
        }
    }
}

Получение трассировки сложной ошибки


Следующий пример демонстрирует обработку сложной ошибки и вывод ее трассировки. chain_err используется для расширения списка возможных ошибок путем добавления новых ошибок. Стек ошибки может быть распутан (unwound), что предоставляет лучший контекст для понимания того, почему возникла ошибка.


В примере мы пытаемся десериализовать значение 256 в u8. Ошибка всплывает (bubble up) из serde через csv в пользовательский код.


use error_chain::error_chain;
use serde::Deserialize;

use std::fmt;

error_chain! {
    foreign_links {
        Reader(csv::Error);
    }
}

#[derive(Debug, Deserialize)]
struct Rgb {
    red: u8,
    blue: u8,
    green: u8,
}

impl Rgb {
    fn from_reader(csv_data: &[u8]) -> Result<Rgb> {
        let color: Rgb = csv::Reader::from_reader(csv_data)
            .deserialize()
            .nth(0)
            .ok_or("Невозможно разобрать первую запись CSV")?
            .chain_err(|| "Невозможно разобрать цвет RGB")?;

        Ok(color)
    }
}

impl fmt::UpperHex for Rgb {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let hexa = u32::from(self.red) << 16 | u32::from(self.blue) << 8 | u32::from(self.green);
        write!(f, "{:X}", hexa)
    }
}

fn run() -> Result<()> {
    let csv = "red,blue,green
102,256,204";

    let rgb = Rgb::from_reader(csv.as_bytes()).chain_err(|| "Невозможно прочитать данные CSV")?;
    println!("{:?} в шестнадцатеричном формате: #{:X}", rgb, rgb);

    Ok(())
}

fn main() {
    if let Err(ref errors) = run() {
        eprintln!("Уровень ошибки - описание");
        errors
            .iter()
            .enumerate()
            .for_each(|(index, error)| eprintln!("└> {} - {}", index, error));

        if let Some(backtrace) = errors.backtrace() {
            eprintln!("{:?}", backtrace);
        }

        // В реальном приложении ошибки должны обрабатываться. Например, так:
        // std::process::exit(1);
    }
}

Обратная трассировка ошибки:


Уровень ошибки - описание
└> 0 - Невозможно прочитать данные CSV
└> 1 - Невозможно разобрать цвет RGB
└> 2 - CSV deserialize error: record 1 (line: 2, byte: 15): field 1: number too large to fit in target type

Запустите пример с RUST_BACKTRACE=1 для отображения подробной обратной трассировки этой ошибки.


12. Файловая система


12.1. Чтение и запись


Чтение линий строк из файла


Записываем сообщение, состоящее из трех строк, в файл, затем читаем его построчно с помощью итератора Lines, созданного с помощью метода BufRead::lines. Структура File реализует трейт Read, который предоставляет трейт BufReader. Метод File::create открывает файл для записи, а метод File::open — для чтения.


use std::fs::File;
use std::io::{Write, BufReader, BufRead, Error};

fn main() -> Result<(), Error> {
    let path = "lines.txt";

    let mut output = File::create(path)?;
    write!(output, "Rust\n?\nFun")?;

    let input = File::open(path)?;
    let buffered = BufReader::new(input);

    for line in buffered.lines() {
        println!("{}", line?);
    }

    Ok(())
}

Блокировка одновременного чтения и записи файла


Структура same_file::Handle используется для сравнения обработчика файла с другими обработчиками. В следующем примере сравниваются обработчики чтения и записи файла:


use same_file::Handle;
use std::fs::File;
use std::io::{BufRead, BufReader, Error, ErrorKind};
use std::path::Path;

fn main() -> Result<(), Error> {
    let path_to_read = Path::new("message.txt");

    let stdout_handle = Handle::stdout()?;
    let handle = Handle::from_path(path_to_read)?;

    if stdout_handle == handle {
        return Err(Error::new(
            ErrorKind::Other,
            "Вы читаете и пишете в один и тот же файл",
        ));
    } else {
        let file = File::open(&path_to_read)?;
        let file = BufReader::new(file);
        for (num, line) in file.lines().enumerate() {
            println!("{} : {}", num, line?.to_uppercase());
        }
    }

    Ok(())
}

cargo run отображает содержимое файла message.txt, а cargo run >> ./message.txt завершается ошибкой, поскольку операции чтения и записи выполняются над одним файлом.


Произвольный доступ к файлу с помощью карты памяти


Создаем карту памяти (memory map) с помощью memmap и имитируем произвольные чтения файла. Использование карты памяти означает, что мы индексируем фрагмент, а не пытаемся перемещаться по файлу.


Функция Mmap::map предполагает, что файл из карты памяти не модифицируется в то же время другим процессом. Иначе возникнет гонка за данными.


use memmap::Mmap;
use std::fs::File;
use std::io::{Write, Error};

fn main() -> Result<(), Error> {
    write!(File::create("content.txt")?, "My hovercraft is full of eels!")?;

    let file = File::open("content.txt")?;
    let map = unsafe { Mmap::map(&file)? };

    let random_indexes = [0, 1, 2, 19, 22, 10, 11, 29];
    assert_eq!(&map[3..13], b"hovercraft");
    let random_bytes: Vec<u8> = random_indexes.iter()
        .map(|&idx| map[idx])
        .collect();
    assert_eq!(&random_bytes[..], b"My loaf!");
    Ok(())
}

12.2. Обход директории


Получение названий файлов, модифицированных в течение последних 24 часов


Получаем текущую рабочую директорию путем вызова env::current_dir, затем для каждой сущности в fs::read_dir, извлекаем DirEntry::path и получаем метаданные через fs::Metadata. Metadata::modified возвращает SystemTime::elapsed — время, прошедшее с момента последней модификации. Duration::as_secs преобразует время в секунды и сравнивает его с 24 часами (24 60 60). Metadata::is_file отфильтровывает директории.


use error_chain::error_chain;

use std::{env, fs};

error_chain! {
    foreign_links {
        Io(std::io::Error);
        SystemTimeError(std::time::SystemTimeError);
    }
}

fn main() -> Result<()> {
    // Получаем текущую директорию
    let current_dir = env::current_dir()?;
    println!(
        "Файлы, модифицированные в течение последних 24 часов в {:?}:",
        current_dir
    );

    // Перебираем сущности, находящиеся в текущей директории
    for entry in fs::read_dir(current_dir)? {
        let entry = entry?;
        // Получаем путь сущности
        let path = entry.path();
        // Извлекаем метаданные сущности
        let metadata = fs::metadata(&path)?;
        // Получаем время последней модификации и преобразуем его в секунды
        let last_modified = metadata.modified()?.elapsed()?.as_secs();

        // Если с момента последней модификации прошло меньше 24 часов и
        // сущность является файлом
        if last_modified < 24 * 3600 && metadata.is_file() {
            println!(
                "Файл: {:?}, с момента последней модификации прошло {:?} секунд, файл доступен только для чтения: {:?}, размер: {:?} байтов.",
                path.file_name().ok_or("Название файла отсутствует")?,
                last_modified,
                metadata.permissions().readonly(),
                metadata.len(),
            );
        }
    }

    Ok(())
}

Рекурсивный поиск дубликатов


Пример рекурсивного поиска повторяющихся файлов, находящихся в текущей директории:


use std::collections::HashMap;
use walkdir::WalkDir;

fn main() {
    let mut filenames = HashMap::new();

    // Перебираем сущности, находящиеся в текущей директории
    for entry in WalkDir::new(".")
            .into_iter()
            .filter_map(Result::ok)
            // игнорируем директории
            .filter(|e| !e.file_type().is_dir()) {
        // Получаем название файла
        let f_name = String::from(entry.file_name().to_string_lossy());
        // Счетчик количества названий файлов
        let counter = filenames.entry(f_name.clone()).or_insert(0);
        *counter += 1;
        // Если название файла дублируется
        if *counter == 2 {
            println!("{}", f_name);
        }
    }
}

Рекурсивный поиск файлов с заданным предикатом


Пример поиска всех файлов JSON, находящихся в текущей директории и модифицированных в течение последних 24 часов. Метод follow_links считает символические ссылки обычными директориями и файлами.


use error_chain::error_chain;

use walkdir::WalkDir;

error_chain! {
    foreign_links {
        WalkDir(walkdir::Error);
        Io(std::io::Error);
        SystemTime(std::time::SystemTimeError);
    }
}

fn main() -> Result<()> {
    for entry in WalkDir::new(".")
            // учитываем символические ссылки
            .follow_links(true)
            .into_iter()
            .filter_map(|e| e.ok()) {
        let f_name = entry.file_name().to_string_lossy();
        let sec = entry.metadata()?.modified()?;

        // Если мы имеем дело с файлом JSON и с момента его
        //  последнего изменения прошло меньше 24 часов
        if f_name.ends_with(".json") && sec.elapsed()?.as_secs() < 86400 {
            println!("{}", f_name);
        }
    }

    Ok(())
}

Обход директорий с пропуском файлов, название которых начинается с точки


Используем метод filter_entry для рекурсивного перебора сущностей. Функция is_not_hidden возвращает индикатор того, является ли файл или директория скрытыми (если название сущности начинается с точки, значит сущность является скрытой). Iterator::filter применяется к каждой WalkDir::DirEntry, даже если предком сущности является скрытая директория.


Корневая директория не считается скрытой благодаря использованию WalkDir::depth в is_not_hidden.


use walkdir::{DirEntry, WalkDir};

fn is_not_hidden(entry: &DirEntry) -> bool {
    entry
        .file_name()
        .to_str()
        // сущность является корневой директорией или ее название начинается с точки
        .map(|s| entry.depth() == 0 || !s.starts_with("."))
        .unwrap_or(false)
}

fn main() {
    WalkDir::new(".")
        .into_iter()
        // отфильтровываем скрытые сущности
        .filter_entry(|e| is_not_hidden(e))
        .filter_map(|v| v.ok())
        .for_each(|x| println!("{}", x.path().display()));
}

Рекурсивное вычисление размера файлов до заданной глубины


Глубина рекурсии может быть гибко установлена с помощью методов WalkDir::min_depth и WalkDir::max_depth. Вычисляем размер файлов на глубине трех поддиректорий, игнорируя файлы в корневой директории:


use walkdir::WalkDir;

fn main() {
    let total_size = WalkDir::new(".")
        .min_depth(1)
        .max_depth(3)
        .into_iter()
        .filter_map(|entry| entry.ok())
        .filter_map(|entry| entry.metadata().ok())
        .filter(|metadata| metadata.is_file())
        .fold(0, |acc, m| acc + m.len());

    println!("Общий размер: {} байтов.", total_size);
}

Рекурсивный поиск всех файлов PNG


Пример рекурсивного поиска всех файлов PNG в текущей директории. В данном случае паттерн ** совпадает с текущей директорией и всеми ее поддиректориями.


Паттерн ** может использоваться в любом месте пути. Например, /media/**/*.png совпадает со всеми файлами PNG в директории media и всех вложенных директориях.


use error_chain::error_chain;

use glob::glob;

error_chain! {
    foreign_links {
        Glob(glob::GlobError);
        Pattern(glob::PatternError);
    }
}

fn main() -> Result<()> {
    for entry in glob("**/*.png")? {
        println!("{}", entry?.display());
    }

    Ok(())
}

Поиск всех файлов PNG, совпадающий с заданным паттерном, независимо от регистра


Пример поиска всех изображений в директории media, совпадающих с паттерном img_[0-9]*.png.


В функцию glob_with передается структура MatchOptions с настройкой case_sensitive: false, что делает поиск нечувствительным к регистру. Остальные настройки остаются дефолтными.


use error_chain::error_chain;
use glob::{glob_with, MatchOptions};

error_chain! {
    foreign_links {
        Glob(glob::GlobError);
        Pattern(glob::PatternError);
    }
}

fn main() -> Result<()> {
    let options = MatchOptions {
        case_sensitive: false,
        ..Default::default()
    };

    for entry in glob_with("/media/img_[0-9]*.png", options)? {
        println!("{}", entry?.display());
    }

    Ok(())
}

13. Разное


Проверка количества логических ядер центрального процессора


fn main() {
    println!("Количество логических ядер ЦП: {}", num_cpus::get());
}

Определение лениво оцениваемой константы


Пример определения лениво оцениваемой (lazy evaluated) константной HashMap. HashMap оценивается один раз и хранится за глобальной статической ссылкой.


use lazy_static::lazy_static;
use std::collections::HashMap;

lazy_static! {
    static ref PRIVILEGES: HashMap<&'static str, Vec<&'static str>> = {
        let mut map = HashMap::new();
        map.insert("Игорь", vec!["user", "admin"]);
        map.insert("Алекс", vec!["user"]);
        map
    };
}

fn show_access(name: &str) {
    let access = PRIVILEGES.get(name);
    println!("{}: {:?}", name, access);
}

fn main() {
    let access = PRIVILEGES.get("Игорь");
    println!("Игорь: {:?}", access);

    show_access("Алекс");
}

Обработка запросов на неиспользуемом порту


В следующем примере порт отображается в терминале и программа принимает подключения до получения запроса. При установке порта в значение 0, SocketAddrV4 присваивает произвольный порт.


use std::net::{SocketAddrV4, Ipv4Addr, TcpListener};
use std::io::{Read, Error};

fn main() -> Result<(), Error> {
    let loopback = Ipv4Addr::new(127, 0, 0, 1);
    let socket = SocketAddrV4::new(loopback, 0);
    let listener = TcpListener::bind(socket)?;
    let port = listener.local_addr()?;
    println!("Listening on {}, access this port to end the program", port);
    let (mut tcp_stream, addr) = listener.accept()?; // блокировка до получения запроса
    println!("Connection received! {:?} is sending data.", addr);
    let mut input = String::new();
    let _ = tcp_stream.read_to_string(&mut input)?;
    println!("{:?} says {}", addr, input);
    Ok(())
}

14. Операционная система


14.1. Внешняя команда


Запуск внешней команды и обработка stdout


Запускаем git log --oneline как внешнюю Command и исследуем ее Output с помощью Regex для получения хеша и сообщений последних 5 коммитов:


use error_chain::error_chain;

use std::process::Command;
use regex::Regex;

error_chain!{
    foreign_links {
        Io(std::io::Error);
        Regex(regex::Error);
        Utf8(std::string::FromUtf8Error);
    }
}

#[derive(PartialEq, Default, Clone, Debug)]
struct Commit {
    hash: String,
    message: String,
}

fn main() -> Result<()> {
    let output = Command::new("git").arg("log").arg("--oneline").output()?;

    if !output.status.success() {
        error_chain::bail!("Выполнение команды завершилось кодом ошибки");
    }

    let pattern = Regex::new(r"(?x)
                               ([0-9a-fA-F]+) # хеш коммита
                               (.*)           # сообщение коммита")?;

    String::from_utf8(output.stdout)?
        .lines()
        .filter_map(|line| pattern.captures(line))
        .map(|cap| {
                 Commit {
                     hash: cap[1].to_string(),
                     message: cap[2].trim().to_string(),
                 }
             })
        .take(5)
        .for_each(|x| println!("{:?}", x));

    Ok(())
}

Обратите внимание: эта программа должна выполняться в директории с инициализированным GIT (fatal: not a git repository (or any of the parent directories): .git), содержащим хотя бы один коммит (fatal: your current branch 'master' does not have any commits yet).


Запуск внешней команды, передача ей stdin и проверка кода ошибки


Запускаем интерпретатор python с помощью внешней Command и передаем ему инструкцию для выполнения. Затем разбираем Output.


use error_chain::error_chain;

use std::collections::HashSet;
use std::io::Write;
use std::process::{Command, Stdio};

error_chain!{
    errors { CmdError }
    foreign_links {
        Io(std::io::Error);
        Utf8(std::string::FromUtf8Error);
    }
}

fn main() -> Result<()> {
    let mut child = Command::new("python").stdin(Stdio::piped())
        .stderr(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()?;

    child.stdin
        .as_mut()
        .ok_or("stdin дочернего процесса не был перехвачен")?
        .write_all(b"import this; copyright(); credits(); exit()")?;

    let output = child.wait_with_output()?;

    if output.status.success() {
        let raw_output = String::from_utf8(output.stdout)?;
        let words = raw_output.split_whitespace()
            .map(|s| s.to_lowercase())
            .collect::<HashSet<_>>();
        println!("Найдено {} уникальных слов:", words.len());
        println!("{:#?}", words);
        Ok(())
    } else {
        let err = String::from_utf8(output.stderr)?;
        error_chain::bail!("Выполнение внешней команды провалилось:\n {}", err)
    }
}

Обратите внимание: для успешного выполнения этой программы на вашей машине должен быть установлен Python.


Запуск внешних команд в конвейере


Получаем список из 10 самых больших файлов и директорий, находящихся в текущей рабочей директории с помощью команды du -ah . | sort -hr | head -n 10, выполняемой программно.


Command представляет процесс. Вывод (output) дочернего процесса перехватывается с помощью Stdio::piped между предком и ребенком.


use error_chain::error_chain;

use std::process::{Command, Stdio};

error_chain! {
    foreign_links {
        Io(std::io::Error);
        Utf8(std::string::FromUtf8Error);
    }
}

fn main() -> Result<()> {
    // Путь к текущей директории
    let directory = std::env::current_dir()?;
    // du -ah .
    let mut du_output_child = Command::new("du")
        .arg("-ah")
        .arg(&directory)
        .stdout(Stdio::piped())
        .spawn()?;

    if let Some(du_output) = du_output_child.stdout.take() {
        // sort -hr
        let mut sort_output_child = Command::new("sort")
            .arg("-hr")
            .stdin(du_output)
            .stdout(Stdio::piped())
            .spawn()?;

        du_output_child.wait()?;

        if let Some(sort_output) = sort_output_child.stdout.take() {
            // head -n 10
            let head_output_child = Command::new("head")
                .args(&["-n", "10"])
                .stdin(sort_output)
                .stdout(Stdio::piped())
                .spawn()?;

            let head_stdout = head_output_child.wait_with_output()?;

            sort_output_child.wait()?;

            println!(
                "10 самых больших файлов и директорий в '{}':\n{}",
                directory.display(),
                String::from_utf8(head_stdout.stdout).unwrap()
            );
        }
    }

    Ok(())
}

Обратите внимание: эта программа предназначена для выполнения в системах Unix. В Windows аналогичную команду можно выполнить с помощью bash -c "du -ah . | sort -hr | head -n 10".


Перенаправление stdout и stderr дочернего процесса в один файл


Создаем (spawn) дочерний процесс и перенаправляем stdout и stderr в один и тот же файл. Этот пример похож на предыдущий, за исключением того, что process::Stdio пишет в указанный файл. File::try_clone ссылается на один обработчик для stdout и stderr. Это гарантирует, что оба дескриптора пишут с одной и той же позиции курсора. Выполнение этой программы аналогично выполнению команды ls . oops >out.txt 2>&1.


use std::fs::File;
use std::io::Error;
use std::process::{Command, Stdio};

fn main() -> Result<(), Error> {
    let outputs = File::create("out.txt")?;
    let errors = outputs.try_clone()?;

    Command::new("ls")
        // вызываем ошибку
        .args(&[".", "oops"])
        .stdout(Stdio::from(outputs))
        .stderr(Stdio::from(errors))
        .spawn()?
        .wait_with_output()?;

    Ok(())
}

Обратите внимание: эта программа предназначена для выполнения в системах Unix. В Windows аналогичную команду можно выполнить с помощью bash -c "ls . oops >out.txt 2>&1".


Непрерывная обработка входных данных дочернего процесса


В примере "Запуск внешней команды и обработка stdout" обработка начиналась только после завершения выполнения внешней Command. В следующем примере мы создаем конвейер с помощью Stdio::piped и непрерывно (continuously) читаем stdout при обновлении BufReader. Выполнение этой программы эквивалентно выполнению команды journalctl | grep usb.


use std::process::{Command, Stdio};
use std::io::{BufRead, BufReader, Error, ErrorKind};

fn main() -> Result<(), Error> {
    let stdout = Command::new("journalctl")
        .stdout(Stdio::piped())
        .spawn()?
        .stdout
        .ok_or_else(|| Error::new(ErrorKind::Other, "Невозможно перехватить stdout"))?;

    let reader = BufReader::new(stdout);

    reader
        .lines()
        .filter_map(|line| line.ok())
        .filter(|line| line.find("usb").is_some())
        .for_each(|line| println!("{}", line));

     Ok(())
}

Обратите внимание: эта программа предназначена для выполнения в системах Unix. В Windows аналогичную команду можно выполнить с помощью bash -c "journalctl | grep usb".


Чтение переменных среды окружения


Пример чтения переменной среды окружения с помощью std::env::var:


use std::env;
use std::fs;
use std::io::Error;

fn main() -> Result<(), Error> {
    // Читаем `config_path` из переменной среды окружения `CONFIG`.
    // Если переменная `CONFIG` не установлена, используется дефолтный путь
    let config_path = env::var("CONFIG")
        .unwrap_or("/etc/myapp/config".to_string());

    let config: String = fs::read_to_string(config_path)?;
    println!("Настройки: {}", config);

    Ok(())
}

Для чтения переменных из файлов .env* используется крейт dotenv.


15. Обработка текста


15.1. Регулярные выражения


Проверка и извлечение логина из адреса email


Пример валидации email и извлечения всего, что предшествует @:


use lazy_static::lazy_static;
use regex::Regex;

// Функция извлечения логина
fn extract_login(input: &str) -> Option<&str> {
    // Лениво оцениваемая статическая ссылка - регулярное выражение
    lazy_static! {
        static ref RE: Regex = Regex::new(r"(?x)
            ^(?P<login>[^@\s]+)@
            ([[:word:]]+\.)*
            [[:word:]]+$
            ").unwrap();
    }
    RE.captures(input).and_then(|cap| {
        // login - захваченная группа (capture group)
        cap.name("login").map(|login| login.as_str())
    })
}

fn main() {
    assert_eq!(extract_login(r"I❤email@example.com"), Some(r"I❤email"));
    assert_eq!(
        extract_login(r"sdf+sdsfsd.as.sdsd@jhkk.d.rl"),
        Some(r"sdf+sdsfsd.as.sdsd")
    );
    assert_eq!(extract_login(r"More@Than@One@at.com"), None);
    assert_eq!(extract_login(r"Not an email@email"), None);
}

Извлечение списка уникальных хештегов из текста


Пример извлечения, сортировки и удаления дублирующихся хештегов из текста.


Регулярное выражение для проверки хештега учитывает только латинские хештеги, которые начинаются с буквы. Полная регулярка проверки хештегов Twitter гораздо сложнее.


use lazy_static::lazy_static;

use regex::Regex;
use std::collections::HashSet;

// Функция извлечения хештегов
fn extract_hashtags(text: &str) -> HashSet<&str> {
    // Лениво оцениваемая статическая ссылка - регулярное выражение
    lazy_static! {
        static ref RE: Regex = Regex::new(
                r"\#[a-zA-Z][0-9a-zA-Z_]*"
            ).unwrap();
    }
    RE.find_iter(text).map(|mat| mat.as_str()).collect()
}

fn main() {
    let tweet = "Hey #world, I just got my new #dog, say hello to Till. #dog #forever #2 #_ ";
    let tags = extract_hashtags(tweet);
    assert!(tags.contains("#dog") && tags.contains("#forever") && tags.contains("#world"));
    assert_eq!(tags.len(), 3);
}

Извлечение из текста номеров телефона


Пример обработки текста с помощью Regex::captures_iter для захвата нескольких номеров телефона. Регулярное выражение учитывает только американские номера.


use error_chain::error_chain;

use regex::Regex;
use std::fmt;

error_chain!{
    foreign_links {
        Regex(regex::Error);
        Io(std::io::Error);
    }
}

struct PhoneNumber<'a> {
    area: &'a str,
    exchange: &'a str,
    subscriber: &'a str,
}

impl<'a> fmt::Display for PhoneNumber<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "1 ({}) {}-{}", self.area, self.exchange, self.subscriber)
    }
}

fn main() -> Result<()> {
    let phone_text = "
    +1 505 881 9292 (v) +1 505 778 2212 (c) +1 505 881 9297 (f)
    (202) 991 9534
    Alex 5553920011
    1 (800) 233-2010
    1.299.339.1020";

    let re = Regex::new(
        r#"(?x)
          (?:\+?1)?                       # опциональный код страны
          [\s\.]?
          (([2-9]\d{2})|\(([2-9]\d{2})\)) # код региона
          [\s\.\-]?
          ([2-9]\d{2})                    # код обмена
          [\s\.\-]?
          (\d{4})                         # код подписчика"#,
    )?;

    let phone_numbers = re.captures_iter(phone_text).filter_map(|cap| {
        let groups = (cap.get(2).or(cap.get(3)), cap.get(4), cap.get(5));
        match groups {
            (Some(area), Some(ext), Some(sub)) => Some(PhoneNumber {
                area: area.as_str(),
                exchange: ext.as_str(),
                subscriber: sub.as_str(),
            }),
            _ => None,
        }
    });

    assert_eq!(
        phone_numbers.map(|m| m.to_string()).collect::<Vec<_>>(),
        vec![
            "1 (505) 881-9292",
            "1 (505) 778-2212",
            "1 (505) 881-9297",
            "1 (202) 991-9534",
            "1 (555) 392-0011",
            "1 (800) 233-2010",
            "1 (299) 339-1020",
        ]
    );

    Ok(())
}

Замена всех подстрок в строке


Пример замены всех стандартных дат ISO 8601 YYYY-MM-DD эквивалентными датами в привычном нам формате. Например 2013-01-15 становится 15.01.2013.


Метод Regex::replace_all заменяет все вхождения всего регулярного выражения. &str реализует трейт Replacer, который позволяет переменным вроде $abcde ссылаться на соответствующие захваченные группы (?P<abcde>REGEX) из результатов поиска регулярки. См. синтаксис замены в строке для примеров и деталей экранирования.


use lazy_static::lazy_static;

use std::borrow::Cow;
use regex::Regex;

// Функция форматирования даты
fn reformat_dates(before: &str) -> Cow<str> {
    // Лениво оцениваемая статическая ссылка - регулярное выражение
    lazy_static! {
        static ref RE : Regex = Regex::new(
            r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})"
            ).unwrap();
    }
    RE.replace_all(before, "$d.$m.$y")
}

fn main() {
    let before = "2012-03-14, 2013-01-15 и 2014-07-05";
    let after = reformat_dates(before);
    assert_eq!(after, "14.03.2012, 15.01.2013 и 05.07.2014");
}

15.3. Разбор строки


Сбор графем Юникода


Собираем индивидуальные графемы Юникода из UTF-8 строки с помощью метода UnicodeSegmentation::graphemes из крейта unicode-segmentation:


use unicode_segmentation::UnicodeSegmentation;

fn main() {
    let name = "Йогурт захватил мир\r\n";
    let graphemes = UnicodeSegmentation::graphemes(name, true)
        .collect::<Vec<&str>>();
    assert_eq!(graphemes[0], "Й");
}

Реализация трейта FromStr для кастомной структуры


Создаем кастомную структуру RGB и реализуем на ней трейт FromStr для преобразования цвета HEX в цвет RGB:


use std::str::FromStr;

#[derive(Debug, PartialEq)]
struct RGB {
    r: u8,
    g: u8,
    b: u8,
}

impl FromStr for RGB {
    type Err = std::num::ParseIntError;

    // Преобразует цвет HEX `#rRgGbB` в экземпляр `RGB`
    fn from_str(hex_code: &str) -> Result<Self, Self::Err> {
        // `u8::from_str_radix(src: &str, radix: u32)` преобразует строковый срез
        // в u8 в указанной системе счисления
        let r: u8 = u8::from_str_radix(&hex_code[1..3], 16)?;
        let g: u8 = u8::from_str_radix(&hex_code[3..5], 16)?;
        let b: u8 = u8::from_str_radix(&hex_code[5..7], 16)?;

        Ok(RGB { r, g, b })
    }
}

fn main() {
    let code = "#fa7268";
    match RGB::from_str(code) {
        Ok(rgb) => {
            println!(
                "The RGB color code is: R: {} G: {} B: {}",
                rgb.r, rgb.g, rgb.b
            );
        }
        Err(_) => {
            println!("{} is not a valid color hex code!", code);
        }
    }

    assert_eq!(
        RGB::from_str(&r"#fa7268").unwrap(),
        RGB {
            r: 250,
            g: 114,
            b: 104
        }
    );
}

16. Веб-разработка


16.1. Извлечение ссылок


Извлечение всех ссылок из HTML-страницы


Выполняем GET-запрос HTTP с помощью reqwest::get и разбираем ответ в документ HTML с помощью Document::from_read. find с a в Name извлекает все ссылки. Вызов filter_map на Selection извлекает URL из ссылок, имеющих attr (атрибут) href.


use error_chain::error_chain;
use select::document::Document;
use select::predicate::Name;

error_chain! {
      foreign_links {
          ReqError(reqwest::Error);
          IoError(std::io::Error);
      }
}

#[tokio::main]
async fn main() -> Result<()> {
    // Выполняем GET-запрос
    let res = reqwest::get("https://www.rust-lang.org/en-US/")
        .await?
        // преобразуем ответ в текст
        .text()
        .await?;

    // Разбираем текст ответа
    Document::from(res.as_str())
        // находим ссылки
        .find(Name("a"))
        // отфильтровываем ссылки без атрибута `href`
        .filter_map(|n| n.attr("href"))
        .for_each(|x| println!("{}", x));

  Ok(())
}

Поиск сломанных ссылок на веб-странице


Вызываем get_base_url для извлечения базового URL. Если документ имеет базовый тег, получаем из него значение attr (атрибута) href. По умолчанию используется Position::BeforePath оригинального URL.


Перебираем ссылки документа и создаем задачу с помощью tokio::spawn для разбора индивидуальной ссылки с помощью url::ParseOptions и Url::parse. Задача выполняет запрос с помощью reqwest и проверяет StatusCode ответа. Программа await (ожидает) выполнения задач перед завершением.


use error_chain::error_chain;
use reqwest::StatusCode;
use select::document::Document;
use select::predicate::Name;
use std::collections::HashSet;
use url::{Position, Url};

error_chain! {
  foreign_links {
      ReqError(reqwest::Error);
      IoError(std::io::Error);
      UrlParseError(url::ParseError);
      JoinError(tokio::task::JoinError);
  }
}

// Функция получения базового URL
async fn get_base_url(url: &Url, doc: &Document) -> Result<Url> {
  let base_tag_href = doc.find(Name("base")).filter_map(|n| n.attr("href")).nth(0);
  let base_url =
    base_tag_href.map_or_else(|| Url::parse(&url[..Position::BeforePath]), Url::parse)?;
  Ok(base_url)
}

// Функция проверки ссылки
async fn check_link(url: &Url) -> Result<bool> {
  let res = reqwest::get(url.as_ref()).await?;
  // Проверяем только отсутствующие страницы (ошибка 404)
  Ok(res.status() != StatusCode::NOT_FOUND)
}

#[tokio::main]
async fn main() -> Result<()> {
  let url = Url::parse("https://www.rust-lang.org/en-US/")?;
  let res = reqwest::get(url.as_ref()).await?.text().await?;
  let document = Document::from(res.as_str());
  let base_url = get_base_url(&url, &document).await?;
  let base_parser = Url::options().base_url(Some(&base_url));
  let links: HashSet<Url> = document
    .find(Name("a"))
    .filter_map(|n| n.attr("href"))
    .filter_map(|link| base_parser.parse(link).ok())
    .collect();
    let mut tasks = vec![];

    for link in links {
        tasks.push(tokio::spawn(async move {
            if check_link(&link).await.unwrap() {
                println!("Ссылка `{}` в порядке", link);
            } else {
                println!("Ссылка `{}` сломана", link);
            }
        }));
    }

    for task in tasks {
        task.await?
    }

  Ok(())
}

Извлечение уникальных ссылок из разметки MediaWiki


Получаем страницу MediaWiki с помощью reqwest::get и ищем все внутренние и внешние ссылки с помощью Regex::captures_iter. Использование Cow позволяет избежать чрезмерного выделения (allocation) String.


Описание синтаксиса MediaWiki можно найти здесь.


use lazy_static::lazy_static;
use regex::Regex;
use std::borrow::Cow;
use std::collections::HashSet;
use std::error::Error;

// Функция извлечения ссылок с помощью регулярного выражения
fn extract_links(content: &str) -> HashSet<Cow<str>> {
  lazy_static! {
    static ref WIKI_REGEX: Regex = Regex::new(
        r"(?x)
            \[\[(?P<internal>[^\[\]|]*)[^\[\]]*\]\]    # внутренние ссылки
            |
            (url=|URL\||\[)(?P<external>http.*?)[ \|}] # внешние ссылки
        "
    )
    .unwrap();
  }

  let links: HashSet<_> = WIKI_REGEX
    // ищем ссылки на странице
    .captures_iter(content)
    // ищем совпадение с образцом-кортежем
    .map(|c| match (c.name("internal"), c.name("external")) {
      (Some(val), None) => Cow::from(val.as_str().to_lowercase()),
      (None, Some(val)) => Cow::from(val.as_str()),
      _ => unreachable!(),
    })
    .collect();

  links
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
  let content = reqwest::get(
    "https://en.wikipedia.org/w/index.php?title=Rust_(programming_language)&action=raw",
  )
  .await?
  .text()
  .await?;

  println!("{:#?}", extract_links(content.as_str()));

  Ok(())
}

16.2. URL


Разбор URL из строки в тип Url


Метод parse крейта url валидирует и разбирает &str в структуру Url. Строка может быть повреждена, поэтому parse возвращает Result<Url, ParseError>.


use url::{Url, ParseError};

fn main() -> Result<(), ParseError> {
    let s = "https://github.com/rust-lang/rust/issues?labels=E-easy&state=open";

    let parsed = Url::parse(s)?;
    println!("Путь URL: {}", parsed.path());
    // Путь URL: /rust-lang/rust/issues

    Ok(())
}

Создание базового URL путем удаления сегментов пути


Базовый URL включает протокол и домен. Такие URL не содержат директорий, файлов и строк запроса (query string). Метод PathSegmentsMut::clear удаляет пути, а метод Url::set_query удаляет строку запроса.


use error_chain::error_chain;
use url::Url;

error_chain! {
    foreign_links {
        UrlParse(url::ParseError);
    }
    errors {
        CannotBeABase
    }
}

fn main() -> Result<()> {
    let full = "https://github.com/rust-lang/cargo?asdf";

    let url = Url::parse(full)?;
    let base = base_url(url)?;

    println!("Базовый URL: {}", base);
    // Базовый URL: https://github.com/

    Ok(())
}

fn base_url(mut url: Url) -> Result<Url> {
    match url.path_segments_mut() {
        Ok(mut path) => {
            path.clear();
        }
        Err(_) => {
            return Err(Error::from_kind(ErrorKind::CannotBeABase));
        }
    }

    url.set_query(None);

    Ok(url)
}

Создание новых URL из базового


Метод join позволяет создавать новые URL из базового и относительного путей:


use url::{Url, ParseError};

fn main() -> Result<(), ParseError> {
    let path = "/rust-lang/cargo";

    let gh = build_github_url(path)?;

    println!("Объединенный URL: {}", gh);
    // Объединенный URL: https://github.com/rust-lang/cargo

    Ok(())
}

fn build_github_url(path: &str) -> Result<Url, ParseError> {
    const GITHUB: &'static str = "https://github.com";

    let base = Url::parse(GITHUB)?;
    let joined = base.join(path)?;

    Ok(joined)
}

Извлечение источника (схема / хост / порт)


Структура Url предоставляет разные методы для извлечения информации об URL, который она представляет:


use url::{Url, Host, ParseError};

fn main() -> Result<(), ParseError> {
    let s = "ftp://rust-lang.org/examples";

    let url = Url::parse(s)?;

    assert_eq!(url.scheme(), "ftp");
    assert_eq!(url.host(), Some(Host::Domain("rust-lang.org")));
    assert_eq!(url.port_or_known_default(), Some(21));

    Ok(())
}

Аналогичный результат можно получить с помощью метода origin:


use error_chain::error_chain;
use url::{Url, Origin, Host};

error_chain! {
    foreign_links {
        UrlParse(url::ParseError);
    }
}

fn main() -> Result<()> {
    let s = "ftp://rust-lang.org/examples";

    let url = Url::parse(s)?;

    let expected_scheme = "ftp".to_owned();
    let expected_host = Host::Domain("rust-lang.org".to_owned());
    let expected_port = 21;
    let expected = Origin::Tuple(expected_scheme, expected_host, expected_port);

    let origin = url.origin();
    assert_eq!(origin, expected);

    Ok(())
}

Удаление идентификаторов фрагментов и пар запросов из URL


Разбираем строку в структуру Url и обрезаем URL с помощью url::Position для удаления лишних частей:


use url::{Url, Position, ParseError};

fn main() -> Result<(), ParseError> {
    let parsed = Url::parse("https://github.com/rust-lang/rust/issues?labels=E-easy&state=open")?;
    let cleaned: &str = &parsed[..Position::AfterPath];
    println!("Очищенный URL: {}", cleaned);
    // Очищенный URL: https://github.com/rust-lang/rust/issues
    Ok(())
}

16.3. Типы медиа


Извлечение MIME-типа из строки


Следующий пример демонстрирует разбор строки в тип MIME с помощью крейта mime. Структура FromStrError генерирует дефолтный MIME-тип в методе unwrap_or.


use mime::{Mime, APPLICATION_OCTET_STREAM};

fn main() {
    let invalid_mime_type = "i n v a l i d";
    // Дефолтный [MIME-тип]
    let default_mime = invalid_mime_type
        .parse::<Mime>()
        .unwrap_or(APPLICATION_OCTET_STREAM);

    println!(
        "MIME для {:?} - дефолтный {:?}",
        invalid_mime_type, default_mime
    );
    // MIME для "i n v a l i d" - дефолтный "application/octet-stream"

    let valid_mime_type = "TEXT/PLAIN";
    let parsed_mime = valid_mime_type
        .parse::<Mime>()
        .unwrap_or(APPLICATION_OCTET_STREAM);

    println!(
        "MIME для {:?} был разобран как {:?}",
        valid_mime_type, parsed_mime
    );
    // MIME для "TEXT/PLAIN" был разобран как "text/plain"
}

Извлечение MIME-типа из названия файла


Следующий пример демонстрирует извлечение корректного MIME-типа из названия файла с помощью крейта mime. Программа проверяет расширение файла и ищет совпадение с известным списком. Возвращаемым значением является mime::Mime.


use mime::Mime;

fn find_mimetype (filename : &String) -> Mime {
    //  Разбиваем название файла на части по точке
    let parts : Vec<&str> = filename.split('.').collect();

    // Ищем совпадение с последней частью названия файла - его расширением
    let res = match parts.last() {
            Some(v) =>
                match *v {
                    "png" => mime::IMAGE_PNG,
                    "jpg" => mime::IMAGE_JPEG,
                    "json" => mime::APPLICATION_JSON,
                    _ => mime::TEXT_PLAIN,
                },
            None => mime::TEXT_PLAIN,
        };

    return res;
}

fn main() {
    let filenames = vec!("foobar.jpg", "foo.bar", "foobar.png");
    for file in filenames {
        let mime = find_mimetype(&file.to_owned());
        println!("MIME для {}: {}", file, mime);
     }
}

Извлечение MIME-типа из ответа HTTP


При получении ответа HTTP с помощью reqwest MIME-тип можно найти в заголовке Content-Type. Метод reqwest::header::HeaderMap::get извлекает заголовок как reqwest::header::HeaderValue, которое может быть преобразовано в строку. Крейт mime затем может разобрать эту строку в значение mime::Mime.


Крейт mime определяет некоторые распространенные MIME-типы.


Обратите внимание, что модуль reqwest::header экспортируется из крейта http.


use error_chain::error_chain;
use mime::Mime;
use std::str::FromStr;
use reqwest::header::CONTENT_TYPE;

error_chain! {
    foreign_links {
        Reqwest(reqwest::Error);
        Header(reqwest::header::ToStrError);
        Mime(mime::FromStrError);
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let response = reqwest::get("https://www.rust-lang.org/logos/rust-logo-32x32.png").await?;
    // Извлекает заголовки из ответа
    let headers = response.headers();

    match headers.get(CONTENT_TYPE) {
        None => {
            println!("Ответ не содердит заголовка `Content-Type`");
        }
        Some(content_type) => {
            let content_type = Mime::from_str(content_type.to_str()?)?;
            let media_type = match (content_type.type_(), content_type.subtype()) {
                (mime::TEXT, mime::HTML) => "документ HTML",
                (mime::TEXT, _) => "текст",
                (mime::IMAGE, mime::PNG) => "изображение PNG",
                (mime::IMAGE, _) => "изображение",
                _ => "не текст и не изображение",
            };

            println!("Ответ содержит {}", media_type);
            // Ответ содержит изображение PNG
        }
    };

    Ok(())
}

16.3. Клиенты


Отправка запроса HTTP


Отправляем синхронный GET-запрос HTTP с помощью метода reqwest::blocking::get, получаем структуру reqwest::blocking::Response, читаем тело ответа в String с помощью метода read_to_string, печатаем статус, заголовки и тело ответа:


use error_chain::error_chain;
use std::io::Read;

error_chain! {
    foreign_links {
        Io(std::io::Error);
        HttpRequest(reqwest::Error);
    }
}

fn main() -> Result<()> {
    // Отправляем запрос/получаем ответ
    let mut res = reqwest::blocking::get("http://httpbin.org/get")?;
    let mut body = String::new();
    // Читаем тело ответа в строку
    res.read_to_string(&mut body)?;

    println!("Статус: {}", res.status());
    println!("Заголовки:\n{:#?}", res.headers());
    println!("Тело ответа:\n{}", body);

    Ok(())
}

Async


Асинхронный вариант предыдущего примера с использованием крейта tokio:


use error_chain::error_chain;

error_chain! {
    foreign_links {
        Io(std::io::Error);
        HttpRequest(reqwest::Error);
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let res = reqwest::get("http://httpbin.org/get").await?;
    println!("Статус: {}", res.status());
    println!("Заголовки:\n{:#?}", res.headers());

    // Читаем тело запроса как текст
    let body = res.text().await?;
    println!("Тело ответа:\n{}", body);
    Ok(())
}

Обращение к GitHub API


Отправляем запрос к stargazers API v3 с помощью reqwest::get для получения списка пользователей, поставивших звезду проекту GitHub. Структура reqwest::Response десериализуется в структуру User, реализующую трейт serde::Deserialize.


tokio::main используется для установки асинхронного исполнителя (executor). Процесс ждет (await) завершения запроса перед обработкой ответа.


use reqwest::{header::USER_AGENT, Error};
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct User {
    login: String,
    id: u32,
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Формируем URL
    let request_url = format!(
        "https://api.github.com/repos/{owner}/{repo}/stargazers",
        owner = "harryheman",
        repo = "my-js"
    );
    println!("{}", request_url);

    let client = reqwest::Client::new();
    // Отправляем запрос
    let response = client
        .get(request_url)
        // Обязательный заголовок
        .header(USER_AGENT, "")
        .send()
        .await?;

    // Преобразуем тело ответа в формате JSON в объекты `User`
    let users: Vec<User> = response.json().await?;
    println!("{:?}", users);
    Ok(())
}

Проверка существования ресурса API


Отправляем HEAD-запрос HTTP (Client::head) в конечную точку пользователей GitHub и определяем успех по статусу ответа. Так можно быстро проверить существование ресурса без получения тела ответа. Настройка reqwest::Client с помощью метода ClientBuilder::timeout отменяет запрос, если он выполняется дольше 5 секунд.


Поскольку методы ClientBuilder::build и ReqwestBuilder::send возвращают типы reqwest::Error, в качестве типа значения, возвращаемого функцией main, используется reqwest::Result.


use reqwest::header::USER_AGENT;
use reqwest::ClientBuilder;
use reqwest::Result;
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<()> {
    // Имя пользователя
    let user = "harryheman";
    // Конечная точка
    let request_url = format!("https://api.github.com/users/{}", user);
    println!("{}", request_url);

    // Таймаут, по истечении которого запрос отменяется
    let timeout = Duration::new(5, 0);
    // Создаем и настраиваем экземпляр клиента
    let client = ClientBuilder::new().timeout(timeout).build()?;
    // Отправляем HEAD-запрос
    let response = client
        .head(&request_url)
        // Обязательный заголовок
        .header(USER_AGENT, "")
        .send()
        .await?;

    // Определяем успех запроса по статусу ответа (200 ОК)
    if response.status().is_success() {
        println!("{} является пользователем", user);
    } else {
        println!("{} не является пользователем", user);
    }

    Ok(())
}

Создание и удаление Gist с помощью GitHub API


Создаем gist с помощью POST-запроса HTTP (Client::post) к gists API v3 и удаляем его с помощью DELETE-запроса (Client::delete).


Структура reqwest::Client отвечает за формирование запроса, включая URL, тело и аутентификацию. Тело запроса в формате JSON формируется с помощью макроса serde_json::json!. Оно устанавливается с помощью метода RequestBuilder::json. Заголовок авторизации устанавливается с помощью метода RequestBuilder::header. Метод RequestBuilder::send отправляет запрос.


Для авторизации в GitHub API необходимо создать токен доступа (не забудьте поставить галочку gist), и добавить его в файл .env в корне проекта (GH_TOKEN=ghp_...). Для доступа к переменным среды окружения из этого файла используется крейт dotenv.


use dotenv::dotenv;
use error_chain::error_chain;
use reqwest::{
    header::{AUTHORIZATION, USER_AGENT},
    Client,
};
use serde::Deserialize;
use serde_json::json;
use std::env;

error_chain! {
    foreign_links {
        EnvVar(env::VarError);
        HttpRequest(reqwest::Error);
    }
}

#[derive(Deserialize, Debug)]
struct Gist {
    id: String,
    html_url: String,
}

#[tokio::main]
async fn main() -> Result<()> {
    // Получаем переменные среды окружения из файла `.env`,
    // находящего в корневой директории
    dotenv().ok();

    // Тело запроса
    let gist_body = json!({
        "description": "описание gist",
        "public": true,
        "files": {
            "main.rs": {
            "content": r#"fn main() { println!("всем привет!");}"#
            }
    }});

    // Конечная точка
    let request_url = "https://api.github.com/gists";
    // Отправляем POST-запрос на создание gist
    let response = Client::new()
        .post(request_url)
        // Обязательный заголовок
        .header(USER_AGENT, "")
        // Заголовок авторизации
        .header(AUTHORIZATION, format!("Bearer {}", env::var("GH_TOKEN")?))
        // Добавляем тело
        .json(&gist_body)
        .send()
        .await?;

    if response.status().is_success() {
        let gist: Gist = response.json().await?;
        println!("Создан {:?}", gist);

        // Конечная точка
        let request_url = format!("{}/{}", request_url, gist.id);
        // Отправляем DELETE-запрос на удаление gist
        let response = Client::new()
            .delete(&request_url)
            // Обязательный заголовок
            .header(USER_AGENT, "")
            // Заголовок авторизации
            .header(AUTHORIZATION, format!("Bearer {}", env::var("GH_TOKEN")?))
            .send()
            .await?;

        if response.status().is_success() {
            println!(
                "Gist {} удален. Статус-код: {}",
                gist.id,
                response.status()
            );
        } else {
            println!("Запрос провалился. Статус-код: {}", response.status());
        }
    } else {
        println!("Запрос провалился. Статус-код: {}", response.status());
    }

    Ok(())
}

Скачивание файла во временную директорию


Создаем временную директорию с помощью структуры tempfile::Builder и асинхронно скачиваем в нее файл через HTTP с помощью метода reqwest::get.


Создаем целевой File с названием, извлеченным из Response::url, внутри метода tempdir, и копируем в нее скачанные данные с помощью метода io::copy. Временная директория автоматически удаляется после завершения программы.


use error_chain::error_chain;
use std::fs::File;
use std::io::copy;
use tempfile::Builder;

error_chain! {
     foreign_links {
         Io(std::io::Error);
         HttpRequest(reqwest::Error);
     }
}

#[tokio::main]
async fn main() -> Result<()> {
    // Временная директория
    let tmp_dir = Builder::new().prefix("example").tempdir()?;
    // Целевой файл
    let target = "https://www.rust-lang.org/logos/rust-logo-512x512.png";
    // Отправляем запрос
    let response = reqwest::get(target).await?;

    let mut dest = {
        let fname = response
            .url()
            .path_segments()
            .and_then(|segments| segments.last())
            .and_then(|name| if name.is_empty() { None } else { Some(name) })
            .unwrap_or("tmp.bin");
        // Названием файла является последняя часть пути или `tmp.bin`
        println!("файл для скачивания: '{}'", fname);
        let fname = tmp_dir.path().join(fname);
        // Путь к временной директории + название файла
        println!("будет находиться в: '{:?}'", fname);
        // Создаем и возвращаем дескриптор файла
        File::create(fname)?
    };
    // Читаем тело ответа как текст
    let content = response.text().await?;
    // Копируем содержимое в файл
    copy(&mut content.as_bytes(), &mut dest)?;
    // Файл и временная директория будут существовать на протяжении 5 секунд,
    // после чего автоматически удалятся
    std::thread::sleep(std::time::Duration::from_secs(5));
    Ok(())
}

Отправка файла в paste-rs


reqwest::Client устанавливает соединение с https://paste.rs с помощью паттерна reqwest::RequestBuilder. Client::post определяет назначение POST-запроса HTTP, RequestBuilder::body устанавливает тело запроса, а RequestBuilder::send отправляет запрос, блокирует поток до загрузки файла и получения ответа.


use error_chain::error_chain;
use std::fs::File;
use std::io::Read;

error_chain! {
    foreign_links {
        HttpRequest(reqwest::Error);
        IoError(::std::io::Error);
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    // Конечная точка
    let paste_api = "https://paste.rs";
    // Дескриптор файла
    let mut file = File::open("message.txt")?;

    let mut contents = String::new();
    // Читаем содержимое файла в строку
    file.read_to_string(&mut contents)?;

    // Создаем клиента
    let client = reqwest::Client::new();
    // Отправляем запрос
    let res = client.post(paste_api).body(contents).send().await?;
    // Читаем ответ как текст
    let response_text = res.text().await?;
    println!("{}", response_text);
    Ok(())
}

Обратите внимание: для корректной работы программы нужно создать непустой файл message.txt в корне проекта.


Частичная загрузка файла по HTTP с помощью заголовка диапазона


Используем reqwest::blocking::Client::head для получения Content-Length (размера содержимого) ответа.


Используем reqwest::blocking::Client::get для загрузки содержимого по частям размером 10240 байт с отслеживанием прогресса. Часть и позиция определяются с помощью заголовка Range, который определяется в RFC7233.


use error_chain::error_chain;
use reqwest::header::{HeaderValue, CONTENT_LENGTH, RANGE};
use reqwest::StatusCode;
use std::fs::File;
use std::str::FromStr;

error_chain! {
    foreign_links {
        Io(std::io::Error);
        Reqwest(reqwest::Error);
        Header(reqwest::header::ToStrError);
    }
}

struct PartialRangeIter {
    start: u64,
    end: u64,
    buffer_size: u32,
}

impl PartialRangeIter {
    pub fn new(start: u64, end: u64, buffer_size: u32) -> Result<Self> {
        if buffer_size == 0 {
            Err("невалидный `buffer_size`, размер буфера должен превышать 0")?;
        }
        Ok(PartialRangeIter {
            start,
            end,
            buffer_size,
        })
    }
}

impl Iterator for PartialRangeIter {
    type Item = HeaderValue;

    fn next(&mut self) -> Option<Self::Item> {
        if self.start > self.end {
            None
        } else {
            let prev_start = self.start;

            self.start += std::cmp::min(self.buffer_size as u64, self.end - self.start + 1);

            Some(
                HeaderValue::from_str(&format!("bytes={}-{}", prev_start, self.start - 1)).unwrap(),
            )
        }
    }
}

fn main() -> Result<()> {
    // Конечная точка
    let url = "https://httpbin.org/range/102400?duration=2";
    // Размер части
    const CHUNK_SIZE: u32 = 10240;

    let client = reqwest::blocking::Client::new();
    // Отправляем HEAD-запрос
    let response = client.head(url).send()?;
    // Получаем заголовок `Content-Length`
    let length = response
        .headers()
        .get(CONTENT_LENGTH)
        .ok_or("Ответ не содержит размера содержимого")?;
    // Получаем размер содержимого
    let length =
        u64::from_str(length.to_str()?).map_err(|_| "Невалидный заголовок `Content-Length`")?;

    // Дескриптор файла
    let mut output_file = File::create("download.bin")?;

    println!("Начинаем загрузку...");
    for range in PartialRangeIter::new(0, length - 1, CHUNK_SIZE)? {
        println!("Диапазон {:?}", range);
        // Отправляем GET-запрос с заголовком `Range`
        let mut response = client.get(url).header(RANGE, range).send()?;

        let status = response.status();
        if !(status == StatusCode::OK || status == StatusCode::PARTIAL_CONTENT) {
            error_chain::bail!("Неожиданный ответ сервера: {}", status)
        }
        // Копируем содержимое ответа в файл
        std::io::copy(&mut response, &mut output_file)?;
    }

    // Читаем ответ как текст
    let content = response.text()?;
    // Копируем байты ответа в файл
    std::io::copy(&mut content.as_bytes(), &mut output_file)?;

    println!("Загрузка успешно завершена");

    Ok(())
}

Обратите внимание: в результате выполнения программы в корне проекта должен появиться файл download.bin.


Базовая аутентификация


Для выполнения базовой аутентификации HTTP используется метод reqwest::RequestBuilder::basic_auth:


use reqwest::blocking::Client;
use reqwest::Error;

fn main() -> Result<(), Error> {
    let client = Client::new();

    let user_name = "testuser".to_string();
    let password: Option<String> = None;

    // Отправляем GET-запрос с базовой аутентификацией
    let response = client
        .get("https://httpbin.org/")
        .basic_auth(user_name, password)
        .send()?;

    println!("{:?}", response);

    Ok(())
}

Это конец второй части и Книги в целом.


Happy coding!



Новости, обзоры продуктов и конкурсы от команды Timeweb.Cloud — в нашем Telegram-канале ↩

Комментарии (0)