#![forbid(unsafe_code)]
pub const DELTA_MIN_SIZE: u64 = 10 * 1024 * 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransferStrategy {
Copy,
Delta,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FileClass {
Small,
Medium,
Large,
}
pub const SMALL_FILE_MAX: u64 = 2 * 1024 * 1024;
pub const MEDIUM_FILE_MAX: u64 = 16 * 1024 * 1024;
#[must_use]
pub fn optimal_thread_count(is_network: bool) -> usize {
let cpus = num_cpus::get();
if is_network { cpus.min(16) } else { cpus }
}
#[must_use]
pub fn classify_file_size(size: u64) -> FileClass {
if size <= SMALL_FILE_MAX {
FileClass::Small
} else if size <= MEDIUM_FILE_MAX {
FileClass::Medium
} else {
FileClass::Large
}
}
#[must_use]
pub fn determine_strategy(src_size: u64, dest_exists: bool) -> TransferStrategy {
if dest_exists && src_size > DELTA_MIN_SIZE {
TransferStrategy::Delta
} else {
TransferStrategy::Copy
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn strategy_copy_below_delta_min() {
assert_eq!(determine_strategy(0, true), TransferStrategy::Copy);
assert_eq!(determine_strategy(DELTA_MIN_SIZE, true), TransferStrategy::Copy);
}
#[test]
fn strategy_delta_above_delta_min_with_dest() {
assert_eq!(
determine_strategy(DELTA_MIN_SIZE + 1, true),
TransferStrategy::Delta
);
}
#[test]
fn strategy_copy_for_small() {
assert_eq!(determine_strategy(100, true), TransferStrategy::Copy);
assert_eq!(determine_strategy(100, false), TransferStrategy::Copy);
}
#[test]
fn strategy_delta_for_large_with_dest() {
assert_eq!(
determine_strategy(50 * 1024 * 1024, true),
TransferStrategy::Delta
);
}
#[test]
fn strategy_copy_for_large_without_dest() {
assert_eq!(
determine_strategy(50 * 1024 * 1024, false),
TransferStrategy::Copy
);
}
#[test]
fn strategy_copy_for_extra_large_without_dest() {
assert_eq!(
determine_strategy(500 * 1024 * 1024, false),
TransferStrategy::Copy
);
}
#[test]
fn classify_size_small() {
assert_eq!(classify_file_size(0), FileClass::Small);
assert_eq!(classify_file_size(SMALL_FILE_MAX), FileClass::Small);
}
#[test]
fn classify_size_medium() {
assert_eq!(classify_file_size(SMALL_FILE_MAX + 1), FileClass::Medium);
assert_eq!(classify_file_size(MEDIUM_FILE_MAX), FileClass::Medium);
}
#[test]
fn classify_size_large() {
assert_eq!(classify_file_size(MEDIUM_FILE_MAX + 1), FileClass::Large);
}
}