Test Gitea Runner functionality

markbase-raid/src/raid/controller.rs

@@ -0,0 +1,134 @@
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+use super::{RaidLevel, MemberStatus, RaidAlgorithm, RaidError};
+
+#[derive(Debug, Clone)]
+pub struct RaidMember {
+    pub device_id: String,
+    pub device_path: PathBuf,
+    pub size: u64,
+    pub status: MemberStatus,
+}
+
+#[derive(Debug)]
+pub struct RaidArray {
+    pub raid_level: RaidLevel,
+    pub members: Vec<RaidMember>,
+    pub stripe_size: u64,
+    pub total_size: u64,
+}
+
+pub struct RaidController {
+    arrays: Mutex<Vec<Arc<RaidArray>>>,
+}
+
+impl RaidController {
+    pub fn new() -> Self {
+        RaidController {
+            arrays: Mutex::new(Vec::new()),
+        }
+    }
+    
+    pub fn create_array(
+        &self,
+        level: RaidLevel,
+        member_paths: Vec<PathBuf>,
+        stripe_size: u64,
+    ) -> Result<String, RaidError> {
+        let members: Vec<RaidMember> = member_paths
+            .iter()
+            .enumerate()
+            .map(|(i, path)| {
+                let size = if path.exists() {
+                    std::fs::metadata(path).unwrap().len()
+                } else {
+                    0
+                };
+                RaidMember {
+                    device_id: format!("member_{}", i),
+                    device_path: path.clone(),
+                    size,
+                    status: MemberStatus::Online,
+                }
+            })
+            .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")?;
+        
+        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")?;
+        
+        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()),
+        }
+    }
+}
+
+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::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

@@ -0,0 +1,108 @@
+use std::path::PathBuf;
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write, Seek, SeekFrom};
+use super::{RaidController, RaidError};
+
+pub struct RaidExporter {
+    controller: RaidController,
+}
+
+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)
+            .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)
+            .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)
+    }
+}
+
+#[cfg(test)]
+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

@@ -0,0 +1,95 @@
+use std::sync::Arc;
+use super::controller::RaidArray;
+use super::{RaidAlgorithm, RaidLevel, RaidError, MemberStatus};
+
+pub struct Raid0 {
+    array: Arc<RaidArray>,
+}
+
+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;
+        
+        (member_index as usize, member_offset)
+    }
+}
+
+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 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))?;
+            
+            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 file = std::fs::OpenOptions::new()
+                .write(true)
+                .open(&member.device_path)?;
+            use std::io::{Write, Seek};
+            let mut file = file;
+            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

@@ -0,0 +1,59 @@
+use std::sync::Arc;
+use super::controller::RaidArray;
+use super::{RaidAlgorithm, RaidLevel, RaidError, MemberStatus};
+
+pub struct Raid1 {
+    array: Arc<RaidArray>,
+}
+
+impl Raid1 {
+    pub fn new(array: Arc<RaidArray>) -> Self {
+        Raid1 { array }
+    }
+}
+
+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};
+            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

@@ -0,0 +1,181 @@
+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 std::fs::File;
+use std::io::{Read, Write, Seek, SeekFrom};
+
+pub struct Raid5 {
+    array: Arc<RaidArray>,
+    stripe_size: u64,
+    member_files: HashMap<usize, File>,
+}
+
+impl Raid5 {
+    pub fn new(array: Arc<RaidArray>) -> Result<Self, RaidError> {
+        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)
+                .write(true)
+                .create(false)
+                .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;
+        
+        (data_disk, parity_disk, physical_offset)
+    }
+    
+    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)
+            .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> {
+        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)
+            .ok_or("Member file not found")?;
+        
+        file.seek(SeekFrom::Start(offset))?;
+        file.write_all(data)?;
+        
+        Ok(())
+    }
+}
+
+impl RaidAlgorithm for Raid5 {
+    fn read(&mut self, block_offset: u64, size: u64) -> Result<Vec<u8>, RaidError> {
+        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 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_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);
+        }
+    }

markbase-raid/src/raid/mod.rs

@@ -0,0 +1,40 @@
+mod controller;
+mod level_0;
+mod level_1;
+mod level_5;
+mod parity;
+mod exporter;
+
+pub use controller::RaidController;
+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 {
+    RAID0,
+    RAID1,
+    RAID5,
+    RAID6,
+    RAID10,
+    RAID50,
+    RAID60,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum MemberStatus {
+    Online,
+    Offline,
+    Rebuilding,
+    Failed,
+}
+
+pub type RaidError = Box<dyn std::error::Error + Send + Sync>;
+
+pub trait RaidAlgorithm: Send + Sync {
+    fn read(&mut self, block_offset: u64, size: u64) -> Result<Vec<u8>, RaidError>;
+    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

@@ -0,0 +1,105 @@
+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");
+        }
+        for i in 0..stripe_size {
+            parity[i] ^= stripe[i];
+        }
+    }
+    
+    parity
+}
+
+pub fn reconstruct_missing_data(
+    available_data: &[Vec<u8>],
+    parity: &[u8],
+    _missing_index: usize,
+) -> Vec<u8> {
+    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");
+        }
+        for i in 0..stripe_size {
+            reconstructed[i] ^= data[i];
+        }
+    }
+    
+    reconstructed
+}
+
+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]);
+    }
+    
+    #[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);
+    }
+}