Backports to beta v1.3.6 (#2571)

* v1.3.6

* Print backtrace on panic (#2535)

* Don't activate peers on connect; Test (#2537)

* Removing unwarps from sync module (#2551)

* Remove unwrap from client module (#2554)

* remove unwraps in client

* imporve block hash expect message

* mining perf trace

* Fixed race condition in trace import (#2555)

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 description = "Ethcore client."
 name = "parity"
-version = "1.3.5"
+version = "1.3.6"
 license = "GPL-3.0"
 authors = ["Ethcore <[email protected]>"]
 build = "build.rs"

ethcore/src/client/client.rs

@@ -159,13 +159,6 @@ pub const DB_COL_ACCOUNT_BLOOM: Option<u32> = Some(5);
 /// Number of columns in DB
 pub const DB_NO_OF_COLUMNS: Option<u32> = Some(6);
 
-/// Append a path element to the given path and return the string.
-pub fn append_path<P>(path: P, item: &str) -> String where P: AsRef<Path> {
-	let mut p = path.as_ref().to_path_buf();
-	p.push(item);
-	p.to_str().unwrap().to_owned()
-}
-
 impl Client {
 	/// Create a new client with given spec and DB path and custom verifier.
 	pub fn new(
@@ -182,7 +175,7 @@ impl Client {
 		db_config.compaction = config.db_compaction.compaction_profile();
 		db_config.wal = config.db_wal;
 
-		let db = Arc::new(try!(Database::open(&db_config, &path.to_str().unwrap()).map_err(ClientError::Database)));
+		let db = Arc::new(try!(Database::open(&db_config, &path.to_str().expect("DB path could not be converted to string.")).map_err(ClientError::Database)));
 		let chain = Arc::new(BlockChain::new(config.blockchain, &gb, db.clone()));
 		let tracedb = Arc::new(try!(TraceDB::new(config.tracing, db.clone(), chain.clone())));
 
@@ -295,31 +288,28 @@ impl Client {
 		};
 
 		// Check if Parent is in chain
-		let chain_has_parent = self.chain.block_header(&header.parent_hash);
-		if let None = chain_has_parent {
-			warn!(target: "client", "Block import failed for #{} ({}): Parent not found ({}) ", header.number(), header.hash(), header.parent_hash);
-			return Err(());
-		};
-
-		// Enact Verified Block
-		let parent = chain_has_parent.unwrap();
-		let last_hashes = self.build_last_hashes(header.parent_hash().clone());
-		let db = self.state_db.lock().boxed_clone_canon(&header.parent_hash);
-
-		let enact_result = enact_verified(block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, &self.vm_factory, self.trie_factory.clone());
-		if let Err(e) = enact_result {
-			warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
-			return Err(());
-		};
+		let chain_has_parent = self.chain.block_header(header.parent_hash());
+		if let Some(parent) = chain_has_parent {
+			// Enact Verified Block
+			let last_hashes = self.build_last_hashes(header.parent_hash().clone());
+			let db = self.state_db.lock().boxed_clone_canon(&header.parent_hash());
+
+			let enact_result = enact_verified(block, engine, self.tracedb.tracing_enabled(), db, &parent, last_hashes, &self.vm_factory, self.trie_factory.clone());
+			let locked_block = try!(enact_result.map_err(|e| {
+				warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
+			}));
+
+			// Final Verification
+			if let Err(e) = self.verifier.verify_block_final(header, locked_block.block().header()) {
+				warn!(target: "client", "Stage 4 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
+				return Err(());
+			}
 
-		// Final Verification
-		let locked_block = enact_result.unwrap();
-		if let Err(e) = self.verifier.verify_block_final(header, locked_block.block().header()) {
-			warn!(target: "client", "Stage 4 block verification failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e);
-			return Err(());
+			Ok(locked_block)
+		} else {
+			warn!(target: "client", "Block import failed for #{} ({}): Parent not found ({}) ", header.number(), header.hash(), header.parent_hash());
+			Err(())
 		}
-
-		Ok(locked_block)
 	}
 
 	fn calculate_enacted_retracted(&self, import_results: &[ImportRoute]) -> (Vec<H256>, Vec<H256>) {
@@ -372,14 +362,17 @@ impl Client {
 					invalid_blocks.insert(header.hash());
 					continue;
 				}
+				let is_invalid = invalid_blocks.contains(header.parent_hash());
+				if let (false, Ok(closed_block)) = (is_invalid, self.check_and_close_block(&block)) {
+					imported_blocks.push(header.hash());
 
-				let closed_block = closed_block.unwrap();
-				imported_blocks.push(header.hash());
-
-				let route = self.commit_block(closed_block, &header.hash(), &block.bytes);
-				import_results.push(route);
+					let route = self.commit_block(closed_block, &header.hash(), &block.bytes);
+					import_results.push(route);
 
-				self.report.write().accrue_block(&block);
+					self.report.write().accrue_block(&block);
+				} else {
+					invalid_blocks.insert(header.hash());
+				}
 			}
 
 			let imported = imported_blocks.len();
@@ -428,7 +421,7 @@ impl Client {
 		// Are we committing an era?
 		let ancient = if number >= HISTORY {
 			let n = number - HISTORY;
-			Some((n, self.chain.block_hash(n).unwrap()))
+			Some((n, self.chain.block_hash(n).expect("only verified blocks can be commited; verified block has hash; qed")))
 		} else {
 			None
 		};
@@ -835,8 +828,9 @@ impl BlockChainClient for Client {
 			let t = self.chain.block_body(&address.block_hash)
 				.and_then(|block| BodyView::new(&block).localized_transaction_at(&address.block_hash, block_number, address.index));
 
-			match (t, self.chain.transaction_receipt(&address)) {
-				(Some(tx), Some(receipt)) => {
+			let tx_and_sender = t.and_then(|tx| tx.sender().ok().map(|sender| (tx, sender)));
+			match (tx_and_sender, self.chain.transaction_receipt(&address)) {
+				(Some((tx, sender)), Some(receipt)) => {
 					let block_hash = tx.block_hash.clone();
 					let block_number = tx.block_number.clone();
 					let transaction_hash = tx.hash();
@@ -858,7 +852,7 @@ impl BlockChainClient for Client {
 						gas_used: receipt.gas_used - prior_gas_used,
 						contract_address: match tx.action {
 							Action::Call(_) => None,
-							Action::Create => Some(contract_address(&tx.sender().unwrap(), &tx.nonce))
+							Action::Create => Some(contract_address(&sender, &tx.nonce))
 						},
 						logs: receipt.logs.into_iter().enumerate().map(|(i, log)| LocalizedLogEntry {
 							entry: log,
@@ -981,17 +975,18 @@ impl BlockChainClient for Client {
 		let start = self.block_number(filter.range.start);
 		let end = self.block_number(filter.range.end);
 
-		if start.is_some() && end.is_some() {
-			let filter = trace::Filter {
-				range: start.unwrap() as usize..end.unwrap() as usize,
-				from_address: From::from(filter.from_address),
-				to_address: From::from(filter.to_address),
-			};
+		match (start, end) {
+			(Some(s), Some(e)) => {
+				let filter = trace::Filter {
+					range: s as usize..e as usize,
+					from_address: From::from(filter.from_address),
+					to_address: From::from(filter.to_address),
+				};
 
-			let traces = self.tracedb.filter(&filter);
-			Some(traces)
-		} else {
-			None
+				let traces = self.tracedb.filter(&filter);
+				Some(traces)
+			},
+			_ => None,
 		}
 	}
 
@@ -1063,11 +1058,15 @@ impl MiningBlockChainClient for Client {
 		// Add uncles
 		self.chain
 			.find_uncle_headers(&h, engine.maximum_uncle_age())
-			.unwrap()
+			.unwrap_or_else(Vec::new)
 			.into_iter()
 			.take(engine.maximum_uncle_count())
 			.foreach(|h| {
-				open_block.push_uncle(h).unwrap();
+				open_block.push_uncle(h).expect("pushing maximum_uncle_count;
+												open_block was just created;
+												push_uncle is not ok only if more than maximum_uncle_count is pushed;
+												so all push_uncle are Ok;
+												qed");
 			});
 
 		open_block

ethcore/src/client/test_client.rs

@@ -53,6 +53,8 @@ pub struct TestBlockChainClient {
 	pub genesis_hash: H256,
 	/// Last block hash.
 	pub last_hash: RwLock<H256>,
+	/// Extra data do set for each block
+	pub extra_data: Bytes,
 	/// Difficulty.
 	pub difficulty: RwLock<U256>,
 	/// Balances.
@@ -99,11 +101,17 @@ impl Default for TestBlockChainClient {
 impl TestBlockChainClient {
 	/// Creates new test client.
 	pub fn new() -> Self {
+		Self::new_with_extra_data(Bytes::new())
+	}
+
+	/// Creates new test client with specified extra data for each block
+	pub fn new_with_extra_data(extra_data: Bytes) -> Self {
 		let spec = Spec::new_test();
 		let mut client = TestBlockChainClient {
 			blocks: RwLock::new(HashMap::new()),
 			numbers: RwLock::new(HashMap::new()),
 			genesis_hash: H256::new(),
+			extra_data: extra_data,
 			last_hash: RwLock::new(H256::new()),
 			difficulty: RwLock::new(From::from(0)),
 			balances: RwLock::new(HashMap::new()),
@@ -121,7 +129,7 @@ impl TestBlockChainClient {
 		client.genesis_hash = client.last_hash.read().clone();
 		client
 	}
-
+	
 	/// Set the transaction receipt result
 	pub fn set_transaction_receipt(&self, id: TransactionID, receipt: LocalizedReceipt) {
 		self.receipts.write().insert(id, receipt);
@@ -166,6 +174,7 @@ impl TestBlockChainClient {
 			header.parent_hash = self.last_hash.read().clone();
 			header.number = n as BlockNumber;
 			header.gas_limit = U256::from(1_000_000);
+			header.extra_data = self.extra_data.clone();
 			let uncles = match with {
 				EachBlockWith::Uncle | EachBlockWith::UncleAndTransaction => {
 					let mut uncles = RlpStream::new_list(1);

ethcore/src/miner/miner.rs

@@ -249,6 +249,7 @@ impl Miner {
 	fn prepare_sealing(&self, chain: &MiningBlockChainClient) {
 		trace!(target: "miner", "prepare_sealing: entering");
 
+		let _timer = PerfTimer::new("prepare_sealing");
 		{
 			trace!(target: "miner", "recalibrating...");
 			let txq = self.transaction_queue.clone();

ethcore/src/trace/db.rs

@@ -268,16 +268,6 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 			return;
 		}
 
-		// at first, let's insert new block traces
-		{
-			let mut traces = self.traces.write();
-			// it's important to use overwrite here,
-			// cause this value might be queried by hash later
-			batch.write_with_cache(DB_COL_TRACE, &mut *traces, request.block_hash, request.traces, CacheUpdatePolicy::Overwrite);
-			// note_used must be called after locking traces to avoid cache/traces deadlock on garbage collection
-			self.note_used(CacheID::Trace(request.block_hash.clone()));
-		}
-
 		// now let's rebuild the blooms
 		{
 			let range_start = request.block_number as Number + 1 - request.enacted.len();
@@ -288,12 +278,25 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 				// all traces are expected to be found here. That's why `expect` has been used
 				// instead of `filter_map`. If some traces haven't been found, it meens that
 				// traces database is corrupted or incomplete.
-				.map(|block_hash| self.traces(block_hash).expect("Traces database is incomplete."))
-				.map(|block_traces| block_traces.bloom())
+				.map(|block_hash| if block_hash == &request.block_hash {
+					request.traces.bloom()
+				} else {
+					self.traces(block_hash).expect("Traces database is incomplete.").bloom()
+				})
 				.map(blooms::Bloom::from)
 				.map(Into::into)
 				.collect();
 
+			// insert new block traces into the cache and the database
+			{
+				let mut traces = self.traces.write();
+				// it's important to use overwrite here,
+				// cause this value might be queried by hash later
+				batch.write_with_cache(DB_COL_TRACE, &mut *traces, request.block_hash, request.traces, CacheUpdatePolicy::Overwrite);
+				// note_used must be called after locking traces to avoid cache/traces deadlock on garbage collection
+				self.note_used(CacheID::Trace(request.block_hash.clone()));
+			}
+
 			let chain = BloomGroupChain::new(self.bloom_config, self);
 			let trace_blooms = chain.replace(&replaced_range, enacted_blooms);
 			let blooms_to_insert = trace_blooms.into_iter()