Struct GuardMonitor

pub struct GuardMonitor {
    id: RequestId,
    pending_status: GuardStatus,
    ignore_indeterminate: bool,
    pending_skew: Option<ClockSkew>,
    snd: Option<UnboundedSender<Msg>>,
}

An object used to tell the GuardMgr about the result of trying to build a circuit through a guard.

The GuardMgr needs to know about these statuses, so that it can tell whether the guard is running or not.

Fields

id: RequestId

The Id that we’re going to report about.

pending_status: GuardStatus

The status that we will report if this monitor is dropped now.

ignore_indeterminate: bool

If set, we change Indeterminate to AttemptAbandoned before reporting it to the guard manager.

We do this when a failure to finish the circuit doesn’t reflect badly against the guard at all: typically, because the circuit’s path is not random.

pending_skew: Option<ClockSkew>

If set, we will report the given clock skew as having been observed and authenticated from this guard or fallback.

snd: Option<UnboundedSender<Msg>>

A sender that needs to get told when the attempt to use the guard is finished or abandoned.

TODO: This doesn’t really need to be an Option, but we use None here to indicate that we’ve already used the sender, and it can’t be used again.

Implementations

impl GuardMonitor

pub(crate) fn new(id: RequestId, snd: UnboundedSender<Msg>) -> Self

Create a new GuardMonitor object.

pub fn succeeded(self)

Report that a circuit was successfully built in a way that indicates that the guard is working.

Note that this doesn’t necessarily mean that the circuit succeeded. For example, we might decide that extending to a second hop means that a guard is usable, even if the circuit stalled at the third hop.

pub fn failed(self)

Report that the circuit could not be built successfully, in a way that indicates that the guard isn’t working.

(This either be because of a network failure, a timeout, or something else.)

pub fn attempt_abandoned(self)

Report that we did not try to build a circuit using the guard, or that we can’t tell whether the guard is working.

Dropping a GuardMonitor is without calling succeeded or failed or pending_status is equivalent to calling this function.

pub fn pending_status(&mut self, status: GuardStatus)

Configure this monitor so that, if it is dropped before use, it sends the status status.

pub fn skew(&mut self, skew: ClockSkew)

Set the given clock skew value to be reported to the guard manager.

Clock skew can be reported on success or failure, but it should only be reported if the first hop is actually authenticated.

pub fn inspect_pending_status(&self) -> (GuardStatus, bool)

Available on crate feature testing only.

Return the current pending status and “ignore indeterminate” status for this guard monitor.

pub fn ignore_indeterminate_status(&mut self)

Configure this monitor to ignore any indeterminate status values, and treat them as abandoned attempts.

We should use this whenever the path being built with this guard is not randomly generated.

pub fn report(self, msg: GuardStatus)

Report a message for this guard.

fn report_impl(&mut self, msg: GuardStatus)

As GuardMonitor::report, but take a &mut reference.

pub fn commit(self)

Report the pending message for his guard, whatever it is.

Trait Implementations

impl Debug for GuardMonitor

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for GuardMonitor

fn drop(&mut self)

Executes the destructor for this type.