Struct tor_hsservice::time_store::Loading

pub struct Loading {
    inst: Instant,
    elapsed: u64,
}

Context for loading Instants from disk

Obtained by Loading::start, from a Reference (loaded from disk alongside the converted timestamps).

Fields

inst: Instant

The current time when this Loading was created

elapsed: u64

How long has elapsed, at inst, since the timestamps were stored

Implementations

impl Loading

pub fn start(runtime: &impl SleepProvider, stored: Reference) -> Loading

Obtain a Loading from a stored Reference, for deserialising Instants

Uses the runtime’s clock as a basis for understanding the supplied Reference and relating it to the current monotonic time (Instant) on this host.

pub fn load_future(&self, stored: FutureTimestamp) -> Instant

Convert a future Instant from a value saved on disk

If the Instant that was saved has since passed, the returned value is the current time.

If the system clock is inaccurate (or was inaccurate when the timestamp was saved), the value may be wrong: but, regardless, the returned value will be no further in the future, than how far it was in the future when it was saved.

In other words, even in the presence of clock skew, the effect is, at worst, as if the local system’s clock has stood still, or has run very fast.

pub fn elapsed(&self) -> Duration

Returns how long has elapsed since the timestamps were stored

This depends on the system wall clock being right both when we stored, and now. In the presence of clock skew, may return a value which is far too large, or too small.

But, if the system wall clock seems to have gone backwards, returns zero.

The time is measured from when start was called. If you need to know that time as an Instant, use as_raw_parts.

pub fn as_raw_parts(&self) -> (u64, Instant)

Returns how long has elapsed, in seconds, and the Instant at which that was true

Returns number of seconds elapsed, between when the timestamps were stored, and the returned Instant.

See elapsed for details of clock skew handling.