fixed broken logs (#7934)

* fixed broken logs

* bring back old lock order

* removed bloom groups from blockchain

* revert unrelated changes

* simplify blockchain_block_blooms

ethcore/src/blockchain/cache.rs

@@ -23,15 +23,13 @@ pub struct CacheSize {
 	pub block_details: usize,
 	/// Transaction addresses cache size.
 	pub transaction_addresses: usize,
-	/// Blooms cache size.
-	pub blocks_blooms: usize,
 	/// Block receipts size.
 	pub block_receipts: usize,
 }
 
 impl CacheSize {
 	/// Total amount used by the cache.
 	pub fn total(&self) -> usize {
-		self.blocks + self.block_details + self.transaction_addresses + self.blocks_blooms + self.block_receipts
+		self.blocks + self.block_details + self.transaction_addresses + self.block_receipts
 	}
 }

ethcore/src/blockchain/extras.rs

@@ -18,8 +18,6 @@
 
 use std::ops;
 use std::io::Write;
-use bloomchain;
-use blooms::{GroupPosition, BloomGroup};
 use db::Key;
 use engines::epoch::{Transition as EpochTransition};
 use header::BlockNumber;
@@ -39,8 +37,6 @@ pub enum ExtrasIndex {
 	BlockHash = 1,
 	/// Transaction address index
 	TransactionAddress = 2,
-	/// Block blooms index
-	BlocksBlooms = 3,
 	/// Block receipts index
 	BlockReceipts = 4,
 	/// Epoch transition data index.
@@ -88,46 +84,6 @@ impl Key<BlockDetails> for H256 {
 	}
 }
 
-pub struct LogGroupKey([u8; 6]);
-
-impl ops::Deref for LogGroupKey {
-	type Target = [u8];
-
-	fn deref(&self) -> &Self::Target {
-		&self.0
-	}
-}
-
-#[derive(Debug, PartialEq, Eq, Hash, Clone)]
-pub struct LogGroupPosition(GroupPosition);
-
-impl From<bloomchain::group::GroupPosition> for LogGroupPosition {
-	fn from(position: bloomchain::group::GroupPosition) -> Self {
-		LogGroupPosition(From::from(position))
-	}
-}
-
-impl HeapSizeOf for LogGroupPosition {
-	fn heap_size_of_children(&self) -> usize {
-		self.0.heap_size_of_children()
-	}
-}
-
-impl Key<BloomGroup> for LogGroupPosition {
-	type Target = LogGroupKey;
-
-	fn key(&self) -> Self::Target {
-		let mut result = [0u8; 6];
-		result[0] = ExtrasIndex::BlocksBlooms as u8;
-		result[1] = self.0.level;
-		result[2] = (self.0.index >> 24) as u8;
-		result[3] = (self.0.index >> 16) as u8;
-		result[4] = (self.0.index >> 8) as u8;
-		result[5] = self.0.index as u8;
-		LogGroupKey(result)
-	}
-}
-
 impl Key<TransactionAddress> for H256 {
 	type Target = H264;
 

ethcore/src/blockchain/generator.rs

@@ -0,0 +1,223 @@
+// Copyright 2015-2017 Parity Technologies (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Blockchain generator for tests.
+
+use std::collections::VecDeque;
+use ethereum_types::{U256, H256, Bloom};
+
+use bytes::Bytes;
+use header::Header;
+use rlp::encode;
+use transaction::SignedTransaction;
+use views::BlockView;
+
+/// Helper structure, used for encoding blocks.
+#[derive(Default, Clone, RlpEncodable)]
+pub struct Block {
+	pub header: Header,
+	pub transactions: Vec<SignedTransaction>,
+	pub uncles: Vec<Header>
+}
+
+impl Block {
+	#[inline]
+	pub fn header(&self) -> Header {
+		self.header.clone()
+	}
+
+	#[inline]
+	pub fn hash(&self) -> H256 {
+		BlockView::new(&self.encoded()).header_view().hash()
+	}
+
+	#[inline]
+	pub fn number(&self) -> u64 {
+		self.header.number()
+	}
+
+	#[inline]
+	pub fn encoded(&self) -> Bytes {
+		encode(self).into_vec()
+	}
+
+	#[inline]
+	pub fn difficulty(&self) -> U256 {
+		*self.header.difficulty()
+	}
+}
+
+#[derive(Debug)]
+pub struct BlockOptions {
+	pub difficulty: U256,
+	pub bloom: Bloom,
+	pub transactions: Vec<SignedTransaction>,
+}
+
+impl Default for BlockOptions {
+	fn default() -> Self {
+		BlockOptions {
+			difficulty: 10.into(),
+			bloom: Bloom::default(),
+			transactions: Vec::new(),
+		}
+	}
+}
+
+#[derive(Clone)]
+pub struct BlockBuilder {
+	blocks: VecDeque<Block>,
+}
+
+impl BlockBuilder {
+	pub fn genesis() -> Self {
+		let mut blocks = VecDeque::with_capacity(1);
+		blocks.push_back(Block::default());
+
+		BlockBuilder {
+			blocks,
+		}
+	}
+
+	#[inline]
+	pub fn add_block(&self) -> Self {
+		self.add_block_with(|| BlockOptions::default())
+	}
+
+	#[inline]
+	pub fn add_blocks(&self, count: usize) -> Self {
+		self.add_blocks_with(count, || BlockOptions::default())
+	}
+
+	#[inline]
+	pub fn add_block_with<T>(&self, get_metadata: T) -> Self where T: Fn() -> BlockOptions {
+		self.add_blocks_with(1, get_metadata)
+	}
+
+	#[inline]
+	pub fn add_block_with_difficulty<T>(&self, difficulty: T) -> Self where T: Into<U256> {
+		let difficulty = difficulty.into();
+		self.add_blocks_with(1, move || BlockOptions {
+			difficulty,
+			..Default::default()
+		})
+	}
+
+	#[inline]
+	pub fn add_block_with_transactions<T>(&self, transactions: T) -> Self
+		where T: IntoIterator<Item = SignedTransaction> {
+		let transactions = transactions.into_iter().collect::<Vec<_>>();
+		self.add_blocks_with(1, || BlockOptions {
+			transactions: transactions.clone(),
+			..Default::default()
+		})
+	}
+
+	#[inline]
+	pub fn add_block_with_bloom(&self, bloom: Bloom) -> Self {
+		self.add_blocks_with(1, move || BlockOptions {
+			bloom,
+			..Default::default()
+		})
+	}
+
+	pub fn add_blocks_with<T>(&self, count: usize, get_metadata: T) -> Self where T: Fn() -> BlockOptions {
+		assert!(count > 0, "There must be at least 1 block");
+		let mut parent_hash = self.last().hash();
+		let mut parent_number = self.last().number();
+		let mut blocks = VecDeque::with_capacity(count);
+		for _ in 0..count {
+			let mut block = Block::default();
+			let metadata = get_metadata();
+			let block_number = parent_number + 1;
+			block.header.set_parent_hash(parent_hash);
+			block.header.set_number(block_number);
+			block.header.set_log_bloom(metadata.bloom);
+			block.header.set_difficulty(metadata.difficulty);
+			block.transactions = metadata.transactions;
+
+			parent_hash = block.hash();
+			parent_number = block_number;
+
+			blocks.push_back(block);
+		}
+
+		BlockBuilder {
+			blocks,
+		}
+	}
+
+	#[inline]
+	pub fn last(&self) -> &Block {
+		self.blocks.back().expect("There is always at least 1 block")
+	}
+}
+
+#[derive(Clone)]
+pub struct BlockGenerator {
+	builders: VecDeque<BlockBuilder>,
+}
+
+impl BlockGenerator {
+	pub fn new<T>(builders: T) -> Self where T: IntoIterator<Item = BlockBuilder> {
+		BlockGenerator {
+			builders: builders.into_iter().collect(),
+		}
+	}
+}
+
+impl Iterator for BlockGenerator {
+	type Item = Block;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		loop {
+			match self.builders.front_mut() {
+				Some(ref mut builder) => {
+					if let Some(block) = builder.blocks.pop_front() {
+						return Some(block);
+					}
+				},
+				None => return None,
+			}
+			self.builders.pop_front();
+		}
+
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{BlockBuilder, BlockOptions, BlockGenerator};
+
+	#[test]
+	fn test_block_builder() {
+		let genesis = BlockBuilder::genesis();
+		let block_1 = genesis.add_block();
+		let block_1001 = block_1.add_blocks(1000);
+		let block_1002 = block_1001.add_block_with(|| BlockOptions::default());
+		let generator = BlockGenerator::new(vec![genesis, block_1, block_1001, block_1002]);
+		assert_eq!(generator.count(), 1003);
+	}
+
+	#[test]
+	fn test_block_builder_fork() {
+		let genesis = BlockBuilder::genesis();
+		let block_10a = genesis.add_blocks(10);
+		let block_11b = genesis.add_blocks(11);
+		assert_eq!(block_10a.last().number(), 10);
+		assert_eq!(block_11b.last().number(), 11);
+	}
+}

ethcore/src/blockchain/update.rs

@@ -2,8 +2,7 @@ use std::collections::HashMap;
 use bigint::hash::H256;
 use header::BlockNumber;
 use blockchain::block_info::BlockInfo;
-use blooms::BloomGroup;
-use super::extras::{BlockDetails, BlockReceipts, TransactionAddress, LogGroupPosition};
+use blockchain::extras::{BlockDetails, BlockReceipts, TransactionAddress};
 
 /// Block extras update info.
 pub struct ExtrasUpdate<'a> {
@@ -19,8 +18,6 @@ pub struct ExtrasUpdate<'a> {
 	pub block_details: HashMap<H256, BlockDetails>,
 	/// Modified block receipts.
 	pub block_receipts: HashMap<H256, BlockReceipts>,
-	/// Modified blocks blooms.
-	pub blocks_blooms: HashMap<LogGroupPosition, BloomGroup>,
 	/// Modified transaction addresses (None signifies removed transactions).
 	pub transactions_addresses: HashMap<H256, Option<TransactionAddress>>,
 }

ethcore/src/client/client.rs

@@ -1673,17 +1673,8 @@ impl BlockChainClient for Client {
 		};
 
 		let chain = self.chain.read();
-		let blocks = filter.bloom_possibilities().iter()
-			.map(move |bloom| {
-				chain.blocks_with_bloom(bloom, from, to)
-			})
-			.flat_map(|m| m)
-			// remove duplicate elements
-			.collect::<HashSet<u64>>()
-			.into_iter()
-			.collect::<Vec<u64>>();
-
-		self.chain.read().logs(blocks, |entry| filter.matches(entry), filter.limit)
+		let blocks = chain.blocks_with_blooms(&filter.bloom_possibilities(), from, to);
+		chain.logs(blocks, |entry| filter.matches(entry), filter.limit)
 	}
 
 	fn filter_traces(&self, filter: TraceFilter) -> Option<Vec<LocalizedTrace>> {

ethcore/src/verification/verification.rs

@@ -461,7 +461,7 @@ mod tests {
 			unimplemented!()
 		}
 
-		fn blocks_with_bloom(&self, _bloom: &H2048, _from_block: BlockNumber, _to_block: BlockNumber) -> Vec<BlockNumber> {
+		fn blocks_with_blooms(&self, _blooms: &[Bloom], _from_block: BlockNumber, _to_block: BlockNumber) -> Vec<BlockNumber> {
 			unimplemented!()
 		}