pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 15:51:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Informant cleanup (#3194)

Browse Source 
* Split informant in two

* Clean up imports

* Don't rely on saturated_into

* Add some documentation to the informant display
This commit is contained in:
Pierre Krieger
2019-07-25 04:51:38 +02:00
committed by Gavin Wood
parent 9f50c8fce4
commit 3a6a309d84
2 changed files with 157 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/core/cli/src/informant.rs
+8 -75
View File
@@ -16,19 +16,16 @@
//! Console informant. Prints sync progress and block events. Runs on the calling thread.
use ansi_term::Colour;
use std::fmt;
use std::time;
use client::{backend::Backend, BlockchainEvents};
use futures::{Future, Stream};
use futures03::{StreamExt as _, TryStreamExt as _};
use log::{info, warn};
use runtime_primitives::generic::BlockId;
use runtime_primitives::traits::Header;
use service::{Service, Components};
use tokio::runtime::TaskExecutor;
use network::SyncState;
use client::{backend::Backend, BlockchainEvents};
use log::{info, warn};
use runtime_primitives::generic::BlockId;
use runtime_primitives::traits::{Header, SaturatedConversion};
mod display;
/// Spawn informant on the event loop
#[deprecated(note = "Please use informant::build instead, and then create the task manually")]
@@ -42,37 +39,12 @@ pub fn start<C>(service: &Service<C>, exit: ::exit_future::Exit, handle: TaskExe
pub fn build<C>(service: &Service<C>) -> impl Future<Item = (), Error = ()>
where C: Components {
let client = service.client();
let mut last_number = None;
let mut last_update = time::Instant::now();
let mut display = display::InformantDisplay::new();
let display_notifications = service.network_status().for_each(move |(net_status, _)| {
let info = client.info();
let best_number = info.chain.best_number.saturated_into::<u64>();
let best_hash = info.chain.best_hash;
let speed = move || speed(best_number, last_number, last_update);
last_update = time::Instant::now();
let (status, target) = match (net_status.sync_state, net_status.best_seen_block) {
(SyncState::Idle, _) => ("Idle".into(), "".into()),
(SyncState::Downloading, None) => (format!("Syncing{}", speed()), "".into()),
(SyncState::Downloading, Some(n)) => (format!("Syncing{}", speed()), format!(", target=#{}", n)),
};
last_number = Some(best_number);
let finalized_number: u64 = info.chain.finalized_number.saturated_into::<u64>();
info!(
target: "substrate",
"{}{} ({} peers), best: #{} ({}), finalized #{} ({}), ⬇ {} ⬆ {}",
Colour::White.bold().paint(&status),
target,
Colour::White.bold().paint(format!("{}", net_status.num_connected_peers)),
Colour::White.paint(format!("{}", best_number)),
best_hash,
Colour::White.paint(format!("{}", finalized_number)),
info.chain.finalized_hash,
TransferRateFormat(net_status.average_download_per_sec),
TransferRateFormat(net_status.average_upload_per_sec),
);
display.display(&info, net_status);
Ok(())
});
@@ -115,42 +87,3 @@ where C: Components {
display_notifications.join(display_block_import)
.map(|((), ())| ())
}
fn speed(best_number: u64, last_number: Option<u64>, last_update: time::Instant) -> String {
let since_last_millis = last_update.elapsed().as_secs() * 1000;
let since_last_subsec_millis = last_update.elapsed().subsec_millis() as u64;
let speed = last_number
.and_then(|num|
(best_number.saturating_sub(num) * 10_000).checked_div(since_last_millis + since_last_subsec_millis))
.map_or(0.0, |s| s as f64);
if speed < 1.0 {
"".into()
} else {
format!(" {:4.1} bps", speed / 10.0)
}
}
/// Contains a number of bytes per second. Implements `fmt::Display` and shows this number of bytes
/// per second in a nice way.
struct TransferRateFormat(u64);
impl fmt::Display for TransferRateFormat {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// Special case 0.
if self.0 == 0 {
return write!(f, "0")
}
// Under 0.1 kiB, display plain bytes.
if self.0 < 100 {
return write!(f, "{} B/s", self.0)
}
// Under 1.0 MiB/sec, display the value in kiB/sec.
if self.0 < 1024 * 1024 {
return write!(f, "{:.1}kiB/s", self.0 as f64 / 1024.0)
}
write!(f, "{:.1}MiB/s", self.0 as f64 / (1024.0 * 1024.0))
}
}