wrap into workspace

smart-house/house/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+edition = "2024"
+name = "smart-house"
+version = "0.0.0"
+
+[dependencies]
+tokio = { version = "1.49.0", features = ["rt", "net", "io-util", "time"] }
+rand = { version = "0.10.0", features = ["std"] }

smart-house/house/src/bin/house_builder.rs

@@ -0,0 +1,11 @@
+use smart_house::{HouseBuilder, PowerSocket, PrintStatus, Thermometer};
+
+fn main() {
+    let house = HouseBuilder::new()
+        .add_room("Main")
+        .add_device("PSockA", PowerSocket::stub(12.0, false))
+        .add_room("Hall")
+        .add_device("ThermA", Thermometer::stub(18.5))
+        .build();
+    house.print_status();
+}

smart-house/house/src/bin/mocks_example.rs

@@ -0,0 +1,32 @@
+//! Пример работы умного дома с имитаторами
+
+use smart_house::{Device, House, PowerSocket, PrintStatus, Room, Thermometer, room};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut house = create_house_demo()?;
+
+    let dev = house.get_room_mut("Main").unwrap().get_device_mut("PSocA").unwrap();
+    if let Device::PowerSocket(psoc) = dev {
+        psoc.set_on(!psoc.is_on().unwrap()).unwrap();
+    }
+
+    house.print_status();
+
+    Ok(())
+}
+
+fn create_house_demo() -> Result<House, Box<dyn std::error::Error>> {
+    println!("# Create new smart house");
+    let house = House::new(
+        [(
+            "Main".to_string(),
+            room!(
+                "PSocA" => PowerSocket::connect("127.0.0.1:10001")?,
+                "ThermA" => Thermometer::connect("127.0.0.1:10002")?,
+            ),
+        )]
+        .into_iter()
+        .collect(),
+    );
+    Ok(house)
+}

smart-house/house/src/bin/power_socket_client.rs

@@ -0,0 +1,19 @@
+//! Пример подключения нескольких клиентов к розетке. Изменение состояния любым из клиентов отражается на всех.
+
+use smart_house::PowerSocket;
+use std::time::Duration;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let power_socket0 = PowerSocket::connect("127.0.0.1:10001")?;
+    let mut power_socket = PowerSocket::connect("127.0.0.1:10001")?;
+    println!("{}", power_socket0.display());
+    println!("{}", power_socket.display());
+
+    std::thread::sleep(Duration::from_secs(2));
+    power_socket.set_on(!power_socket.is_on().unwrap()).unwrap();
+
+    println!("{}", power_socket0.display());
+    println!("{}", power_socket.display());
+
+    Ok(())
+}

smart-house/house/src/bin/power_socket_mock.rs

@@ -0,0 +1,88 @@
+//! Сервер-имитатор умной розетки
+
+use std::net::SocketAddr;
+use std::sync::{Arc, RwLock};
+use std::time::Duration;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+fn parse_args() -> Result<SocketAddr, Box<dyn std::error::Error>> {
+    let mut args = std::env::args();
+    args.next();
+    Ok(args.next().ok_or(std::io::Error::other("no server address parameter specified"))?.parse()?)
+}
+
+struct RealPowerSocket {
+    power_rate: f32,
+    on: bool,
+}
+
+const CMD_GET_ON: u8 = 1;
+const CMD_TURN_ON: u8 = 2;
+const CMD_TURN_OFF: u8 = 3;
+const CMD_GET_POWER: u8 = 4;
+
+const TIMEOUT: Duration = Duration::from_secs(5);
+
+async fn handle_connection(mut socket: tokio::net::TcpStream, real_power_socket: Arc<RwLock<RealPowerSocket>>) -> Result<(), std::io::Error> {
+    let mut buf = [0u8; 1];
+    loop {
+        let read = tokio::time::timeout(TIMEOUT, socket.read(&mut buf)).await??;
+        if read == 0 {
+            println!("connection closed");
+            return Ok(());
+        }
+        match buf {
+            [CMD_GET_ON] => {
+                println!("handling CMD_GET_ON");
+                {
+                    let power_socket = real_power_socket.try_read().map_err(|_| std::io::Error::other("read lock failed"))?;
+                    buf = if power_socket.on { [1u8; 1] } else { [0u8; 1] };
+                }
+                let _ = tokio::time::timeout(TIMEOUT, socket.write(&buf)).await?;
+            }
+            [CMD_TURN_ON] => {
+                println!("handling CMD_TURN_ON");
+                {
+                    let mut power_socket = real_power_socket.try_write().map_err(|_| std::io::Error::other("write lock failed"))?;
+                    power_socket.on = true;
+                }
+                let _ = tokio::time::timeout(TIMEOUT, socket.write(&buf)).await?;
+            }
+            [CMD_TURN_OFF] => {
+                println!("handling CMD_TURN_OFF");
+                {
+                    let mut power_socket = real_power_socket.try_write().map_err(|_| std::io::Error::other("write lock failed"))?;
+                    power_socket.on = false;
+                }
+                let _ = tokio::time::timeout(TIMEOUT, socket.write(&buf)).await?;
+            }
+            [CMD_GET_POWER] => {
+                println!("handling CMD_GET_POWER");
+                let data_buf: [u8; 4];
+                {
+                    let power_socket = real_power_socket.try_read().map_err(|_| std::io::Error::other("read lock failed"))?;
+                    data_buf = power_socket.power_rate.to_le_bytes();
+                }
+                let _ = tokio::time::timeout(TIMEOUT, socket.write(&data_buf)).await?;
+            }
+            _ => {
+                println!("unknown command {} - ignore it", buf[0]);
+            }
+        }
+    }
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let real_power_socket = Arc::new(RwLock::new(RealPowerSocket { power_rate: 12.0, on: false }));
+    let rt = tokio::runtime::Builder::new_current_thread().enable_all().build()?;
+    rt.block_on(async {
+        let listener = tokio::net::TcpListener::bind(parse_args()?).await?;
+
+        loop {
+            let (socket, _) = listener.accept().await?;
+            println!("new connection");
+            let real_power_socket = real_power_socket.clone();
+            tokio::spawn(async move { handle_connection(socket, real_power_socket).await });
+        }
+    })
+}

smart-house/house/src/bin/reporter.rs

@@ -0,0 +1,17 @@
+use smart_house::{HouseBuilder, PowerSocket, Reporter, Thermometer};
+
+fn main() {
+    let house = HouseBuilder::new()
+        .add_room("Main")
+        .add_device("PSockB", PowerSocket::stub(12.0, false))
+        .add_room("Hall")
+        .add_device("ThermB", Thermometer::stub(18.5))
+        .build();
+
+    Reporter::new()
+        .add_reportable(house.get_room("Main").unwrap())
+        .add_reportable(house.get_device("Main", "PSockB").unwrap())
+        .add_reportable(house.get_room("Hall").unwrap())
+        .add_reportable(house.get_device("Hall", "ThermB").unwrap())
+        .report();
+}

smart-house/house/src/bin/stubs_example.rs

@@ -0,0 +1,147 @@
+//! Старый пример работы умного дома на заглушках
+
+use smart_house::{Device, House, PowerSocket, PrintStatus, Room, Thermometer, room};
+
+fn main() {
+    let mut house = create_house_demo();
+
+    switch_off_power_socket_in_hall_demo(&mut house);
+
+    add_new_room_in_house_demo(&mut house);
+
+    add_power_socket_to_closet_room_demo(&mut house);
+
+    remove_thermometer_from_closet_room_demo(&mut house);
+
+    remove_closet_room_demo(&mut house);
+
+    searching_devices_in_house_demo(&house);
+
+    universal_printing_function_demo(&house);
+}
+
+fn create_house_demo() -> House {
+    println!("# Create new smart house");
+    let house = House::new(
+        [
+            (
+                "Hall".to_string(),
+                room!(
+                    "PSocA" => PowerSocket::stub(9.5, true),
+                    "ThermA" => Thermometer::stub(20.1),
+                ),
+            ),
+            (
+                "Main".to_string(),
+                room!(
+                    "PSocB" => PowerSocket::stub(11.2, true),
+                    "ThermB" => Thermometer::stub(24.5),
+                    "PSocC" => PowerSocket::stub(10.4, true),
+                ),
+            ),
+            (
+                "Bedroom".to_string(),
+                room!(
+                    "ThermC" => Thermometer::stub(19.3),
+                    "PSocD" => PowerSocket::stub(12.1, true),
+                ),
+            ),
+        ]
+        .into_iter()
+        .collect(),
+    );
+    house.print_status();
+    house
+}
+
+fn switch_off_power_socket_in_hall_demo(house: &mut House) {
+    print!("# Switching off a power socket in Hall... ");
+    let Device::PowerSocket(power_socket) = house.get_room_mut("Hall").unwrap().get_device_mut("PSocA").unwrap() else {
+        println!("FAILED!");
+        return;
+    };
+    power_socket.set_on(false).unwrap();
+    println!("SUCCESS");
+    house.print_status();
+}
+
+fn add_new_room_in_house_demo(house: &mut House) {
+    println!("# Add new room into house");
+    house.insert_room(
+        "Closet",
+        room!(
+            "ThermD" => Thermometer::stub(9.5)
+        ),
+    );
+    house.print_status();
+}
+
+fn add_power_socket_to_closet_room_demo(house: &mut House) {
+    println!("# Add power socket to 'Closet' room");
+    house
+        .get_room_mut("Closet")
+        .unwrap()
+        .insert_device("PSocE", PowerSocket::stub(8.0, true).into());
+    house.print_status();
+}
+
+fn remove_thermometer_from_closet_room_demo(house: &mut House) {
+    print!("# Removing thermometer from 'Closet' room... ");
+    let Some(_) = house.get_room_mut("Closet").unwrap().remove_device("ThermD") else {
+        println!("FAILED!");
+        return;
+    };
+    println!("SUCCESS");
+    house.print_status();
+}
+
+fn remove_closet_room_demo(house: &mut House) {
+    print!("# Removing 'Closet' room... ");
+    let Some(_) = house.remove_room("Closet") else {
+        println!("FAILED!");
+        return;
+    };
+    println!("SUCCESS");
+    house.print_status();
+}
+
+fn searching_devices_in_house_demo(house: &House) {
+    println!("# Searching dummy device in empty room");
+    find_device_handling_errors_demo(house, "empty", "dummy");
+
+    println!("# Searching dummy device in Bedroom");
+    find_device_handling_errors_demo(house, "Bedroom", "dummy");
+
+    println!("# Searching ThermA device in Hall room");
+    find_device_handling_errors_demo(house, "Hall", "ThermA");
+
+    println!();
+}
+
+fn find_device_handling_errors_demo(house: &House, room: &str, device: &str) {
+    match house.get_device(room, device) {
+        Err(error) => {
+            println!("FAIL. Error: {:?}", error);
+        }
+        Ok(device) => {
+            print!("SUCCESS. Device found: ");
+            device.print_status();
+        }
+    }
+}
+
+fn universal_printing_function_demo(house: &House) {
+    println!("# Print house using universal function");
+    print_status(house);
+
+    println!("# Print Main room using universal function");
+    print_status(house.get_room("Main").unwrap());
+
+    println!();
+    println!("# Print PSocC device from Main room using universal function");
+    print_status(house.get_device("Main", "PSocC").unwrap());
+}
+
+fn print_status(printable: &impl PrintStatus) {
+    printable.print_status();
+}

smart-house/house/src/bin/subscribers.rs

@@ -0,0 +1,22 @@
+use smart_house::{Device, PowerSocket, Room, Subscriber};
+
+fn main() {
+    let mut room = Room::default();
+
+    room.subscribe(MySubscriber::default());
+
+    room.subscribe(|dev: &Device| {
+        println!("device added: {}", dev.display());
+    });
+
+    room.insert_device("", PowerSocket::stub(12.0, false).into());
+}
+
+#[derive(Default)]
+struct MySubscriber {}
+
+impl Subscriber for MySubscriber {
+    fn on_event(&mut self, dev: &Device) {
+        println!("DEVICE ADDED: {}", dev.display());
+    }
+}

smart-house/house/src/bin/thermometer_mock.rs

@@ -0,0 +1,53 @@
+//! Имитатор термометра
+
+use rand::prelude::*;
+use std::io::Read;
+use std::net::{IpAddr, SocketAddr};
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
+
+struct Params {
+    addr: SocketAddr,
+    interval: Duration,
+}
+
+const CONFIG_FILE: &str = "thermometer_mock.cfg";
+
+fn read_parameters_from_file() -> Result<Params, std::io::Error> {
+    let mut file = std::fs::File::open(CONFIG_FILE)?;
+    let mut content = String::new();
+    file.read_to_string(&mut content)?;
+    let lines = content.split("\n").collect::<Vec<&str>>();
+    let addr = lines
+        .first()
+        .map(|v| SocketAddr::from_str(v))
+        .ok_or(std::io::Error::other("no address found in config file"))?
+        .map_err(std::io::Error::other)?;
+    let interval = lines
+        .get(1)
+        .map(|v| v.parse::<u64>())
+        .ok_or(std::io::Error::other("no interval found in config file"))?
+        .map(Duration::from_millis)
+        .map_err(std::io::Error::other)?;
+    Ok(Params { addr, interval })
+}
+
+fn generate_temperature() -> f32 {
+    rand::rng().random_range(18.0..23.0)
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let params = read_parameters_from_file()?;
+    let rt = tokio::runtime::Builder::new_current_thread().enable_all().build()?;
+    rt.block_on(async move {
+        let socket = Arc::new(tokio::net::UdpSocket::bind(SocketAddr::new(IpAddr::from([127, 0, 0, 1]), 10003)).await?);
+        let mut interval = tokio::time::interval(params.interval);
+        loop {
+            interval.tick().await;
+            let new_temperature = generate_temperature();
+            let data = new_temperature.to_le_bytes();
+            socket.send_to(&data, &params.addr).await?;
+        }
+    })
+}

smart-house/house/src/builders.rs

@@ -0,0 +1,53 @@
+use crate::{Device, House, Room};
+use std::collections::HashMap;
+
+pub struct HouseBuilder {
+    rooms: HashMap<String, Room>,
+}
+
+impl HouseBuilder {
+    pub fn new() -> Self {
+        Self { rooms: HashMap::new() }
+    }
+
+    pub fn add_room(self, name: &str) -> RoomBuilder {
+        RoomBuilder {
+            parent: self,
+            name: name.to_string(),
+            devices: HashMap::new(),
+        }
+    }
+
+    pub fn build(self) -> House {
+        House::new(self.rooms)
+    }
+}
+
+impl Default for HouseBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub struct RoomBuilder {
+    parent: HouseBuilder,
+    name: String,
+    devices: HashMap<String, Device>,
+}
+
+impl RoomBuilder {
+    pub fn add_device(mut self, name: &str, device: impl Into<Device>) -> Self {
+        self.devices.insert(name.to_string(), device.into());
+        self
+    }
+
+    pub fn add_room(mut self, name: &str) -> RoomBuilder {
+        self.parent.rooms.insert(self.name, Room::new(self.devices));
+        self.parent.add_room(name)
+    }
+
+    pub fn build(mut self) -> House {
+        self.parent.rooms.insert(self.name, Room::new(self.devices));
+        self.parent.build()
+    }
+}

smart-house/house/src/device.rs

@@ -0,0 +1,72 @@
+use crate::PrintStatus;
+use std::fmt::Display;
+use std::io::Write;
+
+#[derive(Debug)]
+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())
+            }
+        }
+    }
+}
+
+impl From<super::Thermometer> for Device {
+    fn from(value: super::Thermometer) -> Self {
+        Device::Thermometer(value)
+    }
+}
+
+impl From<super::PowerSocket> for Device {
+    fn from(value: super::PowerSocket) -> Self {
+        Device::PowerSocket(value)
+    }
+}
+
+impl PrintStatus for Device {
+    fn print_status_into(&self, out: &mut dyn Write) -> Result<(), std::io::Error> {
+        out.write_fmt(format_args!("{}", self.display()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{PowerSocket, Thermometer};
+
+    #[test]
+    fn smoke_test() {
+        let dev_thermometer = Device::Thermometer(Thermometer::stub(20.1));
+        let dev_power_socket = Device::PowerSocket(PowerSocket::stub(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::stub(20.1));
+        let dev_power_socket = Device::PowerSocket(PowerSocket::stub(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/house/src/error.rs

@@ -0,0 +1,23 @@
+use std::fmt::{Display, Formatter};
+
+#[derive(Debug)]
+pub struct Error {
+    message: String,
+}
+
+impl Error {
+    pub fn new(message: impl AsRef<str>) -> Self {
+        Self {
+            message: message.as_ref().to_string(),
+        }
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{}", self.message))?;
+        Ok(())
+    }
+}
+
+impl std::error::Error for Error {}

smart-house/house/src/house.rs

@@ -0,0 +1,154 @@
+use crate::{Device, Error, PrintStatus, Room};
+use std::collections::HashMap;
+use std::io::Write;
+
+#[derive(Debug)]
+pub struct House {
+    rooms: HashMap<String, Room>,
+}
+
+impl House {
+    pub fn new(rooms: HashMap<String, Room>) -> Self {
+        Self { rooms }
+    }
+
+    pub fn get_room(&self, key: &str) -> Option<&Room> {
+        self.rooms.get(key)
+    }
+
+    pub fn get_room_mut(&mut self, key: &str) -> Option<&mut Room> {
+        self.rooms.get_mut(key)
+    }
+
+    pub fn insert_room(&mut self, name: &str, room: Room) -> Option<Room> {
+        self.rooms.insert(name.to_string(), room)
+    }
+
+    pub fn remove_room(&mut self, key: &str) -> Option<Room> {
+        self.rooms.remove(key)
+    }
+
+    pub fn get_device(&self, room_name: &str, device_name: &str) -> Result<&Device, Error> {
+        let Some(room) = self.get_room(room_name) else {
+            return Err(Error::new(format!("no room named '{}' found", room_name)));
+        };
+        let Some(device) = room.get_device(device_name) else {
+            return Err(Error::new(format!("no device named '{}' found in room '{}'", device_name, room_name)));
+        };
+        Ok(device)
+    }
+}
+
+impl PrintStatus for House {
+    fn print_status_into(&self, out: &mut dyn Write) -> Result<(), std::io::Error> {
+        for (room_name, room) in self.rooms.iter() {
+            out.write_fmt(format_args!("{}:\n", room_name))?;
+            out.write_fmt(format_args!("{}\n", "-".repeat(32)))?;
+            room.print_status_into(out)?;
+            out.write_fmt(format_args!("\n"))?;
+            println!();
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{Device, PowerSocket, Thermometer};
+
+    fn create_test_house() -> House {
+        House::new(
+            [
+                (
+                    "main".to_string(),
+                    Room::new(
+                        [
+                            ("ThermA".to_string(), Thermometer::stub(20.0).into()),
+                            ("PSocA".to_string(), PowerSocket::stub(12.34, false).into()),
+                            ("PSocB".to_string(), PowerSocket::stub(10.01, true).into()),
+                        ]
+                        .into_iter()
+                        .collect(),
+                    ),
+                ),
+                (
+                    "bedroom".to_string(),
+                    Room::new(
+                        [
+                            ("PSocC".to_string(), PowerSocket::stub(11.11, true).into()),
+                            ("ThermB".to_string(), Thermometer::stub(17.99).into()),
+                        ]
+                        .into_iter()
+                        .collect(),
+                    ),
+                ),
+            ]
+            .into_iter()
+            .collect(),
+        )
+    }
+
+    #[test]
+    fn smoke_test() {
+        let mut house = create_test_house();
+        assert_eq!(house.rooms.len(), 2);
+        house.print_status();
+
+        assert_eq!(
+            format!("{}", house.get_room("main").unwrap().get_device("ThermA").unwrap().display()),
+            "DEV:Thermometer[ 20.0 ]"
+        );
+        assert_eq!(
+            format!("{}", house.get_room("main").unwrap().get_device("PSocA").unwrap().display()),
+            "DEV:PowerSocket[ OFF : 0.0 ]"
+        );
+        assert_eq!(
+            format!("{}", house.get_room("bedroom").unwrap().get_device("PSocC").unwrap().display()),
+            "DEV:PowerSocket[ ON : 11.1 ]"
+        );
+
+        let Device::PowerSocket(powers_socket) = house.get_room_mut("main").unwrap().get_device_mut("PSocA").unwrap() else {
+            unreachable!()
+        };
+        powers_socket.set_on(true).unwrap();
+
+        assert_eq!(
+            format!("{}", house.get_room("main").unwrap().get_device("PSocA").unwrap().display()),
+            "DEV:PowerSocket[ ON : 12.3 ]"
+        );
+    }
+
+    #[test]
+    fn check_out_of_bounds() {
+        let house = create_test_house();
+        assert!(house.get_room("absent").is_none());
+    }
+
+    #[test]
+    fn test_add_remove() {
+        let mut house = create_test_house();
+        let room = Room::new(HashMap::new());
+
+        let result = house.insert_room("empty", room);
+        assert!(result.is_none());
+        assert_eq!(house.rooms.len(), 3);
+
+        let Some(result) = house.remove_room("bedroom") else { unreachable!() };
+        assert_eq!(result.get_device("ThermB").unwrap().display().to_string(), "DEV:Thermometer[ 18.0 ]");
+    }
+
+    #[test]
+    fn test_get_device() {
+        let house = create_test_house();
+
+        let result = house.get_device("empty", "dummy");
+        assert_eq!(result.unwrap_err().to_string(), "no room named 'empty' found");
+
+        let result = house.get_device("main", "dummy");
+        assert_eq!(result.unwrap_err().to_string(), "no device named 'dummy' found in room 'main'");
+
+        let result = house.get_device("main", "ThermA");
+        assert_eq!(result.unwrap().display().to_string(), "DEV:Thermometer[ 20.0 ]");
+    }
+}

smart-house/house/src/lib.rs

@@ -0,0 +1,22 @@
+mod device;
+mod error;
+mod house;
+mod power_socket;
+#[macro_use]
+mod room;
+mod builders;
+mod print_status;
+mod reporter;
+mod subscriber;
+mod thermometer;
+
+pub use builders::{HouseBuilder, RoomBuilder};
+pub use device::Device;
+pub use error::Error;
+pub use house::House;
+pub use power_socket::PowerSocket;
+pub use print_status::PrintStatus;
+pub use reporter::Reporter;
+pub use room::Room;
+pub use subscriber::Subscriber;
+pub use thermometer::Thermometer;

smart-house/house/src/main.rs

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

smart-house/house/src/power_socket.rs

@@ -0,0 +1,177 @@
+use std::cell::RefCell;
+use std::fmt::{Debug, Display};
+use std::io::{Read, Write};
+use std::net::{SocketAddr, TcpStream};
+use std::time::Duration;
+
+#[derive(Debug)]
+pub struct PowerSocket {
+    handle: Box<dyn PowerSocketHandle>,
+}
+
+impl PowerSocket {
+    pub fn stub(power_rate: f32, on: bool) -> Self {
+        Self {
+            handle: Box::new(PowerSocketStub::new(power_rate, on)),
+        }
+    }
+
+    pub fn connect(addr: &str) -> Result<Self, std::io::Error> {
+        let handle = PowerSocketClient::new(addr)?;
+        Ok(Self { handle: Box::new(handle) })
+    }
+
+    pub fn is_on(&self) -> Result<bool, std::io::Error> {
+        self.handle.is_on()
+    }
+
+    pub fn set_on(&mut self, on: bool) -> Result<(), std::io::Error> {
+        self.handle.set_on(on)
+    }
+
+    pub fn get_power(&self) -> Result<f32, std::io::Error> {
+        self.handle.get_power()
+    }
+
+    pub fn display(&self) -> impl Display {
+        const ERR: &str = "PowerSocket[ ERR ]";
+        let power = match self.get_power() {
+            Ok(power) => power,
+            Err(e) => {
+                eprintln!("error on get power: {:?}", e);
+                return ERR.to_string();
+            }
+        };
+        let on = match self.is_on() {
+            Ok(state) => state,
+            Err(e) => {
+                eprintln!("error on get state: {:?}", e);
+                return ERR.to_string();
+            }
+        };
+        let state = if on { "ON" } else { "OFF" };
+        format!("PowerSocket[ {} : {:02.1} ]", state, power)
+    }
+}
+
+trait PowerSocketHandle: Debug {
+    fn is_on(&self) -> Result<bool, std::io::Error>;
+
+    fn set_on(&mut self, on: bool) -> Result<(), std::io::Error>;
+
+    fn get_power(&self) -> Result<f32, std::io::Error>;
+}
+
+#[derive(Debug)]
+struct PowerSocketStub {
+    power_rate: f32,
+    on: bool,
+}
+
+impl PowerSocketStub {
+    pub fn new(power_rate: f32, on: bool) -> Self {
+        Self { power_rate, on }
+    }
+}
+
+impl PowerSocketHandle for PowerSocketStub {
+    fn is_on(&self) -> Result<bool, std::io::Error> {
+        Ok(self.on)
+    }
+
+    fn set_on(&mut self, on: bool) -> Result<(), std::io::Error> {
+        self.on = on;
+        Ok(())
+    }
+
+    fn get_power(&self) -> Result<f32, std::io::Error> {
+        Ok(if self.on { self.power_rate } else { 0.0 })
+    }
+}
+
+const TIMEOUT: Duration = Duration::from_secs(5);
+
+#[derive(Debug)]
+struct PowerSocketClient {
+    stream: RefCell<TcpStream>,
+}
+
+impl PowerSocketClient {
+    fn new(addr: &str) -> Result<Self, std::io::Error> {
+        let addr: SocketAddr = addr.parse().map_err(std::io::Error::other)?;
+        let stream = TcpStream::connect_timeout(&addr, TIMEOUT)?;
+        stream.set_write_timeout(Some(TIMEOUT))?;
+        stream.set_read_timeout(Some(TIMEOUT))?;
+        Ok(Self { stream: RefCell::new(stream) })
+    }
+}
+
+const CMD_GET_ON: u8 = 1;
+const CMD_TURN_ON: u8 = 2;
+const CMD_TURN_OFF: u8 = 3;
+const CMD_GET_POWER: u8 = 4;
+
+impl PowerSocketHandle for PowerSocketClient {
+    fn is_on(&self) -> Result<bool, std::io::Error> {
+        let mut buf = [CMD_GET_ON; 1];
+        self.stream
+            .borrow_mut()
+            .write_all(&buf)
+            .map_err(|e| std::io::Error::other(format!("CMD_GET_ON request error: {:?}", e)))?;
+        self.stream
+            .borrow_mut()
+            .read_exact(&mut buf)
+            .map_err(|e| std::io::Error::other(format!("CMD_GET_ON response error: {:?}", e)))?;
+        Ok(!matches!(buf, [0]))
+    }
+
+    fn set_on(&mut self, on: bool) -> Result<(), std::io::Error> {
+        let cmd = if on { CMD_TURN_ON } else { CMD_TURN_OFF };
+        let mut buf = [cmd; 1];
+        self.stream
+            .borrow_mut()
+            .write_all(&buf)
+            .map_err(|e| std::io::Error::other(format!("change state request error: {:?}", e)))?;
+        self.stream
+            .borrow_mut()
+            .read_exact(&mut buf)
+            .map_err(|e| std::io::Error::other(format!("change state response error: {:?}", e)))?;
+        Ok(())
+    }
+
+    fn get_power(&self) -> Result<f32, std::io::Error> {
+        let mut buf = [CMD_GET_POWER; 4];
+        self.stream
+            .borrow_mut()
+            .write_all(&buf[0..1])
+            .map_err(|e| std::io::Error::other(format!("CMD_GET_POWER request error: {:?}", e)))?;
+        self.stream
+            .borrow_mut()
+            .read_exact(&mut buf)
+            .map_err(|e| std::io::Error::other(format!("CMD_GET_POWER response error: {:?}", e)))?;
+        Ok(f32::from_le_bytes(buf))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn smoke_test() {
+        let mut power_socket = PowerSocket::stub(12.4, false);
+        assert!(!power_socket.is_on().unwrap());
+        assert_eq!(power_socket.get_power().unwrap(), 0.0);
+
+        power_socket.set_on(true).unwrap();
+        assert!(power_socket.is_on().unwrap());
+        assert_eq!(power_socket.get_power().unwrap(), 12.4);
+    }
+
+    #[test]
+    fn display_test() {
+        assert_eq!(format!("{}", PowerSocket::stub(11.549, false).display()), "PowerSocket[ OFF : 0.0 ]");
+        assert_eq!(format!("{}", PowerSocket::stub(11.549, true).display()), "PowerSocket[ ON : 11.5 ]");
+        assert_eq!(format!("{}", PowerSocket::stub(11.550, true).display()), "PowerSocket[ ON : 11.6 ]");
+    }
+}

smart-house/house/src/print_status.rs

@@ -0,0 +1,9 @@
+pub trait PrintStatus {
+    fn print_status_into(&self, out: &mut dyn std::io::Write) -> Result<(), std::io::Error>;
+
+    fn print_status(&self) {
+        if let Err(e) = self.print_status_into(&mut std::io::stdout()) {
+            eprintln!("Unexpected print error: {:?}", e);
+        }
+    }
+}

smart-house/house/src/reporter.rs

@@ -0,0 +1,30 @@
+use crate::PrintStatus;
+
+pub struct Reporter<'a> {
+    reportables: Vec<&'a dyn PrintStatus>,
+}
+
+impl<'a> Reporter<'a> {
+    pub fn new() -> Self {
+        Self { reportables: Vec::new() }
+    }
+
+    pub fn add_reportable<T: PrintStatus>(mut self, reportable: &'a T) -> Self {
+        self.reportables.push(reportable);
+        self
+    }
+
+    pub fn report(&self) {
+        println!("{}", "=".repeat(16));
+        for reportable in &self.reportables {
+            reportable.print_status();
+            println!("\n{}", "=".repeat(16));
+        }
+    }
+}
+
+impl<'a> Default for Reporter<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

smart-house/house/src/room.rs

@@ -0,0 +1,126 @@
+use crate::{Device, PrintStatus, Subscriber};
+use std::collections::HashMap;
+use std::fmt::{Debug, Formatter};
+use std::io::Write;
+
+pub struct Room {
+    devices: HashMap<String, Device>,
+    subscribers: Vec<Box<dyn Subscriber>>,
+}
+
+impl Room {
+    pub fn new(devices: HashMap<String, Device>) -> Self {
+        Self {
+            devices,
+            subscribers: Vec::new(),
+        }
+    }
+
+    pub fn get_device(&self, name: &str) -> Option<&Device> {
+        self.devices.get(name)
+    }
+
+    pub fn get_device_mut(&mut self, name: &str) -> Option<&mut Device> {
+        self.devices.get_mut(name)
+    }
+
+    pub fn insert_device(&mut self, name: &str, device: Device) -> Option<Device> {
+        for subscriber in &mut self.subscribers {
+            subscriber.on_event(&device);
+        }
+        self.devices.insert(name.to_string(), device)
+    }
+
+    pub fn remove_device(&mut self, name: &str) -> Option<Device> {
+        self.devices.remove(name)
+    }
+
+    pub fn subscribe(&mut self, subscriber: impl Subscriber + 'static) {
+        self.subscribers.push(Box::new(subscriber));
+    }
+}
+
+impl PrintStatus for Room {
+    fn print_status_into(&self, out: &mut dyn Write) -> Result<(), std::io::Error> {
+        for (name, device) in self.devices.iter() {
+            out.write_fmt(format_args!("{} => ", name))?;
+            device.print_status_into(out)?;
+        }
+        Ok(())
+    }
+}
+
+impl Debug for Room {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Room")
+            .field("devices", &self.devices)
+            .field("subscribers.len()", &self.subscribers.len())
+            .finish()
+    }
+}
+
+impl Default for Room {
+    fn default() -> Self {
+        Room::new(HashMap::new())
+    }
+}
+
+#[macro_export]
+macro_rules! room {
+    ($($key:expr => $dev:expr),* $(,)?) => {
+        Room::new([$(
+            ($key.to_string(), $dev.into()),
+        )*].into_iter().collect())
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{PowerSocket, Thermometer};
+
+    fn create_test_room() -> Room {
+        room!(
+            "PSoc" => PowerSocket::stub(12.34, false),
+            "Therm" => Thermometer::stub(21.56),
+        )
+    }
+
+    #[test]
+    fn smoke_test() {
+        let mut room = create_test_room();
+        assert_eq!(room.devices.len(), 2);
+        room.print_status();
+
+        assert_eq!(format!("{}", room.get_device("PSoc").unwrap().display()), "DEV:PowerSocket[ OFF : 0.0 ]");
+        assert_eq!(format!("{}", room.get_device("Therm").unwrap().display()), "DEV:Thermometer[ 21.6 ]");
+
+        let Device::PowerSocket(power_socket) = room.get_device_mut("PSoc").unwrap() else {
+            unreachable!()
+        };
+        power_socket.set_on(true).unwrap();
+
+        assert_eq!(format!("{}", room.get_device("PSoc").unwrap().display()), "DEV:PowerSocket[ ON : 12.3 ]");
+        assert_eq!(format!("{}", room.get_device("Therm").unwrap().display()), "DEV:Thermometer[ 21.6 ]");
+    }
+
+    #[test]
+    fn check_out_of_bounds() {
+        let room = create_test_room();
+        assert!(room.get_device("dummy").is_none());
+    }
+
+    #[test]
+    fn test_add_remove() {
+        let mut room = create_test_room();
+        let result = room.insert_device("NewTerm", Thermometer::stub(20.0).into());
+        assert!(result.is_none());
+        assert_eq!(room.devices.len(), 3);
+
+        let Some(Device::Thermometer(removed)) = room.remove_device("Therm") else {
+            unreachable!()
+        };
+        assert_eq!(removed.get_temperature().unwrap(), 21.56);
+        assert_eq!(room.devices.len(), 2);
+    }
+}

smart-house/house/src/subscriber.rs

@@ -0,0 +1,14 @@
+use crate::Device;
+
+pub trait Subscriber {
+    fn on_event(&mut self, device: &Device);
+}
+
+impl<F> Subscriber for F
+where
+    F: Fn(&Device),
+{
+    fn on_event(&mut self, value: &Device) {
+        self(value)
+    }
+}

smart-house/house/src/thermometer.rs

@@ -0,0 +1,121 @@
+use std::fmt::{Debug, Display};
+use std::net::UdpSocket;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::time::Duration;
+
+#[derive(Debug)]
+pub struct Thermometer {
+    handle: Box<dyn ThermometerHandle>,
+}
+
+impl Thermometer {
+    pub fn stub(temperature: f32) -> Self {
+        Self {
+            handle: Box::new(ThermometerHandleStub::new(temperature)),
+        }
+    }
+
+    pub fn connect(addr: &str) -> std::io::Result<Self> {
+        let handle = ThermometerClient::new(addr)?;
+        Ok(Self { handle: Box::new(handle) })
+    }
+
+    pub fn get_temperature(&self) -> Result<f32, std::io::Error> {
+        self.handle.get_temperature()
+    }
+
+    pub fn display(&self) -> impl Display {
+        let output = self.get_temperature();
+        match output {
+            Ok(v) => format!("Thermometer[ {:02.1} ]", v),
+            Err(e) => {
+                eprintln!("error fetching temperature: {:?}", e);
+                "Thermometer[ ERR ]".to_string()
+            }
+        }
+    }
+}
+
+trait ThermometerHandle: Debug {
+    fn get_temperature(&self) -> Result<f32, std::io::Error>;
+}
+
+#[derive(Debug)]
+struct ThermometerHandleStub {
+    temperature: f32,
+}
+
+impl ThermometerHandleStub {
+    fn new(temperature: f32) -> Self {
+        Self { temperature }
+    }
+}
+
+impl ThermometerHandle for ThermometerHandleStub {
+    fn get_temperature(&self) -> Result<f32, std::io::Error> {
+        Ok(self.temperature)
+    }
+}
+
+const TIMEOUT: Duration = Duration::from_secs(5);
+
+#[derive(Debug)]
+struct ThermometerClient {
+    value: Arc<AtomicU32>,
+}
+
+impl ThermometerClient {
+    fn read(socket: &UdpSocket) -> std::io::Result<u32> {
+        let mut buf = [0u8; 4];
+        let result = socket.recv_from(&mut buf);
+        result.map(|_| Ok(u32::from_le_bytes(buf)))?
+    }
+
+    fn new(addr: &str) -> std::io::Result<Self> {
+        let value = Arc::new(AtomicU32::new(u32::from_le_bytes(f32::NAN.to_le_bytes())));
+        let socket = UdpSocket::bind(addr)?;
+        socket.set_read_timeout(Some(TIMEOUT))?;
+
+        let data = ThermometerClient::read(&socket)?;
+        value.store(data, Ordering::Relaxed);
+
+        let weak_value = Arc::downgrade(&value);
+        std::thread::spawn(move || {
+            while let Some(value) = weak_value.upgrade() {
+                let result = ThermometerClient::read(&socket);
+                match result {
+                    Ok(data) => value.store(data, Ordering::Relaxed),
+                    Err(e) => {
+                        eprintln!("receiving data failed: {:?}", e);
+                        break;
+                    }
+                };
+            }
+        });
+        Ok(Self { value })
+    }
+}
+
+impl ThermometerHandle for ThermometerClient {
+    fn get_temperature(&self) -> Result<f32, std::io::Error> {
+        Ok(f32::from_le_bytes(self.value.load(Ordering::Relaxed).to_le_bytes()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn smoke_test() {
+        let thermometer = Thermometer::stub(20.0);
+        assert_eq!(thermometer.get_temperature().unwrap(), 20.0);
+    }
+
+    #[test]
+    fn display_test() {
+        assert_eq!(format!("{}", Thermometer::stub(19.550).display()), "Thermometer[ 19.5 ]");
+        assert_eq!(format!("{}", Thermometer::stub(19.551).display()), "Thermometer[ 19.6 ]");
+    }
+}