Struct Sender 

struct Sender<'a> {
    server: &'a Server,
    folder: &'a Path,
    own: &'a str,
    url: &'a str,
    sealed: &'a BTreeMap<String, u64>,
    sending: &'a mut Sending,
    pulled: &'a mut Pulled,
    now: i64,
    frugal: bool,
    lane: Lane,
}

One send beside the sync app.

Fields

server: &'a Server

folder: &'a Path

own: &'a str

url: &'a str

The folder there, an address ending with “/”.

sealed: &'a BTreeMap<String, u64>

sending: &'a mut Sending

pulled: &'a mut Pulled

now: i64

frugal: bool

lane: Lane

Implementations

impl Sender<'_>

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

fn run( &mut self, files: &[String], check: bool, again: bool, ) -> Result<(), Stop>

files in their order (records first, by round, then the notes to the others, the claims, the entry, the sealed files last): nothing large holds back what the others wait for. A records file held back holds the next ones (records go in order); the other files still go.

fn list_own(&mut self) -> Result<BTreeMap<String, Item>, Stop>

The server’s copies of this device’s files, by their path in the folder: the folder itself, devices/, each part’s claims, blobs/ (when this device sealed any), texts/send/. A folder not there holds none.

fn same( &self, relative: &str, there: &Item, bytes: &[u8], sha1: &str, ) -> Result<bool, Stop>

Whether the server’s copy is this file as it is here: a sealed file by its size (its name is its content’s); records by their size (they only grow, one writer) and their checksum when the server keeps one; the rest by their checksum, else read there and compared.

fn one( &mut self, relative: &str, listed: Option<Option<Item>>, again: bool, ) -> Result<Went, Stop>

One of this device’s files, sent when it changed here since it went (or, there listed, when the server’s copy is not this one), over what is there as it was seen. Refused because it changed there meanwhile (412): the server’s copy looked at; the same as here (the sync app sent it), nothing more; else sent over it. A folder missing there (409), made first. Too slow or cut: held back (backoff).

fn failed(&mut self, relative: &str, failed: PutFailed) -> Result<Went, Stop>

A file that did not go, said in detail (Sending::failure). Too slow or cut on its way (the connection made, its bytes moving): that file held back (backoff), the others still going. Else (the server unreachable, refused, out of time): the send stops.

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

What this device sent and let go here, taken out there as it was sent (If-Match): its records past their time (removed here once every device read past them), never its last round, and nothing while none of its records is here; the sealed files it swept. Gone there already, or changed there since: forgotten all the same. Another file gone here (a claim of a part no longer kept) is forgotten, left there.