328 lines
10 KiB
Rust
328 lines
10 KiB
Rust
#[tokio::test]
|
|
async fn graceful_shutdown_flush_moves_hot_objects_and_releases_resident_bytes() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let mut settings = cold_settings();
|
|
settings.max_entries = 8;
|
|
let shutdown = CancellationToken::new();
|
|
let cache = Cache::start(
|
|
11,
|
|
Some(dir.path().to_path_buf()),
|
|
settings.clone(),
|
|
shutdown.clone(),
|
|
);
|
|
fill(&cache, &settings, "/one", "first-payload").await;
|
|
fill(&cache, &settings, "/two", "second-payload").await;
|
|
assert_eq!(cache.view().entries, 2);
|
|
assert!(cache.view().resident_bytes > 0);
|
|
assert_eq!(cache.view().cold_entries, 0);
|
|
|
|
assert_eq!(cache.flush_hot_to_cold().await, 2);
|
|
let view = cache.view();
|
|
assert_eq!(view.entries, 0);
|
|
assert_eq!(view.resident_bytes, 0);
|
|
assert_eq!(view.hot_logical_bytes, 0);
|
|
assert_eq!(
|
|
view.transient_bytes, 0,
|
|
"persisted ColdEntry must not retain the body allocation"
|
|
);
|
|
assert_eq!(view.cold_entries, 2);
|
|
shutdown.cancel();
|
|
|
|
let restart_shutdown = CancellationToken::new();
|
|
let restarted = Cache::start(
|
|
11,
|
|
Some(dir.path().to_path_buf()),
|
|
settings.clone(),
|
|
restart_shutdown.clone(),
|
|
);
|
|
assert_eq!(restarted.view().cold_entries, 2);
|
|
restart_shutdown.cancel();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn managed_update_flush_ignores_shutdown_toggle_when_cold_tier_is_enabled() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let mut settings = cold_settings();
|
|
settings.max_entries = 8;
|
|
settings.cold_on_shutdown = false;
|
|
let shutdown = CancellationToken::new();
|
|
let cache = Cache::start(
|
|
11,
|
|
Some(dir.path().to_path_buf()),
|
|
settings.clone(),
|
|
shutdown.clone(),
|
|
);
|
|
fill(&cache, &settings, "/update", "update-payload").await;
|
|
assert_eq!(cache.flush_hot_to_cold().await, 0);
|
|
assert_eq!(cache.view().entries, 1);
|
|
assert_eq!(cache.flush_hot_to_cold_for_update().await, 1);
|
|
let view = cache.view();
|
|
assert_eq!(view.entries, 0);
|
|
assert_eq!(view.resident_bytes, 0);
|
|
assert_eq!(view.cold_entries, 1);
|
|
shutdown.cancel();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn graceful_shutdown_flush_can_be_disabled() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let mut settings = cold_settings();
|
|
settings.max_entries = 8;
|
|
settings.cold_on_shutdown = false;
|
|
let shutdown = CancellationToken::new();
|
|
let cache = Cache::start(
|
|
11,
|
|
Some(dir.path().to_path_buf()),
|
|
settings.clone(),
|
|
shutdown.clone(),
|
|
);
|
|
fill(&cache, &settings, "/one", "first-payload").await;
|
|
assert_eq!(cache.flush_hot_to_cold().await, 0);
|
|
assert_eq!(cache.view().entries, 1);
|
|
assert_eq!(cache.view().cold_entries, 0);
|
|
shutdown.cancel();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn cold_cache_uses_two_hex_character_shards() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let settings = cold_settings();
|
|
let shutdown = CancellationToken::new();
|
|
let cache = Cache::start(
|
|
11,
|
|
Some(dir.path().to_path_buf()),
|
|
settings.clone(),
|
|
shutdown.clone(),
|
|
);
|
|
fill(&cache, &settings, "/one", "first-payload").await;
|
|
fill(&cache, &settings, "/two", "second-payload").await;
|
|
wait_for_cold(&cache, 1).await;
|
|
let root = dir.path().join(&settings.cold_path);
|
|
let mut shards = Vec::new();
|
|
for item in std::fs::read_dir(&root).unwrap() {
|
|
let item = item.unwrap();
|
|
let name = item.file_name().to_string_lossy().to_string();
|
|
assert!(
|
|
item.path().is_dir(),
|
|
"cold root must contain shard directories only"
|
|
);
|
|
assert_eq!(name.len(), 2);
|
|
assert!(name.bytes().all(|b| b.is_ascii_hexdigit()));
|
|
shards.push(item.path());
|
|
}
|
|
assert!(!shards.is_empty());
|
|
assert!(shards.iter().any(|shard| {
|
|
std::fs::read_dir(shard)
|
|
.unwrap()
|
|
.filter_map(|entry| entry.ok())
|
|
.any(|entry| {
|
|
let name = entry.file_name().to_string_lossy().to_string();
|
|
name.ends_with(".json") || name.ends_with(".body")
|
|
})
|
|
}));
|
|
shutdown.cancel();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn legacy_flat_cold_cache_is_not_migrated() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let settings = cold_settings();
|
|
let root = dir.path().join(&settings.cold_path);
|
|
std::fs::create_dir_all(&root).unwrap();
|
|
std::fs::write(root.join("legacy.body"), b"old").unwrap();
|
|
std::fs::write(root.join("legacy.json"), b"{}").unwrap();
|
|
let shutdown = CancellationToken::new();
|
|
let cache = Cache::start(
|
|
11,
|
|
Some(dir.path().to_path_buf()),
|
|
settings,
|
|
shutdown.clone(),
|
|
);
|
|
assert_eq!(cache.view().cold_entries, 0);
|
|
assert!(!root.join("legacy.body").exists());
|
|
assert!(!root.join("legacy.json").exists());
|
|
shutdown.cancel();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn manual_cold_cleanup_reports_removed_objects_and_freed_bytes() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let mut settings = cold_settings();
|
|
settings.max_entries = 1;
|
|
let shutdown = CancellationToken::new();
|
|
let cache = Cache::start(
|
|
11,
|
|
Some(dir.path().to_path_buf()),
|
|
settings.clone(),
|
|
shutdown.clone(),
|
|
);
|
|
fill(&cache, &settings, "/one", "first-payload").await;
|
|
fill(&cache, &settings, "/two", "second-payload").await;
|
|
fill(&cache, &settings, "/three", "third-payload").await;
|
|
wait_for_cold(&cache, 2).await;
|
|
let job = cache
|
|
.start_cold_cleanup(ColdCleanupRequest {
|
|
unused_for_seconds: None,
|
|
oldest: Some(1),
|
|
hits_zero: false,
|
|
})
|
|
.unwrap();
|
|
for _ in 0..100 {
|
|
let current = cache.cold_cleanup_job(job.id).unwrap();
|
|
if current.status == "done" {
|
|
assert_eq!(current.removed_entries, 1);
|
|
assert!(current.freed_bytes > 0);
|
|
assert_eq!(cache.view().cold_entries, 1);
|
|
shutdown.cancel();
|
|
return;
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(10)).await;
|
|
}
|
|
panic!("cold cleanup did not finish");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn manual_cold_cleanup_is_single_flight() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let settings = cold_settings();
|
|
let shutdown = CancellationToken::new();
|
|
let cache = Cache::start(
|
|
11,
|
|
Some(dir.path().to_path_buf()),
|
|
settings,
|
|
shutdown.clone(),
|
|
);
|
|
let _held = cache.cleanup_slots.clone().try_acquire_owned().unwrap();
|
|
let result = cache.start_cold_cleanup(ColdCleanupRequest {
|
|
unused_for_seconds: None,
|
|
oldest: Some(1),
|
|
hits_zero: false,
|
|
});
|
|
assert!(result.is_err());
|
|
shutdown.cancel();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn cold_cleanup_skips_an_entry_while_a_read_is_pinned() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let mut settings = cold_settings();
|
|
settings.max_entries = 1;
|
|
let shutdown = CancellationToken::new();
|
|
let cache = Cache::start(
|
|
11,
|
|
Some(dir.path().to_path_buf()),
|
|
settings.clone(),
|
|
shutdown.clone(),
|
|
);
|
|
fill(&cache, &settings, "/one", "first-payload").await;
|
|
fill(&cache, &settings, "/two", "second-payload").await;
|
|
wait_for_cold(&cache, 1).await;
|
|
|
|
let key = {
|
|
let mut cold = cache.cold.lock().unwrap();
|
|
let key = *cold.entries.keys().next().unwrap();
|
|
cold.entries.get_mut(&key).unwrap().pinned_reads = 1;
|
|
key
|
|
};
|
|
let request = ColdCleanupRequest {
|
|
unused_for_seconds: None,
|
|
oldest: Some(1),
|
|
hits_zero: false,
|
|
};
|
|
let result = cache
|
|
.remove_cold_candidates(Some(&request), None, None, 1)
|
|
.await;
|
|
assert_eq!(result.removed_entries, 0);
|
|
assert!(cache.cold.lock().unwrap().entries.contains_key(&key));
|
|
|
|
cache
|
|
.cold
|
|
.lock()
|
|
.unwrap()
|
|
.entries
|
|
.get_mut(&key)
|
|
.unwrap()
|
|
.pinned_reads = 0;
|
|
let result = cache
|
|
.remove_cold_candidates(Some(&request), None, None, 1)
|
|
.await;
|
|
assert_eq!(result.removed_entries, 1);
|
|
assert!(!cache.cold.lock().unwrap().entries.contains_key(&key));
|
|
shutdown.cancel();
|
|
}
|
|
|
|
#[test]
|
|
fn old_cold_read_guard_does_not_unpin_a_replacement_with_the_same_key() {
|
|
let cache = Cache::new(1);
|
|
let key = [7_u8; 32];
|
|
let template = ColdEntry {
|
|
base_key: key,
|
|
vary: Vec::new(),
|
|
revision: 1,
|
|
scope: "app".to_owned(),
|
|
scheme: "https".to_owned(),
|
|
authority: "example.test".to_owned(),
|
|
domain: "example.test".to_owned(),
|
|
path: "/asset".to_owned(),
|
|
target: "https://example.test/asset".to_owned(),
|
|
tags: Vec::new(),
|
|
created_at: SystemTime::now(),
|
|
body_path: PathBuf::from("old.body"),
|
|
meta_path: PathBuf::from("old.json"),
|
|
body_bytes: 1,
|
|
body_sha256: [0u8; 32],
|
|
disk_bytes: 2,
|
|
stored_at: SystemTime::now(),
|
|
last_access: SystemTime::now(),
|
|
age_at_store_seconds: 0,
|
|
resident_age_at_store_seconds: 0,
|
|
ttl: 60,
|
|
stale_while_revalidate: 0,
|
|
stale_if_error: 0,
|
|
must_revalidate: false,
|
|
proxy_revalidate: false,
|
|
has_validator: false,
|
|
hits: 0,
|
|
transformed: false,
|
|
sequence: 1,
|
|
generation: 1,
|
|
skip_compression: false,
|
|
requires_revalidation: false,
|
|
pinned_reads: 1,
|
|
};
|
|
cache
|
|
.cold
|
|
.lock()
|
|
.unwrap()
|
|
.entries
|
|
.insert(key, template.clone());
|
|
let old_guard = ColdReadGuard {
|
|
cache: &cache,
|
|
key,
|
|
generation: 1,
|
|
};
|
|
|
|
let mut replacement = template;
|
|
replacement.sequence = 2;
|
|
replacement.generation = 2;
|
|
replacement.pinned_reads = 1;
|
|
cache.cold.lock().unwrap().entries.insert(key, replacement);
|
|
drop(old_guard);
|
|
|
|
let cold = cache.cold.lock().unwrap();
|
|
let replacement = cold.entries.get(&key).unwrap();
|
|
assert_eq!(replacement.generation, 2);
|
|
assert_eq!(replacement.pinned_reads, 1);
|
|
}
|
|
|
|
#[test]
|
|
fn cold_path_cannot_escape_data_directory() {
|
|
let mut settings = Settings::default();
|
|
settings.cold_path = "../outside".into();
|
|
assert!(settings.validate().is_err());
|
|
settings.cold_path = "/tmp/outside".into();
|
|
assert!(settings.validate().is_err());
|
|
settings.cold_path = "cache/cold".into();
|
|
assert!(settings.validate().is_ok());
|
|
}
|