fix: unix socket locking broken on darwin

Author: dpc

Cargo.lock

@@ -1,15 +1,14 @@
 mod root;
 mod util;
 
-use std::os::unix::net::{UnixListener, UnixStream};
 use std::path::{Path, PathBuf};
 use std::{ffi, fs, io, process};
 
 use anyhow::{bail, format_err, Context, Result};
 use chrono::Utc;
 use clap::{Args, Parser, Subcommand};
 use rand::distributions::{Alphanumeric, DistString};
-use root::Root;
+use root::{mk_lock, Root};
 use tracing::{debug, error, warn};
 use tracing_subscriber::EnvFilter;
 
@@ -154,17 +153,16 @@ fn run_exec(ExecOpts { opts, exec }: ExecOpts) -> Result<()> {
 
     let sock_path = root.join(PathBuf::from(format!(
         "lock-{}",
-        Alphanumeric.sample_string(&mut rand::thread_rng(), 10)
+        Alphanumeric.sample_string(&mut rand::thread_rng(), 16)
     )));
 
     debug!(
         target: LOG_TARGET,
         sock_path = %sock_path.display(),
         "Binding liveness socket"
     );
-    let _socket = UnixListener::bind(&sock_path)?;
 
-    assert!(UnixStream::connect(&sock_path).is_ok());
+    let _lock = mk_lock(&sock_path)?;
 
     let exec_dir = lock(None, opts, Some(sock_path.clone()))?;
 

src/main.rs

@@ -1,8 +1,9 @@
 mod dto;
 
 use std::collections::btree_map::Entry;
-use std::io::{self, Read as _};
-use std::os::unix::net::UnixStream;
+use std::io::{self};
+#[cfg(not(target_os = "macos"))]
+use std::os::unix::net::{UnixListener, UnixStream};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 use std::{fs, thread};
@@ -175,18 +176,22 @@ impl<'a> LockedRoot<'a> {
                 }
                 Entry::Occupied(mut e) => {
                     if let Some(prev_sock_path) = e.get().socket_path.as_ref() {
-                        if let Ok(mut s) = UnixStream::connect(prev_sock_path) {
+                        if let Ok(s) = try_lock(prev_sock_path) {
                             info!(
                                 target: LOG_TARGET,
                                 key,
                                 lock_id,
                                 sock_path = %prev_sock_path.display(),
-                                "Previous lock holder still alive"
+                                "Previous lock holder still alive (potentially)"
                             );
                             had_to_wait |= true;
                             self.r#yield_with(|| {
-                                // we are just waiting to get disconnected here
-                                let _ = s.read(&mut [0]);
+                                let _ = clear_lock(s, prev_sock_path).inspect_err(|err| {
+                                    info!(
+                                        %err,
+                                        "Error during waiting for / clearing the old lock"
+                                    )
+                                });
                             })?;
                         } else {
                             debug!(
@@ -289,3 +294,66 @@ fn rm_prev_sock_path(prev_sock_path: &Path) {
         }
     }
 }
+
+// On Darwin Unix Sockets are not automatically removed, and linger,
+// with processes that try to connect to them just hanging. This makes them
+// unsuitable for our needs. Just use a file that we lock exclusively.
+#[cfg(target_os = "macos")]
+pub fn mk_lock(path: &Path) -> Result<fs::File> {
+    let lock_file = fs::File::create(path)?;
+    lock_file.lock_exclusive()?;
+    Ok(lock_file)
+}
+
+// On Linux we can use Unix Sockets as they disappear automatically,
+// which is nice.
+#[cfg(not(target_os = "macos"))]
+pub fn mk_lock(path: &Path) -> Result<UnixListener> {
+    use std::os::unix::net::UnixStream;
+
+    let socket = UnixListener::bind(path)?;
+
+    assert!(UnixStream::connect(path).is_ok());
+
+    Ok(socket)
+}
+
+#[cfg(target_os = "macos")]
+pub fn try_lock(path: &Path) -> Result<fs::File> {
+    let lock_file = fs::File::open(path)?;
+    Ok(lock_file)
+}
+
+#[cfg(not(target_os = "macos"))]
+pub fn try_lock(path: &Path) -> Result<UnixStream> {
+    let socket = UnixStream::connect(path)?;
+
+    Ok(socket)
+}
+
+#[cfg(target_os = "macos")]
+pub fn clear_lock(mut file: fs::File, path: &Path) -> Result<()> {
+    file.lock_exclusive()?;
+
+    // We want to unlock the file, even if we failed to remove it
+    let rm_res = fs::remove_file(path);
+
+    file.unlock()?;
+
+    // if removing failed, report it now
+    rm_res?;
+
+    Ok(())
+}
+
+#[cfg(not(target_os = "macos"))]
+pub fn clear_lock(mut s: UnixStream, _path: &Path) -> Result<()> {
+    // we are just waiting to get disconnected here
+
+    use std::io::Read as _;
+
+    // ignore, we *will* disconnect, nothing interesting about it
+    let _ = s.read(&mut [0]);
+
+    Ok(())
+}