LAB/rust-otus
0
0
Fork 0
Code Pull Requests Activity

ДЗ smart-house-web завершено

Browse Source
This commit is contained in:
Баранов Александр Сергеевич
2026-05-25 14:07:32 +03:00
parent da61248297
commit fc5950c550
28 changed files with 1671 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
smart-house-web/backend/Cargo.toml
+18
View File
@@ -0,0 +1,18 @@
[package]
name = "backend"
version = "0.1.0"
edition = "2024"
[dependencies]
smart_house = { path = "../smart_house" }
tracing = "0.1"
tracing-subscriber = "0.3"
tokio = { version = "1.52", features = ["rt", "rt-multi-thread", "signal", "time"] }
axum = "0.8"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
tower-http = { version = "0.6", features = ["cors"] }
[dev-dependencies]
reqwest = { version = "0.13", features = ["json"] }
smart-house-web/backend/src/lib.rs
+70
View File
@@ -0,0 +1,70 @@
use std::process::exit;
use tracing::{Level, error, trace};
/// Ошибка инициализации логгера
const CODE_LOGGER_INITIALIZATION_ERROR: i32 = 1;
/// Ошибка инициализации рантайма Tokio
const CODE_TOKIO_RUNTIME_CREATION_ERROR: i32 = 2;
/// Ошибка привязки слушателя
const CODE_LISTENER_BINDING_ERROR: i32 = 3;
/// Ошибка запуска сервера
const CODE_STARTIG_SERVER_ERROR: i32 = 4;
/// Ошибка установки обработчика сигнала завершения
const CODE_CTRL_C_SIGNAL_INSTALL_ERROR: i32 = 5;
/// Инициализация логирования
pub fn init_logger() {
use tracing_subscriber::{
Layer, filter::Targets, fmt::layer, layer::SubscriberExt, registry, util::SubscriberInitExt,
};
let layer = layer()
.compact()
.with_thread_names(true)
.with_file(false)
.with_line_number(false)
.with_filter(
Targets::new()
.with_target("axum::serve", Level::INFO)
.with_target("hyper_util::client::legacy", Level::INFO)
.with_target("reqwest::retry", Level::INFO)
.with_default(Level::TRACE),
)
.boxed();
if let Err(e) = registry().with(vec![layer]).try_init() {
eprintln!("Logger initialization failed: {:?}", e);
exit(CODE_LOGGER_INITIALIZATION_ERROR);
} else {
trace!("Logger succesfully initialized");
}
}
pub fn build_runtime() -> tokio::runtime::Runtime {
use std::sync::atomic::{AtomicUsize, Ordering};
match tokio::runtime::Builder::new_multi_thread()
.name("tokio")
.thread_name_fn(|| {
static LAST_ID: AtomicUsize = AtomicUsize::new(0);
let id = LAST_ID.fetch_add(1, Ordering::SeqCst);
format!("tkwr-{id}")
})
.worker_threads(2)
.thread_stack_size(256 * 1024)
.enable_all()
.build()
{
Ok(runtime) => runtime,
Err(e) => {
error!("Failed to create Tokio runtime: {:?}", e);
exit(crate::CODE_TOKIO_RUNTIME_CREATION_ERROR);
}
}
}
mod server;
pub use server::{axum_app, server_main};
smart-house-web/backend/src/main.rs
+8
View File
@@ -0,0 +1,8 @@
use backend::{axum_app, build_runtime, init_logger, server_main};
fn main() {
init_logger();
let runtime = build_runtime();
let app = axum_app();
runtime.block_on(server_main(app));
}
smart-house-web/backend/src/server.rs
+94
View File
@@ -0,0 +1,94 @@
use axum::{
Router,
routing::{delete, get, post, put},
};
use std::{process::exit, sync::Arc};
use tokio::sync::RwLock;
use tower_http::cors::*;
use tracing::{error, info};
use smart_house::House;
/// Тип состояния
type ServerState = Arc<RwLock<House>>;
pub fn axum_app() -> Router {
let state: ServerState = Arc::new(RwLock::new(House::default()));
axum::Router::new()
// Тестовый эндпоинт для экспериментов
.route("/debug", get(debug::debug))
// API дома
.route("/rooms", get(house::get_rooms))
.route("/rooms", post(house::post_rooms))
// API комнат
.route("/room/{name}", get(room::get_room))
.route("/room/{name}", put(room::put_room))
.route("/room/{name}", delete(room::delete_room))
.route("/room/{name}/devices", get(room::get_devices))
// API устройств
.route("/room/{name}/device/{name}", get(device::get_device))
.route("/room/{name}/device/{name}", put(device::put_device))
.route("/room/{name}/device/{name}", delete(device::delete_device))
// Состояние и роут по-умолчанию
.with_state(state)
.fallback(fallback)
.layer(
CorsLayer::new()
.allow_origin(Any)
.allow_headers(Any)
.allow_methods(Any),
)
}
/// Основная функция сервера
pub async fn server_main(app: Router) {
let addr = "127.0.0.1:8081";
let listener = match tokio::net::TcpListener::bind(addr).await {
Ok(listener) => listener,
Err(e) => {
error!("Failed to bind listener to {}: {:?}", addr, e);
exit(crate::CODE_LISTENER_BINDING_ERROR);
}
};
info!("Starting server at {}...", addr);
if let Err(e) = axum::serve(listener, app)
.with_graceful_shutdown(shutdown_signal())
.await
{
error!("Failed to start server: {:?}", e);
exit(crate::CODE_STARTIG_SERVER_ERROR);
};
info!("Shutdown server");
}
/// Эндпоинт по-умолчанию
async fn fallback() -> axum::response::Response {
use axum::response::IntoResponse;
(axum::http::StatusCode::NOT_FOUND, "404 NOT FOUND").into_response()
}
/// Аккуратное завершение работы сервера
async fn shutdown_signal() {
// let timeout = async {
// tokio::time::sleep(std::time::Duration::from_secs(10)).await;
// info!("10 seconds timeout expired");
// };
let ctrl_c = async {
tokio::signal::ctrl_c().await.map_err(|e| {
error!("Can't install Ctrl+C signal handler: {:?}", e);
exit(crate::CODE_CTRL_C_SIGNAL_INSTALL_ERROR);
});
info!("Ctrl+C pressed");
};
let pending = std::future::pending::<()>();
tokio::select! {
// _ = timeout => {},
_ = ctrl_c => {},
_ = pending => {},
}
}
mod debug;
mod device;
mod house;
mod room;
smart-house-web/backend/src/server/debug.rs
+13
View File
@@ -0,0 +1,13 @@
use std::collections::HashMap;
use axum::{Json, extract::State};
use smart_house::{Device, PowerSocket, Room, Thermometer};
pub async fn debug(State(_server_state): State<super::ServerState>) -> Json<Room> {
let map = HashMap::<String, Device>::from([
("thermo".into(), Thermometer::new(20.0).into()),
("psock".into(), PowerSocket::new(10.0, false).into()),
]);
Room::new(map).into()
}
smart-house-web/backend/src/server/device.rs
+44
View File
@@ -0,0 +1,44 @@
use axum::{
Json,
extract::{Path, State},
http::StatusCode,
};
use smart_house::{Device, Room};
pub async fn get_device(
State(server_state): State<super::ServerState>,
Path((room, device)): Path<(String, String)>,
) -> Result<Json<Device>, StatusCode> {
let house = server_state.read().await;
let Some(room) = house.get_rooms().get(&room) else {
return Err(StatusCode::NOT_FOUND);
};
let Some(device) = room.get_devices().get(&device) else {
return Err(StatusCode::NOT_FOUND);
};
Ok(device.clone().into())
}
pub async fn put_device(
State(server_state): State<super::ServerState>,
Path((room, name)): Path<(String, String)>,
Json(device): Json<Device>,
) -> StatusCode {
let mut house = server_state.write().await;
let room = house.get_rooms_mut().entry(room).or_insert(Room::default());
room.get_devices_mut().insert(name, device);
StatusCode::CREATED
}
pub async fn delete_device(
State(server_state): State<super::ServerState>,
Path((room, device)): Path<(String, String)>,
) -> StatusCode {
let mut house = server_state.write().await;
let Some(room) = house.get_rooms_mut().get_mut(&room) else {
return StatusCode::ACCEPTED;
};
room.get_devices_mut().remove(&device);
StatusCode::ACCEPTED
}
smart-house-web/backend/src/server/house.rs
+21
View File
@@ -0,0 +1,21 @@
use std::collections::HashMap;
use axum::{Json, extract::State, http::StatusCode};
use smart_house::Room;
pub async fn get_rooms(
State(server_state): State<super::ServerState>,
) -> Json<HashMap<String, Room>> {
server_state.read().await.get_rooms().clone().into()
}
pub async fn post_rooms(
State(server_state): State<super::ServerState>,
Json(map): Json<HashMap<String, Room>>,
) -> StatusCode {
for (name, room) in map.into_iter() {
server_state.write().await.add_room(name, room);
}
StatusCode::CREATED
}
smart-house-web/backend/src/server/room.rs
+49
View File
@@ -0,0 +1,49 @@
use std::collections::HashMap;
use axum::{
Json,
extract::{Path, State},
http::StatusCode,
};
use smart_house::{Device, Room};
pub async fn get_room(
State(server_state): State<super::ServerState>,
Path(name): Path<String>,
) -> Result<Json<Room>, StatusCode> {
let house = server_state.read().await;
let Some(room) = house.get_rooms().get(&name) else {
return Err(StatusCode::NOT_FOUND);
};
Ok(room.clone().into())
}
pub async fn put_room(
State(server_state): State<super::ServerState>,
Path(name): Path<String>,
Json(room): Json<Room>,
) -> StatusCode {
let mut house = server_state.write().await;
house.add_room(name, room);
StatusCode::CREATED
}
pub async fn delete_room(
State(server_state): State<super::ServerState>,
Path(name): Path<String>,
) -> StatusCode {
server_state.write().await.del_room(&name);
StatusCode::ACCEPTED
}
pub async fn get_devices(
State(server_state): State<super::ServerState>,
Path(name): Path<String>,
) -> Result<Json<HashMap<String, Device>>, StatusCode> {
let house = server_state.read().await;
let Some(room) = house.get_rooms().get(&name) else {
return Err(StatusCode::NOT_FOUND);
};
Ok(room.get_devices().clone().into())
}
smart-house-web/backend/test.http
+71
View File
@@ -0,0 +1,71 @@
### DEBUG
GET http://localhost:8081/debug
### list rooms
GET http://localhost:8081/rooms
### post all rooms
POST http://localhost:8081/rooms
Content-Type: application/json
{
"ROOM0": {
"devices": {}
},
"ROOM1": {
"devices": {
"therm": {
"type": "Thermometer",
"temperature": 22
},
"psock": {
"type": "PowerSocket",
"power_rate": 11,
"on": false
}
}
}
}
### drop room
DELETE http://localhost:8081/room/ROOM
### add room
PUT http://localhost:8081/room/ROOM
Content-Type: application/json
{
"devices": {
"therm": {
"type": "Thermometer",
"temperature": 20
},
"psock": {
"type": "PowerSocket",
"power_rate": 10,
"on": true
}
}
}
### get room
GET http://localhost:8081/room/ROOM1
### get room devices
GET http://localhost:8081/room/ROOM1/devices
### get room device
GET http://localhost:8081/room/ROOM/device/TEST
### get room device
PUT http://localhost:8081/room/ROOM/device/TEST
Content-Type: application/json
{
"type": "PowerSocket",
"power_rate": 5,
"on": true
}
### get room device
DELETE http://localhost:8081/room/ROOM/device/TEST
smart-house-web/backend/tests/api_smoke_test.rs
+239
View File
@@ -0,0 +1,239 @@
use std::collections::HashMap;
use backend::{axum_app, init_logger, server_main};
use reqwest::{Client, Response, StatusCode};
use serde_json::json;
use smart_house::{Device, Room};
use tokio::spawn;
use tracing::info;
type RqResult<T> = Result<T, reqwest::Error>;
#[tokio::test(flavor = "current_thread")]
async fn smoke() -> RqResult<()> {
init_logger();
spawn(server_main(axum_app()));
let client = Client::new();
verify_rooms_state0(&client).await?;
init_rooms(&client).await?;
verify_rooms_state1(&client).await?;
delete_room0(&client).await?;
verify_rooms_state2(&client).await?;
put_room(&client).await?;
verify_rooms_state3(&client).await?;
verify_room1_state0(&client).await?;
verify_room1_devices_state0(&client).await?;
verify_room1_device_psock_state0(&client).await?;
delete_psock(&client).await?;
verify_room1_device_psock_state1(&client).await?;
put_device(&client).await?;
verify_new_device_in_place(&client).await?;
print_house_report(&client).await?;
Ok(())
}
async fn print_resp(resp: Response) -> RqResult<()> {
info!(
"\n<<< StatusCode: {}\n<<< BODY: {}",
resp.status(),
resp.text().await?
);
Ok(())
}
async fn verify_rooms_state0(client: &Client) -> RqResult<()> {
let resp = client.get("http://localhost:8081/rooms").send().await?;
assert_eq!(resp.status(), StatusCode::OK);
let rooms = resp.json::<HashMap<String, Room>>().await?;
assert!(rooms.is_empty());
Ok(())
}
async fn init_rooms(client: &Client) -> RqResult<()> {
let resp = client
.post("http://localhost:8081/rooms")
.json(&json!({
"ROOM0": { "devices": {} },
"ROOM1": { "devices": {
"therm": { "type": "Thermometer", "temperature": 22 },
"psock": { "type": "PowerSocket", "power_rate": 11, "on": false }
} }
}))
.send()
.await?;
assert_eq!(resp.status(), StatusCode::CREATED);
Ok(())
}
async fn verify_rooms_state1(client: &Client) -> RqResult<()> {
let resp = client.get("http://localhost:8081/rooms").send().await?;
assert_eq!(resp.status(), StatusCode::OK);
let rooms = resp.json::<HashMap<String, Room>>().await?;
assert_eq!(rooms.len(), 2);
assert_eq!(rooms.get("ROOM1").unwrap().get_devices().len(), 2);
Ok(())
}
async fn delete_room0(client: &Client) -> RqResult<()> {
let resp = client
.delete("http://localhost:8081/room/ROOM0")
.send()
.await?;
assert_eq!(resp.status(), StatusCode::ACCEPTED);
Ok(())
}
async fn verify_rooms_state2(client: &Client) -> RqResult<()> {
let resp = client.get("http://localhost:8081/rooms").send().await?;
assert_eq!(resp.status(), StatusCode::OK);
let rooms = resp.json::<HashMap<String, Room>>().await?;
assert_eq!(rooms.len(), 1);
assert_eq!(rooms.get("ROOM1").unwrap().get_devices().len(), 2);
Ok(())
}
async fn put_room(client: &Client) -> RqResult<()> {
let resp = client
.put("http://localhost:8081/room/ROOM")
.json(&json!({ "devices": {
"therm": { "type": "Thermometer", "temperature": 20 },
"psock": { "type": "PowerSocket", "power_rate": 10, "on": true }
} }))
.send()
.await?;
assert_eq!(resp.status(), StatusCode::CREATED);
Ok(())
}
async fn verify_rooms_state3(client: &Client) -> RqResult<()> {
let resp = client.get("http://localhost:8081/rooms").send().await?;
assert_eq!(resp.status(), StatusCode::OK);
let rooms = resp.json::<HashMap<String, Room>>().await?;
assert_eq!(rooms.len(), 2);
assert_eq!(rooms.get("ROOM").unwrap().get_devices().len(), 2);
Ok(())
}
async fn verify_room1_state0(client: &Client) -> RqResult<()> {
let resp = client
.get("http://localhost:8081/room/ROOM1")
.send()
.await?;
assert_eq!(resp.status(), StatusCode::OK);
let room = resp.json::<Room>().await?;
assert_eq!(room.get_devices().len(), 2);
Ok(())
}
async fn verify_room1_devices_state0(client: &Client) -> RqResult<()> {
let resp = client
.get("http://localhost:8081/room/ROOM1/devices")
.send()
.await?;
assert_eq!(resp.status(), StatusCode::OK);
let device_map = resp.json::<HashMap<String, Device>>().await?;
assert_eq!(device_map.len(), 2);
Ok(())
}
async fn verify_room1_device_psock_state0(client: &Client) -> RqResult<()> {
let resp = client
.get("http://localhost:8081/room/ROOM1/device/psock")
.send()
.await?;
assert_eq!(resp.status(), StatusCode::OK);
let device = resp.json::<Device>().await?;
let Device::PowerSocket(power_socket) = device else {
panic!("PowerSocket expected");
};
assert_eq!(power_socket.get_power(), 0.0);
assert_eq!(power_socket.is_on(), false);
Ok(())
}
async fn delete_psock(client: &Client) -> RqResult<()> {
let resp = client
.delete("http://localhost:8081/room/ROOM1/device/psock")
.send()
.await?;
assert_eq!(resp.status(), StatusCode::ACCEPTED);
Ok(())
}
async fn verify_room1_device_psock_state1(client: &Client) -> RqResult<()> {
let resp = client
.get("http://localhost:8081/room/ROOM1/device/psock")
.send()
.await?;
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
Ok(())
}
async fn put_device(client: &Client) -> RqResult<()> {
let resp = client
.put("http://localhost:8081/room/ROOM1/device/TEST")
.json(&json!({
"type": "PowerSocket",
"power_rate": 5,
"on": true
}))
.send()
.await?;
assert_eq!(resp.status(), StatusCode::CREATED);
Ok(())
}
async fn verify_new_device_in_place(client: &Client) -> RqResult<()> {
let resp = client.get("http://localhost:8081/rooms").send().await?;
assert_eq!(resp.status(), StatusCode::OK);
let rooms = resp.json::<HashMap<String, Room>>().await?;
assert_eq!(rooms.len(), 2);
assert_eq!(rooms.get("ROOM1").unwrap().get_devices().len(), 2);
let device = rooms
.get("ROOM1")
.unwrap()
.get_devices()
.get("TEST")
.unwrap();
let Device::PowerSocket(power_socket) = device else {
panic!("TEST device must be a PowerSocket")
};
assert!(power_socket.is_on());
assert_eq!(power_socket.get_power(), 5.0);
Ok(())
}
async fn print_house_report(client: &Client) -> RqResult<()> {
let resp = client.get("http://localhost:8081/rooms").send().await?;
assert_eq!(resp.status(), StatusCode::OK);
print_resp(resp).await?;
Ok(())
}