Struct HopMgr 

pub(crate) struct HopMgr<R: Runtime> {
    runtime: R,
    ctx: StreamReactorContext,
    bwd_tx: Sender<ReadyStreamMsg>,
    hops: Arc<RwLock<CircHopList>>,
    memquota: CircuitAccount,
}

The hop manager of a reactor.

This contains the per-hop state (e.g. congestion control information), and a handle to the stream reactor of the hop.

The stream reactor of the hop is launched lazily, when the first StreamMsg is sent via HopMgr::send.

Fields

runtime: R

A handle to the runtime.

ctx: StreamReactorContext

Context used when spawning a stream reactor.

bwd_tx: Sender<ReadyStreamMsg>

Sender for sending messages to BWD.

The receiver is in BWD.

A clone of this is passed to each spawned StreamReactor

hops: Arc<RwLock<CircHopList>>

The underlying senders, indexed by HopNum.

Relays have at most one stream reactor per circuit. Clients have at most one stream reactor per circuit hop.

This is shared with the backward reactor. The backward reactor only ever reads from this (it never mutates the list).

memquota: CircuitAccount

Memory quota account

Implementations

impl<R: Runtime> HopMgr<R>

pub(crate) fn new<S: StreamHandler>( runtime: R, unique_id: UniqId, handler: S, bwd_tx: Sender<ReadyStreamMsg>, memquota: CircuitAccount, ) -> Self

Create a new HopMgr with an empty hop list.

Hops are added with HopMgr::add_hop.

pub(crate) fn hops(&self) -> &Arc<RwLock<CircHopList>>

Return a reference to our hop list.

pub(crate) fn set_incoming_handler( &self, handler: IncomingStreamRequestHandler, ) -> Result<()>

Set the incoming stream handler for this reactor.

There can only be one incoming stream handler per reactor, and each stream handler only pertains to a single hop (see expected_hop()) Returns an error if the hop manager already has a stream handler.

Since the handler is shared with every hop’s stream reactor, this function will update the handler for all of them.

pub(crate) fn add_hop(&mut self, settings: HopSettings) -> Result<()>

Push a new hop to our hop list.

Prepares a cc object for the hop, but does not spawn a stream reactor.

Will return an error if the circuit already has u8::MAX hops.

pub(crate) async fn send( &mut self, hopnum: Option<HopNum>, msg: StreamMsg, ) -> StdResult<(), ReactorError>

Send a message to the stream reactor of the specified hop, spawning it if necessary.

fn get_or_spawn_stream_reactor( &self, hopnum: Option<HopNum>, ) -> StdResult<Sender<StreamMsg>, ReactorError>

Get a handle to the stream reactor, spawning it if necessary

fn spawn_stream_reactor( &self, hopnum: Option<HopNum>, settings: &HopSettings, ccontrol: Arc<Mutex<CongestionControl>>, ) -> StdResult<Sender<StreamMsg>, ReactorError>

Spawn a StreamReactor for the specified hop.