Struct PaddingShared 

struct PaddingShared<S: SleepProvider> {
    runtime: S,
    hops: SmallVec<[Option<Box<dyn PaddingBackend>>; 6]>,
    stats: SmallVec<[Option<PaddingStats>; 6]>,
    blocking: BlockingState,
    next_scheduled_wakeup: Option<Instant>,
    pending_events: VecDeque<PaddingEvent>,
    waker: Waker,
}

The shared state for a single circuit’s padding.

Used by both PaddingController and PaddingEventStream.

Fields

runtime: S

A sleep provider for telling the time and creating sleep futures.

hops: SmallVec<[Option<Box<dyn PaddingBackend>>; 6]>

Per-hop state for each hop that we have enabled padding with.

INVARIANT: the length of this vector is no greater than MAX_HOPS.

stats: SmallVec<[Option<PaddingStats>; 6]>

Records about how much padding and normal traffic we have received from each hop, and how much padding is allowed.

blocking: BlockingState

Which hops are currently blocking, and whether that blocking is bypassable.

next_scheduled_wakeup: Option<Instant>

When will the currently pending sleep future next expire?

We keep track of this so that we know when we need to reset the sleep future. It gets updated by PaddingStream::schedule_next_wakeup, which we call in <PaddingStream as Stream>::poll_next immediately before we create a timer.

pending_events: VecDeque<PaddingEvent>

A deque of PaddingEvent that we want to yield from our PaddingEventStream.

NOTE: If you put new items in this list from anywhere other than inside PaddingEventStream::poll_next, you need to alert the waker.

waker: Waker

A waker to alert if we’ve added any events to padding_events, or if we need the stream to re-poll.

Implementations

impl<S: SleepProvider> PaddingShared<S>

fn trigger_events(&mut self, hop: HopNum, events: &[TriggerEvent])

Trigger a list of maybenot events on every hop up to and including hop.

fn trigger_events_mixed( &mut self, hop: HopNum, intermediate_hop_events: &[TriggerEvent], final_hop_events: &[TriggerEvent], )

Trigger intermediate_hop_events on every hop up to but not including hop.

Trigger final_hop_events on hop.

(Don’t trigger anything on any hops after hop.)

fn inc_normal_received(&mut self, hop: HopNum)

Increment the normal cell count from every hop up to and including hop.

fn inc_padding_received(&mut self, hop: HopNum) -> Result<(), ExcessPadding>

Increment the padding count from hop, and the normal cell count from all earlier hops.

Return an error if a padding cell from hop would not be acceptable.

fn info_for_hop(&self, target_hop: HopNum) -> Option<QueuedCellPaddingInfo>

Return the QueuedCellPaddingInfo to use when sending messages to target_hop

impl<S: SleepProvider> PaddingShared<S>

fn set_hop_backend(&mut self, hop: HopNum, backend: Option<CircuitPadder>)

Install or remove a CircuitPadder for a single hop.

fn process_per_hop_event( blocking: &mut BlockingState, hop_idx: usize, event: PerHopPaddingEvent, ) -> PaddingEvent

Transform a PerHopPaddingEvent for a single hop with index idx into a PaddingEvent, updating our state as appropriate.

fn take_padding_events_at(&mut self, now: Instant) -> VecDeque<PaddingEvent>

Extract every PaddingEvent that is ready to be reported to the circuit at time now.

May trigger other events, or wake up the stream, in the course of running.

fn schedule_next_wakeup(&mut self, waker: &Waker) -> Option<Instant>

Find the next time at which we should wake up the stream, and register it as our “next scheduled wakeup”.