Merge branch 'master' into gav

src/bin/client/main.rs

@@ -7,17 +7,18 @@ extern crate ethcore_util as util;
 extern crate ethcore;
 extern crate log;
 extern crate env_logger;
+extern crate ctrlc;
 
-use std::io::stdin;
 use std::env;
 use log::{LogLevelFilter};
 use env_logger::LogBuilder;
+use ctrlc::CtrlC;
 use util::*;
 use ethcore::client::*;
-use ethcore::service::ClientService;
+use ethcore::service::{ClientService, NetSyncMessage};
 use ethcore::ethereum;
 use ethcore::blockchain::CacheSize;
-use ethcore::sync::*;
+use ethcore::sync::EthSync;
 use docopt::Docopt;
 
 const USAGE: &'static str = "
@@ -66,42 +67,57 @@ fn main() {
 	};
 
 	let mut service = ClientService::start(spec, &init_nodes).unwrap();
-	let io_handler  = Box::new(ClientIoHandler { client: service.client(), timer: 0, info: Default::default() });
-
+	let io_handler  = Arc::new(ClientIoHandler { client: service.client(), info: Default::default(), sync: service.sync() });
 	service.io().register_handler(io_handler).expect("Error registering IO handler");
-	loop {
-		let mut cmd = String::new();
-		stdin().read_line(&mut cmd).unwrap();
-		if cmd == "quit\n" || cmd == "exit\n" || cmd == "q\n" {
-			break;
+
+	let exit = Arc::new(Condvar::new());
+	let e = exit.clone();
+	CtrlC::set_handler(move || { e.notify_all(); });
+	let mutex = Mutex::new(());
+	let _ = exit.wait(mutex.lock().unwrap()).unwrap();
+}
+
+struct Informant {
+	chain_info: RwLock<Option<BlockChainInfo>>,
+	cache_info: RwLock<Option<CacheSize>>,
+	report: RwLock<Option<ClientReport>>,
+}
+
+impl Default for Informant {
+	fn default() -> Self {
+		Informant {
+			chain_info: RwLock::new(None),
+			cache_info: RwLock::new(None),
+			report: RwLock::new(None),
 		}
 	}
 }
 
-#[derive(Default, Debug)]
-struct Informant {
-	chain_info: Option<BlockChainInfo>,
-	cache_info: Option<CacheSize>,
-	report: Option<ClientReport>,
-}
-
 impl Informant {
-	pub fn tick(&mut self, client: &Client) {
+	pub fn tick(&self, client: &Client, sync: &EthSync) {
 		// 5 seconds betwen calls. TODO: calculate this properly.
 		let dur = 5usize;
 
 		let chain_info = client.chain_info();
+		let queue_info = client.queue_info();
 		let cache_info = client.cache_info();
 		let report = client.report();
+		let sync_info = sync.status();
 
-		if let (_, &Some(ref last_cache_info), &Some(ref last_report)) = (&self.chain_info, &self.cache_info, &self.report) {
-			println!("[ {} {} ]---[ {} blk/s | {} tx/s | {} gas/s  //···{}···//  {} ({}) bl  {} ({}) ex ]",
+		if let (_, &Some(ref last_cache_info), &Some(ref last_report)) = (self.chain_info.read().unwrap().deref(), self.cache_info.read().unwrap().deref(), self.report.read().unwrap().deref()) {
+			println!("[ {} {} ]---[ {} blk/s | {} tx/s | {} gas/s  //··· {}/{} peers, {} downloaded, {}+{} queued ···//  {} ({}) bl  {} ({}) ex ]",
 				chain_info.best_block_number,
 				chain_info.best_block_hash,
 				(report.blocks_imported - last_report.blocks_imported) / dur,
 				(report.transactions_applied - last_report.transactions_applied) / dur,
 				(report.gas_processed - last_report.gas_processed) / From::from(dur),
-				0, // TODO: peers
+
+				sync_info.num_active_peers,
+				sync_info.num_peers,
+				sync_info.blocks_received,
+				queue_info.unverified_queue_size,
+				queue_info.verified_queue_size,
+
 				cache_info.blocks,
 				cache_info.blocks as isize - last_cache_info.blocks as isize,
 				cache_info.block_details,
@@ -109,28 +125,28 @@ impl Informant {
 			);
 		}
 
-		self.chain_info = Some(chain_info);
-		self.cache_info = Some(cache_info);
-		self.report = Some(report);
+		*self.chain_info.write().unwrap().deref_mut() = Some(chain_info);
+		*self.cache_info.write().unwrap().deref_mut() = Some(cache_info);
+		*self.report.write().unwrap().deref_mut() = Some(report);
 	}
 }
 
+const INFO_TIMER: TimerToken = 0;
+
 struct ClientIoHandler {
-	client: Arc<RwLock<Client>>,
-	timer: TimerToken,
+	client: Arc<Client>,
+	sync: Arc<EthSync>,
 	info: Informant,
 }
 
 impl IoHandler<NetSyncMessage> for ClientIoHandler {
-	fn initialize<'s>(&'s mut self, io: &mut IoContext<'s, NetSyncMessage>) { 
-		self.timer = io.register_timer(5000).expect("Error registering timer");
+	fn initialize(&self, io: &IoContext<NetSyncMessage>) { 
+		io.register_timer(INFO_TIMER, 5000).expect("Error registering timer");
 	}
 
-	fn timeout<'s>(&'s mut self, _io: &mut IoContext<'s, NetSyncMessage>, timer: TimerToken) {
-		if self.timer == timer {
-			let client = self.client.read().unwrap();
-			client.tick();
-			self.info.tick(client.deref());
+	fn timeout(&self, _io: &IoContext<NetSyncMessage>, timer: TimerToken) {
+		if INFO_TIMER == timer {
+			self.info.tick(&self.client, &self.sync);
 		}
 	}
 }