Struct Sending 

pub struct Sending {

    pub url: String,
    pub last: i64,
    pub tried: i64,
    pub checked: i64,
    pub said: String,
    pub failure: Option<Failure>,
    pub tries: u32,
    pub retry_at: i64,
    pub held: BTreeMap<String, Held>,
    pub rate: u64,
    pub large_at: i64,
    pub again: Again,
    pub sent: BTreeMap<String, Sent>,
}

What sending this device’s own files beside the sync app knows (send): share/sending.toml (share/sending-urgent.toml for the urgent lane), never shared, apart from the backup’s state, so that a pull and a send never write over each other’s.

Fields

url: String

The folder there the files went to: another, and each is looked at again.

last: i64

When a send last went through whole, and was last tried (Unix seconds).

tried: i64

checked: i64

When the server’s copies were last listed and compared with the files here (Unix seconds).

said: String

Why the last send stopped, a code as State::said has them; “” when it went through.

failure: Option<Failure>

The last failure, in detail: which file, how, how long, how many of its bytes went.

tries: u32

The server unreachable (a connection, a certificate, a password refused): how many sends failed in a row, and none tried before retry_at (Unix seconds; “Send everything again” apart).

retry_at: i64

held: BTreeMap<String, Held>

Files that did not go (too slow, cut): how many tries in a row, and not tried again before when (backoff).

rate: u64

The rate of the last file of 64 KiB or more that went, or of what went of one that failed (bytes a second); 0 unknown.

large_at: i64

When a large file was last sent or tried (Unix seconds), for the pace.

again: Again

What “Send everything again” last did, in either mode.

sent: BTreeMap<String, Sent>

This device’s own files as they last went up, or were found there the same, by their path in the folder.

Implementations

impl Sending

pub fn load(memory: &Path) -> Sending

pub fn load_urgent(memory: &Path) -> Sending

The urgent lane’s (send_urgent).

fn load_lane(memory: &Path, lane: Lane) -> Sending

fn save(&self, memory: &Path, lane: Lane) -> Result<(), String>

pub fn note_again(memory: &Path, now: i64, why: &str)

“Send everything again” could not start (no account for the server, the folder not found, sending switched off): why, said as a code.

pub fn slow(&self) -> bool

The connection measured slow: under SLOW on the last large file.

pub fn next_try(&self) -> i64

When the next try is due, when a send waits (Unix seconds): the server unreachable, or a file held back; 0 when nothing waits.

Trait Implementations

impl Clone for Sending

fn clone(&self) -> Sending

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Sending

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Sending

fn default() -> Sending

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Sending

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Sending

impl PartialEq for Sending

fn eq(&self, other: &Sending) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Sending

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Sending