ecstore update ec/disk/error

ecstore/src/disk/os.rs

@@ -3,31 +3,28 @@ use std::{
     path::{Component, Path},
 };
 
-use crate::{
-    disk::error::{is_sys_err_not_dir, is_sys_err_path_not_found, os_is_not_exist},
-    utils::{self, os::same_disk},
-};
-use common::error::{Error, Result};
+use super::error::Result;
+use crate::disk::error_conv::to_file_error;
 use tokio::fs;
 
-use super::error::{os_err_to_file_err, os_is_exist, DiskError};
+use super::error::DiskError;
 
 pub fn check_path_length(path_name: &str) -> Result<()> {
     // Apple OS X path length is limited to 1016
     if cfg!(target_os = "macos") && path_name.len() > 1016 {
-        return Err(Error::new(DiskError::FileNameTooLong));
+        return Err(DiskError::FileNameTooLong);
     }
 
     // Disallow more than 1024 characters on windows, there
     // are no known name_max limits on Windows.
     if cfg!(target_os = "windows") && path_name.len() > 1024 {
-        return Err(Error::new(DiskError::FileNameTooLong));
+        return Err(DiskError::FileNameTooLong);
     }
 
     // On Unix we reject paths if they are just '.', '..' or '/'
     let invalid_paths = [".", "..", "/"];
     if invalid_paths.contains(&path_name) {
-        return Err(Error::new(DiskError::FileAccessDenied));
+        return Err(DiskError::FileAccessDenied);
     }
 
     // Check each path segment length is > 255 on all Unix
@@ -40,7 +37,7 @@ pub fn check_path_length(path_name: &str) -> Result<()> {
             _ => {
                 count += 1;
                 if count > 255 {
-                    return Err(Error::new(DiskError::FileNameTooLong));
+                    return Err(DiskError::FileNameTooLong);
                 }
             }
         }
@@ -55,19 +52,15 @@ pub fn is_root_disk(disk_path: &str, root_disk: &str) -> Result<bool> {
         return Ok(false);
     }
 
-    same_disk(disk_path, root_disk)
+    rustfs_utils::os::same_disk(disk_path, root_disk).map_err(|e| to_file_error(e).into())
 }
 
 pub async fn make_dir_all(path: impl AsRef<Path>, base_dir: impl AsRef<Path>) -> Result<()> {
     check_path_length(path.as_ref().to_string_lossy().to_string().as_str())?;
 
-    if let Err(e) = reliable_mkdir_all(path.as_ref(), base_dir.as_ref()).await {
-        if is_sys_err_not_dir(&e) || is_sys_err_path_not_found(&e) {
-            return Err(Error::new(DiskError::FileAccessDenied));
-        }
-
-        return Err(os_err_to_file_err(e));
-    }
+    reliable_mkdir_all(path.as_ref(), base_dir.as_ref())
+        .await
+        .map_err(to_file_error)?;
 
     Ok(())
 }
@@ -77,7 +70,7 @@ pub async fn is_empty_dir(path: impl AsRef<Path>) -> bool {
 }
 
 // read_dir  count read limit. when count == 0 unlimit.
-pub async fn read_dir(path: impl AsRef<Path>, count: i32) -> Result<Vec<String>> {
+pub async fn read_dir(path: impl AsRef<Path>, count: i32) -> std::io::Result<Vec<String>> {
     let mut entries = fs::read_dir(path.as_ref()).await?;
 
     let mut volumes = Vec::new();
@@ -96,7 +89,7 @@ pub async fn read_dir(path: impl AsRef<Path>, count: i32) -> Result<Vec<String>>
         if file_type.is_file() {
             volumes.push(name);
         } else if file_type.is_dir() {
-            volumes.push(format!("{}{}", name, utils::path::SLASH_SEPARATOR));
+            volumes.push(format!("{}{}", name, super::fs::SLASH_SEPARATOR));
         }
         count -= 1;
         if count == 0 {
@@ -115,17 +108,7 @@ pub async fn rename_all(
 ) -> Result<()> {
     reliable_rename(src_file_path, dst_file_path.as_ref(), base_dir)
         .await
-        .map_err(|e| {
-            if is_sys_err_not_dir(&e) || !os_is_not_exist(&e) || is_sys_err_path_not_found(&e) {
-                Error::new(DiskError::FileAccessDenied)
-            } else if os_is_not_exist(&e) {
-                Error::new(DiskError::FileNotFound)
-            } else if os_is_exist(&e) {
-                Error::new(DiskError::IsNotRegular)
-            } else {
-                Error::new(e)
-            }
-        })?;
+        .map_err(|e| to_file_error(e))?;
 
     Ok(())
 }
@@ -144,8 +127,8 @@ pub async fn reliable_rename(
 
     let mut i = 0;
     loop {
-        if let Err(e) = utils::fs::rename_std(src_file_path.as_ref(), dst_file_path.as_ref()) {
-            if os_is_not_exist(&e) && i == 0 {
+        if let Err(e) = super::fs::rename_std(src_file_path.as_ref(), dst_file_path.as_ref()) {
+            if e.kind() == io::ErrorKind::NotFound && i == 0 {
                 i += 1;
                 continue;
             }
@@ -171,7 +154,7 @@ pub async fn reliable_mkdir_all(path: impl AsRef<Path>, base_dir: impl AsRef<Pat
     let mut base_dir = base_dir.as_ref();
     loop {
         if let Err(e) = os_mkdir_all(path.as_ref(), base_dir).await {
-            if os_is_not_exist(&e) && i == 0 {
+            if e.kind() == io::ErrorKind::NotFound && i == 0 {
                 i += 1;
 
                 if let Some(base_parent) = base_dir.parent() {
@@ -200,8 +183,8 @@ pub async fn os_mkdir_all(dir_path: impl AsRef<Path>, base_dir: impl AsRef<Path>
 
     if let Some(parent) = dir_path.as_ref().parent() {
         // 不支持递归，直接 create_dir_all 了
-        if let Err(e) = utils::fs::make_dir_all(&parent).await {
-            if os_is_exist(&e) {
+        if let Err(e) = super::fs::make_dir_all(&parent).await {
+            if e.kind() == io::ErrorKind::AlreadyExists {
                 return Ok(());
             }
 
@@ -210,8 +193,8 @@ pub async fn os_mkdir_all(dir_path: impl AsRef<Path>, base_dir: impl AsRef<Path>
         // Box::pin(os_mkdir_all(&parent, &base_dir)).await?;
     }
 
-    if let Err(e) = utils::fs::mkdir(dir_path.as_ref()).await {
-        if os_is_exist(&e) {
+    if let Err(e) = super::fs::mkdir(dir_path.as_ref()).await {
+        if e.kind() == io::ErrorKind::AlreadyExists {
             return Ok(());
         }