Refactor RPC Authentication System for Improved Maintainability (#1391)

crates/lock/src/client/mod.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 pub mod local;
-pub mod remote;
+// pub mod remote;
 
 use async_trait::async_trait;
 use std::sync::Arc;
@@ -74,10 +74,10 @@ impl ClientFactory {
         Arc::new(local::LocalClient::new())
     }
 
-    /// Create remote client
-    pub fn create_remote(endpoint: String) -> Arc<dyn LockClient> {
-        Arc::new(remote::RemoteClient::new(endpoint))
-    }
+    // /// Create remote client
+    // pub fn create_remote(endpoint: String) -> Arc<dyn LockClient> {
+    //     Arc::new(remote::RemoteClient::new(endpoint))
+    // }
 }
 
 #[cfg(test)]
@@ -85,15 +85,6 @@ 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();

crates/lock/src/client/remote.rs

@@ -14,7 +14,7 @@
 
 use async_trait::async_trait;
 use rustfs_protos::{
-    node_service_time_out_client,
+    node_service_time_out_client, node_service_time_out_client_no_auth,
     proto_gen::node_service::{GenerallyLockRequest, PingRequest},
 };
 use std::collections::HashMap;
@@ -82,7 +82,7 @@ impl RemoteClient {
 impl LockClient for RemoteClient {
     async fn acquire_exclusive(&self, request: &LockRequest) -> Result<LockResponse> {
         info!("remote acquire_exclusive for {}", request.resource);
-        let mut client = node_service_time_out_client(&self.addr)
+        let mut client = node_service_time_out_client_no_auth(&self.addr)
             .await
             .map_err(|err| LockError::internal(format!("can not get client, err: {err}")))?;
         let req = Request::new(GenerallyLockRequest {
@@ -133,7 +133,7 @@ impl LockClient for RemoteClient {
 
     async fn acquire_shared(&self, request: &LockRequest) -> Result<LockResponse> {
         info!("remote acquire_shared for {}", request.resource);
-        let mut client = node_service_time_out_client(&self.addr)
+        let mut client = node_service_time_out_client_no_auth(&self.addr)
             .await
             .map_err(|err| LockError::internal(format!("can not get client, err: {err}")))?;
         let req = Request::new(GenerallyLockRequest {
@@ -195,7 +195,7 @@ impl LockClient for RemoteClient {
 
         let request_string = serde_json::to_string(&unlock_request)
             .map_err(|e| LockError::internal(format!("Failed to serialize request: {e}")))?;
-        let mut client = node_service_time_out_client(&self.addr)
+        let mut client = node_service_time_out_client_no_auth(&self.addr)
             .await
             .map_err(|err| LockError::internal(format!("can not get client, err: {err}")))?;
 
@@ -238,7 +238,7 @@ impl LockClient for RemoteClient {
     async fn refresh(&self, lock_id: &LockId) -> Result<bool> {
         info!("remote refresh for {}", lock_id);
         let refresh_request = self.create_unlock_request(lock_id, "remote");
-        let mut client = node_service_time_out_client(&self.addr)
+        let mut client = node_service_time_out_client_no_auth(&self.addr)
             .await
             .map_err(|err| LockError::internal(format!("can not get client, err: {err}")))?;
         let req = Request::new(GenerallyLockRequest {
@@ -259,7 +259,7 @@ impl LockClient for RemoteClient {
     async fn force_release(&self, lock_id: &LockId) -> Result<bool> {
         info!("remote force_release for {}", lock_id);
         let force_request = self.create_unlock_request(lock_id, "remote");
-        let mut client = node_service_time_out_client(&self.addr)
+        let mut client = node_service_time_out_client_no_auth(&self.addr)
             .await
             .map_err(|err| LockError::internal(format!("can not get client, err: {err}")))?;
         let req = Request::new(GenerallyLockRequest {
@@ -283,7 +283,7 @@ impl LockClient for RemoteClient {
         // Since there's no direct status query in the gRPC service,
         // we attempt a non-blocking lock acquisition to check if the resource is available
         let status_request = self.create_unlock_request(lock_id, "remote");
-        let mut client = node_service_time_out_client(&self.addr)
+        let mut client = node_service_time_out_client_no_auth(&self.addr)
             .await
             .map_err(|err| LockError::internal(format!("can not get client, err: {err}")))?;
 
@@ -372,7 +372,7 @@ impl LockClient for RemoteClient {
 
     async fn is_online(&self) -> bool {
         // Use Ping interface to test if remote service is online
-        let mut client = match node_service_time_out_client(&self.addr).await {
+        let mut client = match self.get_client().await {
             Ok(client) => client,
             Err(_) => {
                 info!("remote client {} connection failed", self.addr);

crates/lock/src/lib.rs

@@ -37,7 +37,7 @@ pub mod types;
 // Re-export main types for easy access
 pub use crate::{
     // Client interfaces
-    client::{LockClient, local::LocalClient, remote::RemoteClient},
+    client::{LockClient, local::LocalClient},
     // Error types
     error::{LockError, Result},
     // Fast Lock System exports