simplify kvdb error types

ethcore/light/src/client/header_chain.rs

@@ -31,7 +31,7 @@ use std::sync::Arc;
 use cht;
 
 use ethcore::block_status::BlockStatus;
-use ethcore::error::{Error, ErrorKind, BlockImportError, BlockImportErrorKind, BlockError};
+use ethcore::error::{Error, BlockImportError, BlockImportErrorKind, BlockError};
 use ethcore::encoded;
 use ethcore::header::Header;
 use ethcore::ids::BlockId;
@@ -260,7 +260,7 @@ impl HeaderChain {
 			let best_block = {
 				let era = match candidates.get(&curr.best_num) {
 					Some(era) => era,
-					None => bail!(ErrorKind::Database("Database corrupt: highest block referenced but no data.".into())),
+					None => bail!("Database corrupt: highest block referenced but no data."),
 				};
 
 				let best = &era.candidates[0];
@@ -583,27 +583,25 @@ impl HeaderChain {
 					} else {
 						let msg = format!("header of block #{} not found in DB ; database in an \
 											inconsistent state", h_num);
-						bail!(ErrorKind::Database(msg.into()));
+						bail!(msg);
 					};
 
 					let decoded = header.decode().expect("decoding db value failed");
 
 					let entry: Entry = {
 						let bytes = self.db.get(self.col, era_key(h_num).as_bytes())?
 							.ok_or_else(|| {
-								let msg = format!("entry for era #{} not found in DB ; database \
-													in an inconsistent state", h_num);
-								ErrorKind::Database(msg.into())
+								format!("entry for era #{} not found in DB ; database \
+										in an inconsistent state", h_num)
 							})?;
 						::rlp::decode(&bytes).expect("decoding db value failed")
 					};
 
 					let total_difficulty = entry.candidates.iter()
 						.find(|c| c.hash == decoded.hash())
 						.ok_or_else(|| {
-							let msg = "no candidate matching block found in DB ; database in an \
-										inconsistent state";
-							ErrorKind::Database(msg.into())
+							"no candidate matching block found in DB ; database in an \
+										inconsistent state"
 						})?
 						.total_difficulty;
 

ethcore/src/blockchain/blockchain.rs

@@ -17,8 +17,9 @@
 //! Blockchain database.
 
 use std::collections::{HashMap, HashSet};
+use std::path::Path;
 use std::sync::Arc;
-use std::mem;
+use std::{mem, io};
 use itertools::Itertools;
 use blooms_db;
 use heapsize::HeapSizeOf;
@@ -47,8 +48,6 @@ use engines::epoch::{Transition as EpochTransition, PendingTransition as Pending
 use rayon::prelude::*;
 use ansi_term::Colour;
 use kvdb::{DBTransaction, KeyValueDB};
-use error::Error;
-use std::path::Path;
 
 /// Database backing `BlockChain`.
 pub trait BlockChainDB: Send + Sync {
@@ -66,7 +65,7 @@ pub trait BlockChainDB: Send + Sync {
 /// predefined config.
 pub trait BlockChainDBHandler: Send + Sync {
 	/// Open the predefined key-value database.
-	fn open(&self, path: &Path) -> Result<Arc<BlockChainDB>, Error>;
+	fn open(&self, path: &Path) -> io::Result<Arc<BlockChainDB>>;
 }
 
 /// Interface for querying blocks by hash and by number.

ethcore/src/client/client.rs

@@ -718,7 +718,7 @@ impl Client {
 			state_db = spec.ensure_db_good(state_db, &factories)?;
 			let mut batch = DBTransaction::new();
 			state_db.journal_under(&mut batch, 0, &spec.genesis_header().hash())?;
-			db.key_value().write(batch).map_err(ClientError::Database)?;
+			db.key_value().write(batch)?;
 		}
 
 		let gb = spec.genesis_block();
@@ -821,7 +821,7 @@ impl Client {
 		}
 
 		// ensure buffered changes are flushed.
-		client.db.read().key_value().flush().map_err(ClientError::Database)?;
+		client.db.read().key_value().flush()?;
 		Ok(client)
 	}
 

ethcore/src/client/error.rs

@@ -16,16 +16,13 @@
 
 use std::fmt::{Display, Formatter, Error as FmtError};
 use util_error::UtilError;
-use kvdb;
 use trie::TrieError;
 
 /// Client configuration errors.
 #[derive(Debug)]
 pub enum Error {
 	/// TrieDB-related error.
 	Trie(TrieError),
-	/// Database error
-	Database(kvdb::Error),
 	/// Util error
 	Util(UtilError),
 }
@@ -53,7 +50,6 @@ impl Display for Error {
 		match *self {
 			Error::Trie(ref err) => write!(f, "{}", err),
 			Error::Util(ref err) => write!(f, "{}", err),
-			Error::Database(ref s) => write!(f, "Database error: {}", s),
 		}
 	}
 }

ethcore/src/client/evm_test_client.rs

@@ -35,8 +35,6 @@ pub enum EvmTestError {
 	Evm(vm::Error),
 	/// Initialization error.
 	ClientError(::error::Error),
-	/// Low-level database error.
-	Database(kvdb::Error),
 	/// Post-condition failure,
 	PostCondition(String),
 }
@@ -55,7 +53,6 @@ impl fmt::Display for EvmTestError {
 			Trie(ref err) => write!(fmt, "Trie: {}", err),
 			Evm(ref err) => write!(fmt, "EVM: {}", err),
 			ClientError(ref err) => write!(fmt, "{}", err),
-			Database(ref err) => write!(fmt, "DB: {}", err),
 			PostCondition(ref err) => write!(fmt, "{}", err),
 		}
 	}
@@ -135,7 +132,7 @@ impl<'a> EvmTestClient<'a> {
 		{
 			let mut batch = kvdb::DBTransaction::new();
 			state_db.journal_under(&mut batch, 0, &genesis.hash())?;
-			db.write(batch).map_err(EvmTestError::Database)?;
+			db.write(batch)?;
 		}
 
 		state::State::from_existing(

ethcore/src/error.rs

@@ -18,7 +18,6 @@
 
 use std::{fmt, error};
 use std::time::SystemTime;
-use kvdb;
 use ethereum_types::{H256, U256, Address, Bloom};
 use util_error::{self, UtilError};
 use snappy::InvalidInput;
@@ -237,11 +236,10 @@ error_chain! {
 	}
 
 	links {
-		Database(kvdb::Error, kvdb::ErrorKind) #[doc = "Database error."];
 		Util(UtilError, util_error::ErrorKind) #[doc = "Error concerning a utility"];
 		Import(ImportError, ImportErrorKind) #[doc = "Error concerning block import." ];
 	}
-		
+
 	foreign_links {
 		Io(IoError) #[doc = "Io create error"];
 		StdIo(::std::io::Error) #[doc = "Error concerning the Rust standard library's IO subsystem."];
@@ -271,14 +269,14 @@ error_chain! {
 		AccountProvider(err: AccountsError) {
 			description("Accounts Provider error")
 			display("Accounts Provider error {}", err)
-		} 
+		}
 
 		#[doc = "PoW hash is invalid or out of date."]
 		PowHashInvalid {
 			description("PoW hash is invalid or out of date.")
 			display("PoW hash is invalid or out of date.")
 		}
-	
+
 		#[doc = "The value of the nonce or mishash is invalid."]
 		PowInvalid {
 			description("The value of the nonce or mishash is invalid.")
@@ -311,10 +309,10 @@ impl From<ClientError> for Error {
 	}
 }
 
-impl From<AccountsError> for Error { 
-	fn from(err: AccountsError) -> Error { 
+impl From<AccountsError> for Error {
+	fn from(err: AccountsError) -> Error {
 		ErrorKind::AccountProvider(err).into()
-	} 
+	}
 }
 
 impl From<::rlp::DecoderError> for Error {

ethcore/src/test_helpers.rs

@@ -17,15 +17,15 @@
 //! Set of different helpers for client tests
 
 use std::path::Path;
-use std::fs;
+use std::sync::Arc;
+use std::{fs, io};
 use account_provider::AccountProvider;
 use ethereum_types::{H256, U256, Address};
 use block::{OpenBlock, Drain};
 use blockchain::{BlockChain, BlockChainDB, BlockChainDBHandler, Config as BlockChainConfig, ExtrasInsert};
 use bytes::Bytes;
 use client::{Client, ClientConfig, ChainInfo, ImportBlock, ChainNotify, ChainMessageType, PrepareOpenBlock};
 use ethkey::KeyPair;
-use error::Error;
 use evm::Factory as EvmFactory;
 use factory::Factories;
 use hash::keccak;
@@ -37,7 +37,6 @@ use rlp::{self, RlpStream};
 use spec::Spec;
 use state_db::StateDB;
 use state::*;
-use std::sync::Arc;
 use transaction::{Action, Transaction, SignedTransaction};
 use views::BlockView;
 use blooms_db;
@@ -327,7 +326,7 @@ pub fn restoration_db_handler(config: kvdb_rocksdb::DatabaseConfig) -> Box<Block
 	}
 
 	impl BlockChainDBHandler for RestorationDBHandler {
-		fn open(&self, db_path: &Path) -> Result<Arc<BlockChainDB>, Error> {
+		fn open(&self, db_path: &Path) -> io::Result<Arc<BlockChainDB>> {
 			let key_value = Arc::new(kvdb_rocksdb::Database::open(&self.config, &db_path.to_string_lossy())?);
 			let blooms_path = db_path.join("blooms");
 			let trace_blooms_path = db_path.join("trace_blooms");

local-store/src/lib.rs

@@ -56,16 +56,16 @@ const UPDATE_TIMEOUT: Duration = Duration::from_secs(15 * 60); // once every 15
 /// Errors which can occur while using the local data store.
 #[derive(Debug)]
 pub enum Error {
-	/// Database errors: these manifest as `String`s.
-	Database(kvdb::Error),
+	/// Io and database errors: these manifest as `String`s.
+	Io(::std::io::Error),
 	/// JSON errors.
 	Json(::serde_json::Error),
 }
 
 impl fmt::Display for Error {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		match *self {
-			Error::Database(ref val) => write!(f, "{}", val),
+			Error::Io(ref val) => write!(f, "{}", val),
 			Error::Json(ref err) => write!(f, "{}", err),
 		}
 	}
@@ -160,7 +160,7 @@ pub struct LocalDataStore<T: NodeInfo> {
 impl<T: NodeInfo> LocalDataStore<T> {
 	/// Attempt to read pending transactions out of the local store.
 	pub fn pending_transactions(&self) -> Result<Vec<PendingTransaction>, Error> {
-		if let Some(val) = self.db.get(self.col, LOCAL_TRANSACTIONS_KEY).map_err(Error::Database)? {
+		if let Some(val) = self.db.get(self.col, LOCAL_TRANSACTIONS_KEY).map_err(Error::Io)? {
 			let local_txs: Vec<_> = ::serde_json::from_slice::<Vec<TransactionEntry>>(&val)
 				.map_err(Error::Json)?
 				.into_iter()
@@ -200,7 +200,7 @@ impl<T: NodeInfo> LocalDataStore<T> {
 		let json_str = format!("{}", local_json);
 
 		batch.put_vec(self.col, LOCAL_TRANSACTIONS_KEY, json_str.into_bytes());
-		self.db.write(batch).map_err(Error::Database)
+		self.db.write(batch).map_err(Error::Io)
 	}
 }
 

parity/db/rocksdb/migration.rs

@@ -18,7 +18,7 @@ use std::fs;
 use std::io::{Read, Write, Error as IoError, ErrorKind};
 use std::path::{Path, PathBuf};
 use std::fmt::{Display, Formatter, Error as FmtError};
-use super::migration_rocksdb::{self, Manager as MigrationManager, Config as MigrationConfig, ChangeColumns};
+use super::migration_rocksdb::{Manager as MigrationManager, Config as MigrationConfig, ChangeColumns};
 use super::kvdb_rocksdb::{CompactionProfile, DatabaseConfig};
 use ethcore::client::DatabaseCompactionProfile;
 use ethcore::{self, db};
@@ -62,8 +62,6 @@ pub enum Error {
 	FutureDBVersion,
 	/// Migration is not possible.
 	MigrationImpossible,
-	/// Internal migration error.
-	Internal(migration_rocksdb::Error),
 	/// Blooms-db migration error.
 	BloomsDB(ethcore::error::Error),
 	/// Migration was completed succesfully,
@@ -77,7 +75,6 @@ impl Display for Error {
 			Error::UnknownDatabaseVersion => "Current database version cannot be read".into(),
 			Error::FutureDBVersion => "Database was created with newer client version. Upgrade your client or delete DB and resync.".into(),
 			Error::MigrationImpossible => format!("Database migration to version {} is not possible.", CURRENT_VERSION),
-			Error::Internal(ref err) => format!("{}", err),
 			Error::BloomsDB(ref err) => format!("blooms-db migration error: {}", err),
 			Error::Io(ref err) => format!("Unexpected io error on DB migration: {}.", err),
 		};
@@ -92,15 +89,6 @@ impl From<IoError> for Error {
 	}
 }
 
-impl From<migration_rocksdb::Error> for Error {
-	fn from(err: migration_rocksdb::Error) -> Self {
-		match err.into() {
-			migration_rocksdb::ErrorKind::Io(e) => Error::Io(e),
-			err => Error::Internal(err.into()),
-		}
-	}
-}
-
 /// Returns the version file path.
 fn version_file_path(path: &Path) -> PathBuf {
 	let mut file_path = path.to_owned();

parity/db/rocksdb/mod.rs

@@ -17,12 +17,11 @@
 extern crate kvdb_rocksdb;
 extern crate migration_rocksdb;
 
-use std::fs;
+use std::{io, fs};
 use std::sync::Arc;
 use std::path::Path;
 use blooms_db;
 use ethcore::{BlockChainDBHandler, BlockChainDB};
-use ethcore::error::Error;
 use ethcore::db::NUM_COLUMNS;
 use ethcore::client::{ClientConfig, DatabaseCompactionProfile};
 use kvdb::KeyValueDB;
@@ -76,7 +75,7 @@ pub fn restoration_db_handler(client_path: &Path, client_config: &ClientConfig)
 	}
 
 	impl BlockChainDBHandler for RestorationDBHandler {
-		fn open(&self, db_path: &Path) -> Result<Arc<BlockChainDB>, Error> {
+		fn open(&self, db_path: &Path) -> io::Result<Arc<BlockChainDB>> {
 			open_database(&db_path.to_string_lossy(), &self.config)
 		}
 	}
@@ -87,7 +86,7 @@ pub fn restoration_db_handler(client_path: &Path, client_config: &ClientConfig)
 }
 
 /// Open a new main DB.
-pub fn open_db(client_path: &str, cache_config: &CacheConfig, compaction: &DatabaseCompactionProfile, wal: bool) -> Result<Arc<BlockChainDB>, Error> {
+pub fn open_db(client_path: &str, cache_config: &CacheConfig, compaction: &DatabaseCompactionProfile, wal: bool) -> io::Result<Arc<BlockChainDB>> {
 	let path = Path::new(client_path);
 
 	let db_config = DatabaseConfig {
@@ -100,7 +99,7 @@ pub fn open_db(client_path: &str, cache_config: &CacheConfig, compaction: &Datab
 	open_database(client_path, &db_config)
 }
 
-pub fn open_database(client_path: &str, config: &DatabaseConfig) -> Result<Arc<BlockChainDB>, Error> {
+pub fn open_database(client_path: &str, config: &DatabaseConfig) -> io::Result<Arc<BlockChainDB>> {
 	let path = Path::new(client_path);
 
 	let blooms_path = path.join("blooms");