refactor: commands

Author: dineshdb

src/commands/mod.rs

@@ -0,0 +1,64 @@
+use crate::delayed::Delayed;
+use serde::Deserialize;
+use std::{process::Output, sync::Mutex};
+
+#[derive(Debug, Deserialize, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum Command {
+    Unlock,
+    Lock,
+    String(String),
+}
+
+// fixme: don't use sudo, use proper permissions
+// fixme: use dbus to lock/unlock
+static LOCKED: Mutex<bool> = Mutex::new(false);
+static DELAYED_LOCK: Mutex<Option<Delayed>> = Mutex::new(None);
+
+impl Command {
+    pub fn run(&self) -> anyhow::Result<()> {
+        let locked = *LOCKED.lock().unwrap();
+        match self {
+            Command::Unlock => {
+                // cancel the delayed lock
+                if let Some(delayed) = &mut *DELAYED_LOCK.lock().unwrap() {
+                    delayed.cancel();
+                }
+                if locked {
+                    println!("Unlocking desktop...");
+                    run("sudo loginctl unlock-sessions")?;
+                    *LOCKED.lock().unwrap() = false;
+                };
+            }
+
+            // fixme: unlocking might not be good idea if it wasn't locked automatically
+            Command::Lock => {
+                let duration = std::time::Duration::from_secs(15);
+                if !locked {
+                    println!("Locking desktop in {:?}", duration);
+                    if let Some(delayed) = &mut *DELAYED_LOCK.lock().unwrap() {
+                        delayed.cancel();
+                    }
+                    // wait before actually locking the desktop
+                    let delayed = Delayed::new(duration, || async {
+                        run("sudo loginctl lock-sessions").expect("error running lock command");
+                        *LOCKED.lock().unwrap() = true;
+                    });
+                    *DELAYED_LOCK.lock().unwrap() = Some(delayed);
+                }
+            }
+            Command::String(cmd) => {
+                run(cmd)?;
+            }
+        };
+        Ok(())
+    }
+}
+
+pub fn run(cmd: &str) -> anyhow::Result<Output> {
+    let output = std::process::Command::new("sh")
+        .arg("-c")
+        .arg(cmd)
+        .output()?;
+    Ok(output)
+}

src/config.rs

@@ -1,10 +1,9 @@
-use crate::delayed::Delayed;
+use crate::commands::Command;
 use figment::{
     providers::{Env, Format, Toml},
     Figment,
 };
 use serde::Deserialize;
-use std::{process::Output, sync::Mutex};
 
 #[derive(Deserialize, Debug)]
 pub struct Config {
@@ -74,14 +73,6 @@ impl BLEConnection {
     }
 }
 
-pub fn run(cmd: &str) -> anyhow::Result<Output> {
-    let output = std::process::Command::new("sh")
-        .arg("-c")
-        .arg(cmd)
-        .output()?;
-    Ok(output)
-}
-
 #[derive(Deserialize, Debug, Clone)]
 #[serde(tag = "type")]
 #[serde(rename_all = "lowercase")]
@@ -97,59 +88,6 @@ pub struct ProximityAction {
     pub command: Command,
 }
 
-#[derive(Debug, Deserialize, Clone)]
-#[serde(rename_all = "lowercase")]
-pub enum Command {
-    Unlock,
-    Lock,
-    String(String),
-}
-
-// fixme: don't use sudo, use proper permissions
-// fixme: use dbus to lock/unlock
-static LOCKED: Mutex<bool> = Mutex::new(false);
-static DELAYED_LOCK: Mutex<Option<Delayed>> = Mutex::new(None);
-
-impl Command {
-    pub fn run(&self) -> anyhow::Result<()> {
-        let locked = *LOCKED.lock().unwrap();
-        match self {
-            Command::Unlock => {
-                // cancel the delayed lock
-                if let Some(delayed) = &mut *DELAYED_LOCK.lock().unwrap() {
-                    delayed.cancel();
-                }
-                if locked {
-                    println!("Unlocking desktop...");
-                    run("sudo loginctl unlock-sessions")?;
-                    *LOCKED.lock().unwrap() = false;
-                };
-            }
-
-            // fixme: unlocking might not be good idea if it wasn't locked automatically
-            Command::Lock => {
-                let duration = std::time::Duration::from_secs(15);
-                if !locked {
-                    println!("Locking desktop in {:?}", duration);
-                    if let Some(delayed) = &mut *DELAYED_LOCK.lock().unwrap() {
-                        delayed.cancel();
-                    }
-                    // wait before actually locking the desktop
-                    let delayed = Delayed::new(duration, || async {
-                        run("sudo loginctl lock-sessions").expect("error running lock command");
-                        *LOCKED.lock().unwrap() = true;
-                    });
-                    *DELAYED_LOCK.lock().unwrap() = Some(delayed);
-                }
-            }
-            Command::String(cmd) => {
-                run(cmd)?;
-            }
-        };
-        Ok(())
-    }
-}
-
 const APP_NAME: &str = "nearby";
 pub fn get_config() -> anyhow::Result<Config> {
     let config_dir = dirs::config_dir().expect("Could not find config directory");

src/main.rs

@@ -4,6 +4,7 @@ use bluer::{
 use config::{get_config, Connection};
 use futures::{pin_mut, stream::SelectAll, StreamExt};
 use std::collections::HashSet;
+mod commands;
 mod config;
 mod delayed;