use std::fs::File;
use std::io::{self, Read};
use std::path::PathBuf;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Duration;
use crate::error::BhandaarError;
use crate::eviction;
use crate::hasher;
use crate::metadata::EntryMeta;
use crate::shard::{self, Shard};
use crate::store;
static PUT_TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);
pub struct Bhandaar {
config: crate::BhandaarConfig,
shards: Vec<Shard>,
total_size: AtomicU64,
}
impl Bhandaar {
pub fn new(config: crate::BhandaarConfig) -> std::io::Result<Self> {
std::fs::create_dir_all(&config.root)?;
let shards: Vec<Shard> = (0..config.shards).map(|_| Shard::new()).collect();
let cache = Self {
config,
shards,
total_size: AtomicU64::new(0),
};
cache.rebuild_index()?;
Ok(cache)
}
pub fn get_file(&self, key: &str) -> Result<Option<File>, BhandaarError> {
let idx = shard::shard_index(key, self.config.shards);
let shard = &self.shards[idx];
let data_path = self.data_path(key);
let meta_path = self.meta_path(key);
let mut meta = match store::read_meta(&meta_path) {
Ok(m) => m,
Err(BhandaarError::CorruptedMetadata(_)) | Err(BhandaarError::SerializationError(_)) => {
let _ = store::delete_file(&data_path);
let _ = store::delete_file(&meta_path);
shard.remove(key);
return Ok(None);
}
Err(e) => return Err(e),
};
if meta.is_expired() {
let _ = store::delete_file(&data_path);
let _ = store::delete_file(&meta_path);
shard.remove(key);
self.total_size.fetch_sub(meta.size, Ordering::SeqCst);
return Ok(None);
}
let file = File::open(&data_path).map_err(|e| {
let _ = store::delete_file(&meta_path);
shard.remove(key);
BhandaarError::Io(e)
})?;
meta.touch();
let _ = store::write_meta(&meta_path, &meta);
Ok(Some(file))
}
pub fn put_reader<R: Read>(
&self,
key: &str,
mut reader: R,
size: u64,
) -> Result<(), BhandaarError> {
self.put_reader_with_ttl(key, &mut reader, size, self.config.default_ttl)
}
pub fn put_reader_with_ttl<R: Read>(
&self,
key: &str,
mut reader: R,
size: u64,
ttl: Option<Duration>,
) -> Result<(), BhandaarError> {
let idx = shard::shard_index(key, self.config.shards);
let shard = &self.shards[idx];
let data_path = self.data_path(key);
let meta_path = self.meta_path(key);
if let Some(parent) = data_path.parent() {
std::fs::create_dir_all(parent).map_err(BhandaarError::Io)?;
}
let counter = PUT_TEMP_COUNTER.fetch_add(1, Ordering::Relaxed);
let temp_path = data_path.with_file_name(format!(
"{}.{}.put.tmp",
data_path.file_stem().unwrap().to_str().unwrap(),
counter
));
let mut file = File::create(&temp_path).map_err(BhandaarError::Io)?;
io::copy(&mut reader, &mut file).map_err(BhandaarError::Io)?;
file.sync_all().map_err(BhandaarError::Io)?;
let temp_meta_path = meta_path.with_file_name(format!(
"{}.{}.put.meta.tmp",
meta_path.file_stem().unwrap().to_str().unwrap(),
counter
));
let meta = EntryMeta::new(key.to_string(), size, ttl);
store::write_meta(&temp_meta_path, &meta)?;
if !shard.insert_if_absent(key.to_string(), data_path.clone()) {
let _ = store::delete_file(&temp_path);
let _ = store::delete_file(&temp_meta_path);
return Err(BhandaarError::AlreadyExists(key.to_string()));
}
let _ = std::fs::rename(&temp_path, &data_path);
let _ = std::fs::rename(&temp_meta_path, &meta_path);
self.total_size.fetch_add(size, Ordering::SeqCst);
self.evict_if_needed();
Ok(())
}
pub fn put_reader_auto_size<R: Read>(
&self,
key: &str,
mut reader: R,
ttl: Option<Duration>,
) -> Result<u64, BhandaarError> {
let idx = shard::shard_index(key, self.config.shards);
let shard = &self.shards[idx];
let data_path = self.data_path(key);
let meta_path = self.meta_path(key);
if let Some(parent) = data_path.parent() {
std::fs::create_dir_all(parent).map_err(BhandaarError::Io)?;
}
let counter = PUT_TEMP_COUNTER.fetch_add(1, Ordering::Relaxed);
let temp_path = data_path.with_file_name(format!(
"{}.{}.put.tmp",
data_path.file_stem().unwrap().to_str().unwrap(),
counter
));
let mut file = File::create(&temp_path).map_err(BhandaarError::Io)?;
let size = io::copy(&mut reader, &mut file).map_err(BhandaarError::Io)?;
file.sync_all().map_err(BhandaarError::Io)?;
let temp_meta_path = meta_path.with_file_name(format!(
"{}.{}.put.meta.tmp",
meta_path.file_stem().unwrap().to_str().unwrap(),
counter
));
let meta = EntryMeta::new(key.to_string(), size, ttl);
store::write_meta(&temp_meta_path, &meta)?;
if !shard.insert_if_absent(key.to_string(), data_path.clone()) {
let _ = store::delete_file(&temp_path);
let _ = store::delete_file(&temp_meta_path);
return Err(BhandaarError::AlreadyExists(key.to_string()));
}
let _ = std::fs::rename(&temp_path, &data_path);
let _ = std::fs::rename(&temp_meta_path, &meta_path);
self.total_size.fetch_add(size, Ordering::SeqCst);
self.evict_if_needed();
Ok(size)
}
pub fn get(&self, key: &str) -> Result<Option<Vec<u8>>, BhandaarError> {
let idx = shard::shard_index(key, self.config.shards);
let shard = &self.shards[idx];
let data_path = self.data_path(key);
let meta_path = self.meta_path(key);
let mut meta = match store::read_meta(&meta_path) {
Ok(m) => m,
Err(BhandaarError::CorruptedMetadata(_)) | Err(BhandaarError::SerializationError(_)) => {
let _ = store::delete_file(&data_path);
let _ = store::delete_file(&meta_path);
shard.remove(key);
return Ok(None);
}
Err(e) => return Err(e),
};
if meta.is_expired() {
let _ = store::delete_file(&data_path);
let _ = store::delete_file(&meta_path);
shard.remove(key);
self.total_size.fetch_sub(meta.size, Ordering::SeqCst);
return Ok(None);
}
let data = store::read_data(&data_path).map_err(|e| {
let _ = store::delete_file(&meta_path);
shard.remove(key);
BhandaarError::Io(e)
})?;
meta.touch();
let _ = store::write_meta(&meta_path, &meta);
Ok(Some(data))
}
pub fn put(&self, key: &str, data: &[u8]) -> Result<(), BhandaarError> {
self.put_with_ttl(key, data, self.config.default_ttl)
}
pub fn put_with_ttl(
&self,
key: &str,
data: &[u8],
ttl: Option<Duration>,
) -> Result<(), BhandaarError> {
let idx = shard::shard_index(key, self.config.shards);
let shard = &self.shards[idx];
let data_path = self.data_path(key);
let meta_path = self.meta_path(key);
let counter = PUT_TEMP_COUNTER.fetch_add(1, Ordering::Relaxed);
let temp_path = data_path.with_file_name(format!(
"{}.{}.put.tmp",
data_path.file_stem().unwrap().to_str().unwrap(),
counter
));
store::write_data(&temp_path, data).map_err(BhandaarError::Io)?;
let temp_meta_path = meta_path.with_file_name(format!(
"{}.{}.put.meta.tmp",
meta_path.file_stem().unwrap().to_str().unwrap(),
counter
));
let meta = EntryMeta::new(key.to_string(), data.len() as u64, ttl);
store::write_meta(&temp_meta_path, &meta)?;
if !shard.insert_if_absent(key.to_string(), data_path.clone()) {
let _ = store::delete_file(&temp_path);
let _ = store::delete_file(&temp_meta_path);
return Err(BhandaarError::AlreadyExists(key.to_string()));
}
let _ = std::fs::rename(&temp_path, &data_path);
let _ = std::fs::rename(&temp_meta_path, &meta_path);
self.total_size.fetch_add(data.len() as u64, Ordering::SeqCst);
self.evict_if_needed();
Ok(())
}
pub fn remove(&self, key: &str) -> Result<bool, BhandaarError> {
let idx = shard::shard_index(key, self.config.shards);
let shard = &self.shards[idx];
match shard.remove(key) {
Some(data_path) => {
let meta_path = data_path.with_extension("dat.meta");
if let Ok(meta) = store::read_meta(&meta_path) {
self.total_size.fetch_sub(meta.size, Ordering::SeqCst);
}
let _ = store::delete_file(&data_path);
let _ = store::delete_file(&meta_path);
Ok(true)
}
None => Ok(false),
}
}
pub fn contains(&self, key: &str) -> Result<bool, BhandaarError> {
let idx = shard::shard_index(key, self.config.shards);
let shard = &self.shards[idx];
if !shard.contains(key) {
return Ok(false);
}
let meta_path = self.meta_path(key);
match store::read_meta(&meta_path) {
Ok(meta) => Ok(!meta.is_expired()),
Err(_) => Ok(false),
}
}
pub fn size(&self) -> u64 {
self.total_size.load(Ordering::SeqCst)
}
pub fn clear(&self) -> Result<(), BhandaarError> {
for shard in &self.shards {
let entries = shard.entries();
for (key, data_path) in entries {
let meta_path = data_path.with_extension("dat.meta");
let _ = store::delete_file(&data_path);
let _ = store::delete_file(&meta_path);
shard.remove(&key);
}
}
self.total_size.store(0, Ordering::SeqCst);
Ok(())
}
pub fn keys(&self) -> Result<Vec<String>, BhandaarError> {
let mut all_keys = Vec::new();
for shard in &self.shards {
let entries = shard.entries();
for (key, _) in entries {
all_keys.push(key);
}
}
Ok(all_keys)
}
pub fn config(&self) -> &crate::BhandaarConfig {
&self.config
}
fn data_path(&self, key: &str) -> PathBuf {
self.config.root.join(hasher::data_path(key))
}
fn meta_path(&self, key: &str) -> PathBuf {
self.config.root.join(hasher::meta_path(key))
}
fn evict_if_needed(&self) {
while self.total_size.load(Ordering::SeqCst) > self.config.max_size {
let mut evicted = false;
for shard in &self.shards {
let _guard = shard.lock_exclusive();
let freed = eviction::evict_expired(shard);
if freed > 0 {
self.total_size.fetch_sub(freed, Ordering::SeqCst);
evicted = true;
continue;
}
if let Some(freed) = eviction::evict_lru(shard) {
self.total_size.fetch_sub(freed, Ordering::SeqCst);
evicted = true;
break;
}
}
if !evicted {
break;
}
}
}
fn rebuild_index(&self) -> std::io::Result<()> {
for entry in std::fs::read_dir(&self.config.root)? {
let entry = entry?;
let path = entry.path();
if path.is_dir() {
self.rebuild_shard_index(&path)?;
}
}
Ok(())
}
fn rebuild_shard_index(&self, dir: &std::path::Path) -> std::io::Result<()> {
for entry in std::fs::read_dir(dir)? {
let entry = entry?;
let path = entry.path();
if path.is_dir() {
self.rebuild_shard_index(&path)?;
} else if let Some(name) = path.file_name() {
if let Some(name_str) = name.to_str() {
if name_str.ends_with(".dat.meta") {
if let Ok(meta) = store::read_meta(&path) {
let data_path = path.with_extension("");
let idx = shard::shard_index(&meta.key, self.config.shards);
let shard = &self.shards[idx];
shard.insert(meta.key, data_path);
self.total_size.fetch_add(meta.size, Ordering::SeqCst);
}
}
}
}
}
Ok(())
}
}