Struct AtomicChunked 

pub struct AtomicChunked<R: ResourceExt> { /* private fields */ }

Decorator for crash-safe chunked writes.

During the write phase the inner resource is mmapped at <canonical>.tmp. On commit() the data is durably flushed (sync_data), the temp file is atomically renamed to canonical, and the inner is reopened on the canonical path — guaranteeing that any external observer of the canonical path either sees no file or sees the fully durable committed bytes, and that the inner’s internal fs operations all target the file that actually exists on disk.

Implementations

impl<R: ResourceExt> AtomicChunked<R>

pub fn canonical_path(&self) -> &Path

Path the resource will land at on a successful commit.

pub fn open<F>(canonical_path: PathBuf, factory: F) -> StorageResult<Self>

where F: Fn(&Path, OpenIntent) -> StorageResult<R> + Send + Sync + 'static,

Open a fresh chunked-atomic resource at canonical_path. The provided factory opens the inner at a given filesystem path; it is called once with the temp path during this constructor and once more with the canonical path after the atomic rename in ResourceExt::commit.

Atomically claims <canonical>.tmp via OpenOptions::create_new — the filesystem rejects the second concurrent open of the same tmp path. Returns StorageError::TmpClaimed if another AssetStore instance (or another process) is already writing the same canonical path; the caller should poll until the holder releases (commit or drop) and either retry or take a passthrough view of the canonical once committed.

Stale temp left from a prior crashed run is not auto-wiped: liveness is signalled by tmp existence alone, and a leftover from a kill -9 would block subsequent opens until cleaned up explicitly. Maintenance task is the caller’s responsibility (a future enhancement may add PID-aware cleanup).

Errors

• StorageError::Failed — canonical path has no parent / non-utf8 file name.
• StorageError::TmpClaimed — tmp path already exists.
• StorageError::Io / StorageError::Mmap — propagated from the OS or from the supplied factory.

pub fn passthrough(inner: R, canonical_path: PathBuf) -> Self

Wrap an already-opened inner with no atomicity (pass-through). Used for memory-backed inners that have no filesystem to protect, or for re-opens of files that are already committed on disk.

Trait Implementations

impl<R: ResourceExt> Debug for AtomicChunked<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: ResourceExt> Drop for AtomicChunked<R>

fn drop(&mut self)

Clean up the orphaned temp file when a writer is dropped without a successful commit. Best-effort: a kill -9 skips Drop entirely, in which case the next AtomicChunked::open over the same canonical path wipes the stale temp.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl From<AtomicChunked<Resource<MmapDriver>>> for StorageResource

Available on non-WebAssembly only.

fn from(r: AtomicChunked<MmapResource>) -> Self

Converts to this type from the input type.

impl<R: ResourceExt> ResourceExt for AtomicChunked<R>

fn commit(&self, final_len: Option<u64>) -> StorageResult<()>

Mark the resource as fully written.

fn contains_range(&self, range: Range<u64>) -> bool

Check if the given byte range is fully covered by available data (non-blocking).

fn fail(&self, reason: String)

Mark the resource as failed.

fn len(&self) -> Option<u64>

Get the committed length, if known.

fn next_gap(&self, from: u64, limit: u64) -> Option<Range<u64>>

Find the first gap in available data starting from from, up to limit.

fn path(&self) -> Option<&Path>

Get the file path, if backed by a file.

fn reactivate(&self) -> StorageResult<()>

Reactivate a committed resource for continued writing.

fn read_at(&self, offset: u64, buf: &mut [u8]) -> StorageResult<usize>

Read data at the given offset into buf.

fn status(&self) -> ResourceStatus

Get resource status.

fn wait_range(&self, range: Range<u64>) -> StorageResult<WaitOutcome>

Wait until the given byte range is available.

fn write_at(&self, offset: u64, data: &[u8]) -> StorageResult<()>

Write data at the given offset.

fn is_empty(&self) -> bool

Returns true if the resource has been committed with zero length.

fn read_into(&self, buf: &mut Vec<u8>) -> StorageResult<usize>

Read the entire resource contents into a caller-provided buffer.

fn write_all(&self, data: &[u8]) -> StorageResult<()>

Write entire contents and commit atomically.