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,
    blobs: Vec<(String, Item)>,
    blobs_listed: Option<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.

blobs: Vec<(String, Item)>

The others’ sealed files to bring (MIRROR), listed by run, fetched last (fetch_blobs), once this device’s own files went up.

blobs_listed: Option<String>

blobs/’s ETag as listed: kept once every file of it came.

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 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 fetch_blobs(&mut self) -> Result<(), Stop>

The others’ sealed files run listed, brought one after the other, last in the step. One that fails stops the rest until the next step, which looks through the folder again rather than ten minutes later.

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

A sealed file another device put there and not here (MIRROR): fetched whole, kept only whole. One sent from here never comes back.

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 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.