feat(client):support single instance

aw-client-rust/Cargo.toml

@@ -12,6 +12,11 @@ serde_json = "1.0"
 chrono = { version = "0.4", features = ["serde"] }
 aw-models = { path = "../aw-models" }
 tokio = { version = "1.28.2", features = ["rt"] }
+libc = "0.2"
+log = "0.4"
+thiserror = "1.0" 
+dirs = "4.0"
+fs4 = { version = "0.13", features = ["sync"] }
 
 [dev-dependencies]
 aw-datastore = { path = "../aw-datastore" }

aw-client-rust/src/lib.rs

@@ -6,18 +6,22 @@ extern crate serde_json;
 extern crate tokio;
 
 pub mod blocking;
+pub mod single_instance;
 
 use std::{collections::HashMap, error::Error};
 
 use chrono::{DateTime, Utc};
 use serde_json::{json, Map};
+use single_instance::SingleInstance;
 use std::net::TcpStream;
 use std::time::Duration;
 
 pub use aw_models::{Bucket, BucketMetadata, Event};
 
 pub struct AwClient {
     client: reqwest::Client,
+    #[allow(dead_code)]
+    single_instance: SingleInstance,
     pub baseurl: reqwest::Url,
     pub name: String,
     pub hostname: String,
@@ -40,9 +44,13 @@ impl AwClient {
         let client = reqwest::Client::builder()
             .timeout(std::time::Duration::from_secs(120))
             .build()?;
+        //TODO: change localhost string to 127.0.0.1 for feature parity
+        let single_instance_name = format!("{}-at-{}-on-{}", name, host, port);
+        let single_instance = single_instance::SingleInstance::new(single_instance_name.as_str())?;
 
         Ok(AwClient {
             client,
+            single_instance,
             baseurl,
             name: name.to_string(),
             hostname,

aw-client-rust/src/single_instance.rs

@@ -0,0 +1,84 @@
+use dirs::cache_dir;
+use fs4::fs_std::FileExt;
+use log::{debug, error};
+use std::fs::{File, OpenOptions};
+use std::io;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct SingleInstance {
+    file: Option<File>,
+    locked: Arc<AtomicBool>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum SingleInstanceError {
+    #[error("Another instance is already running")]
+    AlreadyRunning,
+    #[error("IO error: {0}")]
+    Io(#[from] io::Error),
+    #[error("Failed to create lock directory")]
+    LockDirCreation,
+}
+
+impl SingleInstance {
+    pub fn new(client_name: &str) -> Result<SingleInstance, SingleInstanceError> {
+        let cache_dir = cache_dir().ok_or(SingleInstanceError::LockDirCreation)?;
+        let lock_dir = cache_dir.join("activitywatch").join("client_locks");
+        std::fs::create_dir_all(&lock_dir).map_err(|_| SingleInstanceError::LockDirCreation)?;
+
+        let lockfile = lock_dir.join(client_name);
+        debug!("SingleInstance lockfile: {:?}", lockfile);
+
+        #[cfg(windows)]
+        {
+            // On Windows, try to create an exclusive file
+            // Remove existing file if it exists (in case of previous crash)
+            let _ = std::fs::remove_file(&lockfile);
+
+            match OpenOptions::new()
+                .write(true)
+                .create(true)
+                .create_new(true)
+                .open(&lockfile)
+            {
+                Ok(file) => Ok(SingleInstance {
+                    file: Some(file),
+                    locked: Arc::new(AtomicBool::new(true)),
+                }),
+                Err(e) if e.kind() == io::ErrorKind::AlreadyExists => {
+                    error!("Another instance is already running");
+                    Err(SingleInstanceError::AlreadyRunning)
+                }
+                Err(e) => Err(SingleInstanceError::Io(e)),
+            }
+        }
+
+        #[cfg(unix)]
+        {
+            // On Unix-like systems, use flock
+            match OpenOptions::new().write(true).create(true).open(&lockfile) {
+                Ok(file) => match file.try_lock_exclusive() {
+                    Ok(true) => Ok(SingleInstance {
+                        file: Some(file),
+                        locked: Arc::new(AtomicBool::new(true)),
+                    }),
+                    Ok(false) => Err(SingleInstanceError::AlreadyRunning),
+                    Err(e) => Err(SingleInstanceError::Io(e)),
+                },
+                Err(e) => Err(SingleInstanceError::Io(e)),
+            }
+        }
+    }
+}
+
+impl Drop for SingleInstance {
+    fn drop(&mut self) {
+        if self.locked.load(Ordering::SeqCst) {
+            //drop the file handle and lock on Unix and Windows
+            self.file.take();
+            self.locked.store(false, Ordering::SeqCst);
+        }
+    }
+}