merge main

ecstore/src/utils/crypto.rs

@@ -10,16 +10,16 @@ pub fn hex(data: impl AsRef<[u8]>) -> String {
     hex_simd::encode_to_string(data, hex_simd::AsciiCase::Lower)
 }
 
-#[cfg(windows)]
-pub fn sha256(data: &[u8]) -> impl AsRef<[u8; 32]> {
-    use sha2::{Digest, Sha256};
-    <Sha256 as Digest>::digest(data)
-}
+// #[cfg(windows)]
+// pub fn sha256(data: &[u8]) -> impl AsRef<[u8; 32]> {
+//     use sha2::{Digest, Sha256};
+//     <Sha256 as Digest>::digest(data)
+// }
 
-#[cfg(not(windows))]
-pub fn sha256(data: &[u8]) -> impl AsRef<[u8]> {
-    use openssl::hash::{Hasher, MessageDigest};
-    let mut h = Hasher::new(MessageDigest::sha256()).unwrap();
-    h.update(data).unwrap();
-    h.finish().unwrap()
-}
+// #[cfg(not(windows))]
+// pub fn sha256(data: &[u8]) -> impl AsRef<[u8]> {
+//     use openssl::hash::{Hasher, MessageDigest};
+//     let mut h = Hasher::new(MessageDigest::sha256()).unwrap();
+//     h.update(data).unwrap();
+//     h.finish().unwrap()
+// }

ecstore/src/utils/mod.rs

@@ -1,3 +1,12 @@
+use crate::bucket::error::BucketMetadataError;
+use crate::config::error::ConfigError;
+use crate::disk::error::DiskError;
+use crate::error::Error;
+use crate::quorum::QuorumError;
+use crate::store_err::StorageError;
+use crate::store_init::ErasureError;
+use protos::proto_gen::node_service::Error as Proto_Error;
+
 pub mod bool_flag;
 pub mod crypto;
 pub mod ellipses;
@@ -8,3 +17,104 @@ pub mod os;
 pub mod path;
 pub mod wildcard;
 pub mod xml;
+
+const ERROR_MODULE_MASK: u32 = 0xFF00;
+pub const ERROR_TYPE_MASK: u32 = 0x00FF;
+const DISK_ERROR_MASK: u32 = 0x0100;
+const STORAGE_ERROR_MASK: u32 = 0x0200;
+const BUCKET_METADATA_ERROR_MASK: u32 = 0x0300;
+const CONFIG_ERROR_MASK: u32 = 0x04000;
+const QUORUM_ERROR_MASK: u32 = 0x0500;
+const ERASURE_ERROR_MASK: u32 = 0x0600;
+
+// error to u8
+pub fn error_to_u32(err: &Error) -> u32 {
+    if let Some(e) = err.downcast_ref::<DiskError>() {
+        DISK_ERROR_MASK | e.to_u32()
+    } else if let Some(e) = err.downcast_ref::<StorageError>() {
+        STORAGE_ERROR_MASK | e.to_u32()
+    } else if let Some(e) = err.downcast_ref::<BucketMetadataError>() {
+        BUCKET_METADATA_ERROR_MASK | e.to_u32()
+    } else if let Some(e) = err.downcast_ref::<ConfigError>() {
+        CONFIG_ERROR_MASK | e.to_u32()
+    } else if let Some(e) = err.downcast_ref::<QuorumError>() {
+        QUORUM_ERROR_MASK | e.to_u32()
+    } else if let Some(e) = err.downcast_ref::<ErasureError>() {
+        ERASURE_ERROR_MASK | e.to_u32()
+    } else {
+        0
+    }
+}
+
+pub fn u32_to_error(e: u32) -> Option<Error> {
+    match e & ERROR_MODULE_MASK {
+        DISK_ERROR_MASK => DiskError::from_u32(e & ERROR_TYPE_MASK).map(|e| Error::new(e)),
+        STORAGE_ERROR_MASK => StorageError::from_u32(e & ERROR_TYPE_MASK).map(|e| Error::new(e)),
+        BUCKET_METADATA_ERROR_MASK => BucketMetadataError::from_u32(e & ERROR_TYPE_MASK).map(|e| Error::new(e)),
+        CONFIG_ERROR_MASK => ConfigError::from_u32(e & ERROR_TYPE_MASK).map(|e| Error::new(e)),
+        QUORUM_ERROR_MASK => QuorumError::from_u32(e & ERROR_TYPE_MASK).map(|e| Error::new(e)),
+        ERASURE_ERROR_MASK => ErasureError::from_u32(e & ERROR_TYPE_MASK).map(|e| Error::new(e)),
+        _ => None,
+    }
+}
+
+pub fn err_to_proto_err(err: &Error, msg: &str) -> Proto_Error {
+    let num = error_to_u32(err);
+    Proto_Error {
+        code: num,
+        error_info: msg.to_string(),
+    }
+}
+
+pub fn proto_err_to_err(err: &Proto_Error) -> Error {
+    if let Some(e) = u32_to_error(err.code) {
+        e
+    } else {
+        Error::from_string(err.error_info.clone())
+    }
+}
+
+#[test]
+fn test_u32_to_error() {
+    let error = Error::new(DiskError::FileCorrupt);
+    let num = error_to_u32(&error);
+    let new_error = u32_to_error(num);
+    assert!(new_error.is_some());
+    assert_eq!(new_error.unwrap().downcast_ref::<DiskError>(), Some(&DiskError::FileCorrupt));
+
+    let error = Error::new(StorageError::BucketNotEmpty(Default::default()));
+    let num = error_to_u32(&error);
+    let new_error = u32_to_error(num);
+    assert!(new_error.is_some());
+    assert_eq!(
+        new_error.unwrap().downcast_ref::<StorageError>(),
+        Some(&StorageError::BucketNotEmpty(Default::default()))
+    );
+
+    let error = Error::new(BucketMetadataError::BucketObjectLockConfigNotFound);
+    let num = error_to_u32(&error);
+    let new_error = u32_to_error(num);
+    assert!(new_error.is_some());
+    assert_eq!(
+        new_error.unwrap().downcast_ref::<BucketMetadataError>(),
+        Some(&BucketMetadataError::BucketObjectLockConfigNotFound)
+    );
+
+    let error = Error::new(ConfigError::NotFound);
+    let num = error_to_u32(&error);
+    let new_error = u32_to_error(num);
+    assert!(new_error.is_some());
+    assert_eq!(new_error.unwrap().downcast_ref::<ConfigError>(), Some(&ConfigError::NotFound));
+
+    let error = Error::new(QuorumError::Read);
+    let num = error_to_u32(&error);
+    let new_error = u32_to_error(num);
+    assert!(new_error.is_some());
+    assert_eq!(new_error.unwrap().downcast_ref::<QuorumError>(), Some(&QuorumError::Read));
+
+    let error = Error::new(ErasureError::ErasureReadQuorum);
+    let num = error_to_u32(&error);
+    let new_error = u32_to_error(num);
+    assert!(new_error.is_some());
+    assert_eq!(new_error.unwrap().downcast_ref::<ErasureError>(), Some(&ErasureError::ErasureReadQuorum));
+}

ecstore/src/utils/os/windows.rs

@@ -1,6 +1,8 @@
+#![allow(unsafe_code)] // TODO: audit unsafe code
+
 use super::IOStats;
 use crate::{disk::Info, error::Result};
-use std::io::{Error, ErrorKind, Result};
+use std::io::{Error, ErrorKind, Result as IoResult};
 use std::mem;
 use std::os::windows::ffi::OsStrExt;
 use std::path::Path;
@@ -32,7 +34,7 @@ pub fn get_info(p: impl AsRef<Path>) -> Result<Info> {
         )
     };
     if success == 0 {
-        return Err(Error::last_os_error());
+        return Err(Error::last_os_error().into());
     }
 
     let total = unsafe { *lp_total_number_of_bytes.QuadPart() };
@@ -47,7 +49,8 @@ pub fn get_info(p: impl AsRef<Path>) -> Result<Info> {
                 total,
                 p.as_ref().display()
             ),
-        ));
+        )
+        .into());
     }
 
     let mut lp_sectors_per_cluster: DWORD = 0;
@@ -65,7 +68,7 @@ pub fn get_info(p: impl AsRef<Path>) -> Result<Info> {
         )
     };
     if success == 0 {
-        return Err(Error::last_os_error());
+        return Err(Error::last_os_error().into());
     }
 
     Ok(Info {
@@ -87,7 +90,7 @@ fn get_volume_name(v: &[WCHAR]) -> Result<LPCWSTR> {
     let success = unsafe { GetVolumePathNameW(v.as_ptr(), lp_volume_name_buffer.as_mut_ptr(), volume_name_size) };
 
     if success == 0 {
-        return Err(Error::last_os_error());
+        return Err(Error::last_os_error().into());
     }
 
     Ok(lp_volume_name_buffer.as_ptr())
@@ -126,7 +129,7 @@ fn get_fs_type(p: &[WCHAR]) -> Result<String> {
     };
 
     if success == 0 {
-        return Err(Error::last_os_error());
+        return Err(Error::last_os_error().into());
     }
 
     Ok(utf16_to_string(&lp_file_system_name_buffer))
@@ -137,5 +140,5 @@ pub fn same_disk(disk1: &str, disk2: &str) -> Result<bool> {
 }
 
 pub fn get_drive_stats(major: u32, minor: u32) -> Result<IOStats> {
-    IOStats::default()
+    Ok(IOStats::default())
 }