Struct RestoreReport 

pub struct RestoreReport {
    pub expected: Checkpoint,
    pub rebuilt: Checkpoint,
    pub runs: usize,
    pub records: usize,
    pub cases: usize,
    pub awaiting: Vec<RunId>,
    pub not_carried: Vec<String>,
}

What a restore did, and what it could not carry across.

Fields

expected: Checkpoint

The checkpoint the export claimed.

rebuilt: Checkpoint

The checkpoint the rebuilt store now reports.

These matching is the whole result. Equal roots at equal size means every record, in every run, in the order the log recorded them, rebuilt to the same commitment — which is a far stronger statement than “the rows loaded”.

runs: usize

records: usize

cases: usize

Cases rebuilt from the export’s case layer.

awaiting: Vec<RunId>

Runs whose history ends in a wait, and which nothing will now wake.

Ids rather than a count, because the operator has to act on each one. A wait is journaled but what performs it is not: the timer, the subscription and the task row live in stores this export does not carry. A restored suspended run has no timer to fire, no subscription to match, and released its lease cleanly when it suspended — so the recovery pass does not see it either. Nothing in the system names it, which is the state the runtime otherwise repairs on sight.

Resuming each one repairs it: replay reaches the announced wait, finds no terminal record, and re-arms from the journal. That needs the agent’s own code, so it is the caller’s step and not the restore’s.

not_carried: Vec<String>

What did not survive, named rather than counted.

Implementations

impl RestoreReport

pub fn is_faithful(&self) -> bool

Whether the rebuilt store commits to exactly the history the export did.

The commitment, not the label. A checkpoint carries a log identity beside its size and root, and a recovery routinely changes that: the realistic restore is into another tenant of a database somebody else is already using, which is the topology for_tenant exists for. Comparing the identity made a byte-perfect restore report as a failed one exactly in the case a disaster puts an operator in — and agentplane restore exits on this predicate.

A relabelling is not silent for being excluded: it is a sentence in not_carried, beside every other thing the file could not bring across, and both checkpoints are on the report for a reader who wants to see the names.

Trait Implementations

impl Clone for RestoreReport

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 RestoreReport

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

Formats the value using the given formatter.

impl Eq for RestoreReport

impl PartialEq for RestoreReport

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RestoreReport

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RestoreReport