Trait tor_hsservice::internal_prelude::SleepProvider

source ·

pub(crate) trait SleepProvider: Clone + Send + Sync + 'static {
    type SleepFuture: Future<Output = ()> + Send + 'static;

    // Required method
    fn sleep(&self, duration: Duration) -> Self::SleepFuture;

    // Provided methods
    fn now(&self) -> Instant { ... }
    fn wallclock(&self) -> SystemTime { ... }
    fn block_advance<T>(&self, _reason: T)
       where T: Into<String> { ... }
    fn release_advance<T>(&self, _reason: T)
       where T: Into<String> { ... }
    fn allow_one_advance(&self, _dur: Duration) { ... }
}

Expand description

Trait for a runtime that can wait until a timer has expired.

Every SleepProvider also implements SleepProviderExt; see that trait for other useful functions.

Required Associated Types§

source

type SleepFuture: Future<Output = ()> + Send + 'static

A future returned by SleepProvider::sleep()

Required Methods§

source

fn sleep(&self, duration: Duration) -> Self::SleepFuture

Return a future that will be ready after duration has elapsed.

Provided Methods§

source

fn now(&self) -> Instant

Return the SleepProvider’s view of the current instant.

(This is the same as Instant::now, if not running in test mode.)

source

fn wallclock(&self) -> SystemTime

Return the SleepProvider’s view of the current wall-clock time.

(This is the same as SystemTime::now, if not running in test mode.)

source

fn block_advance<T>(&self, _reason: T)
where T: Into<String>,

Signify that a test running under mock time shouldn’t advance time yet, with a given unique reason string. This is useful for making sure (mock) time doesn’t advance while things that might require some (real-world) time to complete do so, such as spawning a task on another thread.

Call release_advance with the same reason string in order to unblock.

This method is only for testing: it should never have any effect when invoked on non-testing runtimes.

source

fn release_advance<T>(&self, _reason: T)
where T: Into<String>,

Signify that the reason to withhold time advancing provided in a call to block_advance no longer exists, and it’s fine to move time forward if nothing else is blocking advances.

This method is only for testing: it should never have any effect when invoked on non-testing runtimes.

source