new blooms database

ethcore/src/blockchain/blockchain.rs

@@ -1459,8 +1459,7 @@ mod tests {
 	use std::sync::Arc;
 	use rustc_hex::FromHex;
 	use hash::keccak;
-	use kvdb::{KeyValueDB, DBTransaction};
-	use kvdb_memorydb;
+	use kvdb::{DBTransaction};
 	use ethereum_types::*;
 	use receipt::{Receipt, TransactionOutcome};
 	use blockchain::{BlockProvider, BlockChain, BlockChainDB, Config, ImportRoute};

ethcore/src/snapshot/consensus/mod.rs

@@ -25,7 +25,6 @@ use engines::EthEngine;
 use snapshot::{Error, ManifestData};
 
 use ethereum_types::H256;
-use kvdb::KeyValueDB;
 
 mod authority;
 mod work;

ethcore/src/snapshot/service.rs

@@ -40,7 +40,6 @@ use parking_lot::{Mutex, RwLock, RwLockReadGuard};
 use util_error::UtilError;
 use bytes::Bytes;
 use journaldb::Algorithm;
-use kvdb::{KeyValueDB, KeyValueDBHandler};
 use snappy;
 
 /// Helper for removing directories in case of error.

ethcore/src/snapshot/tests/helpers.rs

@@ -33,7 +33,7 @@ use snapshot::io::{SnapshotReader, PackedWriter, PackedReader};
 use tempdir::TempDir;
 use rand::Rng;
 
-use kvdb::{KeyValueDB, DBValue};
+use kvdb::{DBValue};
 use ethereum_types::H256;
 use hashdb::HashDB;
 use journaldb;

ethcore/src/snapshot/tests/proof_of_authority.rs

@@ -30,7 +30,6 @@ use transaction::{Transaction, Action, SignedTransaction};
 use tempdir::TempDir;
 
 use ethereum_types::Address;
-use kvdb_memorydb;
 use test_helpers;
 
 use_contract!(test_validator_set, "ValidatorSet", "res/contracts/test_validator_set.json");

ethcore/src/snapshot/tests/proof_of_work.rs

@@ -16,7 +16,6 @@
 
 //! PoW block chunker and rebuilder tests.
 
-use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use tempdir::TempDir;
 use error::{Error, ErrorKind};
@@ -28,8 +27,7 @@ use snapshot::io::{PackedReader, PackedWriter, SnapshotReader, SnapshotWriter};
 
 use parking_lot::Mutex;
 use snappy;
-use kvdb::{KeyValueDB, DBTransaction};
-use kvdb_memorydb;
+use kvdb::{DBTransaction};
 use test_helpers;
 
 const SNAPSHOT_MODE: ::snapshot::PowSnapshot = ::snapshot::PowSnapshot { blocks: 30000, max_restore_blocks: 30000 };

ethcore/src/snapshot/tests/service.rs

@@ -24,11 +24,11 @@ use ids::BlockId;
 use snapshot::service::{Service, ServiceParams};
 use snapshot::{self, ManifestData, SnapshotService};
 use spec::Spec;
-use test_helpers::{self, generate_dummy_client_with_spec_and_data};
+use test_helpers::{generate_dummy_client_with_spec_and_data};
 use test_helpers_internal::restoration_db_handler;
 
 use io::IoChannel;
-use kvdb_rocksdb::{Database, DatabaseConfig};
+use kvdb_rocksdb::{DatabaseConfig};
 
 struct NoopDBRestore;
 

ethcore/src/test_helpers.rs

@@ -260,7 +260,7 @@ pub fn get_test_client_with_blocks(blocks: Vec<Bytes>) -> Arc<Client> {
 
 pub fn new_db() -> Arc<BlockChainDB> {
 	struct TestBlockChainDB {
-		blooms_dir: TempDir,
+		_blooms_dir: TempDir,
 		blooms: RwLock<blooms_db::Database>,
 		key_value: Arc<KeyValueDB>,
 	}
@@ -279,7 +279,7 @@ pub fn new_db() -> Arc<BlockChainDB> {
 
 	let db = TestBlockChainDB {
 		blooms: RwLock::new(blooms_db::Database::open(tempdir.path()).unwrap()),
-		blooms_dir: tempdir,
+		_blooms_dir: tempdir,
 		key_value: Arc::new(::kvdb_memorydb::create(::db::NUM_COLUMNS.unwrap()))
 	};
 

ethcore/src/test_helpers_internal.rs

@@ -19,7 +19,7 @@
 use std::path::Path;
 use std::sync::Arc;
 use parking_lot::RwLock;
-use kvdb::{KeyValueDB, KeyValueDBHandler};
+use kvdb::{KeyValueDB};
 use kvdb_rocksdb::{Database, DatabaseConfig};
 use blockchain::{BlockChainDBHandler, BlockChainDB};
 use blooms_db;

ethcore/src/tests/client.rs

@@ -29,7 +29,6 @@ use test_helpers::{
 };
 use types::filter::Filter;
 use ethereum_types::{U256, Address};
-use kvdb_rocksdb::{Database, DatabaseConfig};
 use miner::Miner;
 use spec::Spec;
 use views::BlockView;
@@ -43,10 +42,7 @@ use test_helpers;
 #[test]
 fn imports_from_empty() {
 	let db = test_helpers::new_db();
-	//let tempdir = TempDir::new("").unwrap();
 	let spec = Spec::new_test();
-	//let db_config = DatabaseConfig::with_columns(::db::NUM_COLUMNS);
-	//let client_db = Arc::new(Database::open(&db_config, tempdir.path().to_str().unwrap()).unwrap());
 
 	let client = Client::new(
 		ClientConfig::default(),
@@ -64,8 +60,6 @@ fn should_return_registrar() {
 	let db = test_helpers::new_db();
 	let tempdir = TempDir::new("").unwrap();
 	let spec = ethereum::new_morden(&tempdir.path().to_owned());
-	//let db_config = DatabaseConfig::with_columns(::db::NUM_COLUMNS);
-	//let client_db = Arc::new(Database::open(&db_config, tempdir.path().to_str().unwrap()).unwrap());
 
 	let client = Client::new(
 		ClientConfig::default(),

ethcore/src/tests/trace.rs

@@ -16,7 +16,6 @@
 
 //! Client tests of tracing
 
-use tempdir::TempDir;
 use ethkey::KeyPair;
 use hash::keccak;
 use block::*;
@@ -26,7 +25,6 @@ use spec::*;
 use client::*;
 use test_helpers::get_temp_state_db;
 use client::{BlockChainClient, Client, ClientConfig};
-use kvdb_rocksdb::{Database, DatabaseConfig};
 use std::sync::Arc;
 use header::Header;
 use miner::Miner;

ethcore/src/trace/db.rs

@@ -15,13 +15,12 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 //! Trace database.
-use std::ops::Deref;
-use std::collections::{HashMap, VecDeque};
+use std::collections::{HashMap, BTreeSet, VecDeque};
 use std::sync::Arc;
 use blockchain::{BlockChainDB};
 use heapsize::HeapSizeOf;
 use ethereum_types::{H256, H264};
-use kvdb::{KeyValueDB, DBTransaction};
+use kvdb::{DBTransaction};
 use parking_lot::RwLock;
 use header::BlockNumber;
 use trace::{LocalizedTrace, Config, Filter, Database as TraceDatabase, ImportRequest, DatabaseExtras};
@@ -83,7 +82,6 @@ impl<T> TraceDB<T> where T: DatabaseExtras {
 
 		TraceDB {
 			traces: RwLock::new(HashMap::new()),
-			//blooms: RwLock::new(HashMap::new()),
 			cache_manager: RwLock::new(CacheManager::new(config.pref_cache_size, config.max_cache_size, 10 * 1024)),
 			tracesdb: tracesdb,
 			enabled: config.enabled,
@@ -93,8 +91,6 @@ impl<T> TraceDB<T> where T: DatabaseExtras {
 
 	fn cache_size(&self) -> usize {
 		self.traces.read().heap_size_of_children()
-		//let blooms = self.blooms.read().heap_size_of_children();
-		//traces + blooms
 	}
 
 	/// Let the cache system know that a cacheable item has been used.
@@ -108,18 +104,15 @@ impl<T> TraceDB<T> where T: DatabaseExtras {
 		let current_size = self.cache_size();
 
 		let mut traces = self.traces.write();
-		//let mut blooms = self.blooms.write();
 		let mut cache_manager = self.cache_manager.write();
 
 		cache_manager.collect_garbage(current_size, | ids | {
 			for id in &ids {
 				match *id {
 					CacheId::Trace(ref h) => { traces.remove(h); },
-					//CacheId::Bloom(ref h) => { blooms.remove(h); },
 				}
 			}
 			traces.shrink_to_fit();
-			//blooms.shrink_to_fit();
 
 			traces.heap_size_of_children()
 		});
@@ -211,8 +204,6 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 		// now let's rebuild the blooms
 		if !request.enacted.is_empty() {
 			let range_start = request.block_number + 1 - request.enacted.len() as u64;
-			//let range_end = range_start + request.retracted;
-			//let replaced_range = range_start..range_end;
 			let enacted_blooms: Vec<_> = request.enacted
 				.iter()
 				// all traces are expected to be found here. That's why `expect` has been used
@@ -324,19 +315,25 @@ impl<T> TraceDatabase for TraceDB<T> where T: DatabaseExtras {
 	}
 
 	fn filter(&self, filter: &Filter) -> Vec<LocalizedTrace> {
-		unimplemented!();
-		//let chain = BloomGroupChain::new(self.bloom_config, self);
-		//let numbers = chain.filter(filter);
-		//numbers.into_iter()
-			//.flat_map(|n| {
-				//let number = n as BlockNumber;
-				//let hash = self.extras.block_hash(number)
-					//.expect("Expected to find block hash. Extras db is probably corrupted");
-				//let traces = self.traces(&hash)
-					//.expect("Expected to find a trace. Db is probably corrupted.");
-				//self.matching_block_traces(filter, traces, hash, number)
-			//})
-			//.collect()
+		let possibilities = filter.bloom_possibilities();
+		let blooms_db = self.tracesdb.blooms().read();
+		let numbers = possibilities.iter()
+			.map(|bloom| blooms_db.iterate_matching(filter.range.start as u64, filter.range.end as u64, bloom)?.collect::<Result<Vec<_>, _>>())
+			.collect::<Result<Vec<_>, _>>().expect("TODO: blooms pr")
+			.into_iter()
+			.flat_map(|n| n)
+			.collect::<BTreeSet<_>>();
+
+		numbers.into_iter()
+			.flat_map(|n| {
+				let number = n as BlockNumber;
+				let hash = self.extras.block_hash(number)
+					.expect("Expected to find block hash. Extras db is probably corrupted");
+				let traces = self.traces(&hash)
+					.expect("Expected to find a trace. Db is probably corrupted.");
+				self.matching_block_traces(filter, traces, hash, number)
+			})
+			.collect()
 	}
 }
 
@@ -345,8 +342,7 @@ mod tests {
 	use std::collections::HashMap;
 	use std::sync::Arc;
 	use ethereum_types::{H256, U256, Address};
-	use kvdb::{DBTransaction, KeyValueDB};
-	use kvdb_memorydb;
+	use kvdb::{DBTransaction};
 	use header::BlockNumber;
 	use trace::{Config, TraceDB, Database as TraceDatabase, DatabaseExtras, ImportRequest};
 	use trace::{Filter, LocalizedTrace, AddressesFilter, TraceError};
@@ -542,6 +538,7 @@ mod tests {
 		let mut batch = DBTransaction::new();
 		tracedb.import(&mut batch, request);
 		db.key_value().write(batch).unwrap();
+		db.blooms().write().flush().unwrap();
 
 		let filter = Filter {
 			range: (1..1),
@@ -558,6 +555,7 @@ mod tests {
 		let mut batch = DBTransaction::new();
 		tracedb.import(&mut batch, request);
 		db.key_value().write(batch).unwrap();
+		db.blooms().write().flush().unwrap();
 
 		let filter = Filter {
 			range: (1..2),

ethcore/src/trace/types/filter.rs

@@ -89,7 +89,7 @@ pub struct Filter {
 
 impl Filter {
 	/// Returns combinations of each address.
-	fn bloom_possibilities(&self) -> Vec<Bloom> {
+	pub fn bloom_possibilities(&self) -> Vec<Bloom> {
 		self.to_address.with_blooms(self.from_address.blooms())
 	}