improve code

common/lock/src/local_locker.rs

@@ -275,14 +275,35 @@ impl Locker for LocalLocker {
         Ok(reply)
     }
 
-    async fn close(&self) {}
+    async fn refresh(&mut self, args: &LockArgs) -> Result<bool> {
+        let mut idx = 0;
+        let mut key = args.uid.to_string();
+        format_uuid(&mut key, &idx);
+        match self.lock_uid.get(&key) {
+            Some(resource) => {
+                let mut resource = resource;
+                loop {
+                    match self.lock_map.get_mut(resource) {
+                        Some(_lris) => {}
+                        None => {
+                            let mut key = args.uid.to_string();
+                            format_uuid(&mut key, &0);
+                            self.lock_uid.remove(&key);
+                            return Ok(idx > 0);
+                        }
+                    }
 
-    async fn is_online(&self) -> bool {
-        true
-    }
-
-    async fn is_local(&self) -> bool {
-        true
+                    idx += 1;
+                    let mut key = args.uid.to_string();
+                    format_uuid(&mut key, &idx);
+                    resource = match self.lock_uid.get(&key) {
+                        Some(resource) => resource,
+                        None => return Ok(true),
+                    };
+                }
+            }
+            None => Ok(false),
+        }
     }
 
     // TODO: need add timeout mechanism
@@ -350,37 +371,14 @@ impl Locker for LocalLocker {
         Ok(reply)
     }
 
-    async fn refresh(&mut self, args: &LockArgs) -> Result<bool> {
-        let mut idx = 0;
-        let mut key = args.uid.to_string();
-        format_uuid(&mut key, &idx);
-        match self.lock_uid.get(&key) {
-            Some(resource) => {
-                let mut resource = resource;
-                loop {
-                    match self.lock_map.get_mut(resource) {
-                        Some(_lris) => {}
-                        None => {
-                            let mut key = args.uid.to_string();
-                            format_uuid(&mut key, &0);
-                            self.lock_uid.remove(&key);
-                            return Ok(idx > 0);
-                        }
-                    }
+    async fn close(&self) {}
 
-                    idx += 1;
-                    let mut key = args.uid.to_string();
-                    format_uuid(&mut key, &idx);
-                    resource = match self.lock_uid.get(&key) {
-                        Some(resource) => resource,
-                        None => return Ok(true),
-                    };
-                }
-            }
-            None => {
-                return Ok(false);
-            }
-        }
+    async fn is_online(&self) -> bool {
+        true
+    }
+
+    async fn is_local(&self) -> bool {
+        true
     }
 }
 

common/lock/src/lrwmutex.rs

@@ -141,7 +141,7 @@ mod test {
 
         l_rw_lock.lock().await;
 
-        assert!(!(l_rw_lock.get_r_lock(id, source, &timeout).await));
+        assert!(!l_rw_lock.get_r_lock(id, source, &timeout).await);
         l_rw_lock.un_lock().await;
         assert!(l_rw_lock.get_r_lock(id, source, &timeout).await);
 
@@ -165,7 +165,7 @@ mod test {
         let two_fn = async {
             let two = Arc::clone(&l_rw_lock);
             let timeout = Duration::from_secs(2);
-            assert!(!(two.get_r_lock(id, source, &timeout).await));
+            assert!(!two.get_r_lock(id, source, &timeout).await);
             sleep(Duration::from_secs(5)).await;
             assert!(two.get_r_lock(id, source, &timeout).await);
             two.un_r_lock().await;

common/lock/src/remote_client.rs

@@ -88,23 +88,6 @@ impl Locker for RemoteClient {
         Ok(response.success)
     }
 
-    async fn force_unlock(&mut self, args: &LockArgs) -> Result<bool> {
-        info!("remote force_unlock");
-        let args = serde_json::to_string(args)?;
-        let mut client = node_service_time_out_client(&self.addr)
-            .await
-            .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
-        let request = Request::new(GenerallyLockRequest { args });
-
-        let response = client.force_un_lock(request).await?.into_inner();
-
-        if let Some(error_info) = response.error_info {
-            return Err(Error::from_string(error_info));
-        }
-
-        Ok(response.success)
-    }
-
     async fn refresh(&mut self, args: &LockArgs) -> Result<bool> {
         info!("remote refresh");
         let args = serde_json::to_string(args)?;
@@ -122,8 +105,21 @@ impl Locker for RemoteClient {
         Ok(response.success)
     }
 
-    async fn is_local(&self) -> bool {
-        false
+    async fn force_unlock(&mut self, args: &LockArgs) -> Result<bool> {
+        info!("remote force_unlock");
+        let args = serde_json::to_string(args)?;
+        let mut client = node_service_time_out_client(&self.addr)
+            .await
+            .map_err(|err| Error::from_string(format!("can not get client, err: {}", err)))?;
+        let request = Request::new(GenerallyLockRequest { args });
+
+        let response = client.force_un_lock(request).await?.into_inner();
+
+        if let Some(error_info) = response.error_info {
+            return Err(Error::from_string(error_info));
+        }
+
+        Ok(response.success)
     }
 
     async fn close(&self) {}
@@ -131,4 +127,8 @@ impl Locker for RemoteClient {
     async fn is_online(&self) -> bool {
         true
     }
+
+    async fn is_local(&self) -> bool {
+        false
+    }
 }