refactor(config)!: Moved Timeout into utils module and moved module

The module is now setup in automation_lib::lua::utils.

automation_lib/src/lua/mod.rs

@@ -1 +1,3 @@
 pub mod traits;
+
+mod utils;

automation_lib/src/lua/utils/mod.rs

@@ -0,0 +1,31 @@
+mod timeout;
+
+use std::time::{SystemTime, UNIX_EPOCH};
+
+pub use timeout::Timeout;
+
+use crate::Module;
+
+fn create_module(lua: &mlua::Lua) -> mlua::Result<mlua::Table> {
+    let utils = lua.create_table()?;
+
+    utils.set("Timeout", lua.create_proxy::<Timeout>()?)?;
+
+    let get_hostname = lua.create_function(|_lua, ()| {
+        hostname::get()
+            .map(|name| name.to_str().unwrap_or("unknown").to_owned())
+            .map_err(mlua::ExternalError::into_lua_err)
+    })?;
+    utils.set("get_hostname", get_hostname)?;
+    let get_epoch = lua.create_function(|_lua, ()| {
+        Ok(SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("Time is after UNIX EPOCH")
+            .as_millis())
+    })?;
+    utils.set("get_epoch", get_epoch)?;
+
+    Ok(utils)
+}
+
+inventory::submit! {Module::new("utils", create_module)}

automation_lib/src/lua/utils/timeout.rs

@@ -0,0 +1,76 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use tokio::sync::RwLock;
+use tokio::task::JoinHandle;
+use tracing::debug;
+
+use crate::action_callback::ActionCallback;
+
+#[derive(Debug, Default)]
+pub struct State {
+    handle: Option<JoinHandle<()>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Timeout {
+    state: Arc<RwLock<State>>,
+}
+
+impl mlua::UserData for Timeout {
+    fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
+        methods.add_function("new", |_lua, ()| {
+            let device = Self {
+                state: Default::default(),
+            };
+
+            Ok(device)
+        });
+
+        methods.add_async_method(
+            "start",
+            async |_lua, this, (timeout, callback): (f32, ActionCallback<()>)| {
+                if let Some(handle) = this.state.write().await.handle.take() {
+                    handle.abort();
+                }
+
+                debug!("Running timeout callback after {timeout}s");
+
+                let timeout = Duration::from_secs_f32(timeout);
+
+                this.state.write().await.handle = Some(tokio::spawn({
+                    async move {
+                        tokio::time::sleep(timeout).await;
+
+                        callback.call(()).await;
+                    }
+                }));
+
+                Ok(())
+            },
+        );
+
+        methods.add_async_method("cancel", async |_lua, this, ()| {
+            debug!("Canceling timeout callback");
+
+            if let Some(handle) = this.state.write().await.handle.take() {
+                handle.abort();
+            }
+
+            Ok(())
+        });
+
+        methods.add_async_method("is_waiting", async |_lua, this, ()| {
+            debug!("Canceling timeout callback");
+
+            if let Some(handle) = this.state.read().await.handle.as_ref() {
+                debug!("Join handle: {}", handle.is_finished());
+                return Ok(!handle.is_finished());
+            }
+
+            debug!("Join handle: None");
+
+            Ok(false)
+        });
+    }
+}