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/lock/src/client/mod.rs

@@ -0,0 +1,115 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub mod local;
+pub mod remote;
+
+use async_trait::async_trait;
+use std::sync::Arc;
+
+use crate::{
+    error::Result,
+    types::{LockId, LockInfo, LockRequest, LockResponse, LockStats},
+};
+
+/// Lock client trait
+#[async_trait]
+pub trait LockClient: Send + Sync {
+    /// Acquire exclusive lock
+    async fn acquire_exclusive(&self, request: LockRequest) -> Result<LockResponse>;
+
+    /// Acquire shared lock
+    async fn acquire_shared(&self, request: LockRequest) -> Result<LockResponse>;
+
+    /// Release lock
+    async fn release(&self, lock_id: &LockId) -> Result<bool>;
+
+    /// Refresh lock
+    async fn refresh(&self, lock_id: &LockId) -> Result<bool>;
+
+    /// Force release lock
+    async fn force_release(&self, lock_id: &LockId) -> Result<bool>;
+
+    /// Check lock status
+    async fn check_status(&self, lock_id: &LockId) -> Result<Option<LockInfo>>;
+
+    /// Get statistics
+    async fn get_stats(&self) -> Result<LockStats>;
+
+    /// Close client
+    async fn close(&self) -> Result<()>;
+
+    /// Check if client is online
+    async fn is_online(&self) -> bool;
+
+    /// Check if client is local
+    async fn is_local(&self) -> bool;
+}
+
+/// Client factory
+pub struct ClientFactory;
+
+impl ClientFactory {
+    /// Create local client
+    pub fn create_local() -> Arc<dyn LockClient> {
+        Arc::new(local::LocalClient::new())
+    }
+
+    /// Create remote client
+    pub fn create_remote(endpoint: String) -> Arc<dyn LockClient> {
+        Arc::new(remote::RemoteClient::new(endpoint))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::LockType;
+
+    #[tokio::test]
+    async fn test_client_factory() {
+        let local_client = ClientFactory::create_local();
+        assert!(local_client.is_local().await);
+
+        let remote_client = ClientFactory::create_remote("http://localhost:8080".to_string());
+        assert!(!remote_client.is_local().await);
+    }
+
+    #[tokio::test]
+    async fn test_local_client_basic_operations() {
+        let client = ClientFactory::create_local();
+
+        let request = crate::types::LockRequest::new("test-resource", LockType::Exclusive, "test-owner");
+
+        // Test lock acquisition
+        let response = client.acquire_exclusive(request).await;
+        assert!(response.is_ok());
+
+        if let Ok(response) = response {
+            if response.success {
+                let lock_info = response.lock_info.unwrap();
+
+                // Test status check
+                let status = client.check_status(&lock_info.id).await;
+                assert!(status.is_ok());
+                assert!(status.unwrap().is_some());
+
+                // Test lock release
+                let released = client.release(&lock_info.id).await;
+                assert!(released.is_ok());
+                assert!(released.unwrap());
+            }
+        }
+    }
+}