Struct ClearReport 

pub struct ClearReport {
    pub schema: &'static str,
    pub scope: &'static str,
    pub store: String,
    pub requested: String,
    pub applied: bool,
    pub removed: Vec<RemovedImage>,
    pub removed_unattributed: Vec<Unattributed>,
    pub freed_bytes: u64,
    pub store_bytes_before: u64,
    pub store_bytes_after: u64,
    pub retained: Vec<VerifiedImage>,
    pub preserved: Vec<Preserved>,
}

What a clear would do, or did.

Fields

schema: &'static str

Stable schema tag (SANDBOX_CLEAR_SCHEMA).

scope: &'static str

Always "machine", for the reason SandboxStatus::scope gives.

store: String

The store root that was cleared.

requested: String

What was asked for — a reference, or everything.

applied: bool

Whether this is a plan or a completed removal.

removed: Vec<RemovedImage>

The images removed.

removed_unattributed: Vec<Unattributed>

The unattributed bytes removed. Only ever populated for Scope::Everything.

freed_bytes: u64

Bytes accounted for by the objects removed.

store_bytes_before: u64

Every byte under the store root before the deletion.

store_bytes_after: u64

Every byte under the store root after it. Equal to store_bytes_before on a plan.

retained: Vec<VerifiedImage>

The survivors, re-checked blob by blob after the deletion.

preserved: Vec<Preserved>

State a digest does not re-obtain, left alone and named.

Implementations

impl ClearReport

pub fn measured_freed_bytes(&self) -> u64

The bytes the filesystem actually gave back.

Reported alongside ClearReport::freed_bytes rather than instead of it: the accounted figure is what this module believes it removed, the measured one is what the store shrank by, and the two are checkable against each other by anyone holding a du.

They are not identical, and the gap is one thing: the index moves under a clear without being part of what was removed. SQLite does not shrink a file when rows are deleted — it frees pages inside it — and a DELETE under a write transaction can add a page, while a checkpoint can hand back a write-ahead log. So the gap runs in both directions, it is kilobytes against a clear measured in gigabytes, and the_accounted_bytes_and_the_measured_bytes_differ_only_by_the_index is what keeps that claim true. Anything larger is a defect, which is why both numbers are reported rather than one.

Measured on the real store: dropping an image that shared every layer with a survivor accounted for 0 bytes and measured 32 KiB back, all of it the index.

pub fn survivors_intact(&self) -> bool

Whether every surviving image is still complete.

Trait Implementations

impl Clone for ClearReport

fn clone(&self) -> ClearReport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClearReport

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

Formats the value using the given formatter.

impl Serialize for ClearReport

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.