Struct Run 

pub struct Run<'a> {
    pub platform: &'a dyn Platform,
    pub layout: &'a Layout,
    pub journal: Journal,
    pub interrupt: &'a Interrupt,
    pub say: &'a mut dyn FnMut(&str),
    pub unreadable: BTreeSet<PathBuf>,
}

What: One command’s working state. &'a mut dyn FnMut(&str) is a borrowed progress callback that receives one line at a time. Why: See the module description.

In TS you’d write (pseudocode):

type Run = { platform: Platform; layout: Layout; journal: Journal; interrupt: Interrupt; say: (line: string) => void; unreadable: Set<string> };

Fields

platform: &'a dyn Platform

The operating-system operations.

layout: &'a Layout

Every path of the migration.

journal: Journal

The journal.

interrupt: &'a Interrupt

The simulated kill of the controls; never in release use.

say: &'a mut dyn FnMut(&str)

The progress sink.

unreadable: BTreeSet<PathBuf>

Relative paths of files this user may not read, which stay in the old tree.

Implementations

impl Run<'_>

pub fn open<'a>( platform: &'a dyn Platform, layout: &'a Layout, interrupt: &'a Interrupt, say: &'a mut dyn FnMut(&str), ) -> Result<Run<'a>, MigrateError>

What: Start the state: load the journal and the unreadable list left by an earlier run.

In TS you’d write (pseudocode):

const run = await Run.open(platform, layout, interrupt, say);

pub fn line(&mut self, text: &str)

Send one line to the progress sink.

pub fn pass( &mut self, label: &str, source: &Path, destination: &Path, delete: bool, update_only: bool, ) -> Result<SyncStats, MigrateError>

What: Run one tree pass, report its counts and time, and record the unreadable files it found. Why: The list is written after every pass, so a kill between passes keeps it; the report names the count and the file.

In TS you’d write (pseudocode):

const stats = await run.pass('copy', source, destination, { delete: false, updateOnly: false });

pub fn pass_unrecorded( &mut self, label: &str, source: &Path, destination: &Path, delete: bool, update_only: bool, ) -> Result<SyncStats, MigrateError>

What: Run one tree pass and report its counts and time, without recording the unreadable files it found. Why: The rollback’s carry-back pass reads the new root, whose unreadable files are not the old tree’s: they must not enter the list that guards the deletion of the old tree, and the rollback decides about them itself.

In TS you’d write (pseudocode):

const stats = await run.passUnrecorded('carry back', source, destination, { delete: false, updateOnly: true });

pub fn pass_late( &mut self, label: &str, source: &Path, destination: &Path, since: i64, ) -> Result<SyncStats, MigrateError>

What: Run the update-only pass that carries what was written to the old tree after the catch-up: files newer than their copy, and files the new root lacks that are no older than since (seconds after the epoch). Why: Programs that kept a descriptor in the old tree can write there until the person stops them, and the deletion of the old tree must not be the end of those writes. A file the new root lacks that is older than the catch-up was deleted there on purpose and stays deleted. Unreadable files found are recorded like any other pass.

In TS you’d write (pseudocode):

const stats = await run.passLate('late writes', oldTree, root, catchupSeconds);

pub fn checkpoint(&self, point: &str) -> Result<(), MigrateError>

Stop here when the control asked for a simulated kill at this point.