From a5e934883a66bf382f23d2403820985448726592 Mon Sep 17 00:00:00 2001 From: Mac L Date: Thu, 1 Feb 2024 17:35:22 +1100 Subject: [PATCH] Simplify `compute_distance_tier` and reduce notifier awaits --- validator_client/src/beacon_node_fallback.rs | 65 +++++++------------- validator_client/src/beacon_node_health.rs | 18 ++---- validator_client/src/notifier.rs | 9 ++- 3 files changed, 33 insertions(+), 59 deletions(-) diff --git a/validator_client/src/beacon_node_fallback.rs b/validator_client/src/beacon_node_fallback.rs index 0a99efc868..34230aafbc 100644 --- a/validator_client/src/beacon_node_fallback.rs +++ b/validator_client/src/beacon_node_fallback.rs @@ -383,40 +383,6 @@ impl BeaconNodeFallback { self.candidates.read().await.len() } - /// The count of synced and ready candidates. - pub async fn num_synced(&self) -> usize { - let mut n = 0; - for candidate in self.candidates.read().await.iter() { - if let Ok(cand) = candidate.health().as_ref() { - if self - .distance_tiers - .distance_tier(cand.health_tier.sync_distance) - == SyncDistanceTier::Synced - { - n += 1 - } - } - } - n - } - - /// The count of synced and ready fallbacks excluding the primary beacon node candidate. - pub async fn num_synced_fallback(&self) -> usize { - let mut n = 0; - for candidate in self.candidates.read().await.iter().skip(1) { - if let Ok(cand) = candidate.health().as_ref() { - if self - .distance_tiers - .distance_tier(cand.health_tier.sync_distance) - == SyncDistanceTier::Synced - { - n += 1 - } - } - } - n - } - /// The count of candidates that are online and compatible, but not necessarily synced. pub async fn num_available(&self) -> usize { let mut n = 0; @@ -429,17 +395,32 @@ impl BeaconNodeFallback { n } - pub async fn get_all_candidate_info(&self) -> Vec { + // Returns all data required by the VC notifier. + pub async fn get_notifier_info(&self) -> (Vec, usize, usize) { let candidates = self.candidates.read().await; - let mut results = Vec::with_capacity(candidates.len()); + + let mut candidate_info = Vec::with_capacity(candidates.len()); + let mut num_available = 0; + let mut num_synced = 0; + for candidate in candidates.iter() { - let id = candidate.id; - let node = candidate.beacon_node.to_string(); - let health = candidate.health().ok(); - let info = CandidateInfo { id, node, health }; - results.push(info); + let health = candidate.health(); + + match candidate.health() { + Ok(health) => { + if self.distance_tiers.compute_distance_tier(health.health_tier.sync_distance) == SyncDistanceTier::Synced { + num_synced += 1; + } + num_available += 1; + } + Err(CandidateError::Uninitialized) => num_available += 1, + Err(_) => continue, + } + + candidate_info.push(CandidateInfo { id: candidate.id, node: candidate.beacon_node.to_string(), health: health.ok() }); } - results + + (candidate_info, num_available, num_synced) } /// Loop through ALL candidates in `self.candidates` and update their sync status. diff --git a/validator_client/src/beacon_node_health.rs b/validator_client/src/beacon_node_health.rs index 08fd803822..4761ad2cec 100644 --- a/validator_client/src/beacon_node_health.rs +++ b/validator_client/src/beacon_node_health.rs @@ -61,18 +61,12 @@ impl BeaconNodeSyncDistanceTiers { /// Takes a given sync distance and determines its tier based on the `sync_tolerance` defined by /// the CLI. - pub fn distance_tier(&self, distance: SyncDistance) -> SyncDistanceTier { - let distance = distance.as_u64(); - // Add 1 since we are using exclusive ranges. - let synced = self.synced.as_u64() + 1; - let small = self.small.as_u64() + 1; - let medium = self.medium.as_u64() + 1; - - if (0..synced).contains(&distance) { + pub fn compute_distance_tier(&self, distance: SyncDistance) -> SyncDistanceTier { + if distance.as_u64() <= self.synced.as_u64() { SyncDistanceTier::Synced - } else if (synced..small).contains(&distance) { + } else if distance <= self.small.as_u64() { SyncDistanceTier::Small - } else if (small..medium).contains(&distance) { + } else if distance <= self.medium.as_u64() { SyncDistanceTier::Medium } else { SyncDistanceTier::Large @@ -232,7 +226,7 @@ impl BeaconNodeHealth { execution_status: ExecutionEngineHealth, sync_distance_tiers: &BeaconNodeSyncDistanceTiers, ) -> BeaconNodeHealthTier { - let sync_distance_tier = sync_distance_tiers.distance_tier(sync_distance); + let sync_distance_tier = sync_distance_tiers.compute_distance_tier(sync_distance); let health = (sync_distance_tier, optimistic_status, execution_status); match health { @@ -326,7 +320,7 @@ mod tests { let tier = health_tier.tier; let distance = health_tier.sync_distance; - let distance_tier = beacon_node_sync_distance_tiers.distance_tier(distance); + let distance_tier = beacon_node_sync_distance_tiers.compute_distance_tier(distance); // Check sync distance. if [1, 3, 5, 6].contains(&tier) { diff --git a/validator_client/src/notifier.rs b/validator_client/src/notifier.rs index 521ff49a14..a2c353a5e8 100644 --- a/validator_client/src/notifier.rs +++ b/validator_client/src/notifier.rs @@ -39,18 +39,18 @@ async fn notify( duties_service: &DutiesService, log: &Logger, ) { - let candidate_info = duties_service.beacon_nodes.get_all_candidate_info().await; - let num_available = duties_service.beacon_nodes.num_available().await; + let (candidate_info, num_available, num_synced) = duties_service.beacon_nodes.get_notifier_info().await; + let num_total = candidate_info.len(); + let num_synced_fallback = num_synced.saturating_sub(1); + set_gauge( &http_metrics::metrics::AVAILABLE_BEACON_NODES_COUNT, num_available as i64, ); - let num_synced = duties_service.beacon_nodes.num_synced().await; set_gauge( &http_metrics::metrics::SYNCED_BEACON_NODES_COUNT, num_synced as i64, ); - let num_total = duties_service.beacon_nodes.num_total().await; set_gauge( &http_metrics::metrics::TOTAL_BEACON_NODES_COUNT, num_total as i64, @@ -77,7 +77,6 @@ async fn notify( "synced" => num_synced, ) } - let num_synced_fallback = duties_service.beacon_nodes.num_synced_fallback().await; if num_synced_fallback > 0 { set_gauge(&http_metrics::metrics::ETH2_FALLBACK_CONNECTED, 1); } else {