From 1df667642ca733796c1736d8a020db60f89c2460 Mon Sep 17 00:00:00 2001 From: Clark Alesna Date: Tue, 25 Jun 2024 21:21:48 +0800 Subject: [PATCH] - removed indicatif progress bar - prevent loop back into slot 0 after syncing --- src/sources/mithril.rs | 119 +++++++++++++++++++++++++++-------------- 1 file changed, 78 insertions(+), 41 deletions(-) diff --git a/src/sources/mithril.rs b/src/sources/mithril.rs index 85219918..c4f94f33 100644 --- a/src/sources/mithril.rs +++ b/src/sources/mithril.rs @@ -1,5 +1,4 @@ use gasket::framework::*; -use indicatif::{MultiProgress, ProgressBar, ProgressStyle}; use itertools::Itertools; use miette::{Context as _, IntoDiagnostic as _}; use mithril_client::{ClientBuilder, MessageBuilder, MithrilError, MithrilResult}; @@ -8,51 +7,85 @@ use pallas::{ network::miniprotocols::Point::{self, *}, }; use serde::Deserialize; -use std::{path::Path, sync::Arc}; -use tracing::warn; +use std::{ + path::Path, + sync::{Arc, Mutex}, + time::{Duration, Instant}, +}; +use tracing::{info, warn}; use crate::framework::*; struct Feedback { - _multi: MultiProgress, - download_pb: ProgressBar, - validate_pb: ProgressBar, + progress_logger: Arc>, } impl Feedback { - fn indeterminate_progress_bar(owner: &mut MultiProgress) -> ProgressBar { - let pb = ProgressBar::new_spinner(); - - pb.set_style( - ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] {msg}").unwrap(), - ); - - owner.add(pb) + fn new(log_interval: Duration) -> Self { + Self { + progress_logger: Arc::new(Mutex::new(ProgressLogger::new(log_interval))), + } } - fn bytes_progress_bar(owner: &mut MultiProgress) -> ProgressBar { - let pb = ProgressBar::new_spinner(); - - pb.set_style( - ProgressStyle::with_template( - "{spinner:.green} [{elapsed_precise}] {bar:40.cyan/blue} {bytes}/{total_bytes} (eta: {eta}) {msg}", - ) - .unwrap() - .progress_chars("#>-"), - ); - - owner.add(pb) + fn log_progress(&self, downloaded_bytes: u64, size: u64) { + if let Ok(mut logger) = self.progress_logger.lock() { + logger.log(downloaded_bytes, size); + } } } impl Default for Feedback { fn default() -> Self { - let mut multi = MultiProgress::new(); + Self::new(Duration::from_secs(10)) + } +} + +struct ProgressLogger { + last_log_time: Option, + log_interval: Duration, + initial_logged: bool, +} +impl ProgressLogger { + fn new(log_interval: Duration) -> Self { Self { - download_pb: Self::bytes_progress_bar(&mut multi), - validate_pb: Self::indeterminate_progress_bar(&mut multi), - _multi: multi, + last_log_time: None, + log_interval, + initial_logged: false, + } + } + + fn log(&mut self, downloaded_bytes: u64, size: u64) { + let now = Instant::now(); + let percentage = (downloaded_bytes as f64 / size as f64 * 100.0).round() as u64; + + if !self.initial_logged { + info!( + "Initial snapshot download progress: {}% ({}/{} bytes)", + percentage, downloaded_bytes, size + ); + self.initial_logged = true; + self.last_log_time = Some(now); + return; + } + + if downloaded_bytes == size { + info!( + "Snapshot download complete: 100% ({}/{} bytes)", + downloaded_bytes, size + ); + self.last_log_time = Some(now); + return; + } + + if let Some(last_time) = self.last_log_time { + if now.duration_since(last_time) >= self.log_interval { + info!( + "Snapshot download progress: {}% ({}/{} bytes)", + percentage, downloaded_bytes, size + ); + self.last_log_time = Some(now); + } } } } @@ -62,35 +95,31 @@ impl mithril_client::feedback::FeedbackReceiver for Feedback { async fn handle_event(&self, event: mithril_client::feedback::MithrilEvent) { match event { mithril_client::feedback::MithrilEvent::SnapshotDownloadStarted { .. } => { - self.download_pb.set_message("snapshot download started") + info!("snapshot download started"); } mithril_client::feedback::MithrilEvent::SnapshotDownloadProgress { downloaded_bytes, size, .. } => { - self.download_pb.set_length(size); - self.download_pb.set_position(downloaded_bytes); - self.download_pb.set_message("downloading Mithril snapshot"); + self.log_progress(downloaded_bytes, size); } mithril_client::feedback::MithrilEvent::SnapshotDownloadCompleted { .. } => { - self.download_pb.set_message("snapshot download completed"); + info!("snapshot download completed"); } mithril_client::feedback::MithrilEvent::CertificateChainValidationStarted { .. } => { - self.validate_pb - .set_message("certificate chain validation started"); + info!("certificate chain validation started"); } mithril_client::feedback::MithrilEvent::CertificateValidated { certificate_hash: hash, .. } => { - self.validate_pb - .set_message(format!("validating cert: {hash}")); + info!("certificate validated: {hash}"); } mithril_client::feedback::MithrilEvent::CertificateChainValidated { .. } => { - self.validate_pb.set_message("certificate chain validated"); + info!("certificate chain validation completed"); } } } @@ -158,6 +187,7 @@ pub struct Stage { pub struct Worker { config: Config, + is_bootstrapped: bool, } impl Worker {} @@ -186,11 +216,16 @@ impl gasket::framework::Worker for Worker { Ok(Self { config: stage.config.clone(), + is_bootstrapped: false, }) } async fn schedule(&mut self, _stage: &mut Stage) -> Result, WorkerError> { - Ok(WorkSchedule::Unit(())) + if self.is_bootstrapped { + return Ok(WorkSchedule::Done); + } else { + Ok(WorkSchedule::Unit(())) + } } async fn execute(&mut self, _unit: &(), stage: &mut Stage) -> Result<(), WorkerError> { @@ -225,6 +260,8 @@ impl gasket::framework::Worker for Worker { } } + self.is_bootstrapped = true; + Ok(()) } }