Struct RequestsScheduler

pub struct RequestsScheduler<Env: Environment> { /* private fields */ }

Manages a pool of validator nodes with intelligent load balancing and performance tracking.

The RequestsScheduler maintains performance metrics for each validator node using Exponential Moving Averages (EMA) and uses these metrics to make intelligent routing decisions. It prevents node overload through request capacity limits and automatically retries failed requests on alternative nodes.

Examples

// Create with default configuration (balanced scoring)
let manager = RequestsScheduler::new(validator_nodes);

// Create with custom configuration prioritizing low latency
let latency_weights = ScoringWeights {
    latency: 0.6,
    success: 0.3,
    load: 0.1,
};
let manager = RequestsScheduler::with_config(
    validator_nodes,
    15,                      // max 15 concurrent requests per node
    latency_weights,         // custom scoring weights
    0.2,                     // higher alpha for faster adaptation
    3000.0,                  // max expected latency (3 seconds)
    Duration::from_secs(60), // 60 second cache TTL
    200,                     // cache up to 200 entries
);

Implementations

impl<Env: Environment> RequestsScheduler<Env>

pub fn new( nodes: impl IntoIterator<Item = RemoteNode<Env::ValidatorNode>>, config: RequestsSchedulerConfig, ) -> Self

Creates a new RequestsScheduler with the provided configuration.

pub fn with_config( nodes: impl IntoIterator<Item = RemoteNode<Env::ValidatorNode>>, weights: ScoringWeights, alpha: f64, max_expected_latency_ms: f64, cache_ttl: Duration, max_cache_size: usize, max_request_ttl: Duration, ) -> Self

Creates a new RequestsScheduler with custom configuration.

Arguments

• nodes: Initial set of validator nodes
• max_requests_per_node: Maximum concurrent requests per node
• weights: Scoring weights for performance metrics
• alpha: EMA smoothing factor (0 < alpha < 1)
• max_expected_latency_ms: Maximum expected latency for score normalization
• cache_ttl: Time-to-live for cached responses
• max_cache_size: Maximum number of entries in the cache
• max_request_ttl: Maximum latency for an in-flight request before we stop deduplicating it

pub async fn download_blobs( &self, peers: &[RemoteNode<Env::ValidatorNode>], blob_ids: &[BlobId], timeout: Duration, ) -> Result<Option<Vec<Blob>>, NodeError>

Downloads the blobs with the given IDs. This is done in one concurrent task per blob. Uses intelligent peer selection based on scores and load balancing. Returns None if it couldn’t find all blobs.

pub async fn download_certificates( &self, peer: &RemoteNode<Env::ValidatorNode>, chain_id: ChainId, start: BlockHeight, limit: u64, ) -> Result<Vec<ConfirmedBlockCertificate>, NodeError>

pub async fn download_certificates_by_heights( &self, peer: &RemoteNode<Env::ValidatorNode>, chain_id: ChainId, heights: Vec<BlockHeight>, ) -> Result<Vec<ConfirmedBlockCertificate>, NodeError>

pub async fn download_certificate_for_blob( &self, peer: &RemoteNode<Env::ValidatorNode>, blob_id: BlobId, ) -> Result<ConfirmedBlockCertificate, NodeError>

pub async fn download_pending_blob( &self, peer: &RemoteNode<Env::ValidatorNode>, chain_id: ChainId, blob_id: BlobId, ) -> Result<BlobContent, NodeError>

pub async fn get_alternative_peers( &self, key: &RequestKey, ) -> Option<Vec<RemoteNode<Env::ValidatorNode>>>

Returns the alternative peers registered for an in-flight request, if any.

This can be used to retry a failed request with alternative data sources that were registered during request deduplication.

pub async fn get_node_scores( &self, ) -> BTreeMap<ValidatorPublicKey, (f64, f64, u64)>

Returns current performance metrics for all managed nodes.

Each entry contains:

• Performance score (f64, normalized 0.0-1.0)
• EMA success rate (f64, 0.0-1.0)
• Total requests processed (u64)

Useful for monitoring and debugging node performance.

Trait Implementations

impl<Env: Clone + Environment> Clone for RequestsScheduler<Env>

where Env::ValidatorNode: Clone,

fn clone(&self) -> RequestsScheduler<Env>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Env: Environment> Debug for RequestsScheduler<Env>

where Arc<RwLock<BTreeMap<ValidatorPublicKey, NodeInfo<Env>>>>: Debug, InFlightTracker<RemoteNode<Env::ValidatorNode>>: Debug,

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

Formats the value using the given formatter.