Struct Native 

pub struct Native(PathBuf);

A container’s directory.

Tuple Fields

0: PathBuf

Implementations

impl Native

pub fn at(root: impl Into<PathBuf>) -> Self

pub fn root(&self) -> &Path

fn path(&self, at: &Entry) -> PathBuf

fn holding(&self, at: &Entry) -> Result<PathBuf>

The directory an entry is written into, made if it is not there. A container whose revs/ somebody removed is repaired by the write that needs it.

Trait Implementations

impl Clone for Native

fn clone(&self) -> Native

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Native

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

Formats the value using the given formatter.

impl PartialEq for Native

fn eq(&self, other: &Native) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Storage for Native

async fn append<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Result<()>

The line and an fsync before returning, so a crash anywhere in here loses at most this write — and loses it visibly, since the manifest then ends without a newline.

async fn rename<'a>(&'a mut self, to: &'a Name) -> Result<()>

The directory moves; the session carries on through it, because every entry is named relative to a root this now points somewhere else.

No directory fsync, unlike a fresh container’s layout: a rename a power cut takes back leaves a whole container under its old name, where an interrupted layout would leave half of one.

fn name(&self) -> Name

What this container is called.

fn names(&self, at: &Entry) -> String

What a report calls at — a platform path where there is one. Not a promise that anything is there.

fn residency(&self) -> Residency

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

Where these bytes sit on a filesystem, for a shell that can name one. None for a storage that has no such thing.

async fn read<'a>(&'a self, at: &'a Entry) -> Result<Option<Vec<u8>>>

The bytes at at, or None where nothing is — which is not the same as a read that did not work.

async fn exists<'a>(&'a self, at: &'a Entry) -> Result<bool>

Whether anything stands at at. Separate from Self::read because a payload is filed under a content hash, so the answer is all a write needs — and reading a megabyte to learn it is already there is the one thing that would make every commit cost the artwork on the page.

async fn write<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Result<()>

Whole file or nothing: a reader caught mid-write sees the previous contents, never half of each.

async fn truncate<'a>(&'a self, at: &'a Entry, len: u64) -> Result<()>

async fn list<'a>(&'a self, dir: &'a Entry) -> Result<Vec<String>>

What dir holds, by name, in no particular order.

async fn remove<'a>(&'a self, at: &'a Entry) -> Result<()>

async fn create_dir<'a>(&'a self, dir: &'a Entry) -> Result<()>

Make dir a place entries can be written.

async fn discard(&self) -> Result<()>

Remove the container itself. Only ever asked of one that has been emptied.

fn claim(&self, now: WallTime) -> impl Future<Output = Result<Claim>> + '_

Claim the right to write this container.

fn release(&self)

Give the lock back.

impl Eq for Native

impl StructuralPartialEq for Native