Merge branch 'master' into clone-work

Cargo.lock

@@ -377,6 +377,7 @@ dependencies = [
 name = "ethcore-util"
 version = "1.3.0"
 dependencies = [
+ "ansi_term 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "arrayvec 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
  "bigint 0.1.0",
  "chrono 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",

ethcore/src/client/client.rs

@@ -866,7 +866,6 @@ impl MiningBlockChainClient for Client {
 			self.miner.update_sealing(self);
 		}
 
-		info!("Block {} ({}) submitted and imported.", h.hex(), number);
 		Ok(h)
 	}
 }

ethcore/src/miner/miner.rs

@@ -19,6 +19,7 @@ use std::sync::atomic::AtomicBool;
 use std::time::{Instant, Duration};
 
 use util::*;
+use util::Colour::White;
 use account_provider::AccountProvider;
 use views::{BlockView, HeaderView};
 use client::{MiningBlockChainClient, Executive, Executed, EnvInfo, TransactOptions, BlockID, CallAnalytics};
@@ -616,22 +617,19 @@ impl MinerService for Miner {
 
 	fn submit_seal(&self, chain: &MiningBlockChainClient, pow_hash: H256, seal: Vec<Bytes>) -> Result<(), Error> {
 		let result = if let Some(b) = self.sealing_work.lock().unwrap().get_used_if(if self.options.enable_resubmission { GetAction::Clone } else { GetAction::Take }, |b| &b.hash() == &pow_hash) {
-			match b.lock().try_seal(self.engine(), seal) {
-				Err(_) => {
-					info!(target: "miner", "Mined block rejected, PoW was invalid.");
-					Err(Error::PowInvalid)
-				}
-				Ok(sealed) => {
-					info!(target: "miner", "New block mined, hash: {}", sealed.header().hash().hex());
-					Ok(sealed)
-				}
-			}
+			b.lock().try_seal(self.engine(), seal).or_else(|_| {
+				warn!(target: "miner", "Mined solution rejected: Invalid.");
+				Err(Error::PowInvalid)
+			})
 		} else {
-			info!(target: "miner", "Mined block rejected, PoW hash invalid or out of date.");
+			warn!(target: "miner", "Mined solution rejected: Block unknown or out of date.");
 			Err(Error::PowHashInvalid)
 		};
 		result.and_then(|sealed| {
+			let n = sealed.header().number();
+			let h = sealed.header().hash();
 			try!(chain.import_sealed_block(sealed));
+			info!(target: "miner", "Mined block imported OK. #{}: {}", paint(White.bold(), format!("{}", n)), paint(White.bold(), h.hex()));
 			Ok(())
 		})
 	}

ethcore/src/miner/work_notify.rs

@@ -43,9 +43,7 @@ impl WorkPoster {
 				}
 			}
 		}).collect();
-		let client = Client::<PostHandler>::configure()
-			.keep_alive(false)
-			.build().expect("Error creating HTTP client");
+		let client = WorkPoster::create_client();
 		WorkPoster {
 			client: Mutex::new(client),
 			urls: urls,
@@ -53,6 +51,13 @@ impl WorkPoster {
 		}
 	}
 
+	fn create_client() -> Client<PostHandler> {
+		let client = Client::<PostHandler>::configure()
+			.keep_alive(true)
+			.build().expect("Error creating HTTP client") as Client<PostHandler>;
+		client
+	}
+
 	pub fn notify(&self, pow_hash: H256, difficulty: U256, number: u64) {
 		// TODO: move this to engine
 		let target = Ethash::difficulty_to_boundary(&difficulty);
@@ -60,10 +65,15 @@ impl WorkPoster {
 		let seed_hash = H256::from_slice(&seed_hash[..]);
 		let body = format!(r#"{{ "result": ["0x{}","0x{}","0x{}","0x{:x}"] }}"#,
 			pow_hash.hex(), seed_hash.hex(), target.hex(), number);
-		let client = self.client.lock().unwrap();
+		let mut client = self.client.lock().unwrap();
 		for u in &self.urls {
 			if let Err(e) = client.request(u.clone(), PostHandler { body: body.clone() }) {
-				warn!("Error sending HTTP notification to {} : {}", u, e);
+				warn!("Error sending HTTP notification to {} : {}, retrying", u, e);
+				// TODO: remove this once https://github.com/hyperium/hyper/issues/848 is fixed
+				*client = WorkPoster::create_client();
+				if let Err(e) = client.request(u.clone(), PostHandler { body: body.clone() }) {
+					warn!("Error sending HTTP notification to {} : {}", u, e);
+				}
 			}
 		}
 	}

ethcore/src/service.rs

@@ -17,6 +17,7 @@
 //! Creates and registers client and network services.
 
 use util::*;
+use util::Colour::{Yellow, White};
 use util::panics::*;
 use spec::Spec;
 use error::*;
@@ -71,8 +72,7 @@ impl ClientService {
 			try!(net_service.start());
 		}
 
-		info!("Starting {}", net_service.host_info());
-		info!("Configured for {} using {:?} engine", spec.name, spec.engine.name());
+		info!("Configured for {} using {} engine", paint(White.bold(), spec.name.clone()), paint(Yellow.bold(), spec.engine.name().to_owned()));
 		let client = try!(Client::new(config, spec, db_path, miner, net_service.io().channel()));
 		panic_handler.forward_from(client.deref());
 		let client_io = Arc::new(ClientIoHandler {

parity/configuration.rs

@@ -25,6 +25,7 @@ use docopt::Docopt;
 
 use die::*;
 use util::*;
+use util::log::Colour::*;
 use ethcore::account_provider::AccountProvider;
 use util::network_settings::NetworkSettings;
 use ethcore::client::{append_path, get_db_path, ClientConfig, DatabaseCompactionProfile, Switch, VMType};
@@ -181,7 +182,7 @@ impl Configuration {
 				let wei_per_usd: f32 = 1.0e18 / usd_per_eth;
 				let gas_per_tx: f32 = 21000.0;
 				let wei_per_gas: f32 = wei_per_usd * usd_per_tx / gas_per_tx;
-				info!("Using a conversion rate of Ξ1 = US${} ({} wei/gas)", usd_per_eth, wei_per_gas);
+				info!("Using a conversion rate of Ξ1 = {} ({} wei/gas)", paint(White.bold(), format!("US${}", usd_per_eth)), paint(Yellow.bold(), format!("{}", wei_per_gas)));
 				U256::from_dec_str(&format!("{:.0}", wei_per_gas)).unwrap()
 			}
 		}

parity/main.rs

@@ -80,7 +80,7 @@ use std::thread::sleep;
 use std::time::Duration;
 use rustc_serialize::hex::FromHex;
 use ctrlc::CtrlC;
-use util::{H256, ToPretty, NetworkConfiguration, PayloadInfo, Bytes, UtilError};
+use util::{H256, ToPretty, NetworkConfiguration, PayloadInfo, Bytes, UtilError, paint, Colour, version};
 use util::panics::{MayPanic, ForwardPanic, PanicHandler};
 use ethcore::client::{BlockID, BlockChainClient, ClientConfig, get_db_path};
 use ethcore::error::{Error, ImportError};
@@ -184,10 +184,12 @@ fn execute_client(conf: Configuration, spec: Spec, client_config: ClientConfig)
 	let panic_handler = PanicHandler::new_in_arc();
 
 	// Setup logging
-	let logger = setup_log::setup_log(&conf.args.flag_logging);
+	let logger = setup_log::setup_log(&conf.args.flag_logging, !conf.args.flag_no_color);
 	// Raise fdlimit
 	unsafe { ::fdlimit::raise_fd_limit(); }
 
+	info!("Starting {}", paint(Colour::White.bold(), format!("{}", version())));
+
 	let net_settings = conf.net_settings(&spec);
 	let sync_config = conf.sync_config(&spec);
 
@@ -320,6 +322,8 @@ fn execute_export(conf: Configuration) {
 	// Setup panic handler
 	let panic_handler = PanicHandler::new_in_arc();
 
+	// Setup logging
+	let _logger = setup_log::setup_log(&conf.args.flag_logging, conf.args.flag_no_color);
 	// Raise fdlimit
 	unsafe { ::fdlimit::raise_fd_limit(); }
 
@@ -392,6 +396,8 @@ fn execute_import(conf: Configuration) {
 	// Setup panic handler
 	let panic_handler = PanicHandler::new_in_arc();
 
+	// Setup logging
+	let _logger = setup_log::setup_log(&conf.args.flag_logging, conf.args.flag_no_color);
 	// Raise fdlimit
 	unsafe { ::fdlimit::raise_fd_limit(); }
 

parity/setup_log.rs

@@ -19,10 +19,10 @@ use std::env;
 use std::sync::Arc;
 use time;
 use env_logger::LogBuilder;
-use util::{RotatingLogger};
+use util::RotatingLogger;
 
 /// Sets up the logger
-pub fn setup_log(init: &Option<String>) -> Arc<RotatingLogger> {
+pub fn setup_log(init: &Option<String>, enable_color: bool) -> Arc<RotatingLogger> {
 	use rlog::*;
 
 	let mut levels = String::new();
@@ -43,7 +43,7 @@ pub fn setup_log(init: &Option<String>) -> Arc<RotatingLogger> {
 		builder.parse(s);
 	}
 
-	let logs = Arc::new(RotatingLogger::new(levels));
+	let logs = Arc::new(RotatingLogger::new(levels, enable_color));
 	let logger = logs.clone();
 	let format = move |record: &LogRecord| {
 		let timestamp = time::strftime("%Y-%m-%d %H:%M:%S %Z", &time::now()).unwrap();

rpc/src/v1/tests/mocked/ethcore.rs

@@ -32,7 +32,7 @@ fn client_service() -> Arc<TestBlockChainClient> {
 }
 
 fn logger() -> Arc<RotatingLogger> {
-	Arc::new(RotatingLogger::new("rpc=trace".to_owned()))
+	Arc::new(RotatingLogger::new("rpc=trace".to_owned(), false))
 }
 
 fn settings() -> Arc<NetworkSettings> {

signer/src/authcode_store.rs

@@ -120,7 +120,7 @@ impl<T: TimeProvider> AuthCodes<T> {
 			.filter_map(|f| String::from_utf8(f.to_vec()).ok())
 			.collect::<Vec<String>>()
 			.join("-");
-		info!(target: "signer", "New authentication token generated.");
+		trace!(target: "signer", "New authentication token generated.");
 		self.codes.push(code);
 		Ok(readable_code)
 	}

util/Cargo.toml

@@ -37,6 +37,7 @@ vergen = "0.1"
 target_info = "0.1"
 bigint = { path = "bigint" }
 chrono = "0.2"
+ansi_term = "0.7"
 
 [features]
 default = []

util/src/lib.rs

@@ -117,6 +117,7 @@ extern crate libc;
 extern crate target_info;
 extern crate bigint;
 extern crate chrono;
+extern crate ansi_term;
 
 pub mod standard;
 #[macro_use]

util/src/log.rs

@@ -20,7 +20,21 @@ use std::env;
 use rlog::{LogLevelFilter};
 use env_logger::LogBuilder;
 use std::sync::{RwLock, RwLockReadGuard};
+use std::sync::atomic::{Ordering, AtomicBool};
 use arrayvec::ArrayVec;
+pub use ansi_term::{Colour, Style};
+
+lazy_static! {
+	static ref USE_COLOR: AtomicBool = AtomicBool::new(false);
+}
+
+/// Paint, using colour if desired.
+pub fn paint(c: Style, t: String) -> String {
+	match USE_COLOR.load(Ordering::Relaxed) {
+		true => format!("{}", c.paint(t)),
+		false => t,
+	}
+}
 
 lazy_static! {
 	static ref LOG_DUMMY: bool = {
@@ -57,7 +71,8 @@ impl RotatingLogger {
 
 	/// Creates new `RotatingLogger` with given levels.
 	/// It does not enforce levels - it's just read only.
-	pub fn new(levels: String) -> Self {
+	pub fn new(levels: String, enable_color: bool) -> Self {
+		USE_COLOR.store(enable_color, Ordering::Relaxed);
 		RotatingLogger {
 			levels: levels,
 			logs: RwLock::new(ArrayVec::<[_; LOG_SIZE]>::new()),
@@ -86,7 +101,7 @@ mod test {
 	use super::RotatingLogger;
 
 	fn logger() -> RotatingLogger {
-		RotatingLogger::new("test".to_owned())
+		RotatingLogger::new("test".to_owned(), false)
 	}
 
 	#[test]

util/src/network/host.rs

@@ -32,6 +32,8 @@ use misc::version;
 use crypto::*;
 use sha3::Hashable;
 use rlp::*;
+use log::Colour::White;
+use log::paint;
 use network::session::{Session, SessionData};
 use error::*;
 use io::*;
@@ -343,6 +345,7 @@ pub struct Host<Message> where Message: Send + Sync + Clone {
 	reserved_nodes: RwLock<HashSet<NodeId>>,
 	num_sessions: AtomicUsize,
 	stopping: AtomicBool,
+	first_time: AtomicBool,
 }
 
 impl<Message> Host<Message> where Message: Send + Sync + Clone {
@@ -398,6 +401,7 @@ impl<Message> Host<Message> where Message: Send + Sync + Clone {
 			reserved_nodes: RwLock::new(HashSet::new()),
 			num_sessions: AtomicUsize::new(0),
 			stopping: AtomicBool::new(false),
+			first_time: AtomicBool::new(true),
 		};
 
 		for n in boot_nodes {
@@ -533,7 +537,11 @@ impl<Message> Host<Message> where Message: Send + Sync + Clone {
 		};
 
 		self.info.write().unwrap().public_endpoint = Some(public_endpoint.clone());
-		info!("Public node URL: {}", self.external_url().unwrap());
+
+		if self.first_time.load(AtomicOrdering::Relaxed) {
+			info!("Public node URL: {}", paint(White.bold(), format!("{}", self.external_url().unwrap())));
+			self.first_time.store(false, AtomicOrdering::Relaxed);
+		}
 
 		// Initialize discovery.
 		let discovery = {