Implement sensor status debouncing

This introduces a configurable debouncing delay before which no update
is sent to matrix, which avoids flooding the matrix room with updates
when the door is opened and closed in quick succession. It also allows
to quickly open and close the door without sending notifications.

The debouncing window can be configured in config.yml, see example.

Cargo.toml

@@ -15,5 +15,5 @@ serde_json = "1.0"
 tracing-subscriber = "0.3.18"
 clap = { version = "4.6.7", features = ["derive"] }
 tokio = { version = "1.41", features = ["macros", "rt-multi-thread"] }
-matrix-sdk = { version = "0.8.0", default-features = false, features = [ "native-tls", "anyhow", "markdown" ] }
+matrix-sdk = { version = "0.18.0", default-features = false, features = [ "anyhow", "markdown" ] }
 rumqttc = "0.25"

README.md

@@ -0,0 +1,42 @@
+# matrix-lolopener
+
+A simple matrix bot which posts to a list of matrix rooms everytime the front door is opened or closed.
+The door state is retrieved by subscribing to an MQTT topic, and a matrix event is sent every time that state changes.
+
+## building
+
+```sh
+cargo build --release
+```
+
+## installing
+
+```sh
+useradd -r -M -s /usr/sbin/nologin matrix-lolopener
+install -o matrix-lolopener -g nogroup target/release/matrix-lolopener /opt/matrix-lolopener/bin/
+install -o matrix-lolopener -g nogroup -m 600 -T config.yml.example /opt/matrix-lolopener/etc/config.yml
+cp matrix-lolopener.service /etc/systemd/system/
+$EDITOR /opt/matrix-lolopener/etc/config.yml
+systemctl daemon-reload && systemctl enable --now matrix-lolopener.service
+```
+
+## usage
+
+```
+Matrix bot posting when the front door is opened or closed
+
+Usage: matrix-lolopener [OPTIONS]
+
+Options:
+  -c, --config <CONFIG>  Configuration file path [default: config.yml]
+  -h, --help             Print help
+  -V, --version          Print version
+```
+
+## contributing
+
+Send PRs to https://git.labolyon.fr/mirsal/matrix-lolopener
+
+## license
+
+GPL v3 or later

config.yml.example

@@ -9,6 +9,8 @@ mqtt:
 rooms:
   - "!iFCnqQcvrVIeehrjQO:chat.labolyon.fr"
 
+debounce_delay: 10 # seconds
+
 # username / password login
 # /!\ will create a new device every time the bot starts
 username: "login"

matrix-lolopener.service

@@ -4,8 +4,8 @@ Description=LOL-Opener Matrix Bot
 [Service]
 Type=simple
 User=matrix-lolopener
-WorkingDirectory=/opt/matrix-lolopener/etc
-ExecStart=/opt/matrix-lolopener/bin/matrix-lolopener
+WorkingDirectory=/opt/matrix-lolopener
+ExecStart=/opt/matrix-lolopener/bin/matrix-lolopener -c etc/config.yml
 Restart=on-failure
 RestartSec=5
 

src/config.rs

@@ -46,6 +46,7 @@ pub enum AuthConfig {
 pub struct Config {
     pub mqtt: MQTTConfig,
     pub rooms: Vec<String>,
+    pub debounce_delay: u64,
     #[serde(flatten)]
     pub auth: AuthConfig,
     pub homeserver_uri: String

src/main.rs

@@ -17,12 +17,15 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#![recursion_limit = "256"]
+
 mod config;
 mod matrix;
 mod mqtt;
 
 use tokio::{
-    sync::{Notify, broadcast},
+    sync::{Notify, broadcast, mpsc},
+    time::{sleep, Duration},
     task::JoinHandle,
 };
 
@@ -46,11 +49,16 @@ struct Args {
     config: String,
 }
 
-#[derive(PartialEq)]
-enum LolOpenerStatus {
+#[derive(PartialEq, Clone, Copy, Debug)]
+enum DoorSensorStatus {
     Open,
     Closed,
 }
+#[derive(Debug)]
+struct LolOpenerState {
+    sensor_status: Option<DoorSensorStatus>,
+    pending: Option<(DoorSensorStatus, String)>,
+}
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -78,25 +86,75 @@ async fn main() -> anyhow::Result<()> {
             matrix_ready.notified().await;
             info!("Matrix is ready");
 
-            let current_status = Arc::new(Mutex::new(None));
-            let current_status = Arc::clone(&current_status);
+            let current_state = Arc::new(Mutex::new(LolOpenerState {
+                sensor_status: None,
+                pending: None
+            }));
+            let current_state = Arc::clone(&current_state);
+
+            let (debounce_tx, mut debounce_rx) = mpsc::unbounded_channel::<(DoorSensorStatus, String)>();
+            let debounce_delay = config.debounce_delay;
+            let rooms = config.rooms.clone();
+            let handle = tokio::spawn(async move {
+
+                while let Some((new_status, msg)) = debounce_rx.recv().await {
+                    let should_wait = {
+                        //XXX: Panic if the lock is poisoned
+                        let mut state = current_state.lock().unwrap();
+                        let should_wait = state.pending.is_none();
+
+                        state.pending = Some((new_status, msg));
+                        should_wait
+                    };
+
+                    if should_wait {
+                        let tx = bcast_tx.clone();
+                        let rooms = rooms.clone();
+                        let state = current_state.clone();
+
+                        tokio::spawn(async move {
+                            sleep(Duration::from_secs(debounce_delay)).await;
+
+                            let msg = {
+                                //XXX: Panic if the lock is poisoned
+                                let mut state = state.lock().unwrap();
+                                let pending = state.pending.take();
+
+                                match pending {
+                                    Some((status, msg))
+                                        if state.sensor_status.as_ref() != Some(&status) => {
+                                            state.sensor_status = Some(status);
+                                            Some(msg)
+                                        }
+
+                                    _ => None,
+                                }
+                            };
+
+                            if let Some(msg) = msg {
+                                debug!("Sending msg {}", msg);
+                                //XXX: Panic if the matrix module can't get the message
+                                tx.send((msg, rooms)).unwrap();
+                            }
+                        });
+                    }
+                }
+            });
 
             let mut mqtt = MQTT::new(config.mqtt.clone()).await;
             mqtt.subscribe(move |status: StatusMessage| {
                 let (new_status, msg) = match status {
-                    StatusMessage { contact: true, .. } => (Some(LolOpenerStatus::Closed), "🔴 Le LOL est fermé :("),
-                    StatusMessage { contact: false, .. } => (Some(LolOpenerStatus::Open), "🟢 Le LOL est ouvert :)"),
+                    StatusMessage { contact: true, .. } => (DoorSensorStatus::Closed, "🔴 Le LOL est fermé :("),
+                    StatusMessage { contact: false, .. } => (DoorSensorStatus::Open, "🟢 Le LOL est ouvert :)"),
                 };
 
-                //XXX: Panic if the lock is poisoned (why would that happen?)
-                let mut current_status = current_status.lock().unwrap();
-                if new_status != *current_status {
-                    debug!("Sending msg {}", msg);
-                    //XXX: Panic if the matrix module can't get the message
-                    bcast_tx.send((msg.into(), config.rooms.clone())).unwrap();
-                    *current_status = new_status;
-                }
+                //XXX: Panic if the channel is closed
+                debounce_tx.send((new_status, String::from(msg))).unwrap();
+
             }).await.unwrap(); //XXX: Panic if the mqtt broker fails
+
+            handle.abort();
+            handle.await.unwrap();
         })
     };
 

src/matrix.rs

@@ -18,16 +18,20 @@
  */
 
 use matrix_sdk::{
-    matrix_auth::{
-        MatrixAuth,
-        MatrixSession,
-        MatrixSessionTokens
+    authentication::{
+        matrix::{
+            MatrixAuth,
+            MatrixSession,
+        },
+        SessionTokens,
     },
     SessionMeta,
+    store::RoomLoadSettings,
     config::SyncSettings,
     ruma::events::room::{
         member::StrippedRoomMemberEvent,
-        message::RoomMessageEventContent
+        message::RoomMessageEventContent,
+        pinned_events::RoomPinnedEventsEventContent,
     },
     ruma::{RoomId, OwnedUserId, device_id},
     Client, Room
@@ -41,7 +45,7 @@ use tokio::{
 
 use std::sync::Arc;
 
-use tracing::{error, info};
+use tracing::{error, info, debug};
 use std::error::Error;
 
 use crate::config::AuthConfig;
@@ -51,6 +55,7 @@ async fn on_stripped_state_member(
     client: Client,
     room: Room,
 ) {
+    //XXX: Panic if authentication has failed
     if room_member.state_key != client.user_id().unwrap() {
         return;
     }
@@ -86,16 +91,39 @@ async fn send_to_room(
     match room.client().join_room_by_id(room.room_id()).await {
         Ok(_) => {
             info!("Posting to room {}", room.room_id());
-            room.send(RoomMessageEventContent::text_html(msg.clone(), msg)).await?;
+            let res = room.send(RoomMessageEventContent::text_html(msg.clone(), msg)).await?;
 
-            return Ok(());
+            debug!("Retrieving list of pinned events");
+            let mut old_pinned_eids = room.pinned_event_ids().unwrap_or_default();
+            let mut new_pinned_eids = Vec::with_capacity(old_pinned_eids.len());
+
+            for eid in old_pinned_eids.drain(..) {
+                match room.event(eid.as_ref(), None).await {
+                    Ok(ev) => {
+                        let client = room.client();
+
+                        if client.user_id() != ev.sender().as_deref() {
+                            new_pinned_eids.push(eid);
+                        }
+                    },
+                    Err(err) => {
+                        error!("Failed to retrieve pinned event {eid:?}: {err:?}");
+                    }
+                }
+            }
+
+            info!("Updating pinned events");
+            new_pinned_eids.push(res.response.event_id);
+            room.send_state_event(RoomPinnedEventsEventContent::new(new_pinned_eids)).await?;
+
+            Ok(())
         },
         Err(e) => {
             error!("Failed to join room {e:?}");
 
-            return Err(e.into());
+            Err(e.into())
         }
-    };
+    }
 }
 
 async fn login(
@@ -105,7 +133,9 @@ async fn login(
     match auth_config {
         AuthConfig::PasswordAuthConfig{username, password} => {
             matrix_auth.login_username(username, password)
-                .initial_device_display_name("bender v0.2.0").await?;
+                .initial_device_display_name(
+                    format!("{} v{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION")).as_str()
+                ).await?;
         },
         AuthConfig::TokenAuthConfig{user_id, device_id, access_token} => {
             matrix_auth.restore_session(
@@ -114,11 +144,12 @@ async fn login(
                         user_id: <OwnedUserId>::try_from(user_id.as_str())?,
                         device_id: device_id!(device_id.as_str()).to_owned(),
                     },
-                    tokens: MatrixSessionTokens {
+                    tokens: SessionTokens {
                         access_token: access_token.to_owned(),
                         refresh_token: None,
                     }
-                }
+                },
+                RoomLoadSettings::All
             ).await?;
         },
     }