Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

fix(pathlock): recover expired empty lock tokens (#4545)

baojun-zhang9262df7a6f53
diff --git a/crates/ragfs-python/src/lib.rs b/crates/ragfs-python/src/lib.rs
index 0eef1ebb2..5f375ef93 100644
--- a/crates/ragfs-python/src/lib.rs
+++ b/crates/ragfs-python/src/lib.rs
@@ -161,7 +161,8 @@ fn pathlock_err_to_py(err: PathLockError) -> PyErr {
PathLockError::Conflict { .. }
| PathLockError::Timeout { .. }
| PathLockError::HandoffFailed(_)
- | PathLockError::Busy { .. } =>
+ | PathLockError::Busy { .. }
+ | PathLockError::EmptyToken { .. } =>
{
#[allow(deprecated)]
Python::with_gil(|py| {
diff --git a/crates/ragfs/src/core/builder.rs b/crates/ragfs/src/core/builder.rs
index 770d465ef..22fcfbb60 100644
--- a/crates/ragfs/src/core/builder.rs
+++ b/crates/ragfs/src/core/builder.rs
@@ -200,7 +200,8 @@ async fn build_stack_with_mountable_and_runtime(
let provider: Arc<dyn PathLockProvider> = match config.pathlock.provider.as_str() {
"memory" => Arc::new(MemoryPathLockProvider::new()),
_ => Arc::new(FilesystemPathLockProvider::new(
- mountable.clone() as Arc<dyn FileSystem>
+ mountable.clone() as Arc<dyn FileSystem>,
+ config.pathlock.lock_expire_secs,
)),
};
let pathlock_manager = Arc::new(PathLockManager::new(
diff --git a/crates/ragfs/src/lock/manager.rs b/crates/ragfs/src/lock/manager.rs
index 94bb86e0f..98bd9fb9a 100644
--- a/crates/ragfs/src/lock/manager.rs
+++ b/crates/ragfs/src/lock/manager.rs
@@ -681,7 +681,9 @@ impl PathLockManager {
fn is_retryable_error(error: &PathLockError) -> bool {
matches!(
error,
- PathLockError::Conflict { .. } | PathLockError::Busy { .. }
+ PathLockError::Conflict { .. }
+ | PathLockError::Busy { .. }
+ | PathLockError::EmptyToken { .. }
)
}
@@ -2402,6 +2404,7 @@ mod tests {
fs.mkdir("/data/delete-me", 0o755).await.unwrap();
let provider = Arc::new(crate::lock::provider::FilesystemPathLockProvider::new(
fs.clone(),
+ PathLockConfig::default().lock_expire_secs,
));
let mgr = PathLockManager::new(fs.clone(), provider, PathLockConfig::default());
let lease = mgr
diff --git a/crates/ragfs/src/lock/provider.rs b/crates/ragfs/src/lock/provider.rs
index 1459d3885..3c00eaac3 100644
--- a/crates/ragfs/src/lock/provider.rs
+++ b/crates/ragfs/src/lock/provider.rs
@@ -9,9 +9,9 @@ use std::sync::Arc;
use async_trait::async_trait;
use tokio::sync::RwLock;
-use crate::crypto;
use crate::core::internal_names::is_hidden_runtime_lock_name;
use crate::core::FileSystem;
+use crate::crypto;
use super::codec::LockTokenCodec;
use super::types::{LockToken, PathLockError, PathLockResult};
@@ -164,12 +164,19 @@ impl PathLockProvider for MemoryPathLockProvider {
/// Lock provider that stores tokens as files on the underlying filesystem.
pub struct FilesystemPathLockProvider {
fs: Arc<dyn FileSystem>,
+ empty_token_expire_secs: f64,
}
impl FilesystemPathLockProvider {
- /// Create a filesystem-backed provider.
- pub fn new(fs: Arc<dyn FileSystem>) -> Self {
- Self { fs }
+ /// Create a filesystem-backed provider with an explicit empty-token expiry.
+ ///
+ /// `fs` stores lock files, and `lock_expire_secs` controls empty-token recovery.
+ /// Returns a configured filesystem provider.
+ pub fn new(fs: Arc<dyn FileSystem>, lock_expire_secs: f64) -> Self {
+ Self {
+ fs,
+ empty_token_expire_secs: lock_expire_secs,
+ }
}
/// Read raw token bytes from `lock_path`, returning `None` if no token exists.
@@ -217,10 +224,15 @@ mod tests {
async fn read_token_cleans_up_legacy_encrypted_lock() {
let fs = Arc::new(MemFileSystem::new());
fs.mkdir("/data", 0o755).await.unwrap();
- fs.write("/data/.path.ovlock", b"OVE1legacy-ciphertext", 0, WriteFlag::Create)
- .await
- .unwrap();
- let provider = FilesystemPathLockProvider::new(fs.clone());
+ fs.write(
+ "/data/.path.ovlock",
+ b"OVE1legacy-ciphertext",
+ 0,
+ WriteFlag::Create,
+ )
+ .await
+ .unwrap();
+ let provider = FilesystemPathLockProvider::new(fs.clone(), 30.0);
let token = provider.read_token("/data/.path.ovlock").await.unwrap();
@@ -239,7 +251,7 @@ mod tests {
fs.write("/data/.path.ovlock", b"not-a-token", 0, WriteFlag::Create)
.await
.unwrap();
- let provider = FilesystemPathLockProvider::new(fs.clone());
+ let provider = FilesystemPathLockProvider::new(fs.clone(), 30.0);
let err = provider.read_token("/data/.path.ovlock").await.unwrap_err();
@@ -258,9 +270,13 @@ mod tests {
fs.write("/data/.path.ovlock", b"owner:123:E", 0, WriteFlag::Create)
.await
.unwrap();
- let provider = FilesystemPathLockProvider::new(fs);
+ let provider = FilesystemPathLockProvider::new(fs, 30.0);
- let token = provider.read_token("/data/.path.ovlock").await.unwrap().unwrap();
+ let token = provider
+ .read_token("/data/.path.ovlock")
+ .await
+ .unwrap()
+ .unwrap();
assert_eq!(token.owner_id, "owner");
assert_eq!(token.time_ns, 123);
@@ -289,10 +305,31 @@ impl PathLockProvider for FilesystemPathLockProvider {
loop {
match current {
Some(data) => {
- let raw = String::from_utf8_lossy(&data).trim().to_string();
- if raw.is_empty() {
+ if data.is_empty() {
+ let info = match self.fs.stat(lock_path).await {
+ Ok(info) => info,
+ Err(
+ crate::core::Error::NotFound(_)
+ | crate::core::Error::MountPointNotFound(_),
+ ) => return Ok(None),
+ Err(error) => {
+ return Err(PathLockError::Io(format!(
+ "failed to stat empty lock token at '{lock_path}': {error}"
+ )));
+ }
+ };
+ let age = std::time::SystemTime::now()
+ .duration_since(info.mod_time)
+ .unwrap_or_default()
+ .as_secs_f64();
+ if age <= self.empty_token_expire_secs {
+ return Err(PathLockError::EmptyToken {
+ lock_path: lock_path.to_string(),
+ });
+ }
return Ok(None);
}
+ let raw = String::from_utf8_lossy(&data).trim().to_string();
match LockTokenCodec::decode(&raw) {
Ok(token) => return Ok(Some(token)),
Err(error) if crypto::is_encrypted(&data) => {
@@ -300,7 +337,13 @@ impl PathLockProvider for FilesystemPathLockProvider {
.fs
.compare_and_remove(lock_path, &data)
.await
- .map_err(|e| Self::map_cas_error("legacy encrypted lock cleanup", lock_path, e))?
+ .map_err(|e| {
+ Self::map_cas_error(
+ "legacy encrypted lock cleanup",
+ lock_path,
+ e,
+ )
+ })?
{
return Ok(None);
}
@@ -318,27 +361,42 @@ impl PathLockProvider for FilesystemPathLockProvider {
use crate::core::WriteFlag;
let encoded = LockTokenCodec::encode(token);
- match self
- .fs
- .write(lock_path, encoded.as_bytes(), 0, WriteFlag::CreateNew)
- .await
- {
- Ok(_) => Ok(()),
- Err(_) => {
+ let mut last_error = None;
+ for _ in 0..2 {
+ let error = match self
+ .fs
+ .write(lock_path, encoded.as_bytes(), 0, WriteFlag::CreateNew)
+ .await
+ {
+ Ok(_) => return Ok(()),
+ Err(error) => error,
+ };
+ match self.read_token(lock_path).await? {
// Already exists — read and check if stale.
- let existing = self.read_token(lock_path).await?;
- match existing {
- Some(t) => Err(PathLockError::Conflict {
+ Some(t) => {
+ return Err(PathLockError::Conflict {
lock_path: lock_path.to_string(),
owner: t.owner_id,
kind: t.lock_type,
- }),
- None => Err(PathLockError::Io(format!(
- "failed to create lock token at {lock_path}"
- ))),
+ });
+ }
+ None => {
+ last_error = Some(error);
+ if self
+ .fs
+ .compare_and_write(lock_path, b"", encoded.as_bytes())
+ .await
+ .map_err(|e| Self::map_cas_error("empty lock recovery", lock_path, e))?
+ {
+ return Ok(());
+ }
}
}
}
+ Err(PathLockError::Io(format!(
+ "failed to create lock token at {lock_path}: {}",
+ last_error.unwrap()
+ )))
}
async fn compare_and_write_token(
@@ -407,11 +465,7 @@ impl FilesystemPathLockProvider {
is_hidden_runtime_lock_name(name)
}
- async fn scan_recursive(
- &self,
- dir: &str,
- result: &mut Vec<String>,
- ) -> PathLockResult<()> {
+ async fn scan_recursive(&self, dir: &str, result: &mut Vec<String>) -> PathLockResult<()> {
let entries = match self.fs.read_internal_dir(dir).await {
Ok(entries) => entries,
Err(crate::core::Error::NotFound(_) | crate::core::Error::NotADirectory(_)) => {
diff --git a/crates/ragfs/src/lock/types.rs b/crates/ragfs/src/lock/types.rs
index 24eb9c8c6..8cdbba3a7 100644
--- a/crates/ragfs/src/lock/types.rs
+++ b/crates/ragfs/src/lock/types.rs
@@ -196,6 +196,13 @@ pub enum PathLockError {
#[error("invalid lock token: {0}")]
InvalidToken(String),
+ /// Lock file exists but contains no token data.
+ #[error("empty lock token at '{lock_path}'")]
+ EmptyToken {
+ /// Lock path containing the empty token.
+ lock_path: String,
+ },
+
/// Invalid lock request supplied by a caller.
#[error("invalid lock request: {0}")]
InvalidRequest(String),