Move lights and info tasks to module

backend/src/tasks/lights.rs

@@ -0,0 +1,63 @@
+use common::{ClientMessage, ServerMessage};
+use lighter_manager::manager::{BulbCommand, BulbManager, BulbSelector};
+use tokio::select;
+use tokio::time::{sleep, Duration};
+
+use crate::State;
+
+pub async fn lights_task(state: &State) {
+    let config = &state.config;
+    let server_message = &state.server_message;
+    let mut client_message = state.client_message.subscribe();
+
+    let (cmd, bulb_states) = BulbManager::launch(config.bulbs.clone(), config.mqtt.clone())
+        .await
+        .expect("Failed to launch bulb manager");
+
+    loop {
+        let notify = bulb_states.notify_on_change();
+        sleep(Duration::from_millis(1000 / 10)).await; // limit to 10 updates/second
+        select! {
+            _ = notify => {
+                for (id, mode) in bulb_states.bulbs().await.clone().into_iter() {
+                    if let Err(e) = server_message.send(ServerMessage::BulbMode { id, mode }) {
+                        error!("broadcast channel error: {e}");
+                        return;
+                    }
+                }
+            }
+            request = client_message.recv() => {
+                let request = match request {
+                    Ok(r) => r,
+                    Err(_) => continue,
+                };
+
+                match request.message {
+                    ClientMessage::SetBulbColor { id, color } =>  {
+                        if let Err(e) = cmd.send(BulbCommand::SetColor(BulbSelector::Id(id), color)).await {
+                            error!("bulb manager error: {e}");
+                        }
+                    }
+                    ClientMessage::SetBulbPower { id, power } =>  {
+                        if let Err(e) = cmd.send(BulbCommand::SetPower(BulbSelector::Id(id), power)).await {
+                            error!("bulb manager error: {e}");
+                        }
+                    }
+                    ClientMessage::GetBulbs => {
+                        if let Err(e) = request.response.send(ServerMessage::BulbMap(config.bulb_map.clone())).await {
+                            error!("GetBulbs response channel error: {e}");
+                            return;
+                        }
+                        for (id, mode) in bulb_states.bulbs().await.clone().into_iter() {
+                            if let Err(e) = request.response.send(ServerMessage::BulbMode { id, mode }).await {
+                                error!("GetBulbs response channel error: {e}");
+                                return;
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}