Rename Error to ArchiveError

koushiro · koushiro · commit 047e0d0499dc · 2021-01-07T21:52:45.000+08:00
Signed-off-by: koushiro &lt;koushiro.cqx@gmail.com&gt;
diff --git a/substrate-archive-backend/src/frontend.rs b/substrate-archive-backend/src/frontend.rs
@@ -30,7 +30,7 @@ use sp_api::ConstructRuntimeApi;
 use sp_core::traits::SpawnNamed;
 use sp_runtime::traits::{BlakeTwo256, Block as BlockT};
 
-use substrate_archive_common::{Error as ArchiveError, ReadOnlyDB};
+use substrate_archive_common::{ArchiveError, ReadOnlyDB};
 
 pub use self::client::{Client, GetMetadata, GetRuntimeVersion};
 use crate::{read_only_backend::ReadOnlyBackend, RuntimeApiCollection};
diff --git a/substrate-archive-backend/src/frontend/client.rs b/substrate-archive-backend/src/frontend/client.rs
@@ -35,7 +35,7 @@ use sp_runtime::{
 	traits::{Block as BlockT, Header as HeaderT, One},
 };
 
-use substrate_archive_common::{Error, ReadOnlyDB, Result};
+use substrate_archive_common::{ArchiveError, ReadOnlyDB, Result};
 
 use crate::read_only_backend::{ReadOnlyBackend, TrieState};
 
@@ -78,7 +78,7 @@ where
 	}
 
 	pub fn runtime_version_at(&self, id: &BlockId<Block>) -> Result<RuntimeVersion> {
-		self.executor.runtime_version(id).map_err(Error::from)
+		self.executor.runtime_version(id).map_err(ArchiveError::from)
 	}
 
 	/// get the backend for this client instance
diff --git a/substrate-archive-backend/src/lib.rs b/substrate-archive-backend/src/lib.rs
@@ -32,9 +32,7 @@ use sp_runtime::traits::{BlakeTwo256, Block as BlockT};
 #[cfg(feature = "logging")]
 pub use substrate_archive_common::util::init_logger;
 
-use self::{
-	frontend::{GetMetadata, GetRuntimeVersion},
-};
+use self::frontend::{GetMetadata, GetRuntimeVersion};
 // re-exports
 pub use self::{
 	block_exec::BlockExecutor,
diff --git a/substrate-archive-backend/src/runtime_version_cache.rs b/substrate-archive-backend/src/runtime_version_cache.rs
@@ -33,7 +33,7 @@ use sp_state_machine::BasicExternalities;
 use sp_storage::well_known_keys;
 use sp_version::RuntimeVersion;
 
-use substrate_archive_common::{types::Block, util, Error, ReadOnlyDB, Result};
+use substrate_archive_common::{types::Block, util, ArchiveError, ReadOnlyDB, Result};
 
 use crate::read_only_backend::ReadOnlyBackend;
 
@@ -84,8 +84,10 @@ impl<B: BlockT, D: ReadOnlyDB + 'static> RuntimeVersionCache<B, D> {
 	pub fn get(&self, hash: B::Hash) -> Result<Option<RuntimeVersion>> {
 		// Getting code from the backend is the slowest part of this. Takes an average of
 		// 6ms
-		let code =
-			self.backend.storage(hash, well_known_keys::CODE).ok_or_else(|| Error::from("storage does not exist"))?;
+		let code = self
+			.backend
+			.storage(hash, well_known_keys::CODE)
+			.ok_or_else(|| ArchiveError::from("storage does not exist"))?;
 
 		let code_hash = util::make_hash(&code);
 		if self.versions.load().contains_key(&code_hash) {
@@ -95,7 +97,7 @@ impl<B: BlockT, D: ReadOnlyDB + 'static> RuntimeVersionCache<B, D> {
 			let mut ext: BasicExternalities = BasicExternalities::default();
 			ext.register_extension(CallInWasmExt::new(self.exec.clone()));
 			let v: RuntimeVersion = ext.execute_with(|| {
-				let ver = sp_io::misc::runtime_version(&code).ok_or(Error::WasmExecutionError)?;
+				let ver = sp_io::misc::runtime_version(&code).ok_or(ArchiveError::WasmExecutionError)?;
 				decode_version(ver.as_slice())
 			})?;
 			log::debug!("Registered New Runtime Version: {:?}", v);
@@ -141,15 +143,18 @@ impl<B: BlockT, D: ReadOnlyDB + 'static> RuntimeVersionCache<B, D> {
 		if blocks.is_empty() {
 			return Ok(());
 		} else if blocks.len() == 1 {
-			let version = self.get(blocks[0].block.header().hash())?.ok_or_else(|| Error::from("Version not found"))?;
+			let version =
+				self.get(blocks[0].block.header().hash())?.ok_or_else(|| ArchiveError::from("Version not found"))?;
 			versions.push(VersionRange::new(&blocks[0], &blocks[0], version));
 			return Ok(());
 		}
 
-		let first =
-			self.get(blocks.first().unwrap().block.header().hash())?.ok_or_else(|| Error::from("Version not found"))?;
-		let last =
-			self.get(blocks.last().unwrap().block.header().hash())?.ok_or_else(|| Error::from("Version not found"))?;
+		let first = self
+			.get(blocks.first().unwrap().block.header().hash())?
+			.ok_or_else(|| ArchiveError::from("Version not found"))?;
+		let last = self
+			.get(blocks.last().unwrap().block.header().hash())?
+			.ok_or_else(|| ArchiveError::from("Version not found"))?;
 
 		if first.spec_version != last.spec_version && blocks.len() > 2 {
 			let half = blocks.len() / 2;
diff --git a/substrate-archive-backend/src/util.rs b/substrate-archive-backend/src/util.rs
@@ -26,7 +26,7 @@ use sp_runtime::{
 	traits::{Block as BlockT, Header as HeaderT, UniqueSaturatedFrom, UniqueSaturatedInto, Zero},
 };
 
-use substrate_archive_common::{Error, ReadOnlyDB, Result};
+use substrate_archive_common::{ArchiveError, ReadOnlyDB, Result};
 
 pub type NumberIndexKey = [u8; 4];
 
@@ -82,7 +82,7 @@ pub fn read_header<Block: BlockT, D: ReadOnlyDB>(
 	match read_db(db, col_index, col, id)? {
 		Some(header) => match Block::Header::decode(&mut &header[..]) {
 			Ok(header) => Ok(Some(header)),
-			Err(_) => Err(Error::from("Error decoding header")),
+			Err(_) => Err(ArchiveError::from("Error decoding header")),
 		},
 		None => Ok(None),
 	}
@@ -115,7 +115,7 @@ where
 /// In the current database schema, this kind of key is only used for
 /// lookups into an index, NOT for storing header data or others
 pub fn number_index_key<N: TryInto<u32>>(n: N) -> Result<NumberIndexKey> {
-	let n = n.try_into().map_err(|_| Error::from("Block num cannot be converted to u32"))?;
+	let n = n.try_into().map_err(|_| ArchiveError::from("Block num cannot be converted to u32"))?;
 
 	Ok([(n >> 24) as u8, ((n >> 16) & 0xff) as u8, ((n >> 8) & 0xff) as u8, (n & 0xff) as u8])
 }
diff --git a/substrate-archive-common/src/error.rs b/substrate-archive-common/src/error.rs
@@ -16,11 +16,11 @@
 use std::{env, io};
 use thiserror::Error;
 
-pub type Result<T, E = Error> = std::result::Result<T, E>;
+pub type Result<T, E = ArchiveError> = std::result::Result<T, E>;
 
 /// Substrate Archive Error Enum
 #[derive(Error, Debug)]
-pub enum Error {
+pub enum ArchiveError {
 	#[error("Io Error")]
 	Io(#[from] io::Error),
 	#[error("environment variable for `DATABASE_URL` not found")]
@@ -67,34 +67,34 @@ pub enum Error {
 	Bincode(#[from] Box<bincode::ErrorKind>),
 }
 
-impl From<&str> for Error {
-	fn from(e: &str) -> Error {
-		Error::Msg(e.to_string())
+impl From<&str> for ArchiveError {
+	fn from(e: &str) -> ArchiveError {
+		ArchiveError::Msg(e.to_string())
 	}
 }
 
-impl From<String> for Error {
-	fn from(e: String) -> Error {
-		Error::Msg(e)
+impl From<String> for ArchiveError {
+	fn from(e: String) -> ArchiveError {
+		ArchiveError::Msg(e)
 	}
 }
 
 // this conversion is required for our Error type to be
 // Send + Sync
-impl From<sp_blockchain::Error> for Error {
-	fn from(e: sp_blockchain::Error) -> Error {
-		Error::Blockchain(e.to_string())
+impl From<sp_blockchain::Error> for ArchiveError {
+	fn from(e: sp_blockchain::Error) -> ArchiveError {
+		ArchiveError::Blockchain(e.to_string())
 	}
 }
 
-impl From<xtra::Disconnected> for Error {
-	fn from(_: xtra::Disconnected) -> Error {
-		Error::Disconnected
+impl From<xtra::Disconnected> for ArchiveError {
+	fn from(_: xtra::Disconnected) -> ArchiveError {
+		ArchiveError::Disconnected
 	}
 }
 
-impl<T> From<flume::SendError<T>> for Error {
-	fn from(_: flume::SendError<T>) -> Error {
-		Error::Channel
+impl<T> From<flume::SendError<T>> for ArchiveError {
+	fn from(_: flume::SendError<T>) -> ArchiveError {
+		ArchiveError::Channel
 	}
 }
diff --git a/substrate-archive-common/src/lib.rs b/substrate-archive-common/src/lib.rs
@@ -22,4 +22,4 @@ pub mod types;
 pub mod util;
 
 pub use self::database::{KeyValuePair, ReadOnlyDB, NUM_COLUMNS};
-pub use self::error::{Error, Result};
+pub use self::error::{ArchiveError, Result};
diff --git a/substrate-archive-common/src/util.rs b/substrate-archive-common/src/util.rs
@@ -23,7 +23,7 @@ use std::path::{Path, PathBuf};
 #[cfg(feature = "logging")]
 use fern::colors::{Color, ColoredLevelConfig};
 
-use crate::error::Error as ArchiveError;
+use crate::error::ArchiveError;
 
 #[cfg(feature = "logging")]
 pub fn init_logger(std: log::LevelFilter, file: log::LevelFilter) -> Result<(), ArchiveError> {
diff --git a/substrate-archive/src/actors/workers/blocks.rs b/substrate-archive/src/actors/workers/blocks.rs
@@ -25,7 +25,7 @@ use substrate_archive_backend::{ReadOnlyBackend, RuntimeVersionCache};
 use substrate_archive_common::{
 	msg,
 	types::{BatchBlock, Block},
-	Error, ReadOnlyDB, Result,
+	ArchiveError, ReadOnlyDB, Result,
 };
 
 use crate::{
@@ -200,7 +200,7 @@ where
 	async fn handle(&mut self, _: ReIndex, ctx: &mut Context<Self>) {
 		match self.re_index().await {
 			// stop if disconnected from the metadata actor
-			Err(Error::Disconnected) => ctx.stop(),
+			Err(ArchiveError::Disconnected) => ctx.stop(),
 			Ok(()) => {}
 			Err(e) => log::error!("{}", e.to_string()),
 		}
diff --git a/substrate-archive/src/lib.rs b/substrate-archive/src/lib.rs
@@ -38,7 +38,7 @@ pub use substrate_archive_common::util::init_logger;
 pub use sc_executor::native_executor_instance;
 pub use sp_blockchain::Error as BlockchainError;
 pub use sp_runtime::MultiSignature;
-pub use substrate_archive_common::Error;
+pub use substrate_archive_common::ArchiveError;
 pub mod chain_traits {
 	//! Traits defining functions on the client needed for indexing
 	pub use sc_client_api::client::BlockBackend;
diff --git a/substrate-archive/src/sql_block_builder.rs b/substrate-archive/src/sql_block_builder.rs
@@ -20,13 +20,13 @@
 
 use std::marker::PhantomData;
 
-use codec::{Decode, Encode};
+use codec::{Decode, Encode, Error as DecodeError};
 use sp_runtime::{
 	generic::SignedBlock,
 	traits::{Block as BlockT, DigestFor, Header as HeaderT},
 };
 
-use substrate_archive_common::{models::BlockModel, types, Error};
+use substrate_archive_common::{models::BlockModel, types};
 
 struct GenericParts<B: BlockT>(
 	<B::Header as HeaderT>::Hash,
@@ -40,7 +40,7 @@ pub struct BlockBuilder<B: BlockT> {
 
 impl<'a, B: BlockT> BlockBuilder<B> {
 	/// With a vector of BlockModel
-	pub fn with_vec(blocks: Vec<BlockModel>) -> Result<Vec<types::Block<B>>, Error> {
+	pub fn with_vec(blocks: Vec<BlockModel>) -> Result<Vec<types::Block<B>>, DecodeError> {
 		blocks
 			.into_iter()
 			.map(|b| {
@@ -51,7 +51,7 @@ impl<'a, B: BlockT> BlockBuilder<B> {
 			.collect()
 	}
 
-	pub fn with_single(block: BlockModel) -> Result<(B, u32), Error> {
+	pub fn with_single(block: BlockModel) -> Result<(B, u32), DecodeError> {
 		let digest: DigestFor<B> = Decode::decode(&mut block.digest.as_slice())?;
 		let GenericParts(parent_hash, state_root, extrinsics_root) = Self::generic_parts_from(
 			block.parent_hash.as_slice(),
@@ -70,7 +70,7 @@ impl<'a, B: BlockT> BlockBuilder<B> {
 		mut parent_hash: &[u8],
 		mut state_root: &[u8],
 		mut extrinsics_root: &[u8],
-	) -> Result<GenericParts<B>, Error> {
+	) -> Result<GenericParts<B>, DecodeError> {
 		Ok(GenericParts(
 			Decode::decode(&mut parent_hash)?,
 			Decode::decode(&mut state_root)?,

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ use sp_runtime::{`
`35`	`35`	`traits::{Block as BlockT, Header as HeaderT, One},`
`36`	`36`	`};`
`37`	`37`
`38`		`-use substrate_archive_common::{Error, ReadOnlyDB, Result};`
	`38`	`+use substrate_archive_common::{ArchiveError, ReadOnlyDB, Result};`
`39`	`39`
`40`	`40`	`use crate::read_only_backend::{ReadOnlyBackend, TrieState};`
`41`	`41`
`@@ -78,7 +78,7 @@ where`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`pub fn runtime_version_at(&self, id: &BlockId<Block>) -> Result<RuntimeVersion> {`
`81`		`- self.executor.runtime_version(id).map_err(Error::from)`
	`81`	`+ self.executor.runtime_version(id).map_err(ArchiveError::from)`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`/// get the backend for this client instance`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,11 @@`
`16`	`16`	`use std::{env, io};`
`17`	`17`	`use thiserror::Error;`
`18`	`18`
`19`		`-pub type Result<T, E = Error> = std::result::Result<T, E>;`
	`19`	`+pub type Result<T, E = ArchiveError> = std::result::Result<T, E>;`
`20`	`20`
`21`	`21`	`/// Substrate Archive Error Enum`
`22`	`22`	`#[derive(Error, Debug)]`
`23`		`-pub enum Error {`
	`23`	`+pub enum ArchiveError {`
`24`	`24`	`#[error("Io Error")]`
`25`	`25`	`Io(#[from] io::Error),`
`26`	`26`	#[error("environment variable for `DATABASE_URL` not found")]
`@@ -67,34 +67,34 @@ pub enum Error {`
`67`	`67`	`Bincode(#[from] Box<bincode::ErrorKind>),`
`68`	`68`	`}`
`69`	`69`
`70`		`-impl From<&str> for Error {`
`71`		`- fn from(e: &str) -> Error {`
`72`		`- Error::Msg(e.to_string())`
	`70`	`+impl From<&str> for ArchiveError {`
	`71`	`+ fn from(e: &str) -> ArchiveError {`
	`72`	`+ ArchiveError::Msg(e.to_string())`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
`76`		`-impl From<String> for Error {`
`77`		`- fn from(e: String) -> Error {`
`78`		`- Error::Msg(e)`
	`76`	`+impl From<String> for ArchiveError {`
	`77`	`+ fn from(e: String) -> ArchiveError {`
	`78`	`+ ArchiveError::Msg(e)`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`// this conversion is required for our Error type to be`
`83`	`83`	`// Send + Sync`
`84`		`-impl From<sp_blockchain::Error> for Error {`
`85`		`- fn from(e: sp_blockchain::Error) -> Error {`
`86`		`- Error::Blockchain(e.to_string())`
	`84`	`+impl From<sp_blockchain::Error> for ArchiveError {`
	`85`	`+ fn from(e: sp_blockchain::Error) -> ArchiveError {`
	`86`	`+ ArchiveError::Blockchain(e.to_string())`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`90`		`-impl From<xtra::Disconnected> for Error {`
`91`		`- fn from(_: xtra::Disconnected) -> Error {`
`92`		`- Error::Disconnected`
	`90`	`+impl From<xtra::Disconnected> for ArchiveError {`
	`91`	`+ fn from(_: xtra::Disconnected) -> ArchiveError {`
	`92`	`+ ArchiveError::Disconnected`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`96`		`-impl<T> From<flume::SendError<T>> for Error {`
`97`		`- fn from(_: flume::SendError<T>) -> Error {`
`98`		`- Error::Channel`
	`96`	`+impl<T> From<flume::SendError<T>> for ArchiveError {`
	`97`	`+ fn from(_: flume::SendError<T>) -> ArchiveError {`
	`98`	`+ ArchiveError::Channel`
`99`	`99`	`}`
`100`	`100`	`}`