Struct Puller 

struct Puller<'a> {

    server: &'a Server,
    folder: &'a Path,
    into: &'a Path,
    own: &'a str,
    state: &'a mut State,
    pulled: &'a mut Pulled,
    now: i64,
    own_there: BTreeMap<String, String>,
    covered: BTreeSet<String>,
    lost: bool,
    departed: Departed,
    departed_there: Vec<(String, String)>,
    past: Option<u32>,
    mine: BTreeSet<String>,
}

One pull: the server’s folder looked through, what is newer there fetched.

Fields

server: &'a Server

folder: &'a Path

The sharing folder as the sync app keeps it, and where what comes goes.

into: &'a Path

own: &'a str

state: &'a mut State

pulled: &'a mut Pulled

now: i64

own_there: BTreeMap<String, String>

This device’s own files seen in the folders looked through, their ETags there (MIRROR).

covered: BTreeSet<String>

The folders of the server looked through in this step (“” the folder itself, “devices/”).

lost: bool

Sioul keeping the folder itself, its copy lost: none of its records here.

departed: Departed

What this device took out here of the devices that no longer count (Departed): never fetched again; Sioul keeping the folder itself, taken out there too (push).

departed_there: Vec<(String, String)>

Those of their past rounds still there and gone here, with their ETag as listed (MIRROR): taken out there by push; and every file there of a device whose files you removed (Departed::devices).

past: Option<u32>

Sioul keeping the folder itself: this device’s rounds below this one are past their time (share::rounds_past): taken out there whatever it remembers sending (take_out_own), never brought back (restore).

mine: BTreeSet<String>

Sioul keeping the folder itself: the sealed files this device made or counts as its own (share::own_sealed): one its copy fetched once and its own change names now goes up as its own (own_files).

Implementations

impl Puller<'_>

fn url(&self, relative: &str) -> String

fn unchanged(&self, relative: &str, etag: &str) -> bool

A folder of the server not changed since it was last looked through, lately.

fn looked(&mut self, relative: &str, etag: &str)

A folder looked through to its end: until it changes, not again for a while.

fn run(&mut self) -> Result<(), Stop>

fn away(&mut self, relative: &str, item: &Item)

A file there that this device took out here and never fetches again (Departed): a device’s round past its time, any file of a device whose files you removed. Sioul keeping the folder itself, one gone here is taken out there at the end of the step (push).

fn mirror(&self) -> bool

Sioul keeps the folder itself (MIRROR): what comes goes into it, no sync app beside.

fn own_listed(&mut self, dir: &str, listing: &Listing)

A folder of the server just looked through: this device’s own files in it (MIRROR), their ETags there, for what goes up next.

fn seal(&mut self, root: &Listing) -> Result<(), Stop>

The server’s seal, read again when it changed there or every six hours: another, or none, and nothing more is fetched from there.

fn forget_gone(&mut self, dir: &str, listing: &Listing)

Files of a folder of the server no longer there: forgotten, and their copies fetched gone (a records’ file only once its writer removed it: every device had read past it).

fn small(&mut self, relative: &str, item: &Item) -> Result<(), Stop>

A small file (notes, an entry, a claim) fetched whole when it changed there since it was last fetched; kept only when it differs from the synced folder’s copy, and only when all of it came.

fn restore(&mut self, relative: &str, item: &Item) -> Result<(), Stop>

One of this device’s own files there and not here (MIRROR), never sent from here, or its copy lost (lost: none of its records here): brought back, so that it goes on after its last record rather than numbering them again over the others’ reading.

fn push(&mut self) -> Result<(), Stop>

This device’s own files (MIRROR) changed here since they went up, or changed or gone there since (seen in the folders just looked through), sent, in own_files’ order, each over what is there as it was seen (send). Then what it let go here goes there too: its records past their time (remove_old_rounds: every device read past them), never its last round, and nothing while none of its records is here; the sealed files it swept.

fn take_out_own(&mut self) -> Result<(), Stop>

What this device let go here, taken out there too: its records past their time (remove_old_rounds: every device read past them) listed in this step and gone here, never its last round, and nothing while none of its records is here: those it remembers sending, and those below the readers’ floor (past, share::rounds_past) whatever it remembers (one forgotten after a refused delete, “Send everything again”, its state lost); then the sealed files it swept. Until 17 October 2026 a past round it no longer remembered stayed there, and restore brought it back here at the next step, megabytes each.

fn take_out_departed(&mut self)

What this device took out here of the devices that no longer count (Departed), taken out there too: their past rounds still listed in this step and gone here, over the ETag listed; the sealed files swept, every six hours at most, when still as old there (take_out_swept). Another device doing the same first makes it gone (404), a sync app’s copy sent again since makes it changed (412): left, as any other answer or failure, for a later step.

fn send( &mut self, relative: &str, size: u64, modified: u64, seen: Option<String>, ) -> Result<(), Stop>

One of this device’s files sent whole over what is there as it was seen (seen: its ETag; none there). Refused because it changed there meanwhile (412), sent again over what is there now: it is this device’s own. A folder missing there (409), made first. A sealed file goes only where none is: one there already is the same. Refused again and again: left for the next step; nothing here is lost.

fn make_folders(&mut self, relative: &str) -> Result<(), Stop>

The folders a file’s path goes through, made there (MKCOL) when missing.

fn take_out(&mut self, relative: &str, seen: Option<String>) -> Result<(), Stop>

One of this device’s files taken out there, only as it was seen when its ETag is known; gone already, or changed there since (another device sealed the same content again), forgotten here all the same.

fn round(&mut self, name: &str, item: &Item) -> Result<(), Stop>

A device’s records, when the server’s copy is longer than both the synced folder’s and what was fetched: what is new there, from the end of the longer copy here, its last whole line asked again and checked to be the same there (a copy that does not join comes whole). Only whole lines are kept: a line half arrived comes again next time.