Struct Pool

pub(super) struct Pool<C: AbstractCirc> {
    circuits: Vec<HsCircStem<C>>,
    stem_target: usize,
    guarded_stem_target: usize,
    have_been_exhausted: bool,
    have_been_under_highwater: bool,
    last_changed_target: Option<Instant>,
}

Available on crate feature hs-common only.

A collection of circuits used to fulfil onion-service-related requests.

Fields

circuits: Vec<HsCircStem<C>>

The collection of circuits themselves, in no particular order.

stem_target: usize

The number of NAIVE elements that we would like to have in our pool.

guarded_stem_target: usize

The number of GUARDED elements that we would like to have in our pool.

have_been_exhausted: bool

True if we have exhausted our pool since the last time we decided whether to change our target level.

have_been_under_highwater: bool

True if we have been under 4/5 of our target since the last time we decided whether to change it.

last_changed_target: Option<Instant>

Last time when we changed our target size.

Implementations

impl<C: AbstractCirc> Pool<C>

pub(super) fn insert(&mut self, circ: HsCircStem<C>)

Add circ to this pool

pub(super) fn retain<F>(&mut self, f: F)

where F: FnMut(&HsCircStem<C>) -> bool,

Remove every circuit from this pool for which f returns false.

pub(super) fn very_low(&self) -> bool

Return true if we are very low on circuits and should build more immediately.

pub(super) fn circs_to_launch(&self) -> CircsToLaunch

Return a CircsToLaunch describing the circuits we would currently like to launch.

fn stems_to_launch(&self) -> usize

Return the number of NAIVE circuits we would currently like to launch.

fn guarded_stems_to_launch(&self) -> usize

Return the number of GUARDED circuits we would currently like to launch.

fn target(&self) -> usize

Return the total number of circuits we would like to launch.

We do not discard when we are above this threshold, but we do try to build when we are low.

pub(super) fn take_one_where<R, F>( &mut self, rng: &mut R, f: F, prefs: &HsCircPrefs, ) -> Option<HsCircStem<C>>

where R: Rng, F: Fn(&HsCircStem<C>) -> bool,

If there is any circuit in this pool for which f returns true and that satisfies all of the specified HsCircPrefs, return one such circuit at random, and remove it from the pool.

If none of the circuits satisfy prefs, return a randomly selected circuit for which f returns true, and remove it from the pool.

pub(super) fn update_target_size(&mut self, now: Instant)

Update the target sizes for our pool.

This updates our target numbers of NAIVE and GUARDED circuits.

pub(super) fn retire_all_circuits(&mut self) -> Result<(), ReconfigureError>

Purge all the circuits from the pool.

Trait Implementations

impl<C: AbstractCirc> Default for Pool<C>

fn default() -> Self

Returns the “default value” for a type.