import: keep informant going until finished (#2065)

parity/blockchain.rs

@@ -31,6 +31,7 @@ use ethcore::error::ImportError;
 use ethcore::miner::Miner;
 use cache::CacheConfig;
 use informant::Informant;
+use io_handler::ImportIoHandler;
 use params::{SpecType, Pruning};
 use helpers::{to_client_config, execute_upgrades};
 use dir::Directories;
@@ -170,6 +171,10 @@ fn execute_import(cmd: ImportBlockchain) -> Result<String, String> {
 
 	let informant = Informant::new(client.clone(), None, None, cmd.logger_config.color);
 
+	try!(service.register_io_handler(Arc::new(ImportIoHandler {
+		info: Arc::new(informant),
+	})).map_err(|_| "Unable to register informant handler".to_owned()));
+
 	let do_import = |bytes| {
 		while client.queue_info().is_full() { sleep(Duration::from_secs(1)); }
 		match client.import_block(bytes) {
@@ -181,7 +186,6 @@ fn execute_import(cmd: ImportBlockchain) -> Result<String, String> {
 			},
 			Ok(_) => {},
 		}
-		informant.tick();
 		Ok(())
 	};
 
@@ -266,10 +270,10 @@ fn execute_export(cmd: ExportBlockchain) -> Result<String, String> {
 	};
 
 	let from = try!(client.block_number(cmd.from_block).ok_or("From block could not be found"));
-	let to = try!(client.block_number(cmd.to_block).ok_or("From block could not be found"));
+	let to = try!(client.block_number(cmd.to_block).ok_or("To block could not be found"));
 
 	for i in from..(to + 1) {
-		let b = client.block(BlockID::Number(i)).unwrap();
+		let b = try!(client.block(BlockID::Number(i)).ok_or("Error exporting incomplete chain"));
 		match format {
 			DataFormat::Binary => { out.write(&b).expect("Couldn't write to stream."); }
 			DataFormat::Hex => { out.write_fmt(format_args!("{}", b.pretty())).expect("Couldn't write to stream."); }

parity/io_handler.rs

@@ -46,3 +46,19 @@ impl IoHandler<ClientIoMessage> for ClientIoHandler {
 		}
 	}
 }
+
+pub struct ImportIoHandler {
+	pub info: Arc<Informant>,
+}
+
+impl IoHandler<ClientIoMessage> for ImportIoHandler {
+	fn initialize(&self, io: &IoContext<ClientIoMessage>) {
+		io.register_timer(INFO_TIMER, 5000).expect("Error registering timer");
+	}
+
+	fn timeout(&self, _io: &IoContext<ClientIoMessage>, timer: TimerToken) {
+		if let INFO_TIMER = timer {
+			self.info.tick()
+		}
+	}
+}