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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
use std::io::Error as IoError;
use std::{error, result};
use engine_traits::Error as EngineTraitError;
use kvproto::backup::Error as ErrorPb;
use kvproto::errorpb::{Error as RegionError, ServerIsBusy};
use kvproto::kvrpcpb::KeyError;
use thiserror::Error;
use tikv::storage::kv::{Error as EngineError, ErrorInner as EngineErrorInner};
use tikv::storage::mvcc::{Error as MvccError, ErrorInner as MvccErrorInner};
use tikv::storage::txn::{Error as TxnError, ErrorInner as TxnErrorInner};
use crate::metrics::*;
impl From<Error> for ErrorPb {
fn from(e: Error) -> ErrorPb {
let mut err = ErrorPb::default();
match e {
Error::ClusterID { current, request } => {
BACKUP_RANGE_ERROR_VEC
.with_label_values(&["cluster_mismatch"])
.inc();
err.mut_cluster_id_error().set_current(current);
err.mut_cluster_id_error().set_request(request);
}
Error::Engine(EngineError(box EngineErrorInner::Request(e)))
| Error::Txn(TxnError(box TxnErrorInner::Engine(EngineError(
box EngineErrorInner::Request(e),
))))
| Error::Txn(TxnError(box TxnErrorInner::Mvcc(MvccError(
box MvccErrorInner::Engine(EngineError(box EngineErrorInner::Request(e))),
)))) => {
if e.has_not_leader() {
BACKUP_RANGE_ERROR_VEC
.with_label_values(&["not_leader"])
.inc();
} else if e.has_region_not_found() {
BACKUP_RANGE_ERROR_VEC
.with_label_values(&["region_not_found"])
.inc();
} else if e.has_key_not_in_region() {
BACKUP_RANGE_ERROR_VEC
.with_label_values(&["key_not_in_region"])
.inc();
} else if e.has_epoch_not_match() {
BACKUP_RANGE_ERROR_VEC
.with_label_values(&["epoch_not_match"])
.inc();
} else if e.has_server_is_busy() {
BACKUP_RANGE_ERROR_VEC
.with_label_values(&["server_is_busy"])
.inc();
} else if e.has_stale_command() {
BACKUP_RANGE_ERROR_VEC
.with_label_values(&["stale_command"])
.inc();
} else if e.has_store_not_match() {
BACKUP_RANGE_ERROR_VEC
.with_label_values(&["store_not_match"])
.inc();
}
err.set_region_error(e);
}
Error::Txn(TxnError(box TxnErrorInner::Mvcc(MvccError(
box MvccErrorInner::KeyIsLocked(info),
)))) => {
BACKUP_RANGE_ERROR_VEC
.with_label_values(&["key_is_locked"])
.inc();
let mut e = KeyError::default();
e.set_locked(info);
err.set_kv_error(e);
}
timeout @ Error::Engine(EngineError(box EngineErrorInner::Timeout(_))) => {
BACKUP_RANGE_ERROR_VEC.with_label_values(&["timeout"]).inc();
let mut busy = ServerIsBusy::default();
let reason = format!("{}", timeout);
busy.set_reason(reason.clone());
let mut e = RegionError::default();
e.set_message(reason);
e.set_server_is_busy(busy);
err.set_region_error(e);
}
other => {
BACKUP_RANGE_ERROR_VEC.with_label_values(&["other"]).inc();
err.set_msg(format!("{:?}", other));
}
}
err
}
}
#[derive(Debug, Error)]
pub enum Error {
#[error("Other error {0}")]
Other(#[from] Box<dyn error::Error + Sync + Send>),
#[error("RocksDB error {0}")]
Rocks(String),
#[error("IO error {0}")]
Io(#[from] IoError),
#[error("Engine error {0}")]
Engine(#[from] EngineError),
#[error("Engine error {0}")]
EngineTrait(#[from] EngineTraitError),
#[error("Transaction error {0}")]
Txn(#[from] TxnError),
#[error("ClusterID error current {current}, request {request}")]
ClusterID { current: u64, request: u64 },
#[error("Invalid cf {cf}")]
InvalidCf { cf: String },
}
macro_rules! impl_from {
($($inner:ty => $container:ident,)+) => {
$(
impl From<$inner> for Error {
fn from(inr: $inner) -> Error {
Error::$container(inr)
}
}
)+
};
}
impl_from! {
String => Rocks,
}
pub type Result<T> = result::Result<T, Error>;