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

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

.gitignore

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

practice/.gitignore

@@ -0,0 +1 @@
+/target/

practice/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "practice"
+version = "0.0.0"

practice/Cargo.toml

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

practice/src/bin/a_compare.rs

@@ -0,0 +1,21 @@
+// Напиúите функøиĀ compare<T: PartialOrd>(a: T, b: T) -> T, котораā:
+// ● Возвраûает наиболþúий из двух аргументов (a или b).
+// ● Исполþзуйте трейт PartialOrd длā сравнениā.
+
+#![allow(clippy::approx_constant)]
+
+fn compare<T>(a: T, b: T) -> T
+where
+    T: PartialOrd,
+{
+    if a >= b { a } else { b }
+}
+
+fn main() {
+    println!("{}", compare(5, 10)); // 10
+    println!("{}", compare('a', 'z')); // z
+
+    // Также работает с другими типами, реализующими PartialOrd
+    println!("{}", compare(3.14, 2.71)); // 3.14
+    println!("{}", compare("apple", "banana")); // "banana"
+}

practice/src/bin/b_pair.rs

@@ -0,0 +1,35 @@
+// Создайте структуру Pair<T, U> с двумā полāми разнýх типов:
+// ● Реализуйте метод new(first: T, second: U) -> Self.
+// ● Добавþте метод swap(self) -> Pair<U, T>, которýй менāет местами знаùениā полей.
+
+#![allow(clippy::approx_constant)]
+
+#[derive(Debug)]
+struct Pair<T, U> {
+    first: T,
+    second: U,
+}
+
+impl<T, U> Pair<T, U> {
+    // Создаем новую пару
+    fn new(first: T, second: U) -> Self {
+        Self { first, second }
+    }
+
+    // Меняем местами значения
+    fn swap(self) -> Pair<U, T> {
+        Pair::new(self.second, self.first)
+    }
+}
+
+fn main() {
+    let pair = Pair::new(42, "hello");
+    let swapped = pair.swap();
+
+    println!("{:?}", swapped); // Pair("hello", 42)
+
+    // Дополнительный пример с другими типами
+    let float_str_pair = Pair::new(3.14, "pi");
+    let swapped_pair = float_str_pair.swap();
+    println!("{:?}", swapped_pair); // Pair("pi", 3.14)
+}

practice/src/bin/c_area.rs

@@ -0,0 +1,64 @@
+// 1. Определите типаж Area с методом area(&self) -> f64.
+// 2. Реализуйте его длā структур Circle (с полем radius: f64) и Square (с полем side: f64).
+// 3. Напишите обобщенную функцию print_area<T: Area>(shape: T), которая печатает площадь фигуру.
+
+// Определяем типаж Area
+trait Area {
+    fn area(&self) -> f64;
+}
+
+// Структура Circle
+struct Circle {
+    radius: f64,
+}
+
+// Реализация Area для Circle
+impl Area for Circle {
+    fn area(&self) -> f64 {
+        std::f64::consts::PI * self.radius * self.radius
+    }
+}
+
+// Структура Square
+struct Square {
+    side: f64,
+}
+
+// Реализация Area для Square
+impl Area for Square {
+    fn area(&self) -> f64 {
+        self.side * self.side
+    }
+}
+
+// Обобщённая функция для вывода площади
+fn print_area(area: impl Area) {
+    println!("Area: {}", area.area())
+}
+
+fn main() {
+    let circle = Circle { radius: 5.0 };
+    let square = Square { side: 10.0 };
+
+    print_area(circle); // Area: 78.53981633974483
+    print_area(square); // Area: 100
+
+    // Можно добавить больше фигур, реализующих Area
+    let rectangle = Rectangle {
+        width: 4.0,
+        height: 6.0,
+    };
+    print_area(rectangle); // Area: 24
+}
+
+// Дополнительная структура для демонстрации расширяемости
+struct Rectangle {
+    width: f64,
+    height: f64,
+}
+
+impl Area for Rectangle {
+    fn area(&self) -> f64 {
+        self.width * self.height
+    }
+}

practice/src/bin/d_wrapper.rs

@@ -0,0 +1,37 @@
+// Создайте структуру Wrapper<T> с одним полем value: T:
+// ● Реализуйте метод map<U, F>(self, f: F) -> Wrapper<U>, где F: FnOnce(T) -> U.
+// ● Метод должен применāтþ функøиĀ f к value и возвраûатþ новýй Wrapper с резулþтатом.
+
+#![allow(clippy::approx_constant)]
+
+struct Wrapper<T> {
+    value: T,
+}
+
+impl<T> Wrapper<T> {
+    // Создаем новый Wrapper
+    fn new(value: T) -> Self {
+        Self { value }
+    }
+
+    // Применяем функцию к значению и возвращаем новый Wrapper
+    fn map<U>(self, f: impl FnOnce(T) -> U) -> Wrapper<U> {
+        Wrapper::new(f(self.value))
+    }
+}
+
+fn main() {
+    // Пример из задания
+    let w = Wrapper { value: 42 };
+    let w2 = w.map(|x| x.to_string());
+    println!("{}", w2.value); // "42"
+
+    // Дополнительные примеры
+    let w3 = Wrapper::<f64>::new(3.14);
+    let w4 = w3.map(|x| x.floor() as i32);
+    println!("{}", w4.value); // 3
+
+    let w5 = Wrapper::new("hello");
+    let w6 = w5.map(|s| s.len());
+    println!("{}", w6.value); // 5
+}

practice/src/bin/e_summary.rs

@@ -0,0 +1,59 @@
+// 1. Создайте типаж Summary с методом summarize(&self) -> String.
+// 2. Реализуйте его длā:
+// ○ Vec<T> (где T: ToString), метод должен соединять элементы через запятую.
+// ○ HashMap<K, V> (где K: ToString, V: ToString), метод должен выводить пары key:value.
+// 3. Напиúите функøиĀ print_summary<T: Summary>(item: T), которая печатает результат summarize().
+
+use std::collections::HashMap;
+
+// Определяем типаж Summary
+trait Summary {
+    fn summarize(&self) -> String;
+}
+
+// Реализация для Vec<T> где T: ToString
+impl<T: ToString> Summary for Vec<T> {
+    fn summarize(&self) -> String {
+        self.iter()
+            .map(|v| v.to_string())
+            .collect::<Vec<String>>()
+            .join(",")
+            .to_string()
+    }
+}
+
+// Реализация для HashMap<K, V> где K: ToString, V: ToString
+impl<K: ToString, V: ToString> Summary for HashMap<K, V> {
+    fn summarize(&self) -> String {
+        self.iter()
+            .map(|(k, v)| format!("{}:{}", k.to_string(), v.to_string()))
+            .collect::<Vec<String>>()
+            .join(", ")
+    }
+}
+
+// Обобщённая функция для вывода сводки
+fn print_summary(summary: impl Summary) {
+    println!("{}", summary.summarize())
+}
+
+fn main() {
+    // Пример с вектором
+    let vec = vec![1, 2, 3];
+    print_summary(vec); // "1, 2, 3"
+
+    // Пример с HashMap
+    let mut map = HashMap::new();
+    map.insert("name", "Alice");
+    map.insert("age", "30");
+    print_summary(map); // "name:Alice, age:30" (порядок может отличаться)
+
+    // Дополнительный пример с разными типами
+    let words = vec!["hello", "world"];
+    print_summary(words); // "hello, world"
+
+    let mut scores = HashMap::new();
+    scores.insert("math", 95);
+    scores.insert("science", 90);
+    print_summary(scores); // "math:95, science:90"
+}

practice/src/bin/f_largest_by_key.rs

@@ -0,0 +1,55 @@
+// Напиúите обобщенную функцию largest_by_key<T, F, K>(list: &[T], key: F) -> Option<&T>, где:
+// ● F: Fn(&T) -> K,
+// ● K: PartialOrd.
+// Функция должна возвращать элемент с максимальным значением key(item).
+
+fn largest_by_key<T, K: PartialOrd>(list: &[T], key: impl Fn(&T) -> K) -> Option<&T> {
+    let l_len = list.len();
+    if l_len < 1 {
+        return None;
+    } else if l_len == 1 {
+        return Some(&list[0]);
+    }
+    let mut max = &list[0];
+    let mut max_key = key(max);
+    for element in &list[1..] {
+        let element_key = key(element);
+        if element_key > max_key {
+            (max, max_key) = (element, element_key);
+        }
+    }
+    Some(max)
+}
+
+fn main() {
+    // Пример из задания
+    let words = ["apple", "banana", "cherry"];
+    let longest = largest_by_key(&words, |s| s.len());
+    println!("{:?}", longest); // Some("banana")
+
+    // Дополнительные примеры
+    let numbers = [1, 42, 3, 100, 5];
+    let largest_num = largest_by_key(&numbers, |&n| n);
+    println!("{:?}", largest_num); // Some(100)
+
+    struct Person {
+        name: String,
+        age: u32,
+    }
+    let people = [
+        Person {
+            name: "Alice".to_string(),
+            age: 30,
+        },
+        Person {
+            name: "Bob".to_string(),
+            age: 25,
+        },
+        Person {
+            name: "Charlie".to_string(),
+            age: 35,
+        },
+    ];
+    let oldest = largest_by_key(&people, |p| p.age);
+    println!("Oldest: {:?}", oldest.map(|p| &p.name)); // Some("Charlie")
+}

practice/src/bin/g_draw.rs

@@ -0,0 +1,44 @@
+// Определяем типаж Draw
+trait Draw {
+    fn draw(&self);
+}
+
+// Структура Circle
+struct Circle;
+
+// Реализация Draw для Circle
+impl Draw for Circle {
+    fn draw(&self) {
+        println!("Drawing circle")
+    }
+}
+
+// Структура Square
+struct Square;
+
+// Реализация Draw для Square
+impl Draw for Square {
+    fn draw(&self) {
+        println!("Drawing square")
+    }
+}
+
+fn main() {
+    // Создаем гетерогенную коллекцию фигур
+    let shapes: Vec<Box<dyn Draw>> = vec![Box::new(Circle), Box::new(Square)];
+
+    // Рисуем все фигуры
+    for shape in shapes {
+        shape.draw();
+    }
+
+    // Добавим еще фигур динамически
+    let mut more_shapes: Vec<Box<dyn Draw>> = Vec::new();
+    more_shapes.push(Box::new(Circle));
+    more_shapes.push(Box::new(Square));
+
+    println!("\nЕще фигуры:");
+    for shape in more_shapes {
+        shape.draw();
+    }
+}

practice/src/bin/h_plugins.rs

@@ -0,0 +1,53 @@
+use std::time::SystemTime;
+
+// Определяем типаж Plugin
+trait Plugin {
+    fn execute(&self) -> String;
+}
+
+// Плагин приветствия
+struct GreetPlugin;
+
+impl Plugin for GreetPlugin {
+    fn execute(&self) -> String {
+        "Hello, world!".to_string()
+    }
+}
+
+// Плагин времени
+struct TimePlugin;
+
+impl Plugin for TimePlugin {
+    fn execute(&self) -> String {
+        let now = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap();
+
+        let seconds = now.as_secs();
+        let minutes = seconds / 60;
+        let hours = (minutes / 60) % 24;
+        let minutes = minutes % 60;
+
+        format!("Current time: {:02}:{:02}", hours, minutes)
+    }
+}
+
+fn main() {
+    // Создаем коллекцию плагинов
+    let plugins = Vec::<Box<dyn Plugin>>::with_capacity(2);
+
+    // Выполняем все плагины
+    for plugin in plugins {
+        println!("{}", plugin.execute());
+    }
+
+    // Дополнительный пример с динамическим добавлением
+    let mut dynamic_plugins: Vec<Box<dyn Plugin>> = Vec::new();
+    dynamic_plugins.push(Box::new(GreetPlugin));
+    dynamic_plugins.push(Box::new(TimePlugin));
+
+    println!("\nDynamic execution:");
+    for plugin in dynamic_plugins {
+        println!("{}", plugin.execute());
+    }
+}

practice/src/bin/i_dyn_parser.rs

@@ -0,0 +1,70 @@
+// Определяем типаж Parser
+trait Parser {
+    fn parse(&self, input: &str) -> Result<String, String>;
+}
+
+
+
+// Парсер JSON
+struct JsonParser;
+
+impl Parser for JsonParser {
+    fn parse(&self, input: &str) -> Result<String, String> {
+        if input.trim().starts_with('{') && input.trim().ends_with('}') {
+            Ok("Parsed JSON".to_string())
+        } else {
+            Err("Invalid JSON format".to_string())
+        }
+    }
+}
+
+// Парсер CSV
+struct CsvParser;
+
+impl Parser for CsvParser {
+    fn parse(&self, input: &str) -> Result<String, String> {
+        if input.contains(',') {
+            Ok("Parsed CSV".to_string())
+        } else {
+            Err("Invalid CSV format".to_string())
+        }
+    }
+}
+
+// Функция для обработки данных парсером
+fn parse_data(parser: &dyn Parser, input: &str) -> Result<String, String> {
+    parser.parse(input)
+}
+
+
+
+fn main() {
+    // Пример использования JSON парсера
+    let json_parser = JsonParser;
+    let result = parse_data(&json_parser, r#"{ "name": "Alice" }"#);
+    println!("{:?}", result); // Ok("Parsed JSON")
+
+    // Пример использования CSV парсера
+    let csv_parser = CsvParser;
+    let result = parse_data(&csv_parser, "name,age,location");
+    println!("{:?}", result); // Ok("Parsed CSV")
+
+    // Пример обработки ошибок
+    let invalid_json = parse_data(&json_parser, "not a json");
+    println!("{:?}", invalid_json); // Err("Invalid JSON format")
+
+    let invalid_csv = parse_data(&csv_parser, "no commas here");
+    println!("{:?}", invalid_csv); // Err("Invalid CSV format")
+
+    // Динамический выбор парсера
+    let parsers: Vec<&dyn Parser> = vec![&json_parser, &csv_parser];
+    for parser in parsers {
+        println!("Testing parser:");
+        let test_input = if parser.parse("{").is_ok() {
+            r#"{ "test": "value" }"#
+        } else {
+            "field1,field2,field3"
+        };
+        println!("{:?}", parser.parse(test_input));
+    }
+}

practice/src/bin/j_sort_strategy.rs

@@ -0,0 +1,89 @@
+// Определяем типаж стратегии сортировки
+trait SortStrategy {
+    fn sort(&self, data: &mut [i32]);
+}
+
+
+// Реализация пузырьковой сортировки
+struct BubbleSort;
+
+impl SortStrategy for BubbleSort {
+    fn sort(&self, data: &mut [i32]) {
+        let len = data.len();
+        for i in 0..len {
+            for j in 0..len - i - 1 {
+                if data[j] > data[j + 1] {
+                    data.swap(j, j + 1);
+                }
+            }
+        }
+    }
+}
+
+// Реализация быстрой сортировки
+struct QuickSort;
+
+impl SortStrategy for QuickSort {
+    fn sort(&self, data: &mut [i32]) {
+        if data.len() <= 1 {
+            return;
+        }
+
+        let pivot = data.len() / 2;
+        let mut i = 0;
+        let mut j = data.len() - 1;
+
+        loop {
+            while data[i] < data[pivot] {
+                i += 1;
+            }
+            while data[j] > data[pivot] {
+                j -= 1;
+            }
+
+            if i >= j {
+                break;
+            }
+
+            data.swap(i, j);
+            i += 1;
+            j -= 1;
+        }
+
+        self.sort(&mut data[..i]);
+        self.sort(&mut data[i..]);
+    }
+}
+
+// Функция для применения стратегии сортировки
+fn sort_data(strategy: &dyn SortStrategy, data: &mut [i32]) {
+    strategy.sort(data)
+}
+
+
+
+fn main() {
+    // Тестируем пузырьковую сортировку
+    let mut data1 = [3, 1, 2, 5, 4];
+    let bubble = Box::new(BubbleSort);
+    sort_data(&*bubble, &mut data1);
+    println!("Bubble sort: {:?}", data1); // [1, 2, 3, 4, 5]
+
+    // Тестируем быструю сортировку
+    let mut data2 = [7, 3, 9, 2, 1];
+    let quick = Box::new(QuickSort);
+    sort_data(&*quick, &mut data2);
+    println!("Quick sort: {:?}", data2); // [1, 2, 3, 7, 9]
+
+    // Динамический выбор стратегии
+    let strategies: Vec<Box<dyn SortStrategy>> = vec![
+        Box::new(BubbleSort),
+        Box::new(QuickSort),
+    ];
+
+    for strategy in strategies {
+        let mut test_data = [5, 2, 4, 1, 3];
+        strategy.sort(&mut test_data);
+        println!("Sorted: {:?}", test_data);
+    }
+}

practice/src/bin/k_dyn_logger.rs

@@ -0,0 +1,91 @@
+// Уровни логирования
+#[derive(Debug, PartialEq, PartialOrd, Copy, Clone)]
+enum LogLevel {
+    Error,
+    Warn,
+    Info,
+    Debug,
+}
+
+// Типаж Logger
+trait Logger {
+    fn log(&self, message: &str);
+    fn level(&self) -> LogLevel;
+}
+
+// Логгер в консоль
+struct ConsoleLogger {
+    level: LogLevel,
+}
+
+impl ConsoleLogger {
+    fn new(level: LogLevel) -> Self {
+        ConsoleLogger { level }
+    }
+}
+
+impl Logger for ConsoleLogger {
+    fn log(&self, message: &str) {
+        println!("[Console] {}", message);
+    }
+
+    fn level(&self) -> LogLevel {
+        self.level
+    }
+}
+
+// Логгер в файл (упрощенная реализация)
+struct FileLogger {
+    level: LogLevel,
+    file_path: String,
+}
+
+impl FileLogger {
+    fn new(level: LogLevel, file_path: &str) -> Self {
+        FileLogger {
+            level,
+            file_path: file_path.to_string(),
+        }
+    }
+}
+
+impl Logger for FileLogger {
+    fn log(&self, message: &str) {
+        println!("[File: {}] {}", self.file_path, message);
+        // В реальной реализации здесь была бы запись в файл
+    }
+
+    fn level(&self) -> LogLevel {
+        self.level
+    }
+}
+
+// Функция для логирования сообщения с проверкой уровня
+fn log_message(logger: &dyn Logger, message: &str) {
+    if logger.level() >= LogLevel::Info {  // Пример: логируем только Info и выше
+        logger.log(message);
+    }
+}
+
+fn main() {
+    // Создаем логгеры
+    let console_logger = Box::new(ConsoleLogger::new(LogLevel::Info));
+    let file_logger = Box::new(FileLogger::new(LogLevel::Debug, "app.log"));
+
+    // Логируем сообщения
+    log_message(&*console_logger, "Application started");
+    log_message(&*file_logger, "Debug information");
+
+    // Сообщение, которое не будет залогировано (уровень ниже Info)
+    log_message(&*console_logger, "Trace information");
+
+    // Динамический выбор логгера
+    let loggers: Vec<Box<dyn Logger>> = vec![
+        Box::new(ConsoleLogger::new(LogLevel::Warn)),
+        Box::new(FileLogger::new(LogLevel::Error, "errors.log")),
+    ];
+
+    for logger in loggers {
+        log_message(&*logger, "Testing logger");
+    }
+}

practice/src/bin/l_event_handler.rs

@@ -0,0 +1,80 @@
+use std::collections::HashMap;
+
+// Определяем типаж обработчика событий
+trait EventHandler {
+    fn handle(&self, event: &str);
+}
+
+// Обработчик для отправки email
+struct EmailHandler;
+
+impl EventHandler for EmailHandler {
+    fn handle(&self, event: &str) {
+        println!("EmailHandler handling event '{}'", event)
+    }
+}
+
+// Обработчик для сохранения в базу данных
+struct DatabaseHandler;
+
+impl EventHandler for DatabaseHandler {
+    fn handle(&self, event: &str) {
+        println!("DatabaseHandler handling event '{}'", event)
+    }
+}
+
+// Обработчик для логирования
+struct LogHandler;
+
+impl EventHandler for LogHandler {
+    fn handle(&self, event: &str) {
+        println!("LogHandler handling event '{}'", event)
+    }
+}
+
+fn main() {
+    // Создаем реестр обработчиков событий
+    let mut handlers: HashMap<String, Box<dyn EventHandler>> = HashMap::new();
+
+    // Регистрируем обработчики
+    handlers.insert("email".to_string(), Box::new(EmailHandler));
+    handlers.insert("database".to_string(), Box::new(DatabaseHandler));
+    handlers.insert("log".to_string(), Box::new(LogHandler));
+
+    // Обрабатываем события
+    if let Some(handler) = handlers.get("email") {
+        handler.handle("New user registration");
+    }
+
+    if let Some(handler) = handlers.get("database") {
+        handler.handle("User data update");
+    }
+
+    // Динамическая обработка нескольких событий
+    let events = vec![
+        ("email", "Password reset requested"),
+        ("database", "Order completed"),
+        ("log", "System started"),
+        ("unknown", "This won't be processed"), // Не будет обработано
+    ];
+
+    for (event_type, event_data) in events {
+        if let Some(handler) = handlers.get(event_type) {
+            handler.handle(event_data);
+        } else {
+            println!("No handler registered for event type: {}", event_type);
+        }
+    }
+
+    // Добавление нового обработчика во время выполнения
+    struct NotificationHandler;
+
+    impl EventHandler for NotificationHandler {
+        fn handle(&self, event: &str) {
+            println!("Sending push notification: '{}'", event);
+        }
+    }
+
+    handlers.insert("notification".to_string(), Box::new(NotificationHandler));
+    handlers["notification"].handle("New message received");
+}

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");
+}

practice/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}

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"
-version = "0.0.0"
+name = "cfg-if"
+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]
-edition = "2024"
-name = "smart-house"
-version = "0.0.0"
-
-[dependencies]
+[workspace]
+resolver = "3"
+members = [
+    "power_socket_lib", "use_dynamic",
+    "use_static",
+]

smart-house/README.md

@@ -35,23 +35,229 @@
     - [x] Можно получить ссылку на устройство по указанному индексу.
     - [x] Можно получить мутабельную ссылку на устройство по указанному индексу.
     - [x] Выводить в стандартный вывод отчёт о всех устройствах в комнате.
-- [ ] Опишите тип: умный дом, содержащий массив комнат. Тип должен предоставлять следующий функционал:
-    - [ ] Конструктор, принимающий массив комнат.
-    - [ ] Можно получить ссылку на комнату по указанному индексу.
-    - [ ] Можно получить мутабельную ссылку на комнату по указанному индексу.
-    - [ ] Выводить в стандартный вывод отчёт о всех комнатах.
+- [x] Опишите тип: умный дом, содержащий массив комнат. Тип должен предоставлять следующий функционал:
+    - [x] Конструктор, принимающий массив комнат.
+    - [x] Можно получить ссылку на комнату по указанному индексу.
+    - [x] Можно получить мутабельную ссылку на комнату по указанному индексу.
+    - [x] Выводить в стандартный вывод отчёт о всех комнатах.
 - Размеры массивов можно выбрать произвольно.
 - В случае, если указан индекс, выходящий за пределы массива, приложение должно аварийно завершаться (макрос `panic!()`).
 
 Для примера использования:
 
-- [ ] Реализована в виде bin крейта.
-- [ ] Создайте экземпляр умного дома и выведете отчёт о его содержимом.
-- [ ] Для уже созданного экземпляра дома выключите умную розетку в одной из комнат. Снова выведите отчёт.
+- [x] Реализована в виде bin крейта.
+- [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,14 +0,0 @@
-#![allow(unused)]
-
-mod power_socket;
-mod thermometer;
-
-pub trait Device {
-    fn print_status(&self);
-    fn as_any(&self) -> &dyn Any;
-    fn as_mut_any(&mut self) -> &mut dyn Any;
-}
-
-pub use power_socket::PowerSocket;
-use std::any::Any;
-pub use thermometer::Thermometer;

smart-house/src/device/power_socket.rs

@@ -1,72 +0,0 @@
-#![allow(unused)]
-
-use crate::device::Device;
-use std::any::Any;
-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())
-    }
-}
-
-impl Device for PowerSocket {
-    fn print_status(&self) {
-        println!("{}", self.display())
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn as_mut_any(&mut self) -> &mut dyn Any {
-        self
-    }
-}
-
-#[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/device/thermometer.rs

@@ -1,54 +0,0 @@
-#![allow(unused)]
-
-use std::any::Any;
-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())
-    }
-}
-
-impl super::Device for Thermometer {
-    fn print_status(&self) {
-        println!("{}", self.display())
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn as_mut_any(&mut self) -> &mut dyn Any {
-        self
-    }
-}
-
-#[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/src/house.rs

@@ -1 +0,0 @@
-

smart-house/src/lib.rs

@@ -1,3 +0,0 @@
-mod device;
-mod house;
-mod room;

smart-house/src/main.rs

@@ -1 +0,0 @@
-fn main() {}

smart-house/src/room.rs

@@ -1,77 +0,0 @@
-#![allow(unused)]
-use crate::device::Device;
-
-struct Room<'a> {
-    name: String,
-    devices: &'a mut [Box<dyn Device>],
-}
-
-impl<'a> Room<'a> {
-    pub fn new(name: impl AsRef<str>, devices: &'a mut [Box<dyn Device>]) -> Self {
-        Self {
-            name: name.as_ref().to_string(),
-            devices,
-        }
-    }
-
-    pub fn get(&'a self, idx: usize) -> &'a dyn Device {
-        if idx >= self.devices.len() {
-            panic!("Index is out of bounds")
-        }
-        self.devices[idx].as_ref()
-    }
-
-    pub fn get_mut(&'a mut self, idx: usize) -> &'a mut dyn Device {
-        if idx >= self.devices.len() {
-            panic!("Index is out of bounds")
-        }
-        self.devices[idx].as_mut()
-    }
-
-    pub fn print(&self) {
-        println!("{}", "=".repeat(16));
-        println!("{}:", self.name);
-        println!("{}", "-".repeat(16));
-        for d in self.devices.iter() {
-            d.print_status();
-        }
-        println!("{}", "=".repeat(16));
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::device::{PowerSocket, Thermometer};
-    use std::fmt::format;
-    use std::mem;
-
-    #[test]
-    fn smoke_test() {
-        let mut devices = Box::new([Box::new(PowerSocket::new(12.34, false)) as Box<dyn Device>, Box::new(Thermometer::new(21.56))]);
-        let mut room = Room::new("test_room", &mut *devices);
-        assert_eq!(room.name, "test_room");
-        room.print();
-
-        assert_eq!(
-            format!("{}", room.get(0).as_any().downcast_ref::<PowerSocket>().unwrap().display()),
-            "PowerSocket[ OFF : 0.0 ]"
-        );
-        assert_eq!(
-            format!("{}", room.get(1).as_any().downcast_ref::<Thermometer>().unwrap().display()),
-            "Thermometer[ 21.6 ]"
-        );
-
-        room.get_mut(0).as_mut_any().downcast_mut::<PowerSocket>().unwrap().set_on(true);
-
-        // room.print(); // TODO satisfy compiler
-    }
-
-    #[test]
-    #[should_panic(expected = "Index is out of bounds")]
-    fn panic_test() {
-        let mut devices = [Box::new(PowerSocket::new(12.34, false)) as Box<dyn Device>, Box::new(Thermometer::new(21.56))];
-        let mut room = Room::new("test_room", &mut devices);
-        room.get(2);
-    }
-}

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) });
+}