Watch
0
0
Fork
You've already forked hyperhive
0
hyperhive/swarm-stt/src/cache.rs

149 lines
4.7 KiB
Rust

//! The transcript cache: one `<sha256>.txt` file per memo in a directory, kept
//! for a TTL counted from the file's modification time.
use std::fmt::Write as _;
use std::io::ErrorKind;
use std::path::{Path, PathBuf};
use std::time::{Duration, SystemTime};
use sha2::{Digest as _, Sha256};
/// The lowercase hex SHA-256 of `bytes`: the cache key.
#[must_use]
pub fn key(bytes: &[u8]) -> String {
Sha256::digest(bytes)
.iter()
.fold(String::with_capacity(64), |mut hex, byte| {
let _ = write!(hex, "{byte:02x}");
hex
})
}
/// A directory of transcripts that expire `ttl` after they were written.
#[derive(Debug, Clone)]
pub struct Cache {
dir: PathBuf,
ttl: Duration,
}
impl Cache {
/// A cache in `dir` (created on first write).
#[must_use]
pub fn new(dir: impl Into<PathBuf>, ttl: Duration) -> Self {
Self {
dir: dir.into(),
ttl,
}
}
fn path(&self, key: &str) -> PathBuf {
self.dir.join(format!("{key}.txt"))
}
/// The transcript stored under `key`, unless it is missing or expired. An
/// expired file is removed.
pub async fn get(&self, key: &str) -> Option<String> {
let path = self.path(key);
let age = age_of(&path).await?;
if age >= self.ttl {
let _ = tokio::fs::remove_file(&path).await;
return None;
}
tokio::fs::read_to_string(&path).await.ok()
}
/// Stores `text` under `key`. The file is written beside its name and
/// renamed into place, so a reader never sees half a transcript.
pub async fn put(&self, key: &str, text: &str) -> std::io::Result<()> {
tokio::fs::create_dir_all(&self.dir).await?;
let path = self.path(key);
let tmp = self.dir.join(format!("{key}.tmp"));
tokio::fs::write(&tmp, text).await?;
tokio::fs::rename(&tmp, &path).await
}
/// Removes every expired transcript. Returns how many it removed.
pub async fn purge(&self) -> usize {
let Ok(mut entries) = tokio::fs::read_dir(&self.dir).await else {
return 0;
};
let mut removed = 0;
while let Ok(Some(entry)) = entries.next_entry().await {
let path = entry.path();
if path.extension().is_some_and(|ext| ext == "txt")
&& age_of(&path).await.is_some_and(|age| age >= self.ttl)
&& tokio::fs::remove_file(&path).await.is_ok()
{
removed += 1;
}
}
removed
}
}
/// How long ago `path` was last written, or `None` when it cannot be told.
async fn age_of(path: &Path) -> Option<Duration> {
let modified = match tokio::fs::metadata(path).await {
Ok(meta) => meta.modified().ok()?,
Err(e) if e.kind() == ErrorKind::NotFound => return None,
Err(e) => {
tracing::warn!(path = %path.display(), error = %e, "reading a cached transcript's age failed");
return None;
}
};
// A file dated in the future counts as brand new.
Some(
SystemTime::now()
.duration_since(modified)
.unwrap_or_default(),
)
}
#[cfg(test)]
mod tests {
use super::{Cache, key};
use std::time::Duration;
#[test]
fn the_key_is_the_sha256_of_the_bytes() {
assert_eq!(
key(b"abc"),
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
);
}
#[tokio::test]
async fn a_stored_transcript_is_found_until_it_expires() {
let dir = tempfile::tempdir().unwrap();
let fresh = Cache::new(dir.path(), Duration::from_mins(1));
fresh.put("k", "hello").await.unwrap();
assert_eq!(fresh.get("k").await.as_deref(), Some("hello"));
let expired = Cache::new(dir.path(), Duration::ZERO);
assert_eq!(expired.get("k").await, None);
assert!(
!dir.path().join("k.txt").exists(),
"an expired file is removed"
);
}
#[tokio::test]
async fn purge_removes_only_expired_transcripts() {
let dir = tempfile::tempdir().unwrap();
let cache = Cache::new(dir.path(), Duration::from_mins(1));
cache.put("keep", "a").await.unwrap();
assert_eq!(cache.purge().await, 0);
assert_eq!(cache.get("keep").await.as_deref(), Some("a"));
let expiring = Cache::new(dir.path(), Duration::ZERO);
assert_eq!(expiring.purge().await, 1);
assert_eq!(cache.get("keep").await, None);
}
#[tokio::test]
async fn a_missing_directory_is_a_miss_and_an_empty_purge() {
let cache = Cache::new("/nonexistent/swarm-stt-test", Duration::from_mins(1));
assert_eq!(cache.get("k").await, None);
assert_eq!(cache.purge().await, 0);
}
}