Struct MaybenotPadder 

pub(super) struct MaybenotPadder<const N: usize> {
    framework: Framework<Arc<[Machine]>, ThisThreadRng, Instant>,
    state: PadderState<N>,
    timer: Timer,
    blocking: Option<BlockingState>,
}

An implementation of circuit padding using maybenot.

Supports up to N padding machines without spilling over onto the heap.

Fields

framework: Framework<Arc<[Machine]>, ThisThreadRng, Instant>

Our underlying maybenot::Framework.

state: PadderState<N>

The state of our padding machines.

timer: Timer

Our current timer information.

blocking: Option<BlockingState>

If we are blocking, information about the blocking.

Implementations

impl<const N: usize> MaybenotPadder<N>

pub(super) fn from_framework_rules( rules: &PaddingRules, now: Instant, ) -> Result<Self, Error>

Construct a new MaybyenotPadder from a provided FrameworkRules.

pub(super) fn from_framework( framework: Framework<Arc<[Machine]>, ThisThreadRng, Instant>, ) -> Self

Construct a new MaybenotPadder from a given Framework.

pub(super) fn get_expiration(&mut self, waker: &Waker) -> Option<Instant>

Return the next expiration time, and schedule waker to be alerted whenever the expiration time becomes earlier than that.

pub(super) fn trigger_events_at( &mut self, events: &[TriggerEvent], now: Instant, next_scheduled_wakeup: Option<Instant>, )

Tell the padding machines about all of the given events, report them happening at now, and adjust internal state.

If doing this would cause any timer to become earlier than next_scheduled_wakeup, wake up the registered Waker.

fn take_actions_at( &mut self, now: Instant, next_scheduled_wakeup: Option<Instant>, ) -> Vec<PerHopPaddingEvent>

Take any actions that need to occur at time now.

We should call this function as soon as possible after our timer has expired.

Returns zero or more PerHopPaddingEvents reflecting the padding that we should send, and what we should do with blocking.

Trait Implementations

impl<const N: usize> PaddingBackend for MaybenotPadder<N>

fn report_events_at( &mut self, events: &[TriggerEvent], now: Instant, next_scheduled_wakeup: Option<Instant>, )

Report one or more TriggerEvents to the padder.

fn take_padding_events_at( &mut self, now: Instant, next_scheduled_wakeup: Option<Instant>, ) -> Vec<PerHopPaddingEvent>

Trigger any padding actions that should be taken now.

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

This method should be called when we have no actions to perform, with a Waker that will activate the corresponding PaddingEventStream.