Struct PathPlanner 

pub struct PathPlanner<Surb, R, S> {
    me: OffchainPublicKey,
    pub surb_store: Surb,
    resolver: Arc<R>,
    selector: Arc<S>,
    cache: Cache<(NodeId, NodeId, u32), Arc<WeightedCollection<ValidatedPath>>>,
    refresh_period: Duration,
}

Path planner that resolves [DestinationRouting] to [ResolvedTransportRouting].

The planner delegates path discovery to any PathSelector implementation and owns the moka cache of fully-validated [ValidatedPath] objects paired with their traversal cost, keyed by (source: NodeId, destination: NodeId, hops: u32).

On a cache miss the planner calls the selector, validates every candidate against the chain resolver, and stores an Arc<WeightedCollection<ValidatedPath>> in the cache. On a cache hit a candidate is picked via weighted random selection (higher cost = higher quality = higher probability).

A background sweep (background_refresh) can be spawned to proactively re-warm the cache for all previously-seen keys.

Fields

me: OffchainPublicKey

surb_store: Surb

resolver: Arc<R>

selector: Arc<S>

cache: Cache<(NodeId, NodeId, u32), Arc<WeightedCollection<ValidatedPath>>>

refresh_period: Duration

Implementations

impl<Surb, R, S> PathPlanner<Surb, R, S>

where Surb: SurbStore + Send + Sync + 'static, R: ChainKeyOperations + ChainReadChannelOperations + Send + Sync + 'static, S: PathSelector + Send + Sync + 'static,

pub fn new( me: OffchainPublicKey, surb_store: Surb, resolver: R, selector: S, config: PathPlannerConfig, ) -> Self

Create a new path planner.

me is this node’s [OffchainPublicKey]; it is used as the source in path queries.

async fn resolve_node_id_to_offchain_key( &self, node_id: &NodeId, ) -> Result<OffchainPublicKey>

Resolve a [NodeId] to an [OffchainPublicKey].

async fn resolve_path( &self, source: NodeId, destination: NodeId, options: RoutingOptions, ) -> Result<ValidatedPath>

pub async fn resolve_routing( &self, size_hint: usize, max_surbs: usize, routing: DestinationRouting, ) -> Result<(ResolvedTransportRouting<HoprSurb>, Option<usize>)>

Resolve a [DestinationRouting] to a [ResolvedTransportRouting].

Returns the resolved routing and, for Return variants, the number of remaining SURBs.

Trait Implementations

impl<Surb, R, S> BackgroundPathCacheRefreshable for PathPlanner<Surb, R, S>

where Surb: SurbStore + Send + Sync + 'static, R: ChainKeyOperations + ChainReadChannelOperations + Send + Sync + 'static, S: PathSelector + Send + Sync + 'static,

fn run_background_refresh(&self) -> impl Future<Output = ()> + Send + 'static

Returns a future that runs the background path-cache refresh loop.

The returned future iterates over all keys currently in the planner’s cache and recomputes their paths on a configurable schedule, so that steady-state traffic is always served from cache.

impl<Surb: Clone, R: Clone, S: Clone> Clone for PathPlanner<Surb, R, S>

fn clone(&self) -> PathPlanner<Surb, R, S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.