1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

// Copyright 2021-2022 Parity Technologies (UK) Ltd.
// This file is dual-licensed as Apache-2.0 or MIT.

use crate::column::ColId;
#[cfg(feature = "instrumentation")]
use std::sync::atomic::{AtomicUsize, Ordering};
use std::{fmt, io, sync::Arc};

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug)]
pub enum Error {
	Io(io::Error),
	Corruption(String),
	InvalidConfiguration(String),
	IncompatibleColumnConfig { id: ColId, reason: String },
	InvalidInput(String),
	InvalidValueData,
	Background(Arc<Error>),
	Locked(io::Error),
	Migration(String),
	Compression,
	DatabaseNotFound,
}

impl fmt::Display for Error {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		match self {
			Error::Io(e) => write!(f, "IO Error: {}", e),
			Error::Corruption(e) => write!(f, "Corruption: {}", e),
			Error::InvalidConfiguration(e) => write!(f, "Invalid configuration: {}", e),
			Error::IncompatibleColumnConfig { id, reason } =>
				write!(f, "Invalid column {} configuration : {}", id, reason),
			Error::InvalidInput(e) => write!(f, "Invalid input: {}", e),
			Error::InvalidValueData => write!(f, "Invalid data in value table"),
			Error::Background(e) => write!(f, "Background worker error: {}", e),
			Error::Locked(e) => write!(f, "Database file is in use. ({})", e),
			Error::Migration(e) => write!(f, "Migration error: {}", e),
			Error::Compression => write!(f, "Compression error"),
			Error::DatabaseNotFound => write!(f, "Database does not exist"),
		}
	}
}

impl std::error::Error for Error {
	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
		match self {
			Error::Io(e) => Some(e),
			Error::Background(e) => e.source(),
			Error::Locked(e) => Some(e),
			_ => None,
		}
	}
}

#[cfg(feature = "instrumentation")]
thread_local! {
	pub static IO_COUNTER_BEFORE_ERROR: AtomicUsize = AtomicUsize::new(usize::MAX);
}

#[cfg(feature = "instrumentation")]
pub fn set_number_of_allowed_io_operations(val: usize) {
	IO_COUNTER_BEFORE_ERROR.with(|v| v.store(val, Ordering::Relaxed));
}

#[cfg(feature = "instrumentation")]
macro_rules! try_io {
	($e:expr) => {{
		if crate::error::IO_COUNTER_BEFORE_ERROR.with(|value| {
			value
				.fetch_update(
					::std::sync::atomic::Ordering::SeqCst,
					::std::sync::atomic::Ordering::SeqCst,
					|v| Some(v.saturating_sub(1)),
				)
				.unwrap()
		}) == 0
		{
			Err(crate::error::Error::Io(::std::io::Error::new(
				::std::io::ErrorKind::Other,
				"Instrumented failure",
			)))?
		} else {
			$e.map_err(crate::error::Error::Io)?
		}
	}};
}

#[cfg(not(feature = "instrumentation"))]
macro_rules! try_io {
	($e:expr) => {{
		$e.map_err(crate::error::Error::Io)?
	}};
}

pub(crate) use try_io;