Jan De Landtsheer
bf62e887e8
- Fixed build system to clone source repositories instead of downloading binaries - Enhanced scripts/fetch-github.sh with proper git repo cloning and branch handling - Updated scripts/compile-components.sh for RFS compilation with build-binary feature - Added minimal firmware installation for essential network drivers (73 modules) - Created comprehensive zinit configuration set (15 config files including getty) - Added util-linux package for getty/agetty console support - Optimized package selection for minimal 27MB initramfs footprint - Successfully builds bootable vmlinuz.efi with embedded initramfs - Confirmed working: VM boot, console login, network drivers, zinit init system Components: - initramfs.cpio.xz: 27MB compressed minimal Zero-OS image - vmlinuz.efi: 35MB bootable kernel with embedded initramfs - Complete Zero-OS toolchain: zinit, rfs, mycelium compiled from source
121 lines
4.3 KiB
Rust
121 lines
4.3 KiB
Rust
#[cfg(test)]
|
|
mod parallel_download_tests {
|
|
use anyhow::Result;
|
|
use std::path::Path;
|
|
use std::time::Instant;
|
|
use tempdir::TempDir;
|
|
use tokio::runtime::Runtime;
|
|
|
|
use rfs::cache::Cache;
|
|
use rfs::fungi::{self, meta};
|
|
use rfs::store::{self, dir::DirStore};
|
|
use rfs::{pack, unpack};
|
|
|
|
#[test]
|
|
fn test_parallel_download() -> Result<()> {
|
|
// Create a runtime for async operations
|
|
let rt = Runtime::new()?;
|
|
|
|
rt.block_on(async {
|
|
// Create temporary directories
|
|
let temp_dir = TempDir::new("parallel-test")?;
|
|
let source_dir = temp_dir.path().join("source");
|
|
let dest_dir_parallel = temp_dir.path().join("dest-parallel");
|
|
let dest_dir_serial = temp_dir.path().join("dest-serial");
|
|
let store_dir = temp_dir.path().join("store");
|
|
let cache_dir = temp_dir.path().join("cache");
|
|
|
|
std::fs::create_dir_all(&source_dir)?;
|
|
std::fs::create_dir_all(&dest_dir_parallel)?;
|
|
std::fs::create_dir_all(&dest_dir_serial)?;
|
|
std::fs::create_dir_all(&store_dir)?;
|
|
std::fs::create_dir_all(&cache_dir)?;
|
|
|
|
// Create some test files
|
|
create_test_files(&source_dir, 20, 1024 * 1024).await?; // 20 files of 1MB each
|
|
|
|
// Create a store
|
|
let store = DirStore::new(&store_dir).await?;
|
|
|
|
// Create a flist writer
|
|
let fl_path = temp_dir.path().join("test.fl");
|
|
let writer = fungi::Writer::new(&fl_path, true).await?;
|
|
|
|
// Pack the files
|
|
pack(writer, store.clone(), &source_dir, true, None).await?;
|
|
|
|
// Create a reader for the flist
|
|
let reader = fungi::Reader::new(&fl_path).await?;
|
|
let router = store::get_router(&reader).await?;
|
|
|
|
// Test parallel download (default)
|
|
let cache_parallel = Cache::new(&cache_dir, router.clone());
|
|
let start_parallel = Instant::now();
|
|
unpack(&reader, &cache_parallel, &dest_dir_parallel, false).await?;
|
|
let parallel_duration = start_parallel.elapsed();
|
|
|
|
// Clear cache directory
|
|
std::fs::remove_dir_all(&cache_dir)?;
|
|
std::fs::create_dir_all(&cache_dir)?;
|
|
|
|
// Test serial download by setting PARALLEL_DOWNLOAD to 1
|
|
// This is just a simulation since we can't easily modify the constant at runtime
|
|
// In a real test, we would use a feature flag or environment variable
|
|
let cache_serial = Cache::new(&cache_dir, router);
|
|
let start_serial = Instant::now();
|
|
|
|
// Here we're still using the parallel implementation, but in a real test
|
|
// we would use a version with PARALLEL_DOWNLOAD=1
|
|
unpack(&reader, &cache_serial, &dest_dir_serial, false).await?;
|
|
|
|
let serial_duration = start_serial.elapsed();
|
|
|
|
// Print the results
|
|
println!("Parallel download time: {:?}", parallel_duration);
|
|
println!("Serial download time: {:?}", serial_duration);
|
|
|
|
// Verify files were unpacked correctly
|
|
verify_directories(&source_dir, &dest_dir_parallel)?;
|
|
verify_directories(&source_dir, &dest_dir_serial)?;
|
|
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
// Helper function to create test files
|
|
async fn create_test_files(dir: &Path, count: usize, size: usize) -> Result<()> {
|
|
use rand::{thread_rng, Rng};
|
|
use tokio::fs::File;
|
|
use tokio::io::AsyncWriteExt;
|
|
|
|
for i in 0..count {
|
|
let file_path = dir.join(format!("file_{}.bin", i));
|
|
let mut file = File::create(&file_path).await?;
|
|
|
|
// Create random data
|
|
let mut data = vec![0u8; size];
|
|
thread_rng().fill(&mut data[..]);
|
|
|
|
// Write to file
|
|
file.write_all(&data).await?;
|
|
file.flush().await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// Helper function to verify directories match
|
|
fn verify_directories(source: &Path, dest: &Path) -> Result<()> {
|
|
use std::process::Command;
|
|
|
|
let output = Command::new("diff")
|
|
.arg("-r")
|
|
.arg(source)
|
|
.arg(dest)
|
|
.output()?;
|
|
|
|
assert!(output.status.success(), "Directories don't match");
|
|
Ok(())
|
|
}
|
|
}
|