use std::fs::File;
use std::path::PathBuf;
use std::sync::Arc;
use anyhow::{bail, Context, Result};
use super::segment;
use crate::read_limits::ReadLimits;
use crate::readat::ReadAt;
pub(crate) trait SegmentStore: Send + Sync {
fn append(&mut self, seg: u32, off: u32, frame: &[u8]) -> Result<()>;
fn sync(&mut self, seg: u32) -> Result<()>;
fn admit_roll(&self) -> Result<()>;
fn write_sidecar(&mut self, seg: u32, tail: u32, entries: &[(u32, u32)]) -> Result<()>;
fn stage_active_sidecar(&mut self, seg: u32, tail: u32, entries: &[(u32, u32)]) -> Result<()>;
fn create_segment(
&mut self,
next: u32,
dict_id: [u8; 32],
flags: u32,
) -> Result<Arc<dyn ReadAt>>;
fn punch(&mut self, seg: u32, off: u64, len: u64) -> Result<()>;
}
pub(crate) struct DirSegments {
dir: PathBuf,
active: u32,
active_f: File,
read_limits: ReadLimits,
}
impl DirSegments {
pub(crate) fn new(
dir: PathBuf,
active: u32,
active_f: File,
read_limits: ReadLimits,
) -> DirSegments {
DirSegments { dir, active, active_f, read_limits }
}
}
impl SegmentStore for DirSegments {
fn append(&mut self, seg: u32, off: u32, frame: &[u8]) -> Result<()> {
debug_assert_eq!(seg, self.active, "appends only ever target the active segment");
let path = segment::seg_path(&self.dir, seg);
crate::vfs::write_all_at(&self.active_f, &path, frame, off as u64)?;
Ok(())
}
fn sync(&mut self, seg: u32) -> Result<()> {
debug_assert_eq!(seg, self.active);
crate::vfs::sync_file(&self.active_f, &segment::seg_path(&self.dir, seg))
.context("fsync active fold segment")?;
Ok(())
}
fn admit_roll(&self) -> Result<()> {
let entries = super::count_fold_directory_entries(&self.dir, self.read_limits)?;
self.read_limits.admit_directory_entries(
"fold directory during segment roll",
entries.saturating_add(2),
)?;
Ok(())
}
fn write_sidecar(&mut self, seg: u32, tail: u32, entries: &[(u32, u32)]) -> Result<()> {
let _ = segment::write_dir_sidecar(&self.dir, seg, tail, entries);
Ok(())
}
fn stage_active_sidecar(
&mut self,
_seg: u32,
_tail: u32,
_entries: &[(u32, u32)],
) -> Result<()> {
Ok(())
}
fn create_segment(
&mut self,
next: u32,
dict_id: [u8; 32],
flags: u32,
) -> Result<Arc<dyn ReadAt>> {
let f = segment::create_flagged(&self.dir, next, dict_id, flags)?;
let reader = Arc::new(segment::open_rw(&self.dir, next)?);
self.active_f = f;
self.active = next;
Ok(reader)
}
fn punch(&mut self, seg: u32, off: u64, len: u64) -> Result<()> {
let f = segment::open_rw(&self.dir, seg)?;
let path = segment::seg_path(&self.dir, seg);
segment::punch(&f, &path, off, len)
}
}
pub(crate) struct ContainerSegments {
container: std::sync::Arc<std::sync::Mutex<crate::container::Container>>,
prefix: String,
}
impl ContainerSegments {
pub(crate) fn new(
container: std::sync::Arc<std::sync::Mutex<crate::container::Container>>,
prefix: String,
) -> ContainerSegments {
ContainerSegments { container, prefix }
}
fn member(&self, seg: u32) -> String {
format!("{}/{}", self.prefix, segment::seg_name(seg))
}
}
impl SegmentStore for ContainerSegments {
fn append(&mut self, seg: u32, off: u32, frame: &[u8]) -> Result<()> {
let name = self.member(seg);
let mut c = self.container.lock().expect("container lock poisoned");
let have = c
.member_len(&name)
.ok_or_else(|| anyhow::anyhow!("active segment member {name} is missing"))?;
if have != u64::from(off) {
bail!(
"fold append at segment offset {off} but member {name} holds {have} bytes — the append point and the member disagree"
);
}
c.append_stream(&name, frame.len() as u64, |at, into| {
into.copy_from_slice(&frame[at as usize..at as usize + into.len()]);
Ok(())
})
}
fn sync(&mut self, _seg: u32) -> Result<()> {
Ok(())
}
fn admit_roll(&self) -> Result<()> {
Ok(())
}
fn write_sidecar(&mut self, seg: u32, tail: u32, entries: &[(u32, u32)]) -> Result<()> {
let name = format!("{}/seg-{seg:08}.dir", self.prefix);
let bytes = segment::encode_dir_sidecar(seg, tail, entries);
self.container.lock().expect("container lock poisoned").put_bytes(&name, &bytes)
}
fn stage_active_sidecar(&mut self, seg: u32, tail: u32, entries: &[(u32, u32)]) -> Result<()> {
let name = format!("{}/seg-{seg:08}.dir", self.prefix);
let bytes = segment::encode_dir_sidecar(seg, tail, entries);
self.container.lock().expect("container lock poisoned").put_bytes(&name, &bytes)
}
fn create_segment(
&mut self,
next: u32,
dict_id: [u8; 32],
flags: u32,
) -> Result<Arc<dyn ReadAt>> {
if flags != 0 {
bail!("current fold segments require zero flags");
}
let name = self.member(next);
let header = segment::SegHeader { seg: next, flags, dict_id }.encode();
{
let mut c = self.container.lock().expect("container lock poisoned");
c.put_bytes(&name, &header)?;
}
Ok(Arc::new(crate::container::MemberReader::new(self.container.clone(), name)))
}
fn punch(&mut self, seg: u32, off: u64, len: u64) -> Result<()> {
let name = self.member(seg);
let c = self.container.lock().expect("container lock poisoned");
c.punch_within_member(&name, off, len)
}
}
pub(crate) struct NoSegments;
impl SegmentStore for NoSegments {
fn append(&mut self, _seg: u32, _off: u32, _frame: &[u8]) -> Result<()> {
bail!("read-only fold cannot append")
}
fn sync(&mut self, _seg: u32) -> Result<()> {
bail!("read-only fold cannot sync")
}
fn admit_roll(&self) -> Result<()> {
bail!("read-only fold cannot roll")
}
fn write_sidecar(&mut self, _seg: u32, _tail: u32, _entries: &[(u32, u32)]) -> Result<()> {
bail!("read-only fold cannot write a sidecar")
}
fn stage_active_sidecar(
&mut self,
_seg: u32,
_tail: u32,
_entries: &[(u32, u32)],
) -> Result<()> {
bail!("read-only fold cannot stage an active-segment sidecar")
}
fn create_segment(
&mut self,
_next: u32,
_dict_id: [u8; 32],
_flags: u32,
) -> Result<Arc<dyn ReadAt>> {
bail!("read-only fold cannot roll")
}
fn punch(&mut self, _seg: u32, _off: u64, _len: u64) -> Result<()> {
bail!("read-only fold cannot punch")
}
}