Struct SimFilesystem 

pub struct SimFilesystem { /* private fields */ }

A filesystem in memory that records what was done to it.

Cloning one gives another handle on the same filesystem, not a copy of it, which is what makes it usable in the places a real one would be shared.

Implementations

impl SimFilesystem

pub fn new() -> Self

An empty filesystem.

pub fn ops(&self) -> Vec<Op>

Everything that has been done to this filesystem, in order.

pub fn op_count(&self) -> usize

How many operations have been recorded.

This is the count the failure point enumeration in section 16.5 runs over: record a workload, then rerun it once per index with the failure injected there.

pub fn clear_log(&self)

Forgets the recorded operations, keeping the contents.

For a test that has to set up a database and only wants to enumerate failure points over what comes after the setup.

pub fn fail_at(&self, index: usize)

Makes the operation at index fail once.

This is error path testing and it is a different mechanism from Self::crash, on purpose. An EIO on one write is a thing the caller has to handle and keep running from. A crash is a thing the caller does not get to handle at all, and the question there is what the next process to open the file sees. Conflating them produces a test that proves neither.

pub fn clear_failure(&self)

Cancels an injected failure that has not fired.

pub fn reads_served(&self) -> u64

How many reads have been served since this filesystem was made.

This is the number the read faults below are addressed by, and it is also the byte counting hook’s coarser sibling: a reader that reads a row group it should have pruned makes more reads than one that does not, and the count says so whatever the answer was.

pub fn short_read_at(&self, read: u64, len: usize)

Makes read number read come back with len bytes rather than the length asked for.

A short read is not an error, it is a short read, and the reason it is worth injecting is that a decoder which treats a returned buffer as full reads whatever was in the buffer before, which is a wrong answer and not a crash.

pub fn fail_read_at(&self, read: u64)

Makes read number read fail.

Once, like Self::fail_at, and for the same reason: the interesting question is whether the caller survives one failure, not whether it survives a disk that is gone.

pub fn complete(&self, order: Completions)

Sets the order a batch handed to submit comes back in.

pub fn clear_read_faults(&self)

Cancels every injected read fault and puts completions back in submission order.

pub fn pending(&self) -> Vec<(u64, PathBuf)>

The writes that have been issued and not made durable, as sequence numbers with their file.

These are the numbers Crash::Keeping takes. The order is the order they were issued in, across all files, because two writes to different files race with each other exactly the way two writes to one file do.

pub fn crash(&self, crash: &Crash) -> Self

The filesystem a process would find after a crash.

The durable image, plus whichever pending writes crash says survived, applied in the order they were issued. The result is a fresh filesystem with an empty log, because the log belongs to the process that died.

pub fn durable_contents(&self, path: &Path) -> Option<Vec<u8>>

The durable contents of a file, ignoring anything unsynced.

For a test that wants to assert what is on the disk without going through a crash first.

pub fn contents(&self, path: &Path) -> Option<Vec<u8>>

The contents a reader would see right now, unsynced writes included.

Trait Implementations

impl Clone for SimFilesystem

fn clone(&self) -> SimFilesystem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SimFilesystem

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

Formats the value using the given formatter.

impl Default for SimFilesystem

fn default() -> SimFilesystem

Returns the “default value” for a type.

impl Filesystem for SimFilesystem

fn open(&self, path: &Path, mode: OpenMode) -> Result<Box<dyn File>>

Opens a file.

fn exists(&self, path: &Path) -> bool

Whether a path exists.

fn is_dir(&self, path: &Path) -> bool

Whether a path is a directory.

fn read_dir(&self, path: &Path) -> Result<Vec<PathBuf>>

What is directly inside a directory, as whole paths rather than as names.

fn remove(&self, path: &Path) -> Result<()>

Deletes a file.

fn rename(&self, from: &Path, to: &Path) -> Result<()>

Moves a file, replacing the destination if it exists.

fn create_dir_all(&self, path: &Path) -> Result<()>

Creates a directory and any missing parents.

fn sync_dir(&self, path: &Path) -> Result<()>

Makes a directory entry durable, which is what a rename needs before it counts.