1use std::io::Write;
16use std::path::{Path, PathBuf};
17use std::time::{Duration, Instant, SystemTime};
18
19use crate::error::{KitError, KitResult};
20
21pub const STALE_AFTER: Duration = Duration::from_secs(30 * 60);
26
27const POLL_INTERVAL: Duration = Duration::from_millis(120);
29
30#[derive(Debug)]
32pub struct FileLock {
33 path: PathBuf,
34}
35
36impl FileLock {
37 pub fn acquire(path: &Path, timeout: Duration) -> KitResult<Self> {
44 Self::acquire_with_stale_after(path, timeout, STALE_AFTER)
45 }
46
47 pub(crate) fn acquire_with_stale_after(
52 path: &Path,
53 timeout: Duration,
54 stale_after: Duration,
55 ) -> KitResult<Self> {
56 if let Some(parent) = path.parent() {
57 std::fs::create_dir_all(parent).map_err(|source| KitError::LockIo {
58 path: path.to_path_buf(),
59 source,
60 })?;
61 }
62
63 let deadline = Instant::now() + timeout;
64
65 loop {
66 match Self::try_create(path) {
67 Ok(lock) => return Ok(lock),
68 Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
69 if Self::take_over_if_stale(path, stale_after)? {
71 continue;
72 }
73 if Instant::now() >= deadline {
74 return Err(KitError::LockTimeout {
75 path: path.to_path_buf(),
76 secs: timeout.as_secs(),
77 });
78 }
79 std::thread::sleep(POLL_INTERVAL);
80 }
81 Err(source) => {
82 return Err(KitError::LockIo {
83 path: path.to_path_buf(),
84 source,
85 })
86 }
87 }
88 }
89 }
90
91 fn try_create(path: &Path) -> std::io::Result<Self> {
92 let mut f = std::fs::OpenOptions::new()
93 .write(true)
94 .create_new(true)
95 .open(path)?;
96
97 let _ = writeln!(f, "pid={} at={:?}", std::process::id(), SystemTime::now());
99
100 Ok(Self {
101 path: path.to_path_buf(),
102 })
103 }
104
105 fn take_over_if_stale(path: &Path, stale_after: Duration) -> KitResult<bool> {
107 let Ok(meta) = std::fs::metadata(path) else {
108 return Ok(true);
110 };
111 let Ok(modified) = meta.modified() else {
112 return Ok(false);
113 };
114 let Ok(age) = SystemTime::now().duration_since(modified) else {
115 return Ok(false);
117 };
118
119 if age < stale_after {
120 return Ok(false);
121 }
122
123 match std::fs::remove_file(path) {
124 Ok(()) => Ok(true),
125 Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(true),
127 Err(source) => Err(KitError::LockIo {
128 path: path.to_path_buf(),
129 source,
130 }),
131 }
132 }
133}
134
135impl Drop for FileLock {
136 fn drop(&mut self) {
137 let _ = std::fs::remove_file(&self.path);
138 }
139}
140
141#[cfg(test)]
142mod tests {
143 use super::*;
144
145 fn lock_path(dir: &tempfile::TempDir) -> PathBuf {
146 dir.path().join(".lock")
147 }
148
149 #[test]
150 fn acquires_and_creates_parent_directories() {
151 let dir = tempfile::tempdir().unwrap();
152 let path = dir.path().join("nested").join("deeper").join(".lock");
154
155 let lock = FileLock::acquire(&path, Duration::from_millis(50)).expect("应当能取到锁");
156 assert!(path.is_file(), "锁文件应当已创建");
157 drop(lock);
158 }
159
160 #[test]
161 fn releases_on_drop() {
162 let dir = tempfile::tempdir().unwrap();
163 let path = lock_path(&dir);
164
165 {
166 let _lock = FileLock::acquire(&path, Duration::from_millis(50)).unwrap();
167 assert!(path.is_file());
168 }
169
170 assert!(!path.exists(), "drop 之后锁文件应当被删掉");
171 }
172
173 #[test]
175 fn a_second_holder_times_out() {
176 let dir = tempfile::tempdir().unwrap();
177 let path = lock_path(&dir);
178
179 let _first = FileLock::acquire(&path, Duration::from_millis(50)).unwrap();
180
181 let err = FileLock::acquire(&path, Duration::from_millis(120));
182 assert!(
183 matches!(err, Err(KitError::LockTimeout { .. })),
184 "期望 LockTimeout,得到 {err:?}"
185 );
186 }
187
188 #[test]
190 fn a_later_holder_succeeds_after_release() {
191 let dir = tempfile::tempdir().unwrap();
192 let path = lock_path(&dir);
193
194 let first = FileLock::acquire(&path, Duration::from_millis(50)).unwrap();
195 drop(first);
196
197 let _second = FileLock::acquire(&path, Duration::from_millis(200)).expect("应当能接上");
198 }
199
200 #[test]
205 fn takes_over_a_stale_lock() {
206 let dir = tempfile::tempdir().unwrap();
207 let path = lock_path(&dir);
208
209 std::fs::write(&path, "pid=1 at=<stale>").unwrap();
210
211 let _lock =
212 FileLock::acquire_with_stale_after(&path, Duration::from_millis(500), Duration::ZERO)
213 .expect("陈旧的锁应当被接管");
214 }
215
216 #[test]
218 fn does_not_steal_a_fresh_lock() {
219 let dir = tempfile::tempdir().unwrap();
220 let path = lock_path(&dir);
221
222 std::fs::write(&path, "pid=1 at=<fresh>").unwrap();
223
224 let err =
226 FileLock::acquire_with_stale_after(&path, Duration::from_millis(120), STALE_AFTER);
227 assert!(
228 matches!(err, Err(KitError::LockTimeout { .. })),
229 "新鲜的锁不该被抢走"
230 );
231 }
232
233 #[test]
235 fn writes_diagnostic_content() {
236 let dir = tempfile::tempdir().unwrap();
237 let path = lock_path(&dir);
238
239 let _lock = FileLock::acquire(&path, Duration::from_millis(50)).unwrap();
240
241 let text = std::fs::read_to_string(&path).unwrap();
242 assert!(text.contains("pid="), "锁文件内容:{text:?}");
243 assert!(text.contains(&std::process::id().to_string()));
244 }
245}