use std::fs::File;
use std::path::{Path, PathBuf};
use std::time::Duration;
use fs4::fs_std::FileExt;
use sha2::{Digest, Sha256};
use super::sidecar::{self, Sidecar, SidecarState};
use crate::pager::LockedFile;
pub(crate) fn file_name(agent: &str) -> String {
let h = Sha256::digest(agent.as_bytes());
let hex: String = h[..8].iter().map(|b| format!("{b:02x}")).collect();
format!("presence.{hex}.lock")
}
#[cfg(unix)]
fn identity(f: &File) -> Option<(u64, u64)> {
use std::os::unix::fs::MetadataExt;
f.metadata().ok().map(|m| (m.dev(), m.ino()))
}
#[cfg(not(unix))]
fn identity(_f: &File) -> Option<(u64, u64)> {
Some((0, 0))
}
pub(crate) struct PresenceLock {
brain: PathBuf,
name: String,
side: Sidecar,
file: Option<LockedFile>,
id: Option<(u64, u64)>,
}
impl std::fmt::Debug for PresenceLock {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PresenceLock")
.field("name", &self.name)
.field("held", &self.file.is_some())
.finish()
}
}
impl PresenceLock {
pub(crate) fn take(brain: &Path, agent: &str) -> std::io::Result<PresenceLock> {
let brain = std::fs::canonicalize(brain)?;
let side = match sidecar::open(&brain) {
SidecarState::Ready(s) => s,
SidecarState::Unavailable(why) => return Err(std::io::Error::other(why)),
};
let mut p = PresenceLock {
brain,
name: file_name(agent),
side,
file: None,
id: None,
};
p.lock()?;
Ok(p)
}
fn lock(&mut self) -> std::io::Result<()> {
let f = self.side.lock_file(&self.name)?;
let mut tries = 0;
loop {
match FileExt::try_lock_shared(&f) {
Ok(()) => break,
Err(e) if tries >= 50 => return Err(e),
Err(_) => {
tries += 1;
std::thread::sleep(Duration::from_millis(2));
}
}
}
self.id = identity(&f);
self.file = Some(LockedFile::new(f));
Ok(())
}
pub(crate) fn refresh(&mut self) {
let now = self
.side
.open_existing(&self.name, false)
.ok()
.and_then(|f| identity(&f));
if self.file.is_some() && now.is_some() && now == self.id {
return;
}
self.file = None;
if let SidecarState::Ready(s) = sidecar::open(&self.brain) {
self.side = s;
}
let _ = self.lock();
}
}
pub(crate) fn probe(brain: &Path, agent: &str) -> Option<bool> {
probe_with(brain, agent, true)
}
pub(crate) fn probe_once(brain: &Path, agent: &str) -> Option<bool> {
probe_with(brain, agent, false)
}
fn probe_with(brain: &Path, agent: &str, retry: bool) -> Option<bool> {
let brain = std::fs::canonicalize(brain).ok()?;
let side = sidecar::open_if_present(&brain)?;
let name = file_name(agent);
for attempt in 0..(1 + usize::from(retry)) {
let f = side.open_existing(&name, true).ok()?;
match FileExt::try_lock_exclusive(&f) {
Ok(()) => {
let held = LockedFile::new(f);
let mine = identity(&held);
let named = side
.open_existing(&name, false)
.ok()
.and_then(|g| identity(&g));
drop(held);
return (mine.is_some() && mine == named).then_some(false);
}
Err(_) if attempt == 0 && retry => std::thread::sleep(Duration::from_millis(20)),
Err(_) => return Some(true),
}
}
None
}