Struct ChanMgrEventSender 

pub(crate) struct ChanMgrEventSender {
    last_conn_status: ConnStatus,
    mgr_status: ChanMgrStatus,
    sender: Sender<ConnStatus>,
}

Object that manages information about a ChanMgr’s status, and sends information about connectivity changes over an asynchronous channel

Fields

last_conn_status: ConnStatus

The last ConnStatus that we sent over the channel.

mgr_status: ChanMgrStatus

The unsummarized status information from the ChanMgr.

sender: Sender<ConnStatus>

The channel that we use for sending ConnStatus information.

Implementations

impl ChanMgrEventSender

fn push_at(&mut self, now: Instant)

If the status has changed as of now, tell any listeners.

(This takes a time because we need to know how much time has elapsed without successful attempts.)

Limitations

We are dependent on calls to record_attempt() and similar methods to actually invoke this function; if they were never called, we’d never notice that we had gone too long without building connections. That’s okay for now, though, since any Tor client will immediately start building circuits, which will launch connection attempts until one succeeds or the client gives up entirely.

pub(crate) fn record_attempt(&mut self)

Note that an attempt to connect has been started.

pub(crate) fn record_tcp_success(&mut self)

Note that we’ve successfully done a TCP handshake with an alleged relay.

pub(crate) fn record_tls_finished(&mut self)

Note that we’ve completed a TLS handshake with an alleged relay.

(Its identity won’t be verified till the next step.)

pub(crate) fn record_handshake_done_with_skewed_clock(&mut self)

Record that a handshake has succeeded _except for the certificate timeliness check, which may indicate a skewed clock.

pub(crate) fn record_handshake_done(&mut self)

Note that we’ve completed a Tor handshake with a relay.

(This includes performing the TLS handshake, and verifying that the relay was indeed the one that we wanted to reach.)