use crate::crypto::DatabaseCipher;
use crate::error::{Error, Result};
use crate::pager::{DatabaseHeader, PageId, DATABASE_HEADER_SIZE};
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use std::sync::Arc;
pub trait RemoteRangeReader: Send + Sync {
fn fetch_range(&self, offset: u64, length: usize) -> Result<Vec<u8>>;
fn total_size(&self) -> Result<u64>;
}
pub trait RemoteStorageAdapter: RemoteRangeReader {
fn put_object(&self, data: &[u8]) -> Result<()>;
}
pub struct MockRemoteRangeStorage {
data: RwLock<Vec<u8>>,
fetch_count: AtomicUsize,
bytes_read: AtomicU64,
put_count: AtomicUsize,
}
impl MockRemoteRangeStorage {
pub fn new(data: Vec<u8>) -> Self {
Self {
data: RwLock::new(data),
fetch_count: AtomicUsize::new(0),
bytes_read: AtomicU64::new(0),
put_count: AtomicUsize::new(0),
}
}
pub fn empty() -> Self {
Self::new(Vec::new())
}
pub fn bytes_len(&self) -> usize {
self.data.read().len()
}
pub fn fetch_count(&self) -> usize {
self.fetch_count.load(Ordering::Relaxed)
}
pub fn bytes_transferred(&self) -> u64 {
self.bytes_read.load(Ordering::Relaxed)
}
pub fn put_count(&self) -> usize {
self.put_count.load(Ordering::Relaxed)
}
pub fn data(&self) -> Vec<u8> {
self.data.read().clone()
}
}
impl Default for MockRemoteRangeStorage {
fn default() -> Self {
Self::empty()
}
}
impl RemoteRangeReader for MockRemoteRangeStorage {
fn fetch_range(&self, offset: u64, length: usize) -> Result<Vec<u8>> {
let guard = self.data.read();
let start = offset as usize;
let end = start + length;
if start > guard.len() {
return Err(Error::Corrupted(format!(
"Remote fetch out of bounds: offset {} exceeds file size {}",
offset,
guard.len()
)));
}
let actual_end = end.min(guard.len());
let slice = guard[start..actual_end].to_vec();
self.fetch_count.fetch_add(1, Ordering::Relaxed);
self.bytes_read.fetch_add(slice.len() as u64, Ordering::Relaxed);
Ok(slice)
}
fn total_size(&self) -> Result<u64> {
Ok(self.data.read().len() as u64)
}
}
impl RemoteStorageAdapter for MockRemoteRangeStorage {
fn put_object(&self, data: &[u8]) -> Result<()> {
let mut guard = self.data.write();
*guard = data.to_vec();
self.put_count.fetch_add(1, Ordering::Relaxed);
Ok(())
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct S3StorageConfig {
pub bucket: String,
pub key: String,
pub endpoint: String,
pub region: String,
pub auth_token: Option<String>,
}
impl S3StorageConfig {
pub fn make_range_header(&self, offset: u64, length: usize) -> String {
let end = offset + length as u64 - 1;
format!("bytes={}-{}", offset, end)
}
}
pub struct RemotePager {
header: DatabaseHeader,
reader: Arc<dyn RemoteRangeReader>,
in_memory_pages: HashMap<PageId, Vec<u8>>,
cache_capacity: usize,
cipher: Option<DatabaseCipher>,
cache_hits: usize,
network_fetches: usize,
}
impl RemotePager {
pub fn open(
reader: Arc<dyn RemoteRangeReader>,
cache_capacity: usize,
cipher: Option<DatabaseCipher>,
) -> Result<Self> {
let total_size = reader.total_size()?;
if total_size < DATABASE_HEADER_SIZE as u64 {
return Err(Error::Corrupted(
"Remote database file is smaller than minimum header size".into(),
));
}
let header_bytes = reader.fetch_range(0, DATABASE_HEADER_SIZE)?;
let mut header_buf = [0u8; DATABASE_HEADER_SIZE];
header_buf.copy_from_slice(&header_bytes[..DATABASE_HEADER_SIZE]);
let header = DatabaseHeader::from_bytes(&header_buf)?;
if header.encryption_flags == 1 {
if let Some(ref c) = cipher {
if !c.verify_kcv(&header.kcv) {
return Err(Error::DecryptionFailed(1));
}
} else {
return Err(Error::EncryptedDatabase);
}
}
Ok(Self {
header,
reader,
in_memory_pages: HashMap::new(),
cache_capacity: cache_capacity.max(64),
cipher,
cache_hits: 0,
network_fetches: 0,
})
}
pub fn header(&self) -> &DatabaseHeader {
&self.header
}
pub fn page_size(&self) -> usize {
self.header.page_size as usize
}
pub fn total_pages(&self) -> u32 {
self.header.total_pages
}
pub fn cache_hits(&self) -> usize {
self.cache_hits
}
pub fn network_fetches(&self) -> usize {
self.network_fetches
}
pub fn read_page(&mut self, page_id: PageId) -> Result<Vec<u8>> {
let page_size = self.page_size();
if page_id == 0 || page_id > self.header.total_pages {
return Err(Error::PageNotFound(page_id));
}
if let Some(page) = self.in_memory_pages.get(&page_id) {
self.cache_hits += 1;
return Ok(page.clone());
}
let offset = (page_id as u64 - 1) * page_size as u64;
let raw_bytes = self.reader.fetch_range(offset, page_size)?;
self.network_fetches += 1;
if raw_bytes.len() != page_size {
return Err(Error::Corrupted(format!(
"Incomplete page fetch: expected {} bytes, got {}",
page_size,
raw_bytes.len()
)));
}
let plaintext = if let Some(ref cipher) = self.cipher {
cipher.decrypt_page(page_id, &raw_bytes)?
} else {
raw_bytes
};
if self.in_memory_pages.len() >= self.cache_capacity {
if let Some(&first_key) = self.in_memory_pages.keys().next() {
self.in_memory_pages.remove(&first_key);
}
}
self.in_memory_pages.insert(page_id, plaintext.clone());
Ok(plaintext)
}
}