use crate::crypto::DatabaseCipher;
use crate::error::{Error, Result};
use crate::pager::{DATABASE_HEADER_SIZE, DatabaseHeader, PageId};
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
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(crate) struct AdapterRangeReader(pub Arc<dyn RemoteStorageAdapter>);
impl RemoteRangeReader for AdapterRangeReader {
fn fetch_range(&self, offset: u64, length: usize) -> Result<Vec<u8>> {
self.0.fetch_range(offset, length)
}
fn total_size(&self) -> Result<u64> {
self.0.total_size()
}
}
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)
}
}
#[cfg(feature = "cloud-s3")]
pub struct CloudS3RemoteStorage {
config: S3StorageConfig,
agent: ureq::Agent,
}
#[cfg(feature = "cloud-s3")]
impl CloudS3RemoteStorage {
pub fn new(config: S3StorageConfig) -> Self {
let agent = ureq::Agent::config_builder()
.timeout_per_read(Some(web_time::Duration::from_secs(30)))
.timeout_per_write(Some(web_time::Duration::from_secs(30)))
.build()
.new_agent();
Self { config, agent }
}
pub fn object_url(&self) -> String {
let base = self.config.endpoint.trim_end_matches('/');
let bucket = self.config.bucket.trim_matches('/');
let key = self.config.key.trim_start_matches('/');
if bucket.is_empty() {
format!("{base}/{key}")
} else {
format!("{base}/{bucket}/{key}")
}
}
}
#[cfg(feature = "cloud-s3")]
impl RemoteRangeReader for CloudS3RemoteStorage {
fn fetch_range(&self, offset: u64, length: usize) -> Result<Vec<u8>> {
let url = self.object_url();
let range_header = self.config.make_range_header(offset, length);
let mut req = self.agent.get(&url).header("Range", &range_header);
if let Some(ref token) = self.config.auth_token {
if token.starts_with("Bearer ") || token.starts_with("AWS ") {
req = req.header("Authorization", token);
} else {
req = req.header("Authorization", format!("Bearer {token}"));
}
}
let resp = req.call().map_err(|e| {
Error::Io(std::io::Error::other(format!(
"Cloud S3 range request failed for {url} [Range: {range_header}]: {e}"
)))
})?;
let mut reader = resp.into_body().into_reader();
let mut buf = Vec::with_capacity(length);
std::io::Read::read_to_end(&mut reader, &mut buf)?;
Ok(buf)
}
fn total_size(&self) -> Result<u64> {
let url = self.object_url();
let mut req = self.agent.head(&url);
if let Some(ref token) = self.config.auth_token {
if token.starts_with("Bearer ") || token.starts_with("AWS ") {
req = req.header("Authorization", token);
} else {
req = req.header("Authorization", format!("Bearer {token}"));
}
}
if let Ok(resp) = req.call()
&& let Some(cl) = resp
.headers()
.get("content-length")
.and_then(|v| v.to_str().ok())
&& let Ok(size) = cl.parse::<u64>()
{
return Ok(size);
}
let mut req_range = self.agent.get(&url).header("Range", "bytes=0-0");
if let Some(ref token) = self.config.auth_token {
if token.starts_with("Bearer ") || token.starts_with("AWS ") {
req_range = req_range.header("Authorization", token);
} else {
req_range = req_range.header("Authorization", format!("Bearer {token}"));
}
}
let resp = req_range.call().map_err(|e| {
Error::Io(std::io::Error::other(format!(
"Failed to determine S3 object size for {url}: {e}"
)))
})?;
if let Some(cr) = resp
.headers()
.get("content-range")
.and_then(|v| v.to_str().ok())
&& let Some(slash_idx) = cr.rfind('/')
{
let total_str = &cr[slash_idx + 1..];
if let Ok(size) = total_str.trim().parse::<u64>() {
return Ok(size);
}
}
if let Some(cl) = resp
.headers()
.get("content-length")
.and_then(|v| v.to_str().ok())
&& let Ok(size) = cl.parse::<u64>()
{
return Ok(size);
}
Err(Error::Corrupted(format!(
"Cloud S3 response missing Content-Length or Content-Range headers for {url}"
)))
}
}
#[cfg(feature = "cloud-s3")]
impl RemoteStorageAdapter for CloudS3RemoteStorage {
fn put_object(&self, data: &[u8]) -> Result<()> {
let url = self.object_url();
let mut req = self
.agent
.put(&url)
.header("Content-Type", "application/octet-stream");
if let Some(ref token) = self.config.auth_token {
if token.starts_with("Bearer ") || token.starts_with("AWS ") {
req = req.header("Authorization", token);
} else {
req = req.header("Authorization", format!("Bearer {token}"));
}
}
req.send(data).map_err(|e| {
Error::Io(std::io::Error::other(format!(
"Cloud S3 PUT request failed for {url}: {e}"
)))
})?;
Ok(())
}
}
#[cfg(all(test, feature = "cloud-s3"))]
mod tests {
use super::*;
#[test]
#[cfg(feature = "cloud-s3")]
fn test_cloud_s3_http_range_streaming_live() {
use std::io::{Read, Write};
use std::net::TcpListener;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
let listener = TcpListener::bind("127.0.0.1:0").expect("Failed to bind test HTTP server");
let port = listener.local_addr().unwrap().port();
let running = Arc::new(AtomicBool::new(true));
let running_clone = running.clone();
let payload_data: Arc<parking_lot::RwLock<Vec<u8>>> = Arc::new(parking_lot::RwLock::new(
(0..8192).map(|i| (i % 256) as u8).collect(),
));
let server_payload = payload_data.clone();
let server_thread = std::thread::spawn(move || {
listener.set_nonblocking(true).unwrap();
while running_clone.load(Ordering::Relaxed) {
if let Ok((mut stream, _)) = listener.accept() {
stream.set_nonblocking(false).unwrap();
stream
.set_read_timeout(Some(std::time::Duration::from_secs(5)))
.unwrap();
let mut req_buf = [0u8; 2048];
let mut n = 0;
while n < req_buf.len() {
let read = stream.read(&mut req_buf[n..]).unwrap_or(0);
if read == 0 {
break;
}
n += read;
if req_buf[..n].windows(4).any(|part| part == b"\r\n\r\n") {
break;
}
}
let req_str = String::from_utf8_lossy(&req_buf[..n]);
if req_str.starts_with("HEAD ") {
let len = server_payload.read().len();
let resp = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {len}\r\nAccept-Ranges: bytes\r\nConnection: close\r\n\r\n"
);
let _ = stream.write_all(resp.as_bytes());
} else if req_str.starts_with("GET ") {
let range_header = req_str
.lines()
.find(|l| l.to_lowercase().starts_with("range:"))
.unwrap_or("");
let data = server_payload.read().clone();
let total = data.len();
if let Some(range_val) = range_header.split(':').nth(1) {
let range_val = range_val.trim();
if let Some(bytes_part) = range_val.strip_prefix("bytes=") {
let parts: Vec<&str> = bytes_part.split('-').collect();
let start: usize = parts[0].parse().unwrap_or(0);
let end: usize = parts[1].parse().unwrap_or(total - 1);
let end = end.min(total - 1);
let slice = &data[start..=end];
let resp = format!(
"HTTP/1.1 206 Partial Content\r\nContent-Length: {}\r\nContent-Range: bytes {start}-{end}/{total}\r\nConnection: close\r\n\r\n",
slice.len()
);
let _ = stream.write_all(resp.as_bytes());
let _ = stream.write_all(slice);
}
}
} else if req_str.starts_with("PUT ") {
let cl_line = req_str
.lines()
.find(|l| l.to_lowercase().starts_with("content-length:"))
.unwrap_or("");
let body_len: usize = cl_line
.split(':')
.nth(1)
.and_then(|v| v.trim().parse().ok())
.unwrap_or(0);
let double_crlf = req_str.find("\r\n\r\n").unwrap_or(0);
let body_start = if double_crlf > 0 { double_crlf + 4 } else { 0 };
let mut body_bytes = req_buf[body_start..n].to_vec();
while body_bytes.len() < body_len {
let mut extra = [0u8; 1024];
let extra_n = stream.read(&mut extra).unwrap_or(0);
if extra_n == 0 {
break;
}
body_bytes.extend_from_slice(&extra[..extra_n]);
}
*server_payload.write() = body_bytes;
let resp =
"HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
let _ = stream.write_all(resp.as_bytes());
}
}
std::thread::sleep(web_time::Duration::from_millis(5));
}
});
let config = S3StorageConfig {
bucket: "test-bucket".into(),
key: "db.tapir".into(),
endpoint: format!("http://127.0.0.1:{port}"),
region: "us-east-1".into(),
auth_token: Some("secret-token-xyz".into()),
};
let storage = CloudS3RemoteStorage::new(config);
let size = storage.total_size().expect("Failed to get total size");
assert_eq!(size, 8192);
let page1 = storage
.fetch_range(0, 4096)
.expect("Failed to fetch page 1");
assert_eq!(page1.len(), 4096);
assert_eq!(page1[0], 0);
assert_eq!(page1[1], 1);
let page2 = storage
.fetch_range(4096, 4096)
.expect("Failed to fetch page 2");
assert_eq!(page2.len(), 4096);
let new_data = vec![42u8; 1024];
storage.put_object(&new_data).expect("Failed to put object");
let new_size = storage.total_size().expect("Failed to get updated size");
assert_eq!(new_size, 1024);
let fetched_new = storage
.fetch_range(0, 1024)
.expect("Failed to fetch updated data");
assert_eq!(fetched_new, new_data);
running.store(false, Ordering::Relaxed);
let _ = server_thread.join();
}
}