edit ids that are already mapped

closes #18

.gitignore

@@ -1 +1,2 @@
 /target
+/build

Cargo.lock

@@ -41,6 +41,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+
 [[package]]
 name = "async-stream"
 version = "0.3.6"
@@ -419,6 +425,7 @@ dependencies = [
 name = "fw-anwesenheit"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "chrono",
  "gpio",
  "log",

Cargo.toml

@@ -22,4 +22,5 @@ rppal = { version = "0.22.1", features = ["hal"] }
 smart-leds = "0.3"
 ws2812-spi = "0.3"
 rgb = "0.8.50"
+anyhow = "1.0.98"
 

Makefile

@@ -0,0 +1,61 @@
+PACKAGE_NAME := fwa
+VERSION := 1.0
+ARCH := armhf
+BUILD_DIR := build
+DEB_DIR := $(BUILD_DIR)/$(PACKAGE_NAME)-$(VERSION)
+BIN_DIR := $(DEB_DIR)/usr/local/bin
+SERVICE_DIR := $(DEB_DIR)/lib/systemd/system
+CONFIG_DIR := $(DEB_DIR)/etc
+PM3_DIR := $(DEB_DIR)/usr/share/pm3
+
+.PHONY: all build clean package prepare_package
+	
+all: package
+
+build: $(BUILD_DIR)/fwa 
+
+$(BUILD_DIR)/fwa: web/dist
+	cross build --release --target arm-unknown-linux-gnueabihf
+	cp ./target/arm-unknown-linux-gnueabihf/release/fw-anwesenheit $@
+
+prepare_package: $(DEB_DIR)/DEBIAN $(BIN_DIR)/fwa
+	mkdir -p $(SERVICE_DIR)
+	cp ./service/fwa.service $(SERVICE_DIR)/
+	cp ./service/fwa-fail.service $(SERVICE_DIR)/
+
+	mkdir -p $(CONFIG_DIR)
+	cp ./service/fwa.env $(CONFIG_DIR)/
+
+	mkdir -p $(PM3_DIR)
+	cp -r ./pre-compiled/* $(PM3_DIR)/
+
+	mkdir -p $(DEB_DIR)/var/lib/fwa/
+
+$(BIN_DIR)/fwa: $(BUILD_DIR)/fwa
+	mkdir -p $(BIN_DIR)
+	cp $< $@
+
+
+$(DEB_DIR)/DEBIAN:
+	mkdir -p $(DEB_DIR)/DEBIAN
+	echo "Package: $(PACKAGE_NAME)" > $(DEB_DIR)/DEBIAN/control
+	echo "Version: $(VERSION)" >> $(DEB_DIR)/DEBIAN/control
+	echo "Section: utils" >> $(DEB_DIR)/DEBIAN/control
+	echo "Priority: optional" >> $(DEB_DIR)/DEBIAN/control
+	echo "Architecture: $(ARCH)" >> $(DEB_DIR)/DEBIAN/control
+	echo "Depends: libc6 (>= 2.28)" >> $(DEB_DIR)/DEBIAN/control
+	echo "Maintainer: Niklas Kapelle <niklas@kapelle.org>" >> $(DEB_DIR)/DEBIAN/control
+	echo "Description: Feuerwehr anwesenheit" >> $(DEB_DIR)/DEBIAN/control
+
+	echo "/etc/fwa.env" > $(DEB_DIR)/DEBIAN/conffiles
+
+web/dist:
+	(cd web && npm run build)
+
+package: prepare_package
+	dpkg-deb --build $(DEB_DIR)
+
+clean:
+	cargo clean
+	rm -rf web/dist
+	rm -rf $(BUILD_DIR)

README.md

@@ -9,6 +9,10 @@ I²C fpr RTC `sudo raspi-config` -> interface -> enable I²C
 
 # Config 
 
+Flags:
+
+`--error` or `-e`: Enters error state. The LED turns red and the hotspot is activated. This state gets called from systemd if the service is in a failure state.
+
 Environment variables:
 
 - `PM3_BIN`: Path to the pm3 binary. Seach in path if not set. Can also be set to the `pm3_mock.sh` for testing.
@@ -18,3 +22,11 @@ Environment variables:
 - `HOTSPOT_SSID`: Set the hotspot ssid. Defaults to "fwa".
 - `HOTSPOT_PW`: Set the hotspot password. Default to "a9LG2kUVrsRRVUo1". Recommended to change.
 
+Systemd:
+
+The service is run as a systemd service. There are two service `fwa.service` and `fwa-fail.service`. They read their config 
+from a env file located at `/etc/fwa.env`. See example [env file](service/fwa.env).
+
+# Building
+
+Run `make package` to create `.deb` file. [Cross](https://github.com/cross-rs/cross) is used for building the rust code.

service/fwa-fail.service

@@ -0,0 +1,19 @@
+[Unit]
+Description=Failure state for fwa.service
+Requires=local-fs.target
+After=local-fs.target
+StartLimitIntervalSec=500
+StartLimitBurst=5
+
+[Service]
+Type=simple
+ExecStart=/usr/local/bin/fwa --error
+Restart=on-failure
+RestartSec=5
+User=root
+Group=root
+WorkingDirectory=/var/lib/fwa
+EnvironmentFile=/etc/fwa.env
+
+[Install]
+WantedBy=multi-user.target

service/fwa.env

@@ -0,0 +1,5 @@
+PM3_BIN=/usr/share/pm3/pm3
+LOG_LEVEL=warn
+HOTSPOT_IDS=578B5DF2;c1532b57
+HOTSPOT_SSID=fwa
+HOTSPOT_PW=a9LG2kUVrsRRVUo1

service/fwa.service

@@ -4,6 +4,7 @@ Requires=local-fs.target
 After=local-fs.target
 StartLimitIntervalSec=500
 StartLimitBurst=5
+OnFailure= fwa-fail.service
 
 [Service]
 Type=simple
@@ -12,13 +13,8 @@ Restart=on-failure
 RestartSec=5
 User=root
 Group=root
-RuntimeDirectory=/var/lib/fwa
-
-Environment="PM3_BIN=/usr/local/bin/pm3/pm3"
-#Environment="LOG_LEVEL=warn"
-#Environment="HOTSPOT_IDS=578B5DF2;c1532b57"
-#Environment="HOTSPOT_SSID=fwa"
-#Environment="HOTSPOT_PW=a9LG2kUVrsRRVUo1"
+WorkingDirectory=/var/lib/fwa
+EnvironmentFile=/etc/fwa.env
 
 [Install]
 WantedBy=multi-user.target

src/buzzer.rs

@@ -1,61 +0,0 @@
-use rppal::pwm::{Channel, Error, Polarity, Pwm};
-use std::{future::Future, time::Duration};
-use tokio::time::sleep;
-
-pub trait Buzzer {
-    fn beep_ack(&mut self) -> impl Future<Output = Result<(), Error>> + std::marker::Send;
-
-    fn beep_nak(&mut self) -> impl Future<Output = Result<(), Error>> + std::marker::Send;
-}
-
-pub struct GPIOBuzzer {
-    pwm: Pwm,
-}
-
-impl GPIOBuzzer {
-    /// Create a new GPIOBuzzer instance.
-    /// 0.5 duty cyle
-    /// # Arguments
-    /// * "channel" - PWM channel for buzzer PWM0 = GPIO 12 / PWM1 = GPIO 13
-    pub fn new(channel: Channel) -> Result<Self, Error> {
-        // Enable with dummy values; we'll set frequency/duty in the tone method
-        let duty_cycle: f64 = 0.5;
-        let pwm = Pwm::with_frequency(channel, 1000.0, duty_cycle, Polarity::Normal, true)?;
-        pwm.disable()?; // Start disabled
-
-        Ok(GPIOBuzzer { pwm })
-    }
-
-    /// Play a tone using hardware PWM on supported GPIO pins.
-    ///
-    /// # Arguments
-    /// * `frequency` - Frequency in Hz.
-    /// * `duration_ms` - Duration in milliseconds.
-    async fn modulated_tone(&mut self, frequency: f64, duration_ms: u64) -> Result<(), Error> {
-        self.pwm.set_frequency(frequency, 0.5)?; // 50% duty cycle (square wave)
-        self.pwm.enable()?;
-        sleep(Duration::from_millis(duration_ms)).await;
-        self.pwm.disable()?;
-        Ok(())
-    }
-}
-
-impl Buzzer for GPIOBuzzer {
-    async fn beep_ack(&mut self) -> Result<(), Error> {
-        let sleep_ms: u64 = 10;
-
-        self.modulated_tone(1200.0, 100).await?;
-        sleep(Duration::from_millis(sleep_ms)).await;
-        self.modulated_tone(2000.0, 50).await?;
-        Ok(())
-    }
-
-    async fn beep_nak(&mut self) -> Result<(), Error> {
-        let sleep_ms: u64 = 100;
-
-        self.modulated_tone(600.0, 150).await?;
-        sleep(Duration::from_millis(sleep_ms)).await;
-        self.modulated_tone(600.0, 150).await?;
-        Ok(())
-    }
-}

src/color.rs

@@ -1,56 +0,0 @@
-use rgb::Rgb;
-
-#[derive(Debug)]
-pub enum NamedColor {
-    Red,
-    Green,
-    Blue,
-    White,
-    Off,
-    Yellow,
-    Cyan,
-    Magenta,
-}
-
-impl Into<Rgb<u8>> for NamedColor {
-    fn into(self) -> Rgb<u8> {
-        match self {
-            NamedColor::Red => Rgb { r: 150, g: 0, b: 0 },
-            NamedColor::Green => Rgb { r: 0, g: 150, b: 0 },
-            NamedColor::Blue => Rgb { r: 0, g: 0, b: 150 },
-            NamedColor::White => Rgb {
-                r: 255,
-                g: 255,
-                b: 255,
-            },
-            NamedColor::Off => Rgb { r: 0, g: 0, b: 0 },
-            NamedColor::Yellow => Rgb {
-                r: 255,
-                g: 255,
-                b: 0,
-            },
-            NamedColor::Cyan => Rgb {
-                r: 0,
-                g: 255,
-                b: 255,
-            },
-            NamedColor::Magenta => Rgb {
-                r: 255,
-                g: 0,
-                b: 255,
-            },
-        }
-    }
-}
-
-
-impl IntoIterator for NamedColor {
-    type Item = Self;
-
-    type IntoIter = std::vec::IntoIter<Self>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        vec![self].into_iter()
-    }
-}
-

src/feedback.rs

@@ -0,0 +1,181 @@
+use anyhow::Result;
+use log::error;
+use rgb::RGB8;
+use smart_leds::colors::{GREEN, RED};
+use std::time::Duration;
+use tokio::{join, time::sleep};
+
+use crate::hardware::{Buzzer, StatusLed};
+
+#[cfg(not(feature = "mock_pi"))]
+use crate::{hardware::GPIOBuzzer, hardware::SpiLed};
+
+#[cfg(feature = "mock_pi")]
+use crate::hardware::{MockBuzzer, MockLed};
+
+const LED_BLINK_DURATION: Duration = Duration::from_secs(1);
+
+pub enum DeviceStatus {
+    NotReady,
+    Ready,
+    HotspotEnabled,
+}
+
+impl DeviceStatus {
+    pub fn color(&self) -> RGB8 {
+        match self {
+            Self::NotReady => RGB8::new(0, 0, 0),
+            Self::Ready => RGB8::new(0, 50, 0),
+            Self::HotspotEnabled => RGB8::new(0, 0, 50),
+        }
+    }
+}
+pub struct Feedback<B: Buzzer, L: StatusLed> {
+    device_status: DeviceStatus,
+    buzzer: B,
+    led: L,
+}
+
+impl<B: Buzzer, L: StatusLed> Feedback<B, L> {
+    pub async fn success(&mut self) {
+        let buzzer_handle = Self::beep_ack(&mut self.buzzer);
+        let led_handle = Self::flash_led_for_duration(&mut self.led, GREEN, LED_BLINK_DURATION);
+        let (buzzer_result, _) = join!(buzzer_handle, led_handle);
+
+        buzzer_result.unwrap_or_else(|err| {
+            error!("Failed to buzz: {err}");
+        });
+
+        let _ = self.led_to_status();
+    }
+
+    pub async fn failure(&mut self) {
+        let buzzer_handle = Self::beep_nak(&mut self.buzzer);
+        let led_handle = Self::flash_led_for_duration(&mut self.led, RED, LED_BLINK_DURATION);
+
+        let (buzzer_result, _) = join!(buzzer_handle, led_handle);
+
+        buzzer_result.unwrap_or_else(|err| {
+            error!("Failed to buzz: {err}");
+        });
+
+        let _ = self.led_to_status();
+    }
+
+    pub async fn activate_error_state(&mut self) -> Result<()> {
+        self.led.turn_on(RED)?;
+        Self::beep_nak(&mut self.buzzer).await?;
+        Ok(())
+    }
+
+    pub async fn startup(&mut self){
+        self.device_status = DeviceStatus::Ready;
+
+        let led_handle = Self::flash_led_for_duration(&mut self.led, GREEN, Duration::from_secs(1));
+        let buzzer_handle = Self::beep_startup(&mut self.buzzer);
+
+        let (buzzer_result, led_result) = join!(buzzer_handle, led_handle);
+
+        buzzer_result.unwrap_or_else(|err| {
+            error!("Failed to buzz: {err}");
+        });
+
+        led_result.unwrap_or_else(|err| {
+            error!("Failed to blink led: {err}");
+        });
+
+        let _ = self.led_to_status();
+    }
+
+    pub fn set_device_status(&mut self, status: DeviceStatus){
+        self.device_status = status;
+        let _ = self.led_to_status();
+    }
+
+    fn led_to_status(&mut self) -> Result<()> {
+        self.led.turn_on(self.device_status.color())
+    }
+
+    async fn flash_led_for_duration(led: &mut L, color: RGB8, duration: Duration) -> Result<()> {
+        led.turn_on(color)?;
+
+        sleep(duration).await;
+
+        led.turn_off()?;
+
+        Ok(())
+    }
+
+    async fn beep_ack(buzzer: &mut B) -> Result<()> {
+        buzzer
+            .modulated_tone(1200.0, Duration::from_millis(100))
+            .await?;
+        sleep(Duration::from_millis(10)).await;
+        buzzer
+            .modulated_tone(2000.0, Duration::from_millis(50))
+            .await?;
+        Ok(())
+    }
+
+    async fn beep_nak(buzzer: &mut B) -> Result<()> {
+        buzzer
+            .modulated_tone(600.0, Duration::from_millis(150))
+            .await?;
+        sleep(Duration::from_millis(100)).await;
+        buzzer
+            .modulated_tone(600.0, Duration::from_millis(150))
+            .await?;
+        Ok(())
+    }
+
+    async fn beep_startup(buzzer: &mut B) -> Result<()> {
+        buzzer
+            .modulated_tone(523.0, Duration::from_millis(150))
+            .await?;
+        buzzer
+            .modulated_tone(659.0, Duration::from_millis(150))
+            .await?;
+        buzzer
+            .modulated_tone(784.0, Duration::from_millis(150))
+            .await?;
+        buzzer
+            .modulated_tone(1046.0, Duration::from_millis(200))
+            .await?;
+
+        sleep(Duration::from_millis(100)).await;
+
+        buzzer
+            .modulated_tone(784.0, Duration::from_millis(100))
+            .await?;
+        buzzer
+            .modulated_tone(880.0, Duration::from_millis(200))
+            .await?;
+        Ok(())
+    }
+}
+
+#[cfg(feature = "mock_pi")]
+pub type FeedbackImpl = Feedback<MockBuzzer, MockLed>;
+#[cfg(not(feature = "mock_pi"))]
+pub type FeedbackImpl = Feedback<GPIOBuzzer, SpiLed>;
+
+impl FeedbackImpl {
+    pub fn new() -> Result<Self> {
+        #[cfg(feature = "mock_pi")]
+        {
+            Ok(Feedback {
+                device_status: DeviceStatus::NotReady,
+                buzzer: MockBuzzer {},
+                led: MockLed {},
+            })
+        }
+        #[cfg(not(feature = "mock_pi"))]
+        {
+            Ok(Feedback {
+                device_status: DeviceStatus::NotReady,
+                buzzer: GPIOBuzzer::new_default()?,
+                led: SpiLed::new()?,
+            })
+        }
+    }
+}

src/hardware/gpio_buzzer.rs

@@ -0,0 +1,37 @@
+use anyhow::Result;
+use rppal::pwm::{Channel, Polarity, Pwm};
+use std::time::Duration;
+use tokio::time::sleep;
+
+use crate::hardware::Buzzer;
+
+const DEFAULT_PWM_CHANNEL_BUZZER: Channel = Channel::Pwm0; //PWM0 = GPIO18/Physical pin 12
+
+pub struct GPIOBuzzer {
+    pwm: Pwm,
+}
+
+impl GPIOBuzzer {
+    pub fn new_from_channel(channel: Channel) -> Result<Self, rppal::pwm::Error> {
+        // Enable with dummy values; we'll set frequency/duty in the tone method
+        let duty_cycle: f64 = 0.5;
+        let pwm = Pwm::with_frequency(channel, 1000.0, duty_cycle, Polarity::Normal, true)?;
+        pwm.disable()?;
+
+        Ok(GPIOBuzzer { pwm })
+    }
+
+    pub fn new_default() -> Result<Self, rppal::pwm::Error> {
+        Self::new_from_channel(DEFAULT_PWM_CHANNEL_BUZZER)
+    }
+}
+
+impl Buzzer for GPIOBuzzer {
+    async fn modulated_tone(&mut self, frequency_hz: f64, duration: Duration) -> Result<()> {
+        self.pwm.set_frequency(frequency_hz, 0.5)?; // 50% duty cycle (square wave)
+        self.pwm.enable()?;
+        sleep(duration).await;
+        self.pwm.disable()?;
+        Ok(())
+    }
+}

src/hardware/hotspot.rs

@@ -1,54 +1,15 @@
-use log::{error, trace, warn};
-use std::{
-    env,
-    fmt::{self},
-    process::Output,
-};
+use anyhow::{Result, anyhow};
+use log::{trace, warn};
+use std::env;
 use tokio::process::Command;
 
+use crate::hardware::Hotspot;
+
 const SSID: &str = "fwa";
 const CON_NAME: &str = "fwa-hotspot";
 const PASSWORD: &str = "a9LG2kUVrsRRVUo1";
 const IPV4_ADDRES: &str = "192.168.4.1/24";
 
-#[derive(Debug)]
-pub enum HotspotError {
-    IoError(std::io::Error),
-    NonZeroExit(Output),
-    PasswordToShort,
-}
-
-impl fmt::Display for HotspotError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            HotspotError::IoError(err) => {
-                write!(f, "Failed to run hotspot command. I/O error: {err}")
-            }
-            HotspotError::NonZeroExit(output) => {
-                let stdout = String::from_utf8_lossy(&output.stdout);
-                let stderr = String::from_utf8_lossy(&output.stderr);
-                write!(
-                    f,
-                    "Failed to run hotspot command.\nStdout: {stdout}\nStderr: {stderr}",
-                )
-            }
-            HotspotError::PasswordToShort => {
-                write!(f, "The password must be at leat 8 characters long")
-            }
-        }
-    }
-}
-
-impl std::error::Error for HotspotError {}
-
-pub trait Hotspot {
-    fn enable_hotspot(
-        &self,
-    ) -> impl std::future::Future<Output = Result<(), HotspotError>> + std::marker::Send;
-
-    async fn disable_hotspot(&self) -> Result<(), HotspotError>;
-}
-
 /// NetworkManager Hotspot
 pub struct NMHotspot {
     ssid: String,
@@ -58,7 +19,7 @@ pub struct NMHotspot {
 }
 
 impl NMHotspot {
-    pub fn new_from_env() -> Result<Self, HotspotError> {
+    pub fn new_from_env() -> Result<Self> {
         let ssid = env::var("HOTSPOT_SSID").unwrap_or(SSID.to_owned());
         let password = env::var("HOTSPOT_PW").unwrap_or_else(|_| {
             warn!("HOTSPOT_PW not set. Using default password");
@@ -66,8 +27,7 @@ impl NMHotspot {
         });
 
         if password.len() < 8 {
-            error!("Hotspot PW is to short");
-            return Err(HotspotError::PasswordToShort);
+            return Err(anyhow!("Hotspot password to short"));
         }
 
         Ok(NMHotspot {
@@ -78,7 +38,7 @@ impl NMHotspot {
         })
     }
 
-    async fn create_hotspot(&self) -> Result<(), HotspotError> {
+    async fn create_hotspot(&self) -> Result<()> {
         let cmd = Command::new("nmcli")
             .args(["device", "wifi", "hotspot"])
             .arg("con-name")
@@ -88,14 +48,13 @@ impl NMHotspot {
             .arg("password")
             .arg(&self.password)
             .output()
-            .await
-            .map_err(HotspotError::IoError)?;
+            .await?;
 
         trace!("nmcli (std): {}", String::from_utf8_lossy(&cmd.stdout));
         trace!("nmcli (err): {}", String::from_utf8_lossy(&cmd.stderr));
 
         if !cmd.status.success() {
-            return Err(HotspotError::NonZeroExit(cmd));
+            return Err(anyhow!("nmcli command had non-zero exit code"));
         }
 
         let cmd = Command::new("nmcli")
@@ -107,24 +66,22 @@ impl NMHotspot {
             .arg("ipv4.addresses")
             .arg(&self.ipv4)
             .output()
-            .await
-            .map_err(HotspotError::IoError)?;
+            .await?;
 
         if !cmd.status.success() {
-            return Err(HotspotError::NonZeroExit(cmd));
+            return Err(anyhow!("nmcli command had non-zero exit code"));
         }
 
         Ok(())
     }
 
     /// Checks if the connection already exists
-    async fn exists(&self) -> Result<bool, HotspotError> {
+    async fn exists(&self) -> Result<bool> {
         let cmd = Command::new("nmcli")
             .args(["connection", "show"])
             .arg(&self.con_name)
             .output()
-            .await
-            .map_err(HotspotError::IoError)?;
+            .await?;
 
         trace!("nmcli (std): {}", String::from_utf8_lossy(&cmd.stdout));
         trace!("nmcli (err): {}", String::from_utf8_lossy(&cmd.stderr));
@@ -134,7 +91,7 @@ impl NMHotspot {
 }
 
 impl Hotspot for NMHotspot {
-    async fn enable_hotspot(&self) -> Result<(), HotspotError> {
+    async fn enable_hotspot(&self) -> Result<()> {
         if !self.exists().await? {
             self.create_hotspot().await?;
         }
@@ -143,32 +100,30 @@ impl Hotspot for NMHotspot {
             .args(["connection", "up"])
             .arg(&self.con_name)
             .output()
-            .await
-            .map_err(HotspotError::IoError)?;
+            .await?;
 
         trace!("nmcli (std): {}", String::from_utf8_lossy(&cmd.stdout));
         trace!("nmcli (err): {}", String::from_utf8_lossy(&cmd.stderr));
 
         if !cmd.status.success() {
-            return Err(HotspotError::NonZeroExit(cmd));
+            return Err(anyhow!("nmcli command had non-zero exit code"));
         }
 
         Ok(())
     }
 
-    async fn disable_hotspot(&self) -> Result<(), HotspotError> {
+    async fn disable_hotspot(&self) -> Result<()> {
         let cmd = Command::new("nmcli")
             .args(["connection", "down"])
             .arg(&self.con_name)
             .output()
-            .await
-            .map_err(HotspotError::IoError)?;
+            .await?;
 
         trace!("nmcli (std): {}", String::from_utf8_lossy(&cmd.stdout));
         trace!("nmcli (err): {}", String::from_utf8_lossy(&cmd.stderr));
 
         if !cmd.status.success() {
-            return Err(HotspotError::NonZeroExit(cmd));
+            return Err(anyhow!("nmcli command had non-zero exit code"));
         }
 
         Ok(())

src/hardware/mock.rs

@@ -0,0 +1,44 @@
+use anyhow::Result;
+use log::debug;
+use std::time::Duration;
+use tokio::time::sleep;
+
+use crate::hardware::{Buzzer, Hotspot, StatusLed};
+
+pub struct MockBuzzer {}
+
+impl Buzzer for MockBuzzer {
+    async fn modulated_tone(&mut self, frequency_hz: f64, duration: Duration) -> Result<()> {
+        debug!("MockBuzzer: modulte tone: {frequency_hz} Hz");
+        sleep(duration).await;
+        Ok(())
+    }
+}
+
+pub struct MockLed {}
+
+impl StatusLed for MockLed {
+    fn turn_off(&mut self) -> Result<()> {
+        debug!("Turn mock LED off");
+        Ok(())
+    }
+
+    fn turn_on(&mut self, color: rgb::RGB8) -> Result<()> {
+        debug!("Turn mock LED on to: {color}");
+        Ok(())
+    }
+}
+
+pub struct MockHotspot {}
+
+impl Hotspot for MockHotspot {
+    async fn enable_hotspot(&self) -> Result<()> {
+        debug!("Mockhotspot: Enable hotspot");
+        Ok(())
+    }
+
+    async fn disable_hotspot(&self) -> Result<()> {
+        debug!("Mockhotspot: Disable hotspot");
+        Ok(())
+    }
+}

src/hardware/mod.rs

@@ -0,0 +1,45 @@
+use anyhow::Result;
+use std::time::Duration;
+
+mod gpio_buzzer;
+mod hotspot;
+mod mock;
+mod spi_led;
+
+pub use gpio_buzzer::GPIOBuzzer;
+pub use mock::{MockBuzzer, MockHotspot, MockLed};
+pub use spi_led::SpiLed;
+
+pub trait StatusLed {
+    fn turn_off(&mut self) -> Result<()>;
+
+    fn turn_on(&mut self, color: rgb::RGB8) -> Result<()>;
+}
+
+pub trait Buzzer {
+    fn modulated_tone(
+        &mut self,
+        frequency_hz: f64,
+        duration: Duration,
+    ) -> impl Future<Output = Result<()>> + std::marker::Send;
+}
+
+pub trait Hotspot {
+    fn enable_hotspot(&self) -> impl std::future::Future<Output = Result<()>> + std::marker::Send;
+
+    fn disable_hotspot(&self) -> impl std::future::Future<Output = Result<()>> + std::marker::Send;
+}
+
+/// Create a struct to manage the hotspot
+/// Respects the `mock_pi` flag.
+pub fn create_hotspot() -> Result<impl Hotspot> {
+    #[cfg(feature = "mock_pi")]
+    {
+        Ok(mock::MockHotspot {})
+    }
+
+    #[cfg(not(feature = "mock_pi"))]
+    {
+        hotspot::NMHotspot::new_from_env()
+    }
+}

src/hardware/spi_led.rs

@@ -0,0 +1,33 @@
+use anyhow::Result;
+use rppal::spi::{Bus, Mode, SlaveSelect, Spi};
+use smart_leds::SmartLedsWrite;
+use ws2812_spi::Ws2812;
+
+use crate::hardware::StatusLed;
+
+const SPI_CLOCK_SPEED: u32 = 3_800_000;
+
+pub struct SpiLed {
+    controller: Ws2812<Spi>,
+}
+
+impl SpiLed {
+    pub fn new() -> Result<Self, rppal::spi::Error> {
+        let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, SPI_CLOCK_SPEED, Mode::Mode0)?;
+        let controller = Ws2812::new(spi);
+        Ok(SpiLed { controller })
+    }
+}
+
+impl StatusLed for SpiLed {
+    fn turn_off(&mut self) -> Result<()> {
+        self.controller
+            .write(vec![rgb::RGB8::new(0, 0, 0)].into_iter())?;
+        Ok(())
+    }
+
+    fn turn_on(&mut self, color: rgb::RGB8) -> Result<()> {
+        self.controller.write(vec![color].into_iter())?;
+        Ok(())
+    }
+}

src/led.rs

@@ -1,53 +0,0 @@
-use std::time::Duration;
-
-use rppal::spi::{Bus, Error, Mode, SlaveSelect, Spi};
-use smart_leds::SmartLedsWrite;
-use tokio::time::sleep;
-use ws2812_spi::Ws2812;
-
-use crate::color::NamedColor;
-
-const STATUS_DURATION: Duration = Duration::from_secs(1); // 1s sleep for all status led signals
-
-pub trait StatusLed {
-    fn turn_green_on_1s(
-        &mut self,
-    ) -> impl std::future::Future<Output = Result<(), Error>> + std::marker::Send;
-
-    fn turn_red_on_1s(
-        &mut self,
-    ) -> impl std::future::Future<Output = Result<(), Error>> + std::marker::Send;
-}
-
-pub struct SpiLed {
-    controller: Ws2812<Spi>,
-}
-
-impl SpiLed {
-    pub fn new() -> Result<Self, Error> {
-        let spi = Spi::new(Bus::Spi0, SlaveSelect::Ss0, 3_800_000, Mode::Mode0)?;
-        let controller = Ws2812::new(spi);
-        Ok(SpiLed { controller })
-    }
-
-    fn turn_off(&mut self) -> Result<(), Error> {
-        self.controller.write(NamedColor::Off.into_iter())?;
-        Ok(())
-    }
-}
-
-impl StatusLed for SpiLed {
-    async fn turn_green_on_1s(&mut self) -> Result<(), Error> {
-        self.controller.write(NamedColor::Green.into_iter())?;
-        sleep(STATUS_DURATION).await;
-        self.turn_off()?;
-        Ok(())
-    }
-
-    async fn turn_red_on_1s(&mut self) -> Result<(), Error> {
-        self.controller.write(NamedColor::Red.into_iter())?;
-        sleep(STATUS_DURATION).await;
-        self.turn_off()?;
-        Ok(())
-    }
-}

src/logger.rs

@@ -0,0 +1,25 @@
+use std::env;
+
+use log::LevelFilter;
+use simplelog::{ConfigBuilder, SimpleLogger};
+
+pub fn setup_logger() {
+    let log_level = env::var("LOG_LEVEL")
+        .ok()
+        .and_then(|level| level.parse::<LevelFilter>().ok())
+        .unwrap_or({
+            if cfg!(debug_assertions) {
+                LevelFilter::Debug
+            } else {
+                LevelFilter::Warn
+            }
+        });
+
+    let config = ConfigBuilder::new()
+        .set_target_level(LevelFilter::Off)
+        .set_location_level(LevelFilter::Off)
+        .set_thread_level(LevelFilter::Off)
+        .build();
+
+    let _ = SimpleLogger::init(log_level, config);
+}

src/main.rs

@@ -1,173 +1,79 @@
-use buzzer::{Buzzer, GPIOBuzzer};
-use hotspot::{Hotspot, HotspotError, NMHotspot};
-use id_store::IDStore;
-use led::{SpiLed, StatusLed};
-use log::{LevelFilter, debug, error, info, warn};
-use pm3::run_pm3;
-use rppal::pwm::Channel;
-use simplelog::{ConfigBuilder, SimpleLogger};
-use std::{env, error::Error, sync::Arc};
+#![allow(dead_code)]
+
+use anyhow::Result;
+use feedback::{Feedback, FeedbackImpl};
+use log::{error, info, warn};
+use std::{
+    env::{self, args},
+    sync::Arc,
+    time::Duration,
+};
 use tally_id::TallyID;
 use tokio::{
-    fs, join,
-    sync::{Mutex, broadcast, mpsc},
+    fs,
+    signal::unix::{SignalKind, signal},
+    sync::{
+        Mutex,
+        broadcast::{self, Receiver, Sender},
+    },
+    try_join,
 };
 use webserver::start_webserver;
 
-#[cfg(feature = "mock_pi")]
-use mock::{MockBuzzer, MockHotspot, MockLed};
+use crate::{hardware::{create_hotspot, Hotspot}, pm3::run_pm3, store::IDStore, webserver::{spawn_idle_watcher, ActivityNotifier}};
 
-mod buzzer;
-mod color;
-mod hotspot;
-mod id_mapping;
-mod id_store;
-mod led;
-mod mock;
-mod parser;
+mod feedback;
+mod hardware;
 mod pm3;
+mod logger;
 mod tally_id;
 mod webserver;
+mod store;
 
 const STORE_PATH: &str = "./data.json";
-const PWM_CHANNEL_BUZZER: Channel = Channel::Pwm0; //PWM0 = GPIO18/Physical pin 12
 
-fn setup_logger() {
-    let log_level = env::var("LOG_LEVEL")
-        .ok()
-        .and_then(|level| level.parse::<LevelFilter>().ok())
-        .unwrap_or({
-            if cfg!(debug_assertions) {
-                LevelFilter::Debug
-            } else {
-                LevelFilter::Warn
-            }
-        });
-
-    let config = ConfigBuilder::new()
-        .set_target_level(LevelFilter::Off)
-        .set_location_level(LevelFilter::Off)
-        .set_thread_level(LevelFilter::Off)
-        .build();
-
-    let _ = SimpleLogger::init(log_level, config);
-}
-
-/// Signal the user success via buzzer and led
-async fn feedback_success<T: Buzzer, I: StatusLed>(
-    gpio_buzzer: &Arc<Mutex<T>>,
-    status_led: &Arc<Mutex<I>>,
-) {
-    let mut buzzer_guard = gpio_buzzer.lock().await;
-    let mut led_guard = status_led.lock().await;
-
-    let (buzz, led) = join!(buzzer_guard.beep_ack(), led_guard.turn_green_on_1s());
-
-    buzz.unwrap_or_else(|err| {
-        error!("Failed to buzz: {err}");
-    });
-
-    led.unwrap_or_else(|err| {
-        error!("Failed to set LED: {err}");
-    });
-}
-
-/// Signal the user failure via buzzer and led
-async fn feedback_failure<T: Buzzer, I: StatusLed>(
-    gpio_buzzer: &Arc<Mutex<T>>,
-    status_led: &Arc<Mutex<I>>,
-) {
-    let mut buzzer_guard = gpio_buzzer.lock().await;
-    let mut led_guard = status_led.lock().await;
-
-    let (buzz, led) = join!(buzzer_guard.beep_nak(), led_guard.turn_red_on_1s());
-
-    buzz.unwrap_or_else(|err| {
-        error!("Failed to buzz: {err}");
-    });
-
-    led.unwrap_or_else(|err| {
-        error!("Failed to set LED: {err}");
-    });
-}
-
-/// Create a buzzer
-/// Respects the `mock_pi` flag.
-fn create_buzzer() -> Result<Arc<Mutex<impl Buzzer>>, rppal::pwm::Error> {
-    #[cfg(feature = "mock_pi")]
+async fn run_webserver<H>(
+    store: Arc<Mutex<IDStore>>,
+    id_channel: Sender<String>,
+    hotspot: Arc<Mutex<H>>,
+    user_feedback: Arc<Mutex<FeedbackImpl>>,
+) -> Result<()>
+where
+    H: Hotspot + Send + Sync + 'static,
 {
-        Ok(Arc::new(Mutex::new(MockBuzzer {})))
-    }
-
-    #[cfg(not(feature = "mock_pi"))]
-    {
-        Ok(Arc::new(Mutex::new(GPIOBuzzer::new(PWM_CHANNEL_BUZZER)?)))
-    }
-}
-
-/// Creates a status led.
-/// Respects the `mock_pi` flag.
-fn create_status_led() -> Result<Arc<Mutex<impl StatusLed>>, rppal::spi::Error> {
-    #[cfg(feature = "mock_pi")]
-    {
-        Ok(Arc::new(Mutex::new(MockLed {})))
-    }
-
-    #[cfg(not(feature = "mock_pi"))]
-    {
-        Ok(Arc::new(Mutex::new(SpiLed::new()?)))
-    }
-}
-
-/// Create a struct to manage the hotspot
-/// Respects the `mock_pi` flag.
-fn create_hotspot() -> Result<impl Hotspot, HotspotError> {
-    #[cfg(feature = "mock_pi")]
-    {
-        Ok(MockHotspot {})
-    }
-
-    #[cfg(not(feature = "mock_pi"))]
-    {
-        NMHotspot::new_from_env()
-    }
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    setup_logger();
-
-    info!("Starting application");
-
-    let (tx, mut rx) = broadcast::channel::<String>(32);
-    let sse_tx = tx.clone();
-
+    let activity_channel = spawn_idle_watcher(Duration::from_secs(60 * 30), move || {
+        info!("No activity on webserver. Disabling hotspot");
+        let cloned_hotspot = hotspot.clone();
+        let cloned_user_feedback = user_feedback.clone();
         tokio::spawn(async move {
-        match run_pm3(tx).await {
-            Ok(()) => {
-                warn!("PM3 exited with a zero exit code");
-            }
-            Err(e) => {
-                error!("Failed to run PM3: {e}");
-            }
-        }
+            let _ = cloned_hotspot.lock().await.disable_hotspot().await;
+            cloned_user_feedback
+                .lock()
+                .await
+                .set_device_status(feedback::DeviceStatus::Ready);
+        });
     });
 
-    let raw_store = if fs::try_exists(STORE_PATH).await? {
-        info!("Loading data from file");
-        IDStore::new_from_json(STORE_PATH).await?
-    } else {
-        info!("No data file found. Creating empty one.");
-        IDStore::new()
+    let notifier = ActivityNotifier {
+        sender: activity_channel,
     };
 
-    debug!("created store sucessfully");
+    start_webserver(store, id_channel, notifier).await?;
 
-    let store: Arc<Mutex<IDStore>> = Arc::new(Mutex::new(raw_store));
-    let gpio_buzzer = create_buzzer()?;
-    let status_led = create_status_led()?;
-    let hotspot = create_hotspot()?;
+    Ok(())
+}
 
+async fn load_or_create_store() -> Result<IDStore> {
+    if fs::try_exists(STORE_PATH).await? {
+        info!("Loading data from file");
+        IDStore::new_from_json(STORE_PATH).await
+    } else {
+        info!("No data file found. Creating empty one.");
+        Ok(IDStore::new())
+    }
+}
+
+fn get_hotspot_enable_ids() -> Vec<TallyID> {
     let hotspot_ids: Vec<TallyID> = env::var("HOTSPOT_IDS")
         .map(|ids| ids.split(";").map(|id| TallyID(id.to_owned())).collect())
         .unwrap_or_default();
@@ -178,39 +84,109 @@ async fn main() -> Result<(), Box<dyn Error>> {
         );
     }
 
-    let channel_store = store.clone();
-    tokio::spawn(async move {
-        while let Ok(tally_id_string) = rx.recv().await {
+    hotspot_ids
+}
+
+async fn handle_ids_loop(
+    mut id_channel: Receiver<String>,
+    hotspot_enable_ids: Vec<TallyID>,
+    id_store: Arc<Mutex<IDStore>>,
+    hotspot: Arc<Mutex<impl Hotspot>>,
+    user_feedback: Arc<Mutex<FeedbackImpl>>,
+) -> Result<()> {
+    while let Ok(tally_id_string) = id_channel.recv().await {
         let tally_id = TallyID(tally_id_string);
 
-            if hotspot_ids.contains(&tally_id) {
+        if hotspot_enable_ids.contains(&tally_id) {
             info!("Enableing hotspot");
-                hotspot.enable_hotspot().await.unwrap_or_else(|err| {
-                    error!("Hotspot: {err}");
-                });
+            let hotspot_enable_result = hotspot.lock().await.enable_hotspot().await;
+
+            match hotspot_enable_result {
+                Ok(_) => {
+                    user_feedback
+                        .lock()
+                        .await
+                        .set_device_status(feedback::DeviceStatus::HotspotEnabled);
+                }
+                Err(e) => {
+                    error!("Hotspot: {e}");
+                }
+            }
+
             // TODO: Should the ID be added anyway or ignored ?
         }
 
-            if channel_store.lock().await.add_id(tally_id) {
+        if id_store.lock().await.add_id(tally_id) {
             info!("Added new id to current day");
 
-                feedback_success(&gpio_buzzer, &status_led).await;
+            user_feedback.lock().await.success().await;
 
-                if let Err(e) = channel_store.lock().await.export_json(STORE_PATH).await {
+            if let Err(e) = id_store.lock().await.export_json(STORE_PATH).await {
                 error!("Failed to save id store to file: {e}");
-                    feedback_failure(&gpio_buzzer, &status_led).await;
+                user_feedback.lock().await.failure().await;
                 // TODO: How to handle a failure to save ?
             }
         }
     }
-    });
-
-    match start_webserver(store.clone(), sse_tx).await {
-        Ok(()) => {}
-        Err(e) => {
-            error!("Failed to start webserver: {e}");
-        }
-    }
+
+    Ok(())
+}
+
+async fn enter_error_state(feedback: Arc<Mutex<FeedbackImpl>>, hotspot: Arc<Mutex<impl Hotspot>>) {
+    let _ = feedback.lock().await.activate_error_state().await;
+    let _ = hotspot.lock().await.enable_hotspot().await;
+
+    let mut sigterm = signal(SignalKind::terminate()).unwrap();
+    sigterm.recv().await;
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    logger::setup_logger();
+
+    info!("Starting application");
+
+    let user_feedback = Arc::new(Mutex::new(Feedback::new()?));
+    let hotspot = Arc::new(Mutex::new(create_hotspot()?));
+
+    let error_flag_set = args().any(|e| e == "--error" || e == "-e");
+    if error_flag_set {
+        error!("Error flag set. Entering error state");
+        enter_error_state(user_feedback.clone(), hotspot).await;
+        return Ok(());
+    }
+
+    let store: Arc<Mutex<IDStore>> = Arc::new(Mutex::new(load_or_create_store().await?));
+    let hotspot_enable_ids = get_hotspot_enable_ids();
+
+    let (tx, rx) = broadcast::channel::<String>(32);
+    let sse_tx = tx.clone();
+
+    let pm3_handle = run_pm3(tx);
+
+    user_feedback.lock().await.startup().await;
+
+    let loop_handle = handle_ids_loop(
+        rx,
+        hotspot_enable_ids,
+        store.clone(),
+        hotspot.clone(),
+        user_feedback.clone(),
+    );
+
+    let webserver_handle = run_webserver(
+        store.clone(),
+        sse_tx,
+        hotspot.clone(),
+        user_feedback.clone(),
+    );
+
+    let run_result = try_join!(pm3_handle, loop_handle, webserver_handle);
+
+    if let Err(e) = run_result {
+        error!("Failed to run application: {e}");
+        return Err(e);
+    }
 
     Ok(())
 }

src/mock.rs

@@ -1,45 +0,0 @@
-use log::debug;
-
-use crate::{buzzer::Buzzer, hotspot::Hotspot, led::StatusLed};
-
-pub struct MockBuzzer {}
-
-impl Buzzer for MockBuzzer {
-    async fn beep_ack(&mut self) -> Result<(), rppal::pwm::Error> {
-        debug!("Mockbuzzer: ACK");
-        Ok(())
-    }
-
-    async fn beep_nak(&mut self) -> Result<(), rppal::pwm::Error> {
-        debug!("Mockbuzzer: NAK");
-        Ok(())
-    }
-}
-
-pub struct MockLed {}
-
-impl StatusLed for MockLed {
-    async fn turn_green_on_1s(&mut self) -> Result<(), rppal::spi::Error> {
-        debug!("Mockled: Turn LED green for 1 sec");
-        Ok(())
-    }
-
-    async fn turn_red_on_1s(&mut self) -> Result<(), rppal::spi::Error> {
-        debug!("Mockled: Turn LED red for 1 sec");
-        Ok(())
-    }
-}
-
-pub struct MockHotspot {}
-
-impl Hotspot for MockHotspot {
-    async fn enable_hotspot(&self) -> Result<(), crate::hotspot::HotspotError> {
-        debug!("Mockhotspot: Enable hotspot");
-        Ok(())
-    }
-
-    async fn disable_hotspot(&self) -> Result<(), crate::hotspot::HotspotError> {
-        debug!("Mockhotspot: Disable hotspot");
-        Ok(())
-    }
-}

src/pm3/mod.rs

@@ -0,0 +1,4 @@
+mod runner;
+mod parser;
+
+pub use runner::run_pm3;

src/pm3/runner.rs

@@ -1,15 +1,17 @@
+use anyhow::{Result, anyhow};
 use log::{debug, info, trace, warn};
 use std::env;
-use std::error::Error;
 use std::process::Stdio;
-use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::Command;
+use tokio::select;
+use tokio::signal::unix::{SignalKind, signal};
 use tokio::sync::broadcast;
 
 /// Runs the pm3 binary and monitors it's output
 /// The pm3 binary is ether set in the env var PM3_BIN or found in the path
 /// The ouput is parsed and send via the `tx` channel
-pub async fn run_pm3(tx: broadcast::Sender<String>) -> Result<(), Box<dyn Error>> {
+pub async fn run_pm3(tx: broadcast::Sender<String>) -> Result<()> {
     kill_orphans().await;
 
     let pm3_path = match env::var("PM3_BIN") {
@@ -27,31 +29,48 @@ pub async fn run_pm3(tx: broadcast::Sender<String>) -> Result<(), Box<dyn Error>
         .arg("lf hitag reader -@")
         .stdout(Stdio::piped())
         .stderr(Stdio::null())
-        .stdin(Stdio::null())
+        .stdin(Stdio::piped())
         .spawn()?;
 
-    let stdout = cmd.stdout.take().ok_or("Failed to get stdout")?;
+    let stdout = cmd.stdout.take().ok_or(anyhow!("Failed to get stdout"))?;
+    let mut stdin = cmd.stdin.take().ok_or(anyhow!("Failed to get stdin"))?;
 
     let mut reader = BufReader::new(stdout).lines();
 
-    let mut last_id: String = "".to_owned();
+    let mut sigterm = signal(SignalKind::terminate())?;
 
-    while let Some(line) = reader.next_line().await? {
+    let child_handle = tokio::spawn(async move {
+        let mut last_id: String = "".to_owned();
+        while let Some(line) = reader.next_line().await.unwrap_or(None) {
             trace!("PM3: {line}");
             if let Some(uid) = super::parser::parse_line(&line) {
                 if last_id == uid {
-                tx.send(uid.clone())?;
+                    let _ = tx.send(uid.clone());
                 }
-            last_id = uid.to_owned();
+                last_id = uid;
             }
         }
+    });
+
+    select! {
+        _ = child_handle => {}
+        _ = sigterm.recv() => {
+            debug!("Graceful shutdown of PM3");
+            let _ = stdin.write_all(b"\n").await;
+            let _ = stdin.flush().await;
+        }
+    };
 
     let status = cmd.wait().await?;
 
-    if status.success() {
+    // We use the exit code here because status.success() is false if the child was terminated by a
+    // signal
+    let code = status.code().unwrap_or(0);
+
+    if code == 0 {
         Ok(())
     } else {
-        Err("PM3 exited with a non zero exit code".into())
+        Err(anyhow!("PM3 exited with a non-zero exit code: {code}"))
     }
 }
 

src/store/id_store.rs

@@ -1,11 +1,9 @@
+use anyhow::{Result, anyhow};
 use serde::{Deserialize, Serialize};
-use std::{
-    collections::{HashMap, HashSet},
-    error::Error,
-};
+use std::collections::{HashMap, HashSet};
 use tokio::fs;
 
-use crate::{id_mapping::IDMapping, tally_id::TallyID};
+use crate::{store::IDMapping, tally_id::TallyID};
 
 /// Represents a single day that IDs can attend
 #[derive(Deserialize, Serialize)]
@@ -30,7 +28,7 @@ impl IDStore {
     }
 
     /// Creats a new `IDStore` from a json file
-    pub async fn new_from_json(filepath: &str) -> Result<Self, Box<dyn Error>> {
+    pub async fn new_from_json(filepath: &str) -> Result<Self> {
         let read_string = fs::read_to_string(filepath).await?;
         Ok(serde_json::from_str(&read_string)?)
     }
@@ -59,14 +57,14 @@ impl IDStore {
     }
 
     /// Writes the store to a json file
-    pub async fn export_json(&self, filepath: &str) -> Result<(), Box<dyn Error + Send + Sync>> {
+    pub async fn export_json(&self, filepath: &str) -> Result<()> {
         fs::write(filepath, serde_json::to_string(&self)?).await?;
         Ok(())
     }
 
     /// Export the store to a csv file.
     /// With days in the rows and IDs in the collum.
-    pub fn export_csv(&self) -> Result<String, Box<dyn Error>> {
+    pub fn export_csv(&self) -> Result<String> {
         let mut csv = String::new();
         let seperator = ";";
         let mut user_ids: HashSet<TallyID> = HashSet::new();
@@ -100,7 +98,7 @@ impl IDStore {
                 let was_there: bool = self
                     .days
                     .get(day)
-                    .ok_or("Failed to access day")?
+                    .ok_or(anyhow!("Failed to access day"))?
                     .ids
                     .contains(user_id);
 

src/store/mod.rs

@@ -0,0 +1,5 @@
+mod id_store;
+mod id_mapping;
+
+pub use id_store::IDStore;
+pub use id_mapping::{IDMapping,Name};

src/webserver/activity_fairing.rs

@@ -0,0 +1,46 @@
+use std::time::Duration;
+
+use log::error;
+use rocket::{
+    Data, Request,
+    fairing::{Fairing, Info, Kind},
+};
+use tokio::{sync::mpsc, time::timeout};
+
+pub struct ActivityNotifier {
+    pub sender: mpsc::Sender<()>,
+}
+
+#[rocket::async_trait]
+impl Fairing for ActivityNotifier {
+    fn info(&self) -> Info {
+        Info {
+            name: "Keeps track of time since the last request",
+            kind: Kind::Request | Kind::Response,
+        }
+    }
+
+    async fn on_request(&self, _: &mut Request<'_>, _: &mut Data<'_>) {
+        error!("on_request");
+        let _ = self.sender.try_send(());
+    }
+}
+
+pub fn spawn_idle_watcher<F>(idle_duration: Duration, mut on_idle: F) -> mpsc::Sender<()>
+where
+    F: FnMut() + Send + 'static,
+{
+    let (tx, mut rx) = mpsc::channel::<()>(100);
+
+    tokio::spawn(async move {
+        loop {
+            let idle = timeout(idle_duration, rx.recv()).await;
+            if idle.is_err() {
+                // No activity received in the duration
+                on_idle();
+            }
+        }
+    });
+
+    tx
+}

src/webserver/mod.rs

@@ -0,0 +1,6 @@
+mod server;
+mod activity_fairing;
+
+pub use activity_fairing::{ActivityNotifier,spawn_idle_watcher};
+pub use server::start_webserver;
+

src/webserver/server.rs

@@ -2,7 +2,7 @@ use log::{error, info, warn};
 use rocket::http::Status;
 use rocket::response::stream::{Event, EventStream};
 use rocket::serde::json::Json;
-use rocket::{Config, State, post};
+use rocket::{Config, Shutdown, State, post};
 use rocket::{get, http::ContentType, response::content::RawHtml, routes};
 use rust_embed::Embed;
 use serde::Deserialize;
@@ -10,12 +10,13 @@ use std::borrow::Cow;
 use std::env;
 use std::ffi::OsStr;
 use std::sync::Arc;
+use tokio::select;
 use tokio::sync::Mutex;
 use tokio::sync::broadcast::Sender;
 
-use crate::id_mapping::{IDMapping, Name};
-use crate::id_store::IDStore;
+use crate::store::{IDMapping, IDStore, Name};
 use crate::tally_id::TallyID;
+use crate::webserver::ActivityNotifier;
 
 #[derive(Embed)]
 #[folder = "web/dist"]
@@ -30,6 +31,7 @@ struct NewMapping {
 pub async fn start_webserver(
     store: Arc<Mutex<IDStore>>,
     sse_broadcaster: Sender<String>,
+    fairing: ActivityNotifier,
 ) -> Result<(), rocket::Error> {
     let port = match env::var("HTTP_PORT") {
         Ok(port) => port.parse().unwrap_or_else(|_| {
@@ -46,6 +48,7 @@ pub async fn start_webserver(
     };
 
     rocket::custom(config)
+        .attach(fairing)
         .mount(
             "/",
             routes![
@@ -84,15 +87,22 @@ fn static_files(file: std::path::PathBuf) -> Option<(ContentType, Vec<u8>)> {
 }
 
 #[get("/api/idevent")]
-fn id_event(sse_broadcaster: &State<Sender<String>>) -> EventStream![] {
+fn id_event(sse_broadcaster: &State<Sender<String>>, shutdown: Shutdown) -> EventStream![] {
     let mut rx = sse_broadcaster.subscribe();
     EventStream! {
         loop {
-            let msg = rx.recv().await;
+            select! {
+                msg = rx.recv() => {
                     if let Ok(id) = msg {
                         yield Event::data(id);
                     }
                 }
+                _ = &mut shutdown.clone() => {
+                    // Shutdown signal received, exit the loop
+                    break;
+                }
+            }
+        }
     }
 }
 

web/src/App.svelte

@@ -42,7 +42,9 @@
     />
   </div>
   <div>
-    <IDTable bind:this={idTable} />
+    <IDTable bind:this={idTable} onEdit={(id,firstName,lastName)=>{
+      addModal.open(id,firstName,lastName);
+    }}/>
   </div>
 
   <AddIDModal

web/src/lib/AddIDModal.svelte

@@ -9,8 +9,12 @@
 
   let modal: Modal;
 
-  export function open(id: string) {
-    displayID = id;
+  export function open(presetID: string, presetFirstName?: string, presetLastName?: string) {
+    displayID = presetID;
+
+    firstName = presetFirstName ?? "";
+    lastName = presetLastName ?? "";
+
     modal.open();
   }
 

web/src/lib/IDTable.svelte

@@ -3,6 +3,8 @@
   import type { IDMapping } from "./IDMapping";
   let data: IDMapping | undefined = $state();
 
+  let { onEdit }: { onEdit?: (string,string,string) => void } = $props();
+
   export async function reloadData() {
     let res = await fetch("/api/mapping");
 
@@ -82,6 +84,8 @@
 
             <span class="indicator">{indicator("first")}</span>
           </th>
+          <th>
+          </th>
         </tr>
       </thead>
       <tbody>
@@ -90,6 +94,9 @@
             <td class="whitespace-nowrap pr-5 pl-2 py-1">{row.id}</td>
             <td class="whitespace-nowrap pr-5">{row.last}</td>
             <td class="whitespace-nowrap pr-5">{row.first}</td>
+            <td class="pr-5" ><button onclick={()=>{
+              onEdit && onEdit(row.id,row.first,row.last);
+            }} class="cursor-pointer">🔧</button></td>
           </tr>
         {/each}
       </tbody>

web/src/lib/LastID.svelte

@@ -27,7 +27,7 @@
     <button
       class="bg-indigo-500 rounded-2xl px-2 cursor-pointer mx-2"
       onclick={() => {
-        if (onAdd && id != "") {
+        if (onAdd) {
           onAdd(id);
         }
       }}>+</button