refactor(lock): restructure lock crate, remove unused modules and clarify directory layout

- Remove unused core/rwlock.rs and manager/ modules (ManagerFactory, LifecycleManager, NamespaceManager)
- Move all lock-related code into crates/lock/src with clear submodules: client, core, utils, etc.
- Ensure only necessary files and APIs are exposed, improve maintainability
- No functional logic change, pure structure and cleanup refactor

Signed-off-by: dandan <dandan@dandandeMac-Studio.local>

crates/ecstore/src/client/object_handlers_common.rs

@@ -18,7 +18,7 @@ use crate::bucket::versioning::VersioningApi;
 use crate::bucket::versioning_sys::BucketVersioningSys;
 use crate::store::ECStore;
 use crate::store_api::{ObjectOptions, ObjectToDelete};
-use rustfs_lock::local_locker::MAX_DELETE_LIST;
+use rustfs_lock::MAX_DELETE_LIST;
 
 pub async fn delete_object_versions(api: ECStore, bucket: &str, to_del: &[ObjectToDelete], _lc_event: lifecycle::Event) {
     let mut remaining = to_del;

crates/ecstore/src/rpc/tonic_service.rs

@@ -34,7 +34,7 @@ use crate::{
 };
 use futures::{Stream, StreamExt};
 use futures_util::future::join_all;
-use rustfs_lock::{GLOBAL_LOCAL_SERVER, Locker, lock_args::LockArgs};
+use rustfs_lock::{GLOBAL_LOCAL_SERVER, core::local::LocalLockManager, lock_args::LockArgs};
 
 use rustfs_common::globals::GLOBAL_Local_Node_Name;
 
@@ -1527,16 +1527,28 @@ impl Node for NodeService {
     async fn lock(&self, request: Request<GenerallyLockRequest>) -> Result<Response<GenerallyLockResponse>, Status> {
         let request = request.into_inner();
         match &serde_json::from_str::<LockArgs>(&request.args) {
-            Ok(args) => match GLOBAL_LOCAL_SERVER.write().await.lock(args).await {
-                Ok(result) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: result,
-                    error_info: None,
-                })),
-                Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: false,
-                    error_info: Some(format!("can not lock, args: {args}, err: {err}")),
-                })),
-            },
+            Ok(args) => {
+                let resource = match args.resources.first() {
+                    Some(r) => r,
+                    None => {
+                        return Ok(tonic::Response::new(GenerallyLockResponse {
+                            success: false,
+                            error_info: Some("No resource specified".to_string()),
+                        }));
+                    }
+                };
+                let timeout = std::time::Duration::from_secs(30);
+                match GLOBAL_LOCAL_SERVER.write().await.lock(resource, &args.owner, timeout).await {
+                    Ok(result) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: result,
+                        error_info: None,
+                    })),
+                    Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: false,
+                        error_info: Some(format!("can not lock, args: {args}, err: {err}")),
+                    })),
+                }
+            }
             Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
                 success: false,
                 error_info: Some(format!("can not decode args, err: {err}")),
@@ -1547,16 +1559,27 @@ impl Node for NodeService {
     async fn un_lock(&self, request: Request<GenerallyLockRequest>) -> Result<Response<GenerallyLockResponse>, Status> {
         let request = request.into_inner();
         match &serde_json::from_str::<LockArgs>(&request.args) {
-            Ok(args) => match GLOBAL_LOCAL_SERVER.write().await.unlock(args).await {
-                Ok(result) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: result,
-                    error_info: None,
-                })),
-                Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: false,
-                    error_info: Some(format!("can not unlock, args: {args}, err: {err}")),
-                })),
-            },
+            Ok(args) => {
+                let resource = match args.resources.first() {
+                    Some(r) => r,
+                    None => {
+                        return Ok(tonic::Response::new(GenerallyLockResponse {
+                            success: false,
+                            error_info: Some("No resource specified".to_string()),
+                        }));
+                    }
+                };
+                match GLOBAL_LOCAL_SERVER.write().await.unlock(resource, &args.owner).await {
+                    Ok(_) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: true,
+                        error_info: None,
+                    })),
+                    Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: false,
+                        error_info: Some(format!("can not unlock, args: {args}, err: {err}")),
+                    })),
+                }
+            }
             Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
                 success: false,
                 error_info: Some(format!("can not decode args, err: {err}")),
@@ -1567,16 +1590,28 @@ impl Node for NodeService {
     async fn r_lock(&self, request: Request<GenerallyLockRequest>) -> Result<Response<GenerallyLockResponse>, Status> {
         let request = request.into_inner();
         match &serde_json::from_str::<LockArgs>(&request.args) {
-            Ok(args) => match GLOBAL_LOCAL_SERVER.write().await.rlock(args).await {
-                Ok(result) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: result,
-                    error_info: None,
-                })),
-                Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: false,
-                    error_info: Some(format!("can not rlock, args: {args}, err: {err}")),
-                })),
-            },
+            Ok(args) => {
+                let resource = match args.resources.first() {
+                    Some(r) => r,
+                    None => {
+                        return Ok(tonic::Response::new(GenerallyLockResponse {
+                            success: false,
+                            error_info: Some("No resource specified".to_string()),
+                        }));
+                    }
+                };
+                let timeout = std::time::Duration::from_secs(30);
+                match GLOBAL_LOCAL_SERVER.write().await.rlock(resource, &args.owner, timeout).await {
+                    Ok(result) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: result,
+                        error_info: None,
+                    })),
+                    Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: false,
+                        error_info: Some(format!("can not rlock, args: {args}, err: {err}")),
+                    })),
+                }
+            }
             Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
                 success: false,
                 error_info: Some(format!("can not decode args, err: {err}")),
@@ -1587,16 +1622,27 @@ impl Node for NodeService {
     async fn r_un_lock(&self, request: Request<GenerallyLockRequest>) -> Result<Response<GenerallyLockResponse>, Status> {
         let request = request.into_inner();
         match &serde_json::from_str::<LockArgs>(&request.args) {
-            Ok(args) => match GLOBAL_LOCAL_SERVER.write().await.runlock(args).await {
-                Ok(result) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: result,
-                    error_info: None,
-                })),
-                Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: false,
-                    error_info: Some(format!("can not runlock, args: {args}, err: {err}")),
-                })),
-            },
+            Ok(args) => {
+                let resource = match args.resources.first() {
+                    Some(r) => r,
+                    None => {
+                        return Ok(tonic::Response::new(GenerallyLockResponse {
+                            success: false,
+                            error_info: Some("No resource specified".to_string()),
+                        }));
+                    }
+                };
+                match GLOBAL_LOCAL_SERVER.write().await.runlock(resource, &args.owner).await {
+                    Ok(_) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: true,
+                        error_info: None,
+                    })),
+                    Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: false,
+                        error_info: Some(format!("can not runlock, args: {args}, err: {err}")),
+                    })),
+                }
+            }
             Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
                 success: false,
                 error_info: Some(format!("can not decode args, err: {err}")),
@@ -1607,16 +1653,27 @@ impl Node for NodeService {
     async fn force_un_lock(&self, request: Request<GenerallyLockRequest>) -> Result<Response<GenerallyLockResponse>, Status> {
         let request = request.into_inner();
         match &serde_json::from_str::<LockArgs>(&request.args) {
-            Ok(args) => match GLOBAL_LOCAL_SERVER.write().await.force_unlock(args).await {
-                Ok(result) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: result,
-                    error_info: None,
-                })),
-                Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: false,
-                    error_info: Some(format!("can not force_unlock, args: {args}, err: {err}")),
-                })),
-            },
+            Ok(args) => {
+                let resource = match args.resources.first() {
+                    Some(r) => r,
+                    None => {
+                        return Ok(tonic::Response::new(GenerallyLockResponse {
+                            success: false,
+                            error_info: Some("No resource specified".to_string()),
+                        }));
+                    }
+                };
+                match GLOBAL_LOCAL_SERVER.write().await.unlock(resource, &args.owner).await {
+                    Ok(_) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: true,
+                        error_info: None,
+                    })),
+                    Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
+                        success: false,
+                        error_info: Some(format!("can not force_unlock, args: {args}, err: {err}")),
+                    })),
+                }
+            }
             Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
                 success: false,
                 error_info: Some(format!("can not decode args, err: {err}")),
@@ -1627,16 +1684,13 @@ impl Node for NodeService {
     async fn refresh(&self, request: Request<GenerallyLockRequest>) -> Result<Response<GenerallyLockResponse>, Status> {
         let request = request.into_inner();
         match &serde_json::from_str::<LockArgs>(&request.args) {
-            Ok(args) => match GLOBAL_LOCAL_SERVER.write().await.refresh(args).await {
-                Ok(result) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: result,
+            Ok(_args) => {
+                // 本地锁不需要刷新
+                Ok(tonic::Response::new(GenerallyLockResponse {
+                    success: true,
                     error_info: None,
-                })),
-                Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
-                    success: false,
-                    error_info: Some(format!("can not refresh, args: {args}, err: {err}")),
-                })),
-            },
+                }))
+            }
             Err(err) => Ok(tonic::Response::new(GenerallyLockResponse {
                 success: false,
                 error_info: Some(format!("can not decode args, err: {err}")),

crates/ecstore/src/set_disk.rs

@@ -83,7 +83,7 @@ use rustfs_filemeta::{
     headers::{AMZ_OBJECT_TAGGING, AMZ_STORAGE_CLASS},
     merge_file_meta_versions,
 };
-use rustfs_lock::{LockApi, namespace_lock::NsLockMap};
+use rustfs_lock::{LockApi, NsLockMap};
 use rustfs_madmin::heal_commands::{HealDriveInfo, HealResultItem};
 use rustfs_rio::{EtagResolvable, HashReader, TryGetIndex as _, WarpReader};
 use rustfs_utils::{
@@ -121,11 +121,11 @@ use uuid::Uuid;
 pub const DEFAULT_READ_BUFFER_SIZE: usize = 1024 * 1024;
 pub const MAX_PARTS_COUNT: usize = 10000;
 
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug)]
 pub struct SetDisks {
     pub lockers: Vec<LockApi>,
     pub locker_owner: String,
-    pub ns_mutex: Arc<RwLock<NsLockMap>>,
+    pub ns_mutex: Arc<NsLockMap>,
     pub disks: Arc<RwLock<Vec<Option<DiskStore>>>>,
     pub set_endpoints: Vec<Endpoint>,
     pub set_drive_count: usize,
@@ -140,7 +140,7 @@ impl SetDisks {
     pub async fn new(
         lockers: Vec<LockApi>,
         locker_owner: String,
-        ns_mutex: Arc<RwLock<NsLockMap>>,
+        ns_mutex: Arc<NsLockMap>,
         disks: Arc<RwLock<Vec<Option<DiskStore>>>>,
         set_drive_count: usize,
         default_parity_count: usize,
@@ -4066,33 +4066,28 @@ impl ObjectIO for SetDisks {
     async fn put_object(&self, bucket: &str, object: &str, data: &mut PutObjReader, opts: &ObjectOptions) -> Result<ObjectInfo> {
         let disks = self.disks.read().await;
 
-        // let mut _ns = None;
-        // if !opts.no_lock {
-        //     let paths = vec![object.to_string()];
-        //     let ns_lock = new_nslock(
-        //         Arc::clone(&self.ns_mutex),
-        //         self.locker_owner.clone(),
-        //         bucket.to_string(),
-        //         paths,
-        //         self.lockers.clone(),
-        //     )
-        //     .await;
-        //     if !ns_lock
-        //         .0
-        //         .write()
-        //         .await
-        //         .get_lock(&Options {
-        //             timeout: Duration::from_secs(5),
-        //             retry_interval: Duration::from_secs(1),
-        //         })
-        //         .await
-        //         .map_err(|err| Error::other(err.to_string()))?
-        //     {
-        //         return Err(Error::other("can not get lock. please retry".to_string()));
-        //     }
+        // 获取对象锁
+        let mut _ns = None;
+        if !opts.no_lock {
+            let paths = vec![object.to_string()];
+            let ns_lock = self
+                .ns_mutex
+                .new_nslock(None)
+                .await
+                .map_err(|err| Error::other(err.to_string()))?;
 
-        //     _ns = Some(ns_lock);
-        // }
+            // 尝试获取锁
+            let lock_acquired = ns_lock
+                .lock_batch(&paths, &self.locker_owner, std::time::Duration::from_secs(5))
+                .await
+                .map_err(|err| Error::other(err.to_string()))?;
+
+            if !lock_acquired {
+                return Err(Error::other("can not get lock. please retry".to_string()));
+            }
+
+            _ns = Some(ns_lock);
+        }
 
         let mut user_defined = opts.user_defined.clone();
 
@@ -4298,9 +4293,13 @@ impl ObjectIO for SetDisks {
 
         self.delete_all(RUSTFS_META_TMP_BUCKET, &tmp_dir).await?;
 
-        // if let Some(mut locker) = ns {
-        //     locker.un_lock().await.map_err(|err| Error::other(err.to_string()))?;
-        // }
+        // 释放对象锁
+        if let Some(ns_lock) = _ns {
+            let paths = vec![object.to_string()];
+            if let Err(err) = ns_lock.unlock_batch(&paths, &self.locker_owner).await {
+                error!("Failed to unlock object {}: {}", object, err);
+            }
+        }
 
         for (i, op_disk) in online_disks.iter().enumerate() {
             if let Some(disk) = op_disk {

crates/ecstore/src/sets.rs

@@ -43,7 +43,7 @@ use futures::future::join_all;
 use http::HeaderMap;
 use rustfs_common::globals::GLOBAL_Local_Node_Name;
 use rustfs_filemeta::FileInfo;
-use rustfs_lock::{LockApi, namespace_lock::NsLockMap, new_lock_api};
+use rustfs_lock::{LockApi, NsLockMap, new_lock_api};
 use rustfs_madmin::heal_commands::{HealDriveInfo, HealResultItem};
 use rustfs_utils::{crc_hash, path::path_join_buf, sip_hash};
 use tokio::sync::RwLock;
@@ -170,7 +170,7 @@ impl Sets {
             let set_disks = SetDisks::new(
                 locker.clone(),
                 GLOBAL_Local_Node_Name.read().await.to_string(),
-                Arc::new(RwLock::new(NsLockMap::new(is_dist_erasure().await))),
+                Arc::new(NsLockMap::new(is_dist_erasure().await, None)),
                 Arc::new(RwLock::new(set_drive)),
                 set_drive_count,
                 parity_count,