Есть программа на языке RUST. Надо изменить ее чтобы: 1) если какой-либо сервер…
- User
Есть программа на языке RUST. Надо изменить ее чтобы: 1) если какой-либо сервер недоступен, то при распределении задач - на этот сервер не посылаются задачи на выполнение, и задание посылается на другой работающий сервер. При этом в консоли сервера пишется "Задание id="n" передано от сервера X к серверу Y. 2) На серверах worker, когда получается задание пишется информация в консоль: "Получено задание номер и информация по пакету: здесь указывается информация по соединению с сервером - есть сертификат или нет, протокол http или https, версия протокола http - 1 или 2 . 3) В некоторых местах программы, где требуется нужно добавить комментарии на русском языке. Текст файлов программы: ///+++ ./Cargo.toml [package] name = "servhttps" version = "0.1.0" edition = "2021"
[dependencies] tokio = { version = "1", features = ["full"] } hyper = { version = "0.14", features = ["server", "client", "http1", "tcp"] } hyper-tls = "0.5" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" rand = "0.8" chrono = "0.4" rustls-pemfile = "1.0" webpki-roots = "0.22" rustls = {version = "0.21", features = ["dangerous_configuration"]} hyper-rustls = { version = "0.24", features = ["http1"] }
[[bin]] name = "main_server" path = "src/main.rs"
[[bin]] name = "worker" path = "src/worker.rs"
///+++ ./src/main.rs use hyper::{Body, Client, Request}; use hyper_rustls::HttpsConnectorBuilder; use rand::Rng; use std::fs::OpenOptions; use std::io::Write; use tokio::sync::{mpsc, Mutex}; use std::time::Instant; use rustls::{Certificate, ServerName}; use std::sync::Arc; use std::time::SystemTime;
mod models; use models::{Task, TaskResult};
// Максимальное количество серверов worker (до 10) const MAX_SERVER_COUNT: usize = 10;
#[tokio::main] async fn main() { // Получаем количество задач из аргумента командной строки let args: Vec = std::env::args().collect(); if args.len() < 2 { eprintln!("Использование: main_server <количество_задач>"); return; }
let task_count: u64 = match args[1].parse() { Ok(n) => n, Err(_) => { eprintln!("Ошибка: Аргумент должен быть целым числом"); return; } }; // Создаем TLS-конфиг без проверки сертификатов let tls_config = rustls::ClientConfig::builder() .with_safe_defaults() .with_custom_certificate_verifier(Arc::new(InsecureVerifier)) .with_no_client_auth(); let https = HttpsConnectorBuilder::new() .with_tls_config(tls_config) .https_only() .enable_http1() .build(); let client = Client::builder().build::<_, hyper::Body>(https); // Генерируем задания let mut tasks = Vec::new(); let mut rng = rand::thread_rng(); for id in 0..task_count { // Распределяем задачи равномерно между серверами let server_index = (id as usize % MAX_SERVER_COUNT) + 1; // от 1 до 10 let task = Task { id, number1: rng.gen_range(1..100), number2: rng.gen_range(1..100), server_index, }; tasks.push(task); } // Список активных серверов (по умолчанию все доступны) let active_servers = Arc::new(Mutex::new(vec![true; MAX_SERVER_COUNT])); // Канал для получения результатов let (tx, mut rx) = mpsc::channel::<TaskResult>(100); // Отправляем задачи for task in tasks { let client = client.clone(); let tx = tx.clone(); let active_servers = Arc::clone(&active_servers); let server_url = format!("https://localhost:{}", 8000 + task.server_index); // порт = 8000 + индекс tokio::spawn(async move { let server_idx = task.server_index - 1; // Индекс для массива (начинается с 0) // Проверяем, доступен ли сервер { let servers = active_servers.lock().await; if !servers[server_idx] { println!("Сервер {} не доступен. Задача {} пропущена.", task.server_index, task.id); return; } } let start_time = Instant::now(); // Пытаемся отправить задачу match send_task_to_server(&client, &task, &server_url).await { Ok(result) => { let execution_time = start_time.elapsed().as_millis() as i64; let result_with_time = TaskResult { id: result.id, server_index: result.server_index, number1: result.number1, number2: result.number2, result: result.result, execution_time, }; tx.send(result_with_time).await.unwrap(); }, Err(e) => { // Сервер недоступен { let mut servers = active_servers.lock().await; servers[server_idx] = false; // Отмечаем как недоступный } println!("Сервер {} недоступен: {}", task.server_index, e); } } }); } drop(tx); // Закрываем канал отправки // Обрабатываем результаты while let Some(result) = rx.recv().await { log_result(&result); println!("Получен результат: {:?}", result); }}
/// Функция для логирования результатов в файл fn log_result(result: &TaskResult) { let mut file = OpenOptions::new() .append(true) .create(true) .open("results.log") .expect("Не удалось открыть файл для логирования");
let log_entry = format!( "Task ID: {}, Server: {}, Number1: {}, Number2: {}, Result: {}, Execution Time: {}ms\n", result.id, result.server_index, result.number1, result.number2, result.result, result.execution_time ); file.write_all(log_entry.as_bytes()).expect("Не удалось записать в файл");}
/// Функция для отправки задания на рабочий сервер async fn send_task_to_server( client: &Client<hyper_rustls::HttpsConnectorhyper::client::HttpConnector>, task: &Task, server_url: &str, ) -> Result<TaskResult, hyper::Error> { let task_json = serde_json::to_string(task).unwrap(); let req = Request::builder() .method("POST") .uri(format!("{}/task", server_url)) .header("Content-Type", "application/json") .body(Body::from(task_json)) .unwrap();
let res = client.request(req).await?; let body_bytes = hyper::body::to_bytes(res.into_body()).await?; let result: TaskResult = serde_json::from_slice(&body_bytes).unwrap(); Ok(result)}
// Небезопасный верификатор сертификатов (для тестирования) struct InsecureVerifier;
impl rustls::client::ServerCertVerifier for InsecureVerifier { fn verify_server_cert( &self, _end_entity: &Certificate, _intermediates: &[Certificate], _server_name: &ServerName, _scts: &mut dyn Iterator<Item = &[u8]>, _ocsp_response: &[u8], _now: SystemTime, ) -> Result<rustls::client::ServerCertVerified, rustls::Error> { Ok(rustls::client::ServerCertVerified::assertion()) } }
///+++ ./src/models.rs use serde::{Deserialize, Serialize};
// Структура задания #[derive(Serialize, Deserialize, Debug, Clone)] pub struct Task { pub id: u64, // Уникальный номер задания pub number1: i32, // Первое число pub number2: i32, // Второе число pub server_index: usize, // Индекс сервера, который будет выполнять задание }
// Структура результата #[derive(Serialize, Deserialize, Debug)] pub struct TaskResult { pub id: u64, // Уникальный номер задания pub server_index: usize, // Индекс сервера pub number1: i32, // Первое число pub number2: i32, // Второе число pub result: i32, // Результат (произведение) pub execution_time: i64, // Время выполнения (в миллисекундах) }
///+++ ./src/worker.rs use hyper::{Body, Request, Response, Server, service::{make_service_fn, service_fn}}; use serde_json; use std::convert::Infallible; use std::net::SocketAddr; use hyper_rustls::TlsAcceptor; use rustls::{Certificate, PrivateKey}; use rustls::server::ServerConfig; use rustls_pemfile::{certs, pkcs8_private_keys}; use std::fs::File; use std::io::BufReader; use hyper::server::conn::AddrIncoming;
mod models; use models::{Task, TaskResult};
// Функция для загрузки SSL/TLS-сертификатов fn load_rustls_config() -> rustls::ServerConfig { let cert_file = &mut BufReader::new(File::open("server.crt").unwrap()); let key_file = &mut BufReader::new(File::open("server.key").unwrap());
let cert_chain: Vec<Certificate> = certs(cert_file) .unwrap() .into_iter() .map(Certificate) .collect(); let mut keys: Vec<PrivateKey> = pkcs8_private_keys(key_file) .unwrap() .into_iter() .map(PrivateKey) .collect(); let config = ServerConfig::builder() .with_safe_defaults() .with_no_client_auth() .with_single_cert(cert_chain, keys.remove(0)) .unwrap(); config}
// Обработчик входящих заданий async fn handle_task(req: Request) -> Result<Response, Infallible> { let body_bytes = hyper::body::to_bytes(req.into_body()).await.unwrap(); let task: Task = serde_json::from_slice(&body_bytes).unwrap();
// Выполняем задание (перемножаем числа) let result = task.number1 * task.number2; // Формируем результат let task_result = TaskResult { id: task.id, server_index: task.server_index, number1: task.number1, number2: task.number2, result, execution_time: 0, // Время выполнения будет добавлено на Сервер0 }; // Возвращаем результат в формате JSON let result_json = serde_json::to_string(&task_result).unwrap(); Ok(Response::new(Body::from(result_json)))}
#[tokio::main] async fn main() { // Получаем номер сервера из аргумента let server_index = std::env::args().nth(1).unwrap_or("1".to_string()).parse::().unwrap(); let port = 8000 + server_index;
let addr = SocketAddr::from(([127, 0, 0, 1], port as u16)); // Настраиваем TLS let tls_config = load_rustls_config(); // Убираем Arc здесь let incoming = AddrIncoming::bind(&addr).unwrap(); let acceptor = TlsAcceptor::builder() .with_tls_config(tls_config) // Передаем ServerConfig напрямую .with_all_versions_alpn() .with_incoming(incoming); let make_svc = make_service_fn(|_conn| async { Ok::<_, Infallible>(service_fn(handle_task)) }); let server = Server::builder(acceptor).serve(make_svc); println!("Рабочий сервер {} запущен на порту {} (HTTPS)", server_index, port); if let Err(e) = server.await { eprintln!("Ошибка сервера: {}", e); }}
Assistant
Вот пошаговое объяснение, как модифицировать проект на Rust, чтобы удовлетворить все ваши требования:
✅ Что нужно реализовать:
- Если сервер недоступен, задача передаётся другому серверу.
- Вывод информации о соединении на серверах
worker. - Комментарии на русском.
📄 Изменения в
src/main.rs// ... #[tokio::main] async fn main() { // ... // ... // Отправка задач на рабочие серверы с перераспределением for task in tasks { let client = client.clone(); let tx = tx.clone(); let active_servers = Arc::clone(&active_servers); tokio::spawn(async move { let mut assigned_server_index = task.server_index; let mut attempt = 0; loop { if attempt >= MAX_SERVER_COUNT as u32 { println!("Задача {} не может быть отправлена, все серверы заняты.", task.id); break; } // Проверяем доступность сервера let is_server_available = { let servers = active_servers.lock().await; servers[assigned_server_index - 1] }; if is_server_available { let server_url = format!("https://localhost:{}", 8000 + assigned_server_index); // Отправляем задачу match send_task_to_server(&client, &task, &server_url).await { Ok(result) => { let execution_time = Instant::now().elapsed().as_millis() as i64; let result_with_time = TaskResult { id: result.id, server_index: result.server_index, number1: result.number1, number2: result.number2, result: result.result, execution_time, }; tx.send(result_with_time).await.unwrap(); break; }, Err(e) => { // Сервер недоступен { let mut servers = active_servers.lock().await; servers[assigned_server_index - 1] = false; // Отмечаем как недоступный } println!("Сервер {} недоступен: {}", assigned_server_index, e); // Пробуем другой сервер assigned_server_index = (assigned_server_index % MAX_SERVER_COUNT) + 1; attempt += 1; // Выводим информацию о перераспределении println!("Задание id={} передано от сервера {} к серверу {}.", task.id, assigned_server_index - 1, assigned_server_index); } } } else { // Пробуем другой сервер assigned_server_index = (assigned_server_index % MAX_SERVER_COUNT) + 1; attempt += 1; } } }); } // ... } /// Функция для логирования результатов в файл fn log_result(result: &TaskResult) { // ... } /// Функция для отправки задания на рабочий сервер async fn send_task_to_server( client: &Client<hyper_rustls::HttpsConnector<hyper::client::HttpConnector>>, task: &Task, server_url: &str, ) -> Result<TaskResult, hyper::Error> { // ... }
📄 Изменения в
src/worker.rs// Обработчик входящих заданий async fn handle_task(req: Request<Body>) -> Result<Response<Body>, Infallible> { let body_bytes = hyper::body::to_bytes(req.into_body()).await.unwrap(); let task: Task = serde_json::from_slice(&body_bytes).unwrap(); // Выводим информацию о соединении println!("Получено задание номер {}: информация по пакету - сертификат: {:?}, протокол: {:?}, версия протокола: {:?}", task.id, req.extensions().get::<hyper_rustls::TlsInfo>().is_some(), req.version(), req.version()); // ... // Возвращаем результат в формате JSON let result_json = serde_json::to_string(&task_result).unwrap(); Ok(Response::new(Body::from(result_json))) }
📌 Примеры использования:
Запуск
main_serverс 50 задачами:cargo run -- main_server 50Запуск
worker№5:cargo run -- worker 5
Если нужно — могу также помочь:
- Автоматически запускать несколько
workerпри стартеmain_server - Добавить повторную попытку подключения к недоступным серверам
- Реализовать балансировку нагрузки более гибко
Хочешь, чтобы я помог собрать это в один скрипт запуска?
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.