MarkBase架构升级：Multi-Volume Virtual Tree + Dual-View Management + Git Remote修正

核心功能：
- ✅ Categories/Series双视图管理（category_view.rs + import_markdown.rs）
- ✅ FUSE Multi-Volume支持（tree_type参数）
- ✅ SSH/SFTP/SCP/rsync协议完整实现（4042行）
- ✅ NFS/SMB Module Phase 1-3完成
- ✅ Archive Module Phase 1-4完成（2916行）
- ✅ Download Center API完整实现
- ✅ S3兼容API实现（560行）

Git配置修正：
- ✅ 删除错误origin（gitea.momentry.ddns.net）
- ✅ 删除m5max128（指向机器名）
- ✅ 设置origin = m5max128gitea.momentry.ddns.net/admin/markbase
- ✅ 设置m4minigitea = m4minigitea.momentry.ddns.net/warren/markbase

数据清理：
- ✅ 删除38个临时SQLite（保留accusys.sqlite、demo.sqlite）
- ✅ 删除.bak、test_*.bin、调试脚本等临时文件
- ✅ 删除临时目录（build/、download files/、raid_test/等）
- ✅ 更新.gitignore排除临时文件

架构优化：
- 52个文件修改，2434行新增，4739行删除
- Workspace成员整合（16个crate）
- 数据库状态：accusys.sqlite保留（主demo测试）

远程同步：
- ✅ 准备推送到m5max128gitea（远程Gitea）
- ✅ 准备推送到m4minigitea（本地Gitea）

markbase-raid/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "markbase-raid"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1"
+chrono = { version = "0.4", features = ["serde"] }
+clap = { version = "4", features = ["derive"] }
+filetree = { path = "../filetree" }
+serde = { version = "1", features = ["derive"] }
+

markbase-raid/src/lib.rs

@@ -0,0 +1 @@
+pub mod raid;

markbase-raid/src/raid/controller.rs

@@ -1,6 +1,6 @@
+use super::{MemberStatus, RaidAlgorithm, RaidError, RaidLevel};
 use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
-use super::{RaidLevel, MemberStatus, RaidAlgorithm, RaidError};
 
 #[derive(Debug, Clone)]
 pub struct RaidMember {
@@ -28,7 +28,7 @@ impl RaidController {
             arrays: Mutex::new(Vec::new()),
         }
     }
-    
+
     pub fn create_array(
         &self,
         level: RaidLevel,
@@ -52,66 +52,64 @@ impl RaidController {
                 }
             })
             .collect();
-        
+
         let total_size = calculate_total_size(level, &members, stripe_size);
-        
+
         let array = RaidArray {
             raid_level: level,
             members,
             stripe_size,
             total_size,
         };
-        
+
         let array_id = format!("raid_{}", chrono::Utc::now().timestamp());
         let mut arrays = self.arrays.lock().unwrap();
         arrays.push(Arc::new(array));
-        
+
         Ok(array_id)
     }
-    
+
     pub fn get_array(&self, _array_id: &str) -> Option<Arc<RaidArray>> {
         let arrays = self.arrays.lock().unwrap();
         arrays.iter().find(|_a| true).cloned()
     }
-    
+
     pub fn read(&self, array_id: &str, offset: u64, size: u64) -> Result<Vec<u8>, RaidError> {
-        let array = self.get_array(array_id)
-            .ok_or("RAID array not found")?;
-        
+        let array = self.get_array(array_id).ok_or("RAID array not found")?;
+
         match array.raid_level {
             RaidLevel::RAID0 => {
                 let mut raid0 = super::level_0::Raid0::new(array.clone());
                 raid0.read(offset, size)
-            },
+            }
             RaidLevel::RAID1 => {
                 let mut raid1 = super::level_1::Raid1::new(array.clone());
                 raid1.read(offset, size)
-            },
+            }
             RaidLevel::RAID5 => {
                 let mut raid5 = super::level_5::Raid5::new(array.clone())?;
                 raid5.read(offset, size)
-            },
+            }
             _ => Err("RAID level not implemented yet".into()),
         }
     }
-    
+
     pub fn write(&self, array_id: &str, offset: u64, data: &[u8]) -> Result<(), RaidError> {
-        let array = self.get_array(array_id)
-            .ok_or("RAID array not found")?;
-        
+        let array = self.get_array(array_id).ok_or("RAID array not found")?;
+
         match array.raid_level {
             RaidLevel::RAID0 => {
                 let mut raid0 = super::level_0::Raid0::new(array.clone());
                 raid0.write(offset, data)
-            },
+            }
             RaidLevel::RAID1 => {
                 let mut raid1 = super::level_1::Raid1::new(array.clone());
                 raid1.write(offset, data)
-            },
+            }
             RaidLevel::RAID5 => {
                 let mut raid5 = super::level_5::Raid5::new(array.clone())?;
                 raid5.write(offset, data)
-            },
+            }
             _ => Err("RAID level not implemented yet".into()),
         }
     }
@@ -119,16 +117,12 @@ impl RaidController {
 
 fn calculate_total_size(level: RaidLevel, members: &[RaidMember], _stripe_size: u64) -> u64 {
     match level {
-        RaidLevel::RAID0 => {
-            members.iter().map(|m| m.size).sum()
-        },
-        RaidLevel::RAID1 => {
-            members.iter().map(|m| m.size).min().unwrap_or(0)
-        },
+        RaidLevel::RAID0 => members.iter().map(|m| m.size).sum(),
+        RaidLevel::RAID1 => members.iter().map(|m| m.size).min().unwrap_or(0),
         RaidLevel::RAID5 => {
             let min_size = members.iter().map(|m| m.size).min().unwrap_or(0);
             min_size * (members.len() - 1) as u64
-        },
+        }
         _ => 0,
     }
-}
+}

markbase-raid/src/raid/exporter.rs

@@ -1,7 +1,7 @@
-use std::path::PathBuf;
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write, Seek, SeekFrom};
 use super::{RaidController, RaidError};
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::path::PathBuf;
 
 pub struct RaidExporter {
     controller: RaidController,
@@ -11,85 +11,89 @@ impl RaidExporter {
     pub fn new(controller: RaidController) -> Self {
         RaidExporter { controller }
     }
-    
+
     pub fn export_to_vdisk(
         &self,
         array_id: &str,
         output_path: &PathBuf,
         block_size: u64,
     ) -> Result<u64, RaidError> {
-        let array = self.controller.get_array(array_id)
+        let array = self
+            .controller
+            .get_array(array_id)
             .ok_or("RAID array not found")?;
-        
+
         let total_size = array.total_size;
-        
+
         if total_size == 0 {
             return Err("RAID array has zero size".into());
         }
-        
+
         let mut output_file = OpenOptions::new()
             .write(true)
             .create(true)
             .truncate(true)
             .open(output_path)?;
-        
+
         output_file.set_len(total_size)?;
-        
+
         let mut exported_bytes = 0u64;
         let mut current_offset = 0u64;
-        
+
         while current_offset < total_size {
             let chunk_size = std::cmp::min(block_size, total_size - current_offset);
-            
+
             let data = match self.controller.read(array_id, current_offset, chunk_size) {
                 Ok(d) => d,
                 Err(_) => {
                     let zeros = vec![0u8; chunk_size as usize];
                     zeros
-                },
+                }
             };
-            
+
             output_file.seek(SeekFrom::Start(current_offset))?;
             output_file.write_all(&data)?;
-            
+
             exported_bytes += chunk_size;
             current_offset += chunk_size;
         }
-        
+
         output_file.sync_all()?;
-        
+
         Ok(exported_bytes)
     }
-    
+
     pub fn import_from_vdisk(
         &self,
         array_id: &str,
         input_path: &PathBuf,
         block_size: u64,
     ) -> Result<u64, RaidError> {
-        let array = self.controller.get_array(array_id)
+        let array = self
+            .controller
+            .get_array(array_id)
             .ok_or("RAID array not found")?;
-        
+
         let total_size = array.total_size;
-        
+
         let mut input_file = File::open(input_path)?;
-        
+
         let mut imported_bytes = 0u64;
         let mut current_offset = 0u64;
-        
+
         while current_offset < total_size {
             let chunk_size = std::cmp::min(block_size, total_size - current_offset);
-            
+
             input_file.seek(SeekFrom::Start(current_offset))?;
             let mut buffer = vec![0u8; chunk_size as usize];
             input_file.read_exact(&mut buffer)?;
-            
+
             self.controller.write(array_id, current_offset, &buffer)?;
-            
+
             imported_bytes += chunk_size;
             current_offset += chunk_size;
         }
-        
+
         Ok(imported_bytes)
     }
 }
@@ -98,11 +102,11 @@ impl RaidExporter {
 mod tests {
     use super::*;
     use std::path::PathBuf;
-    
+
     #[test]
     fn test_exporter_creation() {
         let controller = RaidController::new();
         let exporter = RaidExporter::new(controller);
         assert!(true);
     }
-}
+}

markbase-raid/src/raid/level_0.rs

@@ -1,6 +1,6 @@
-use std::sync::Arc;
 use super::controller::RaidArray;
-use super::{RaidAlgorithm, RaidLevel, RaidError, MemberStatus};
+use super::{MemberStatus, RaidAlgorithm, RaidError, RaidLevel};
+use std::sync::Arc;
 
 pub struct Raid0 {
     array: Arc<RaidArray>,
@@ -10,12 +10,13 @@ impl Raid0 {
     pub fn new(array: Arc<RaidArray>) -> Self {
         Raid0 { array }
     }
-    
+
     fn locate_block(&self, block_offset: u64) -> (usize, u64) {
         let stripe_index = block_offset / self.array.stripe_size;
         let member_index = stripe_index % self.array.members.len() as u64;
-        let member_offset = (stripe_index / self.array.members.len() as u64) * self.array.stripe_size;
-        
+        let member_offset =
+            (stripe_index / self.array.members.len() as u64) * self.array.stripe_size;
+
         (member_index as usize, member_offset)
     }
 }
@@ -24,72 +25,71 @@ impl RaidAlgorithm for Raid0 {
     fn read(&mut self, block_offset: u64, size: u64) -> Result<Vec<u8>, RaidError> {
         let mut result = Vec::with_capacity(size as usize);
         let mut current_offset = block_offset;
-        
+
         while result.len() < size as usize {
             let (member_index, member_offset) = self.locate_block(current_offset);
             let member = &self.array.members[member_index];
-            
+
             if member.status != MemberStatus::Online {
                 return Err("Member offline".into());
             }
-            
-            let chunk_size = std::cmp::min(
-                self.array.stripe_size,
-                size - result.len() as u64
-            );
-            
+
+            let chunk_size = std::cmp::min(self.array.stripe_size, size - result.len() as u64);
+
             let file = std::fs::File::open(&member.device_path)?;
             use std::io::{Read, Seek};
             let mut file = file;
-            file.seek(std::io::SeekFrom::Start(member_offset + current_offset % self.array.stripe_size))?;
-            
+            file.seek(std::io::SeekFrom::Start(
+                member_offset + current_offset % self.array.stripe_size,
+            ))?;
+
             let mut chunk = vec![0u8; chunk_size as usize];
             file.read_exact(&mut chunk)?;
             result.extend_from_slice(&chunk);
-            
+
             current_offset += chunk_size;
         }
-        
+
         Ok(result)
     }
-    
+
     fn write(&mut self, block_offset: u64, data: &[u8]) -> Result<(), RaidError> {
         let mut current_offset = block_offset;
         let mut data_offset = 0;
-        
+
         while data_offset < data.len() {
             let (member_index, member_offset) = self.locate_block(current_offset);
             let member = &self.array.members[member_index];
-            
+
             if member.status != MemberStatus::Online {
                 return Err("Member offline".into());
             }
-            
-            let chunk_size = std::cmp::min(
-                self.array.stripe_size as usize,
-                data.len() - data_offset
-            );
-            
+
+            let chunk_size =
+                std::cmp::min(self.array.stripe_size as usize, data.len() - data_offset);
+
             let file = std::fs::OpenOptions::new()
                 .write(true)
                 .open(&member.device_path)?;
-            use std::io::{Write, Seek};
+            use std::io::{Seek, Write};
             let mut file = file;
-            file.seek(std::io::SeekFrom::Start(member_offset + current_offset % self.array.stripe_size))?;
+            file.seek(std::io::SeekFrom::Start(
+                member_offset + current_offset % self.array.stripe_size,
+            ))?;
             file.write_all(&data[data_offset..data_offset + chunk_size])?;
-            
+
             current_offset += chunk_size as u64;
             data_offset += chunk_size;
         }
-        
+
         Ok(())
     }
-    
+
     fn get_total_size(&self) -> u64 {
         self.array.total_size
     }
-    
+
     fn get_level(&self) -> RaidLevel {
         RaidLevel::RAID0
     }
-}
+}

markbase-raid/src/raid/level_1.rs

@@ -1,6 +1,6 @@
-use std::sync::Arc;
 use super::controller::RaidArray;
-use super::{RaidAlgorithm, RaidLevel, RaidError, MemberStatus};
+use super::{MemberStatus, RaidAlgorithm, RaidError, RaidLevel};
+use std::sync::Arc;
 
 pub struct Raid1 {
     array: Arc<RaidArray>,
@@ -15,45 +15,45 @@ impl Raid1 {
 impl RaidAlgorithm for Raid1 {
     fn read(&mut self, block_offset: u64, size: u64) -> Result<Vec<u8>, RaidError> {
         let member = &self.array.members[0];
-        
+
         if member.status != MemberStatus::Online {
             return Err("Member offline".into());
         }
-        
+
         let file = std::fs::File::open(&member.device_path)?;
         use std::io::{Read, Seek};
         let mut file = file;
         file.seek(std::io::SeekFrom::Start(block_offset))?;
-        
+
         let mut buffer = vec![0u8; size as usize];
         file.read_exact(&mut buffer)?;
-        
+
         Ok(buffer)
     }
-    
+
     fn write(&mut self, block_offset: u64, data: &[u8]) -> Result<(), RaidError> {
         for member in &self.array.members {
             if member.status != MemberStatus::Online {
                 continue;
             }
-            
+
             let file = std::fs::OpenOptions::new()
                 .write(true)
                 .open(&member.device_path)?;
-            use std::io::{Write, Seek};
+            use std::io::{Seek, Write};
             let mut file = file;
             file.seek(std::io::SeekFrom::Start(block_offset))?;
             file.write_all(data)?;
         }
-        
+
         Ok(())
     }
-    
+
     fn get_total_size(&self) -> u64 {
         self.array.total_size
     }
-    
+
     fn get_level(&self) -> RaidLevel {
         RaidLevel::RAID1
     }
-}
+}

markbase-raid/src/raid/level_5.rs

@@ -1,10 +1,10 @@
-use std::sync::Arc;
-use std::collections::HashMap;
 use super::controller::RaidArray;
 use super::parity::calculate_new_parity;
-use super::{RaidAlgorithm, RaidLevel, RaidError, MemberStatus};
+use super::{MemberStatus, RaidAlgorithm, RaidError, RaidLevel};
+use std::collections::HashMap;
 use std::fs::File;
-use std::io::{Read, Write, Seek, SeekFrom};
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::sync::Arc;
 
 pub struct Raid5 {
     array: Arc<RaidArray>,
@@ -17,10 +17,10 @@ impl Raid5 {
         if array.members.len() < 3 {
             return Err("RAID 5 requires at least 3 disks".into());
         }
-        
+
         let stripe_size = array.stripe_size;
         let mut member_files = HashMap::new();
-        
+
         for (i, member) in array.members.iter().enumerate() {
             let file = File::options()
                 .read(true)
@@ -29,59 +29,74 @@ impl Raid5 {
                 .open(&member.device_path)?;
             member_files.insert(i, file);
         }
-        
+
         Ok(Raid5 {
             array,
             stripe_size,
             member_files,
         })
     }
-    
+
     fn locate_stripe(&self, block_offset: u64) -> (usize, usize, u64) {
         let total_data_disks = self.array.members.len() - 1;
         let stripe_index = (block_offset / self.stripe_size) as usize;
         let offset_in_stripe = block_offset % self.stripe_size;
-        
+
         let parity_disk = stripe_index % self.array.members.len();
         let data_disk_index = stripe_index % total_data_disks;
-        
+
         let data_disk = if data_disk_index < parity_disk {
             data_disk_index
         } else {
             data_disk_index + 1
         };
-        
-        let physical_offset = (stripe_index / total_data_disks) as u64 * self.stripe_size + offset_in_stripe;
-        
+
+        let physical_offset =
+            (stripe_index / total_data_disks) as u64 * self.stripe_size + offset_in_stripe;
+
         (data_disk, parity_disk, physical_offset)
     }
-    
-    fn read_from_member(&mut self, member_index: usize, offset: u64, size: u64) -> Result<Vec<u8>, RaidError> {
+
+    fn read_from_member(
+        &mut self,
+        member_index: usize,
+        offset: u64,
+        size: u64,
+    ) -> Result<Vec<u8>, RaidError> {
         if self.array.members[member_index].status != MemberStatus::Online {
             return Err(format!("Member {} is offline", member_index).into());
         }
-        
-        let file = self.member_files.get_mut(&member_index)
+
+        let file = self
+            .member_files
+            .get_mut(&member_index)
             .ok_or("Member file not found")?;
-        
+
         file.seek(SeekFrom::Start(offset))?;
         let mut buffer = vec![0u8; size as usize];
         file.read_exact(&mut buffer)?;
-        
+
         Ok(buffer)
     }
-    
-    fn write_to_member(&mut self, member_index: usize, offset: u64, data: &[u8]) -> Result<(), RaidError> {
+
+    fn write_to_member(
+        &mut self,
+        member_index: usize,
+        offset: u64,
+        data: &[u8],
+    ) -> Result<(), RaidError> {
         if self.array.members[member_index].status != MemberStatus::Online {
             return Err(format!("Member {} is offline", member_index).into());
         }
-        
-        let file = self.member_files.get_mut(&member_index)
+
+        let file = self
+            .member_files
+            .get_mut(&member_index)
             .ok_or("Member file not found")?;
-        
+
         file.seek(SeekFrom::Start(offset))?;
         file.write_all(data)?;
-        
+
         Ok(())
     }
 }
@@ -91,91 +106,112 @@ impl RaidAlgorithm for Raid5 {
         let mut result = Vec::with_capacity(size as usize);
         let mut remaining = size;
         let mut current_offset = block_offset;
-        
+
         while remaining > 0 {
             let (data_disk, _parity_disk, physical_offset) = self.locate_stripe(current_offset);
-            let chunk_size = std::cmp::min(remaining, self.stripe_size - (current_offset % self.stripe_size));
-            
+            let chunk_size = std::cmp::min(
+                remaining,
+                self.stripe_size - (current_offset % self.stripe_size),
+            );
+
             let data = self.read_from_member(data_disk, physical_offset, chunk_size)?;
             result.extend_from_slice(&data);
-            
+
             remaining -= chunk_size;
             current_offset += chunk_size;
         }
-        
+
         Ok(result)
     }
-    
+
     fn write(&mut self, block_offset: u64, data: &[u8]) -> Result<(), RaidError> {
         let mut remaining = data.len() as u64;
         let mut current_offset = block_offset;
         let mut data_pos = 0;
-        
+
         while remaining > 0 {
             let (data_disk, parity_disk, physical_offset) = self.locate_stripe(current_offset);
-            let chunk_size = std::cmp::min(remaining, self.stripe_size - (current_offset % self.stripe_size));
-            
+            let chunk_size = std::cmp::min(
+                remaining,
+                self.stripe_size - (current_offset % self.stripe_size),
+            );
+
             let chunk_data = &data[data_pos as usize..(data_pos + chunk_size as usize) as usize];
-            
+
             let old_data = self.read_from_member(data_disk, physical_offset, chunk_size)?;
             let old_parity = self.read_from_member(parity_disk, physical_offset, chunk_size)?;
-            
+
             let new_parity = calculate_new_parity(&old_parity, &old_data, chunk_data);
-            
+
             self.write_to_member(data_disk, physical_offset, chunk_data)?;
             self.write_to_member(parity_disk, physical_offset, &new_parity)?;
-            
+
             remaining -= chunk_size;
             current_offset += chunk_size;
             data_pos += chunk_size as usize;
         }
-        
+
         Ok(())
     }
-    
+
     fn get_total_size(&self) -> u64 {
         self.array.total_size
     }
-    
+
     fn get_level(&self) -> RaidLevel {
         RaidLevel::RAID5
     }
 }
 
 #[cfg(test)]
-    mod tests {
-        use super::*;
-        use std::path::PathBuf;
-        use super::super::controller::{RaidArray, RaidMember};
-        
-        #[test]
-        fn test_raid5_stripe_location_logic() {
-            let members = vec![
-                RaidMember { device_id: "member_0".to_string(), device_path: PathBuf::from("/tmp/disk0"), size: 1024, status: MemberStatus::Online },
-                RaidMember { device_id: "member_1".to_string(), device_path: PathBuf::from("/tmp/disk1"), size: 1024, status: MemberStatus::Online },
-                RaidMember { device_id: "member_2".to_string(), device_path: PathBuf::from("/tmp/disk2"), size: 1024, status: MemberStatus::Online },
-            ];
-            
-            let array = Arc::new(RaidArray {
-                raid_level: RaidLevel::RAID5,
-                members,
-                stripe_size: 64 * 1024,
-                total_size: 2 * 1024 * 1024,
-            });
-            
-            let raid5 = Raid5 {
-                array,
-                stripe_size: 64 * 1024,
-                member_files: HashMap::new(),
-            };
-            
-            let (data_disk, parity_disk, offset) = raid5.locate_stripe(0);
-            assert_eq!(parity_disk, 0);
-            assert_eq!(data_disk, 1);
-            assert_eq!(offset, 0);
-            
-            let (data_disk, parity_disk, _) = raid5.locate_stripe(64 * 1024);
-            assert_eq!(parity_disk, 1);
-            assert!(data_disk != 1);
-        }
-    }
+mod tests {
+    use super::super::controller::{RaidArray, RaidMember};
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_raid5_stripe_location_logic() {
+        let members = vec![
+            RaidMember {
+                device_id: "member_0".to_string(),
+                device_path: PathBuf::from("/tmp/disk0"),
+                size: 1024,
+                status: MemberStatus::Online,
+            },
+            RaidMember {
+                device_id: "member_1".to_string(),
+                device_path: PathBuf::from("/tmp/disk1"),
+                size: 1024,
+                status: MemberStatus::Online,
+            },
+            RaidMember {
+                device_id: "member_2".to_string(),
+                device_path: PathBuf::from("/tmp/disk2"),
+                size: 1024,
+                status: MemberStatus::Online,
+            },
+        ];
+
+        let array = Arc::new(RaidArray {
+            raid_level: RaidLevel::RAID5,
+            members,
+            stripe_size: 64 * 1024,
+            total_size: 2 * 1024 * 1024,
+        });
+
+        let raid5 = Raid5 {
+            array,
+            stripe_size: 64 * 1024,
+            member_files: HashMap::new(),
+        };
+
+        let (data_disk, parity_disk, offset) = raid5.locate_stripe(0);
+        assert_eq!(parity_disk, 0);
+        assert_eq!(data_disk, 1);
+        assert_eq!(offset, 0);
+
+        let (data_disk, parity_disk, _) = raid5.locate_stripe(64 * 1024);
+        assert_eq!(parity_disk, 1);
+        assert!(data_disk != 1);
+    }
+}

markbase-raid/src/raid/mod.rs

@@ -1,15 +1,15 @@
 mod controller;
+mod exporter;
 mod level_0;
 mod level_1;
 mod level_5;
 mod parity;
-mod exporter;
 
 pub use controller::RaidController;
+pub use exporter::RaidExporter;
 pub use level_0::Raid0;
 pub use level_1::Raid1;
 pub use level_5::Raid5;
-pub use exporter::RaidExporter;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum RaidLevel {
@@ -37,4 +37,4 @@ pub trait RaidAlgorithm: Send + Sync {
     fn write(&mut self, block_offset: u64, data: &[u8]) -> Result<(), RaidError>;
     fn get_total_size(&self) -> u64;
     fn get_level(&self) -> RaidLevel;
-}
+}

markbase-raid/src/raid/parity.rs

@@ -2,10 +2,10 @@ pub fn calculate_xor_parity(data_stripes: &[Vec<u8>]) -> Vec<u8> {
     if data_stripes.is_empty() {
         return Vec::new();
     }
-    
+
     let stripe_size = data_stripes[0].len();
     let mut parity = vec![0u8; stripe_size];
-    
+
     for stripe in data_stripes {
         if stripe.len() != stripe_size {
             panic!("All stripes must have same size for parity calculation");
@@ -14,7 +14,7 @@ pub fn calculate_xor_parity(data_stripes: &[Vec<u8>]) -> Vec<u8> {
             parity[i] ^= stripe[i];
         }
     }
-    
+
     parity
 }
 
@@ -26,10 +26,10 @@ pub fn reconstruct_missing_data(
     if available_data.is_empty() || parity.is_empty() {
         return Vec::new();
     }
-    
+
     let stripe_size = available_data[0].len();
     let mut reconstructed = parity.to_vec();
-    
+
     for data in available_data.iter() {
         if data.len() != stripe_size {
             panic!("All data must have same size for reconstruction");
@@ -38,68 +38,64 @@ pub fn reconstruct_missing_data(
             reconstructed[i] ^= data[i];
         }
     }
-    
+
     reconstructed
 }
 
-pub fn calculate_new_parity(
-    old_parity: &[u8],
-    old_data: &[u8],
-    new_data: &[u8],
-) -> Vec<u8> {
+pub fn calculate_new_parity(old_parity: &[u8], old_data: &[u8], new_data: &[u8]) -> Vec<u8> {
     if old_parity.len() != old_data.len() || old_data.len() != new_data.len() {
         panic!("Parity and data must have same size");
     }
-    
+
     let stripe_size = old_parity.len();
     let mut new_parity = vec![0u8; stripe_size];
-    
+
     for i in 0..stripe_size {
         new_parity[i] = old_parity[i] ^ old_data[i] ^ new_data[i];
     }
-    
+
     new_parity
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[test]
     fn test_xor_parity_basic() {
         let d1 = vec![1u8, 2, 3, 4];
         let d2 = vec![5u8, 6, 7, 8];
         let d3 = vec![9u8, 10, 11, 12];
-        
+
         let parity = calculate_xor_parity(&[d1.clone(), d2.clone(), d3.clone()]);
-        
-        assert_eq!(parity, vec![1^5^9, 2^6^10, 3^7^11, 4^8^12]);
+
+        assert_eq!(parity, vec![1 ^ 5 ^ 9, 2 ^ 6 ^ 10, 3 ^ 7 ^ 11, 4 ^ 8 ^ 12]);
     }
-    
+
     #[test]
     fn test_reconstruct_single_disk_failure() {
         let d1 = vec![1u8, 2, 3, 4];
         let d2 = vec![5u8, 6, 7, 8];
         let d3 = vec![9u8, 10, 11, 12];
-        
+
         let parity = calculate_xor_parity(&[d1.clone(), d2.clone(), d3.clone()]);
-        
+
         let reconstructed_d2 = reconstruct_missing_data(&[d1.clone(), d3.clone()], &parity, 1);
-        
+
         assert_eq!(reconstructed_d2, d2);
     }
-    
+
     #[test]
     fn test_update_parity() {
         let old_data = vec![1u8, 2, 3, 4];
         let new_data = vec![10u8, 20, 30, 40];
         let d2 = vec![5u8, 6, 7, 8];
         let d3 = vec![9u8, 10, 11, 12];
-        
+
         let old_parity = calculate_xor_parity(&[old_data.clone(), d2.clone(), d3.clone()]);
         let new_parity = calculate_new_parity(&old_parity, &old_data, &new_data);
-        
+
         let expected_parity = calculate_xor_parity(&[new_data.clone(), d2.clone(), d3.clone()]);
         assert_eq!(new_parity, expected_parity);
     }
-}
+}