Struct LayerStore 

pub struct LayerStore { /* private fields */ }

A content-addressed store of layer blobs, unpacked layers and images:

<root>/blobs/sha256/<hex>   verified blobs, one copy each
<root>/layers/<diff_id>/    one layer unpacked once, in overlayfs format
                            (whiteouts as 0/0 devices, opaque xattrs);
                            shared by every image that has it
<root>/images/<id>.json     an image: its layers, bottom first; the
                            refcount of a layer is the images naming it
<root>/rootfs/<chain>/      optional flattened rootfs ([`LayerStore::rootfs`])
                            for tools that want one tree; not used by
                            overlays and not collected by gc
<root>/tmp/                 downloads and unpacks in progress

A container rootfs is an crate::Overlay over LayerStore::image_layers; an updated image unpacks only its new layers.

Everything lands by rename, so a crash leaves only tmp/ debris.

Implementations

impl LayerStore

pub fn open(root: &Path) -> Result<Self>

Open (and create) a store at root.

pub fn root(&self) -> &Path

pub fn blob_path(&self, digest: &Digest) -> PathBuf

pub fn has_blob(&self, digest: &Digest) -> bool

pub fn put_blob(&self, digest: &Digest, reader: impl Read) -> Result<PathBuf>

Store everything reader yields as digest; refused (and nothing kept) if the bytes hash to something else.

pub fn blob_writer(&self) -> Result<BlobWriter>

A blob that arrives in chunks (a registry download).

pub fn rootfs(&self, layers: &[Digest], opts: &UnpackOptions) -> Result<PathBuf>

The rootfs for layers (bottom first), unpacked on first use.

pub fn rootfs_path(&self, layers: &[Digest]) -> PathBuf

Where the rootfs for layers lives (whether or not it exists yet).

impl LayerStore

pub fn layer_path(&self, diff_id: &Digest) -> PathBuf

Where the unpacked directory of a layer lives.

pub fn has_layer(&self, diff_id: &Digest) -> bool

pub fn missing_layers(&self, layers: &[ImageLayer]) -> Vec<ImageLayer>

The layers not yet unpacked: what a pull still has to fetch.

pub fn unpack_layer( &self, layer: &ImageLayer, opts: &UnpackOptions, ) -> Result<PathBuf>

Unpack one layer into its own directory (overlayfs format), once. The uncompressed stream must hash to layer.diff_id.

pub fn add_image( &self, id: &Digest, layers: &[ImageLayer], opts: &UnpackOptions, ) -> Result<Vec<PathBuf>>

Record image id as layers (bottom first), unpacking the layers not in the store yet. Returns the layer directories, bottom first.

pub fn image_layers(&self, id: &Digest) -> Result<Vec<PathBuf>>

The layer directories of a recorded image, bottom first.

pub fn remove_image(&self, id: &Digest) -> Result<()>

Forget image id; its layers stay until LayerStore::gc.

pub fn refcount(&self, diff_id: &Digest) -> Result<usize>

How many recorded images use the layer.

pub fn gc(&self) -> Result<GcStats>

Remove layer directories and blobs that no recorded image uses, and leftovers in tmp/. Run it while no pull is in progress.

pub fn prune_unpacked_blobs(&self) -> Result<usize>

Delete the blobs of layers that are unpacked (to save disk); a later pull of the same layers needs neither the blob nor a download.

Trait Implementations

impl Clone for LayerStore

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LayerStore

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

Formats the value using the given formatter.