Struct Server 

pub(crate) struct Server {
    agent: Agent,
    authorization: String,
    started: Instant,
    limits: Limits,
}

One server, signed in: requests with the account’s login, over TLS (plain HTTP only to a test’s own stand-in, dav::allowed), never redirected. Its requests go through the process’s one agent (dav::shared_agent): a pull, the sends after it and the next pull reuse one connection while it is open, each request with its own budget (limits).

Fields

agent: Agent

authorization: String

started: Instant

limits: Limits

Implementations

impl Server

pub(crate) fn new(login: &Login, limits: Limits) -> Result<Server, SyncError>

pub(crate) fn request( &self, large: bool, method: &str, url: &str, headers: &[(&str, &str)], body: Vec<u8>, ) -> Result<Response<Body>, SyncError>

fn request_with( &self, whole: Duration, method: &str, url: &str, headers: &[(&str, &str)], body: Vec<u8>, ) -> Result<Response<Body>, SyncError>

A request run with whole for all of it, limits.wait to connect and for each read or write (stalls::ask, its answer’s body read after included).

pub(crate) fn list(&self, url: &str) -> Result<Listing, SyncError>

A folder’s own ETag and what it holds (Depth: 1), by name.

pub(crate) fn stat(&self, url: &str) -> Result<Option<Item>, SyncError>

One file as the server has it now (Depth: 0): its ETag, size and checksums; none when it is not there.

pub(crate) fn put_file( &self, url: &str, body: Vec<u8>, seen: Option<&str>, modified_s: u64, sha1: &str, ) -> Result<(u16, Option<String>), PutFailed>

One of this device’s files sent whole beside a sync app (send): over what is there as it was seen (If-Match its ETag, If-None-Match: * when none was there), dated as the file here (X-OC-Mtime), with its SHA-1 (OC-Checksum): a Nextcloud client finding the same file there as here, same size, date and checksum, takes it as its own, without a download and without a conflicted copy. Its status, and its ETag there.

Given the time its size asks: limits.large, and as long more as it takes at limits.floor bytes a second (a file still moving is not cut at a flat minute); cut when nothing moved for limits.stall. Failed: why, how long it lasted and how many of its bytes went (PutFailed).

pub(crate) fn small( &self, url: &str, ) -> Result<Option<(Vec<u8>, Option<String>)>, SyncError>

A small file whole (share::SMALL_FILE at most) and its ETag; none when it is not there, or larger than any such file. A body that came cut, or whose end cannot be told, is an error: never taken as whole.

pub(crate) fn small_up_to( &self, url: &str, cap: u64, ) -> Result<Option<(Vec<u8>, Option<String>)>, SyncError>

The same, at most cap bytes (a texts’ file may grow past a small file’s).

fn tail(&self, url: &str, from: u64) -> Result<Option<Got>, SyncError>

A file from from on (all of it from 0): where what came starts (0 when the server sent it all), what came as it came, and why the rest did not; none when it is not there, or shorter than from now.

pub(crate) fn put( &self, url: &str, body: Vec<u8>, seen: Option<&str>, ) -> Result<(u16, Option<String>), SyncError>

A file sent whole (PUT), over what is there as it was seen: If-Match its ETag, or If-None-Match: * when none was there. Its status, and its ETag there when the server says it.

pub(crate) fn mkcol(&self, url: &str) -> Result<u16, SyncError>

A folder made (MKCOL): 201 made, 405 there already.

pub(crate) fn delete( &self, url: &str, seen: Option<&str>, ) -> Result<u16, SyncError>

One of this device’s files taken out (DELETE), only as it was seen (If-Match) when its ETag is known.

pub(crate) fn etag(&self, url: &str) -> Result<Option<String>, SyncError>

A file’s ETag there now (Depth: 0); none when it is not there.

pub(crate) fn download( &self, url: &str, path: &Path, limit: u64, ) -> Result<Option<u64>, SyncError>

A file fetched whole into path, under a hidden name beside it, then renamed once all of it came (its length said, or chunked to its end), at most limit bytes, as long as it moves (Limits::blob). Its size; none when it is not there, or larger.