smart-house-web: в работе

smart-house-web: в работе

.gitignore

@@ -1 +1,3 @@
-/.idea/
+/.idea/
+/**/.DS_Store
+/tmp/

practice/src/bin/m_node.rs

@@ -0,0 +1,45 @@
+use std::cell::RefCell;
+use std::rc::{Rc, Weak};
+
+#[derive(Debug)]
+struct Node {
+    value: i32,
+    parent: RefCell<Option<Weak<Node>>>,                            // <-- weak ref to parent
+    children: RefCell<Vec<Rc<Node>>>,
+}
+
+impl Node {
+    fn new(value: i32) -> Rc<Self> {
+        Rc::new(Self {
+            value,
+            parent: Default::default(),
+            children: Default::default(),
+        })
+    }
+
+    fn set_parent(&self, parent: Rc<Node>) {
+        *self.parent.borrow_mut() = Some(Rc::downgrade(&parent));   // <-- create weak ref to parent
+    }
+
+    fn add_child(self: &Rc<Self>, child: Rc<Node>) {
+        child.set_parent(self.clone());
+        self.children.borrow_mut().push(child);
+    }
+}
+
+impl Drop for Node {
+    fn drop(&mut self) {
+        println!(
+            "Dropping node with value {} and {} children",
+            self.value,
+            self.children.borrow().len()
+        );
+    }
+}
+
+fn main() {
+    let tree = Node::new(1);
+    tree.add_child(Node::new(3));
+    tree.add_child(Node::new(5));
+    println!("Finishing program now");
+}

smart-house-web/.gitignore

@@ -0,0 +1,2 @@
+/target/
+/Cargo.lock

smart-house-web/Cargo.toml

@@ -0,0 +1,15 @@
+[workspace]
+resolver = "3"
+members = ["backend"]
+
+[profile.release]
+opt-level = "z"
+strip = "symbols"
+lto = "fat"
+panic = "abort"
+codegen-units = 1
+overflow-checks = false
+debug-assertions = false
+incremental = false
+
+[workspace.dependencies]

smart-house-web/README.md

@@ -0,0 +1,40 @@
+# ДЗ 2026-04-28 - Веб-сервис умного дома
+
+## Цель:
+
+Превращаем умный дом в веб-сервис.
+
+## Срок:
+
+Сдать до: **2026-05-25**
+
+## Описание/Пошаговая инструкция выполнения домашнего задания:
+
+Реализовать backend сервис для управления умным домом и frontend приложение для взаимодействия с ним.
+
+- Технология взаимодействия с backend сервисом (gRPC, REST, GraphQL, ...) выбирается произвольно.
+
+API backend сервиса предоставляет доступ ко всему базовому функционалу библиотеки умного дома:
+
+- [ ] Добавление/удаление/перечисление комнат в доме и получение информации о конкретной комнате.
+- [ ] Добавление/удаление/перечисление устройств в комнате и получение информации о конкретном устройстве.
+- [ ] Получение отчёта о доме.
+- [ ] Присутствуют функциональные тесты, которые общаются с backend-ом и проверяют его ответы.
+
+Frontend приложение:
+
+- [ ] Отображает список комнат в доме.
+- [ ] Позволяет перейти к конкретной комнате или добавить новую комнату.
+- [ ] Отображает список устройств в комнате.
+- [ ] Позволяет перейти к конкретному устройству или добавить новое устройство.
+- [ ] Позволяет запросить отчёт о состоянии дома.
+
+**Критерии оценки:**
+
+- Workspace успешно собирается.
+- Приложения-примеры успешно выполняются.
+- Команды cargo clippy, и cargo fmt --check не выводят ошибок и предупреждений.
+
+## Демо
+
+**TBD**

smart-house-web/backend/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "backend"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+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"
+
+[dev-dependencies]
+hyper = "1.9.0"

smart-house-web/backend/src/house.rs

@@ -0,0 +1,126 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PowerSocket {
+    power_rate: f32,
+    on: bool,
+}
+
+impl PowerSocket {
+    pub fn new(power_rate: f32, on: bool) -> Self {
+        Self { power_rate, on }
+    }
+
+    pub fn is_on(&self) -> bool {
+        self.on
+    }
+
+    pub fn set_on(&mut self, on: bool) {
+        self.on = on
+    }
+
+    pub fn get_power(&self) -> f32 {
+        if self.is_on() { self.power_rate } else { 0.0 }
+    }
+
+    pub fn report(&self) -> String {
+        let state = if self.is_on() { "ON" } else { "OFF" };
+        let power = self.get_power();
+        format!("PowerSocket[ {} : {:02.1} ]", state, power)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Thermometer {
+    temperature: f32,
+}
+
+impl Thermometer {
+    pub fn new(temperature: f32) -> Self {
+        Self { temperature }
+    }
+
+    pub fn get_temperature(&self) -> f32 {
+        self.temperature
+    }
+
+    pub fn report(&self) -> String {
+        let temperature = self.get_temperature();
+        format!("Thermometer[ {:02.1} ]", temperature)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum Device {
+    PowerSocket(PowerSocket),
+    Thermometer(Thermometer),
+}
+
+impl Device {
+    pub fn report(&self) -> String {
+        match self {
+            Device::PowerSocket(v) => v.report().to_string(),
+            Device::Thermometer(v) => v.report().to_string(),
+        }
+    }
+}
+
+impl From<PowerSocket> for Device {
+    fn from(value: PowerSocket) -> Self {
+        Device::PowerSocket(value)
+    }
+}
+
+impl From<Thermometer> for Device {
+    fn from(value: Thermometer) -> Self {
+        Device::Thermometer(value)
+    }
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct Room {
+    devices: HashMap<String, Device>,
+}
+
+impl Room {
+    pub fn new(devices: HashMap<String, Device>) -> Self {
+        Self { devices }
+    }
+
+    pub fn get_devices(&self) -> &HashMap<String, Device> {
+        &self.devices
+    }
+
+    pub fn get_devices_mut(&mut self) -> &mut HashMap<String, Device> {
+        &mut self.devices
+    }
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct House {
+    rooms: HashMap<String, Room>,
+}
+
+impl House {
+    pub fn new(rooms: HashMap<String, Room>) -> Self {
+        Self { rooms }
+    }
+
+    pub fn get_rooms(&self) -> &HashMap<String, Room> {
+        &self.rooms
+    }
+
+    pub fn get_rooms_mut(&mut self) -> &mut HashMap<String, Room> {
+        &mut self.rooms
+    }
+
+    pub fn add_room(&mut self, name: String, room: Room) {
+        self.rooms.insert(name, room);
+    }
+
+    pub fn del_room(&mut self, name: &str) {
+        self.rooms.remove(name);
+    }
+}

smart-house-web/backend/src/lib.rs

@@ -0,0 +1,47 @@
+/// Ошибка инициализации логгера
+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 std::process::exit;
+    use tracing::{Level, trace};
+    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_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");
+    }
+}
+
+mod server;
+pub use server::run_server;
+
+mod house;
+pub use house::{Device, House, PowerSocket, Room, Thermometer};

smart-house-web/backend/src/main.rs

@@ -0,0 +1,6 @@
+use backend::{init_logger, run_server};
+
+fn main() {
+    init_logger();
+    run_server();
+}

smart-house-web/backend/src/server.rs

@@ -0,0 +1,111 @@
+use axum::routing::{delete, get, post, put};
+use std::{
+    process::exit,
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+};
+use tokio::sync::RwLock;
+use tracing::{error, info};
+
+use crate::House;
+
+/// Запуск сервера
+pub fn run_server() {
+    let runtime = 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);
+        }
+    };
+    runtime.block_on(server_main());
+}
+
+/// Тип состояния
+type ServerState = Arc<RwLock<House>>;
+
+/// Основная функция сервера
+async fn server_main() {
+    let state: ServerState = Arc::new(RwLock::new(House::default()));
+
+    let app = 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);
+    let addr = "127.0.0.1:8080";
+    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

@@ -0,0 +1,13 @@
+use std::collections::HashMap;
+
+use axum::{Json, extract::State};
+
+use crate::{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

@@ -0,0 +1,44 @@
+use axum::{
+    Json,
+    extract::{Path, State},
+    http::StatusCode,
+};
+
+use crate::{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

@@ -0,0 +1,21 @@
+use std::collections::HashMap;
+
+use axum::{Json, extract::State, http::StatusCode};
+
+use crate::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

@@ -0,0 +1,49 @@
+use std::collections::HashMap;
+
+use axum::{
+    Json,
+    extract::{Path, State},
+    http::StatusCode,
+};
+
+use crate::{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

@@ -0,0 +1,71 @@
+### DEBUG
+GET http://localhost:8080/debug
+
+### list rooms
+GET http://localhost:8080/rooms
+
+### post all rooms
+POST http://localhost:8080/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:8080/room/ROOM
+
+### add room
+PUT http://localhost:8080/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:8080/room/ROOM1
+
+### get room devices
+GET http://localhost:8080/room/ROOM1/devices
+
+### get room device
+GET http://localhost:8080/room/ROOM/device/TEST
+
+### get room device
+PUT http://localhost:8080/room/ROOM/device/TEST
+Content-Type: application/json
+
+{
+  "type": "PowerSocket",
+  "power_rate": 5,
+  "on": true
+}
+
+### get room device
+DELETE http://localhost:8080/room/ROOM/device/TEST

smart-house-web/backend/tests/api_tests.rs

@@ -0,0 +1,4 @@
+#[tokio::test(flavor = "current_thread")]
+async fn smoke() {
+    println!("Hello test!")
+}

smart-house/Cargo.lock

@@ -3,5 +3,38 @@
 version = 4
 
 [[package]]
-name = "smart-house"
+name = "cfg-if"
-version = "0.0.0"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "libloading"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "754ca22de805bb5744484a5b151a9e1a8e837d5dc232c2d7d8c2e3492edc8b60"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "power_socket_lib"
+version = "0.1.0"
+
+[[package]]
+name = "use_dynamic"
+version = "0.1.0"
+dependencies = [
+ "libloading",
+]
+
+[[package]]
+name = "use_static"
+version = "0.1.0"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"

smart-house/Cargo.toml

@@ -1,6 +1,6 @@
-[package]
+[workspace]
-edition = "2024"
+resolver = "3"
-name = "smart-house"
+members = [
-version = "0.0.0"
+    "power_socket_lib", "use_dynamic",
-
+    "use_static",
-[dependencies]
+]

smart-house/README.md

@@ -49,9 +49,215 @@
 - [x] Создайте экземпляр умного дома и выведете отчёт о его содержимом.
 - [x] Для уже созданного экземпляра дома выключите умную розетку в одной из комнат. Снова выведите отчёт.
 
-**Критерии оценки**:
+**Критерии оценки:**
 
 - Package успешно собирается.
 - Приложение-пример успешно выполняется и выводит отчёт о доме.
 - Команды cargo clippy и cargo fmt --check не выводят ошибок и предупреждений.
 - Присутствуют и успешно выполняются модульные тесты.
+
+## ДЗ 2026-01-20
+
+Дорабатываем умный дом
+
+### Цель:
+
+Дорабатываем функционал умного дома, используя возможности стандартной библиотеки.
+
+### Срок:
+
+Сдать до: **2026-02-11**
+
+### Описание/Пошаговая инструкция выполнения домашнего задания:
+
+Добавить обработку ошибок:
+- [x] Заменить паники на возврат Option в методах получения комнаты по ключу.
+- [x] Заменить паники на возврат Option в методах получения устройства по ключу.
+
+Доработать хранение объектов:
+- [x] Заменить массивы устройств и комнат на ассоциативные коллекции из std. В качестве ключей использовать строки.
+- [x] Реализовать трейт Debug на всех типах.
+- [x] Добавить возможность динамически добавлять/удалять устройства в комнату.
+- [x] Добавить возможность динамически добавлять/удалять комнату в дом.
+- [x] Добавить в тип умного дома метод, позволяющий сразу получить ссылку на умное устройство. Метод принимает имя комнаты
+      и имя устройства. В случае, если устройство или комната не найдены, возвращать тип ошибки, сообщающий, что именно
+      произошло. Тип ошибки должен реализовывать трейт `std::error::Error`.
+- [x] Добавить реализации трейта `From`, позволяющие преобразовывать объекты умной розетки и умного термометра в объект
+      умного устройства.
+- [x] Написать макрос для упрощенного создания комнаты, принимающий пары вида (ключ, объект умной розетки) или (ключ,
+      объект умного термометра) и возвращающий объект комнаты, содержащей все перечисленные устройства с
+      соответствующими ключами.
+
+Доработать формирование отчёта:
+- [x] Вынести метод формирования отчёта в трейт и реализовать его на всех типах, которые возвращают отчёт: умное устройство,
+      комната, дом.
+
+Привести тесты в соответствие с новым функционалом.
+
+Доработать приложение-пример:
+- [x] Продемонстрировать возможность динамического добавления/удаления комнат.
+- [x] Продемонстрировать возможность динамического добавления/удаления устройств.
+- [x] Добавить функцию, которая принимает любой объект, умеющий выводить отчёт. Вывести с её помощью отчёты о доме,
+      отдельной комнате, отдельном устройстве.
+- [x] Продемонстрировать возможность обработки ошибок.
+
+**Критерии оценки:**
+- Package успешно собирается.
+- Приложение-пример успешно выполняется и выводит отчёт о доме.
+- Команды cargo clippy и cargo fmt --check не выводят ошибок и предупреждений.
+- Присутствуют и успешно выполняются модульные тесты.
+
+## ДЗ 2026-02-12
+
+Дорабатываем умные устройства
+
+### Цель:
+
+Описать для умной розетки и умного термометра логику взаимодействия с удалённым устройством и написать имитаторы устройств для тестирования.
+
+### Срок:
+
+Сдать до: **2026-03-04**
+
+### Описание/Пошаговая инструкция выполнения домашнего задания:
+
+Для типа умной розетки:
+- [x] Функционал не изменяется: включение/выключение + запрос мощности.
+- [x] Взаимодействие организовано синхронно, через TCP.
+- [x] Розетка может использовать как реальный TCP-обмен, так и имитировать реальную работу (для тестов).
+
+Для имитатора умной розетки:
+- [x] Читает адрес для приёма TCP-соединений из аргументов командной строки.
+- [x] Реализован с использованием неблокирующего сетевого взаимодействия.
+- [x] Хранит состояние розетки.
+- [x] Позволяет управлять розеткой множеству клиентов одновременно.
+
+Для умного термометра:
+- [x] Функционал не изменяется: возвращает температуру.
+- [x] Получает значения температуры в виде UDP-пакетов в параллельном потоке.
+- [x] Параллельный поток запускается при создании объекта термометра и завершается при уничтожении этого объекта.
+- [x] Объект термометра возвращает последнее полученное значение температуры.
+- [x] Термометр может имитировать удалённое получение данных о температуре (для тестов).
+
+Для имитатора умного термометра:
+- [x] Реализован с использованием неблокирующего сетевого взаимодействия.
+- [x] Читает адрес для отправки UDP-пакетов и временной период отправки из файла.
+- [x] Отправляет произвольное значение температуры на указанный адрес с указанной периодичностью.
+
+Добавлен дополнительный пример умного дома с розетками и термометрами, которые работают с имитаторами. Данный пример должен запускаться и:
+- [x] Выводить отчёт о состоянии дома, если имитаторы запущены.
+- [x] Сообщать об ошибке, если устройству не удалось получить данные.
+
+**Критерии оценки:**
+
+- Package успешно собирается.
+- Приложение-пример успешно выполняется.
+- Команды cargo clippy и cargo fmt --check не выводят ошибок и предупреждений.
+- Присутствуют и успешно выполняются модульные тесты.
+
+### Запуск примеров
+
+Запуск имитатора умной розетки:
+
+    cargo run --bin power_socket_mock -- 127.0.0.1:10001
+
+Запуск имитатора термометра:
+
+    cargo run --bin thermometer_mock
+
+Запуск примера умного дома:
+
+    cargo run --bin mocks_example
+
+## ДЗ 2026-03-05
+
+Паттерны в умном доме
+
+### Цель:
+
+Делаем код умного дома более удобным с использованием различных паттернов.
+
+### Срок:
+
+Сдать до: **2026-04-01**
+
+### Описание/Пошаговая инструкция выполнения домашнего задания:
+
+Реализовать билдер для умного дома, позволяющий инициализировать объект умного дома в [таком стиле](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=5d0527e4684f726d54dc375829d983f4).
+
+- [x] До добавления первой комнаты, билдер запрещает добавлять устройства. Это должно контролироваться компилятором.
+
+Реализовать компоновщик для построения отчёта об объектах умного дома в [таком стиле](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=c07dfc726e8ccbccdcc2d88a79d3f190).
+
+- [x] Использовать статический полиморфизм (дженерики).
+- [x] Вызов метода report() должен выводить в терминал отчёт обо всех добавленных объектах.
+
+Добавить возможность добавления callback-ов в объект комнаты, которые срабатывают при добавлении новых устройств в комнату (паттерн Observer).
+
+- [x] Использовать динамический полиморфизм (трейт-объекты).
+- [x] Можно передавать как объект-subscriber, так и [замыкание](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=06e9dc9bcce297d1e80a22d7e9338ee8).
+
+Добавить example-ы, демонстрирующие новый функционал.
+
+**Критерии оценки:**
+
+- Package успешно собирается.
+- Приложение-пример успешно выполняется.
+- Команды cargo clippy и cargo fmt --check не выводят ошибок и предупреждений.
+- Присутствуют и успешно выполняются модульные тесты.
+
+### Демонстационные примеры
+
+- `src/bin/house_builder.rs` - билдер для умного дома
+- `src/bin/reporter.rs` - компоновщик для построения отчета
+- `src/bin/subscribers.rs` - добавление коллбеков в объект комнаты
+
+## ДЗ 2026-04-09
+
+Си-style умная розетка
+
+### Цель:
+
+Реализуем Си ABI для работы с умной розеткой.
+
+### Срок:
+
+Сдать до: **2026-04-27**
+
+### Описание/Пошаговая инструкция выполнения домашнего задания:
+
+Реализовать workspace со следующими package-ами:
+
+- [x] Библиотека умной розетки с Си ABI.
+- [x] Приложение, использующее библиотеку умной розетки, линкуя её статически.
+- [x] Приложение, использующее библиотеку умной розетки, линкуя её динамически в runtime.
+
+Библиотека умной розетки с Си ABI:
+
+- [x] Функционал не изменяется: включение/выключение + запрос мощности.
+- [x] При сборке создаёт три артефакта:
+    1. Rust библиотеку
+    2. Статическую библиотеку с Си ABI.
+    3. Динамическую библиотеку с Си ABI
+
+Пакеты-приложения должны демонстрировать функционал умной библиотеки.
+
+**Критерии оценки:**
+
+- Workspace успешно собирается.
+- Приложения-примеры успешно выполняются.
+- Команды cargo clippy, и cargo fmt --check не выводят ошибок и предупреждений.
+
+### Демо
+
+1. Собрать библиотеку:
+
+        cargo build -p power_socket_lib
+
+2. Статическая линковка:
+    
+        cargo run -p use_static
+
+3. Динамическая линковка:
+
+        cargo run -p use_dynamic

smart-house/power_socket_lib/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "power_socket_lib"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["rlib", "staticlib", "cdylib"]
+
+[dependencies]

smart-house/power_socket_lib/src/lib.rs

@@ -0,0 +1,45 @@
+#[repr(C)]
+pub struct PowerSocket {
+    power_rate: f32,
+    on: bool,
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn power_socket_new(power_rate: f32, on: bool) -> PowerSocket {
+    PowerSocket { power_rate, on }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn power_socket_is_on(power_socket: &PowerSocket) -> bool {
+    power_socket.on
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn power_socket_set_on(power_socket: &mut PowerSocket, on: bool) {
+    power_socket.on = on
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn power_socket_get_power(power_socket: &PowerSocket) -> f32 {
+    if power_socket.on { power_socket.power_rate } else { 0.0 }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        let mut power_socket = power_socket_new(12.0, false);
+        assert_eq!(power_socket.power_rate, 12.0);
+        assert_eq!(power_socket.on, false);
+
+        assert_eq!(power_socket_is_on(&power_socket), false);
+        assert_eq!(power_socket_get_power(&power_socket), 0.0);
+
+        power_socket_set_on(&mut power_socket, true);
+
+        assert_eq!(power_socket_is_on(&power_socket), true);
+        assert_eq!(power_socket_get_power(&power_socket), 12.0);
+    }
+}

smart-house/src/device.rs

@@ -1,55 +0,0 @@
-use std::fmt::Display;
-
-pub enum Device {
-    Thermometer(super::Thermometer),
-    PowerSocket(super::PowerSocket),
-}
-
-impl Device {
-    pub fn display(&self) -> impl Display {
-        match self {
-            Device::Thermometer(thermometer) => {
-                format!("DEV:{}", thermometer.display())
-            }
-            Device::PowerSocket(power_socket) => {
-                format!("DEV:{}", power_socket.display())
-            }
-        }
-    }
-
-    pub fn print_status(&self) {
-        println!("{}", self.display());
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{PowerSocket, Thermometer};
-
-    #[test]
-    fn smoke_test() {
-        let dev_thermometer = Device::Thermometer(Thermometer::new(20.1));
-        let dev_power_socket = Device::PowerSocket(PowerSocket::new(11.2, false));
-
-        dev_thermometer.print_status();
-        dev_power_socket.print_status();
-
-        let Device::Thermometer(thermometer) = dev_thermometer else { unreachable!() };
-        let Device::PowerSocket(power_socket) = dev_power_socket else {
-            unreachable!()
-        };
-
-        assert_eq!(format!("{}", thermometer.display()), "Thermometer[ 20.1 ]");
-        assert_eq!(format!("{}", power_socket.display()), "PowerSocket[ OFF : 0.0 ]");
-    }
-
-    #[test]
-    fn display_test() {
-        let dev_thermometer = Device::Thermometer(Thermometer::new(20.1));
-        let dev_power_socket = Device::PowerSocket(PowerSocket::new(11.2, false));
-
-        assert_eq!(format!("{}", dev_thermometer.display()), "DEV:Thermometer[ 20.1 ]");
-        assert_eq!(format!("{}", dev_power_socket.display()), "DEV:PowerSocket[ OFF : 0.0 ]");
-    }
-}

smart-house/src/house.rs

@@ -1,91 +0,0 @@
-use crate::Room;
-
-pub struct House {
-    address: String,
-    rooms: Box<[Room]>,
-}
-
-impl House {
-    pub fn new(address: impl AsRef<str>, rooms: Box<[Room]>) -> Self {
-        Self {
-            address: address.as_ref().to_string(),
-            rooms,
-        }
-    }
-
-    fn check_bounds(&self, idx: usize) {
-        if idx >= self.rooms.len() {
-            panic!("Index is out of bounds")
-        }
-    }
-
-    pub fn get_room(&self, idx: usize) -> &Room {
-        self.check_bounds(idx);
-        &self.rooms[idx]
-    }
-
-    pub fn get_room_mut(&mut self, idx: usize) -> &mut Room {
-        self.check_bounds(idx);
-        &mut self.rooms[idx]
-    }
-
-    pub fn print_status(&self) {
-        println!("HOUSE '{}':", self.address);
-        println!("{}", "=".repeat(32));
-        for d in self.rooms.iter() {
-            d.print_status();
-            println!();
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{Device, PowerSocket, Thermometer};
-
-    fn create_test_house() -> House {
-        House::new(
-            "Best street, 777",
-            Box::new([
-                Room::new(
-                    "main",
-                    Box::new([
-                        Device::Thermometer(Thermometer::new(20.0)),
-                        Device::PowerSocket(PowerSocket::new(12.34, false)),
-                        Device::PowerSocket(PowerSocket::new(10.01, true)),
-                    ]),
-                ),
-                Room::new(
-                    "bedroom",
-                    Box::new([Device::PowerSocket(PowerSocket::new(11.11, true)), Device::Thermometer(Thermometer::new(17.99))]),
-                ),
-            ]),
-        )
-    }
-
-    #[test]
-    fn smoke_test() {
-        let mut house = create_test_house();
-        house.print_status();
-        assert_eq!(house.address, "Best street, 777");
-
-        assert_eq!(format!("{}", house.get_room(0).get_device(0).display()), "DEV:Thermometer[ 20.0 ]");
-        assert_eq!(format!("{}", house.get_room(0).get_device(1).display()), "DEV:PowerSocket[ OFF : 0.0 ]");
-        assert_eq!(format!("{}", house.get_room(1).get_device(0).display()), "DEV:PowerSocket[ ON : 11.1 ]");
-
-        let Device::PowerSocket(powers_socket) = house.get_room_mut(0).get_device_mut(1) else {
-            unreachable!()
-        };
-        powers_socket.set_on(true);
-
-        assert_eq!(format!("{}", house.get_room(0).get_device(1).display()), "DEV:PowerSocket[ ON : 12.3 ]");
-    }
-
-    #[test]
-    #[should_panic(expected = "Index is out of bounds")]
-    fn panic_test() {
-        let house = create_test_house();
-        house.check_bounds(2);
-    }
-}

smart-house/src/lib.rs

@@ -1,11 +0,0 @@
-mod device;
-mod house;
-mod power_socket;
-mod room;
-mod thermometer;
-
-pub use device::Device;
-pub use house::House;
-pub use power_socket::PowerSocket;
-pub use room::Room;
-pub use thermometer::Thermometer;

smart-house/src/main.rs

@@ -1,38 +0,0 @@
-use smart_house::{Device, House, PowerSocket, Room, Thermometer};
-
-fn main() {
-    let mut house = House::new(
-        "A house of dream",
-        Box::new([
-            Room::new(
-                "Hall",
-                Box::new([Device::PowerSocket(PowerSocket::new(9.5, true)), Device::Thermometer(Thermometer::new(20.1))]),
-            ),
-            Room::new(
-                "Main",
-                Box::new([
-                    Device::PowerSocket(PowerSocket::new(11.2, true)),
-                    Device::Thermometer(Thermometer::new(24.5)),
-                    Device::PowerSocket(PowerSocket::new(10.4, true)),
-                ]),
-            ),
-            Room::new(
-                "Bedroom",
-                Box::new([Device::Thermometer(Thermometer::new(19.3)), Device::PowerSocket(PowerSocket::new(12.1, true))]),
-            ),
-        ]),
-    );
-
-    house.print_status();
-
-    print!("# Switching off a power socket in Hall... ");
-    let Device::PowerSocket(power_socket) = house.get_room_mut(0).get_device_mut(0) else {
-        println!("FAILED!");
-        return;
-    };
-    power_socket.set_on(false);
-    println!("SUCCESS");
-    println!();
-
-    house.print_status();
-}

smart-house/src/power_socket.rs

@@ -1,54 +0,0 @@
-use std::fmt::Display;
-
-pub struct PowerSocket {
-    power_rate: f32,
-    on: bool,
-}
-
-impl PowerSocket {
-    pub fn new(power_rate: f32, on: bool) -> Self {
-        Self { power_rate, on }
-    }
-
-    pub fn is_on(&self) -> bool {
-        self.on
-    }
-
-    pub fn set_on(&mut self, on: bool) {
-        self.on = on
-    }
-
-    pub fn get_power(&self) -> f32 {
-        if self.on { self.power_rate } else { 0.0 }
-    }
-
-    pub fn display(&self) -> impl Display {
-        let state = if self.is_on() { "ON" } else { "OFF" };
-        format!("PowerSocket[ {} : {:02.1} ]", state, self.get_power())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn smoke_test() {
-        let mut power_socket = PowerSocket::new(12.4, false);
-        assert_eq!(power_socket.power_rate, 12.4);
-        assert!(!power_socket.on);
-        assert!(!power_socket.is_on());
-        assert_eq!(power_socket.get_power(), 0.0);
-
-        power_socket.set_on(true);
-        assert!(power_socket.is_on());
-        assert_eq!(power_socket.get_power(), 12.4);
-    }
-
-    #[test]
-    fn display_test() {
-        assert_eq!(format!("{}", PowerSocket::new(11.549, false).display()), "PowerSocket[ OFF : 0.0 ]");
-        assert_eq!(format!("{}", PowerSocket::new(11.549, true).display()), "PowerSocket[ ON : 11.5 ]");
-        assert_eq!(format!("{}", PowerSocket::new(11.550, true).display()), "PowerSocket[ ON : 11.6 ]");
-    }
-}

smart-house/src/room.rs

@@ -1,80 +0,0 @@
-use crate::Device;
-
-pub struct Room {
-    name: String,
-    devices: Box<[Device]>,
-}
-
-impl Room {
-    pub fn new(name: impl AsRef<str>, devices: Box<[Device]>) -> Self {
-        Self {
-            name: name.as_ref().to_string(),
-            devices,
-        }
-    }
-
-    fn check_bounds(&self, idx: usize) {
-        if idx >= self.devices.len() {
-            panic!("Index is out of bounds")
-        }
-    }
-
-    pub fn get_device(&self, idx: usize) -> &Device {
-        self.check_bounds(idx);
-        &self.devices[idx]
-    }
-
-    pub fn get_device_mut(&mut self, idx: usize) -> &mut Device {
-        self.check_bounds(idx);
-        &mut self.devices[idx]
-    }
-
-    pub fn print_status(&self) {
-        println!("ROOM '{}':", self.name);
-        println!("{}", "-".repeat(24));
-        for d in self.devices.iter() {
-            d.print_status();
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{PowerSocket, Thermometer};
-
-    #[test]
-    fn smoke_test() {
-        let devices = Box::new([
-            Device::PowerSocket(PowerSocket::new(12.34, false)),
-            Device::Thermometer(Thermometer::new(21.56)),
-        ]);
-        let mut room = Room::new("test_room", devices);
-        assert_eq!(room.name, "test_room");
-        room.print_status();
-
-        assert_eq!(format!("{}", room.get_device(0).display()), "DEV:PowerSocket[ OFF : 0.0 ]");
-        assert_eq!(format!("{}", room.get_device(1).display()), "DEV:Thermometer[ 21.6 ]");
-
-        let Device::PowerSocket(power_socket) = room.get_device_mut(0) else {
-            unreachable!()
-        };
-        power_socket.set_on(true);
-
-        assert_eq!(format!("{}", room.get_device(0).display()), "DEV:PowerSocket[ ON : 12.3 ]");
-        assert_eq!(format!("{}", room.get_device(1).display()), "DEV:Thermometer[ 21.6 ]");
-    }
-
-    #[test]
-    #[should_panic(expected = "Index is out of bounds")]
-    fn panic_test() {
-        let room = Room::new(
-            "test_room",
-            Box::new([
-                Device::PowerSocket(PowerSocket::new(12.34, false)),
-                Device::Thermometer(Thermometer::new(21.56)),
-            ]),
-        );
-        room.check_bounds(2);
-    }
-}

smart-house/src/thermometer.rs

@@ -1,37 +0,0 @@
-use std::fmt::Display;
-
-pub struct Thermometer {
-    temperature: f32,
-}
-
-impl Thermometer {
-    pub fn new(temperature: f32) -> Self {
-        Self { temperature }
-    }
-
-    pub fn get_temperature(&self) -> f32 {
-        self.temperature
-    }
-
-    pub fn display(&self) -> impl Display {
-        format!("Thermometer[ {:02.1} ]", self.get_temperature())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn smoke_test() {
-        let thermometer = Thermometer::new(20.0);
-        assert_eq!(thermometer.temperature, 20.0);
-        assert_eq!(thermometer.get_temperature(), 20.0);
-    }
-
-    #[test]
-    fn display_test() {
-        assert_eq!(format!("{}", Thermometer::new(19.550).display()), "Thermometer[ 19.5 ]");
-        assert_eq!(format!("{}", Thermometer::new(19.551).display()), "Thermometer[ 19.6 ]");
-    }
-}

smart-house/use_dynamic/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "use_dynamic"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+libloading = "0.9.0"

smart-house/use_dynamic/src/main.rs

@@ -0,0 +1,51 @@
+mod ps {
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct PowerSocket {
+        power_rate: f32,
+        on: bool,
+    }
+
+    pub type FnPowerSocketNew = unsafe extern "C" fn(power_rate: f32, on: bool) -> PowerSocket;
+    pub type FnPowerSocketIsOn = unsafe extern "C" fn(power_socket: &PowerSocket) -> bool;
+    pub type FnPowerSocketSetOn = unsafe extern "C" fn(power_socket: &mut PowerSocket, on: bool);
+    pub type FnPowerSocketGetPower = unsafe extern "C" fn(power_socket: &PowerSocket) -> f32;
+}
+
+use ps::*;
+
+fn main() {
+    let path = "target/debug/power_socket_lib.dll";
+    let Ok(lib) = (unsafe { libloading::Library::new(path) }) else {
+        eprintln!("Failed to load lib: {}", path);
+        return;
+    };
+    let Ok(power_socket_new) = (unsafe { lib.get::<FnPowerSocketNew>("power_socket_new") }) else {
+        eprintln!("Failed to get power_socket_new function from lib: {}", path);
+        return;
+    };
+    let Ok(power_socket_is_on) = (unsafe { lib.get::<FnPowerSocketIsOn>("power_socket_is_on") }) else {
+        eprintln!("Failed to get power_socket_is_on function from lib: {}", path);
+        return;
+    };
+    let Ok(power_socket_set_on) = (unsafe { lib.get::<FnPowerSocketSetOn>("power_socket_set_on") }) else {
+        eprintln!("Failed to get power_socket_set_on function from lib: {}", path);
+        return;
+    };
+    let Ok(power_socket_get_power) = (unsafe { lib.get::<FnPowerSocketGetPower>("power_socket_get_power") }) else {
+        eprintln!("Failed to get power_socket_get_power function from lib: {}", path);
+        return;
+    };
+
+    let mut power_socket = unsafe { power_socket_new(12.0, false) };
+    println!("call power_socket_new -> {:?}", power_socket);
+
+    println!("call power_socket_is_on -> {:?}", unsafe { power_socket_is_on(&power_socket) });
+    println!("call power_socket_get_power -> {:?}", unsafe { power_socket_get_power(&power_socket) });
+
+    unsafe { power_socket_set_on(&mut power_socket, true) };
+    println!("call power_socket_set_on(&ref, true)");
+
+    println!("call power_socket_is_on -> {:?}", unsafe { power_socket_is_on(&power_socket) });
+    println!("call power_socket_get_power -> {:?}", unsafe { power_socket_get_power(&power_socket) });
+}

smart-house/use_static/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "use_static"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

smart-house/use_static/build.rs

@@ -0,0 +1,4 @@
+fn main() {
+    println!("cargo:rustc-link-lib=static=power_socket_lib");
+    println!("cargo:rustc-link-search=target/debug");
+}

smart-house/use_static/src/main.rs

@@ -0,0 +1,34 @@
+mod ps {
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct PowerSocket {
+        power_rate: f32,
+        on: bool,
+    }
+    // #[link(name = "power_socket_lib", kind = "static")]
+    unsafe extern "C" {
+        pub fn power_socket_new(power_rate: f32, on: bool) -> PowerSocket;
+
+        pub fn power_socket_is_on(power_socket: &PowerSocket) -> bool;
+
+        pub fn power_socket_set_on(power_socket: &mut PowerSocket, on: bool);
+
+        pub fn power_socket_get_power(power_socket: &PowerSocket) -> f32;
+    }
+}
+
+use ps::*;
+
+fn main() {
+    let mut power_socket = unsafe { power_socket_new(12.0, false) };
+    println!("call power_socket_new -> {:?}", power_socket);
+
+    println!("call power_socket_is_on -> {:?}", unsafe { power_socket_is_on(&power_socket) });
+    println!("call power_socket_get_power -> {:?}", unsafe { power_socket_get_power(&power_socket) });
+
+    unsafe { power_socket_set_on(&mut power_socket, true) };
+    println!("call power_socket_set_on(&ref, true)");
+
+    println!("call power_socket_is_on -> {:?}", unsafe { power_socket_is_on(&power_socket) });
+    println!("call power_socket_get_power -> {:?}", unsafe { power_socket_get_power(&power_socket) });
+}