@@ -6,9 +6,12 @@ use std::{io, net::SocketAddr, ops::Deref, sync::Arc};
6
6
7
7
use iroh:: Endpoint ;
8
8
use irpc:: rpc:: { Handler , listen} ;
9
+ use n0_snafu:: SpanTrace ;
10
+ use nested_enum_utils:: common_fields;
9
11
use proto:: { Request , ShutdownRequest , SyncDbRequest } ;
10
12
use ref_cast:: RefCast ;
11
13
use serde:: { Deserialize , Serialize } ;
14
+ use snafu:: { Backtrace , IntoError , Snafu } ;
12
15
use tags:: Tags ;
13
16
14
17
pub mod blobs;
@@ -20,85 +23,123 @@ pub use crate::{store::util::Tag, util::temp_tag::TempTag};
20
23
21
24
pub ( crate ) type ApiClient = irpc:: Client < proto:: Command , proto:: Request , proto:: StoreService > ;
22
25
23
- #[ derive( Debug , thiserror:: Error ) ]
26
+ #[ common_fields( {
27
+ backtrace: Option <Backtrace >,
28
+ #[ snafu( implicit) ]
29
+ span_trace: SpanTrace ,
30
+ } ) ]
31
+ #[ allow( missing_docs) ]
32
+ #[ non_exhaustive]
33
+ #[ derive( Debug , Snafu ) ]
24
34
pub enum RequestError {
25
35
/// Request failed due to rpc error.
26
- #[ error ( "rpc error: {0}" ) ]
27
- Rpc ( # [ from ] irpc:: Error ) ,
36
+ #[ snafu ( display ( "rpc error: {source}" ) ) ]
37
+ Rpc { source : irpc:: Error } ,
28
38
/// Request failed due an actual error.
29
- #[ error ( "inner error: {0}" ) ]
30
- Inner ( # [ from ] Error ) ,
39
+ #[ snafu ( display ( "inner error: {source}" ) ) ]
40
+ Inner { source : Error } ,
31
41
}
32
42
33
- pub type RequestResult < T > = std:: result:: Result < T , RequestError > ;
34
-
35
- impl From < irpc:: channel:: SendError > for RequestError {
36
- fn from ( e : irpc:: channel:: SendError ) -> Self {
37
- Self :: Rpc ( e. into ( ) )
43
+ impl From < irpc:: Error > for RequestError {
44
+ fn from ( value : irpc:: Error ) -> Self {
45
+ RpcSnafu . into_error ( value)
38
46
}
39
47
}
40
48
41
- impl From < irpc :: channel :: RecvError > for RequestError {
42
- fn from ( e : irpc :: channel :: RecvError ) -> Self {
43
- Self :: Rpc ( e . into ( ) )
49
+ impl From < Error > for RequestError {
50
+ fn from ( value : Error ) -> Self {
51
+ InnerSnafu . into_error ( value )
44
52
}
45
53
}
46
54
47
- impl From < irpc :: RequestError > for RequestError {
48
- fn from ( e : irpc :: RequestError ) -> Self {
49
- Self :: Rpc ( e . into ( ) )
55
+ impl From < io :: Error > for RequestError {
56
+ fn from ( value : io :: Error ) -> Self {
57
+ InnerSnafu . into_error ( value . into ( ) )
50
58
}
51
59
}
52
60
53
- impl From < irpc:: rpc :: WriteError > for RequestError {
54
- fn from ( e : irpc:: rpc :: WriteError ) -> Self {
55
- Self :: Rpc ( e . into ( ) )
61
+ impl From < irpc:: channel :: RecvError > for RequestError {
62
+ fn from ( value : irpc:: channel :: RecvError ) -> Self {
63
+ RpcSnafu . into_error ( value . into ( ) )
56
64
}
57
65
}
58
66
59
- impl From < io:: Error > for RequestError {
60
- fn from ( e : io:: Error ) -> Self {
61
- Self :: Inner ( e. into ( ) )
62
- }
63
- }
67
+ pub type RequestResult < T > = std:: result:: Result < T , RequestError > ;
64
68
65
- #[ derive( Debug , thiserror:: Error ) ]
69
+ #[ common_fields( {
70
+ backtrace: Option <Backtrace >,
71
+ #[ snafu( implicit) ]
72
+ span_trace: SpanTrace ,
73
+ } ) ]
74
+ #[ allow( missing_docs) ]
75
+ #[ non_exhaustive]
76
+ #[ derive( Debug , Snafu ) ]
66
77
pub enum ExportBaoError {
67
- #[ error ( "send error: {0}" ) ]
68
- Send ( # [ from ] irpc:: channel:: SendError ) ,
69
- #[ error ( "recv error: {0}" ) ]
70
- Recv ( # [ from ] irpc:: channel:: RecvError ) ,
71
- #[ error ( "request error: {0}" ) ]
72
- Request ( # [ from ] irpc:: RequestError ) ,
73
- #[ error ( "io error: {0}" ) ]
74
- Io ( # [ from ] io:: Error ) ,
75
- #[ error ( "encode error: {0}" ) ]
76
- Inner ( # [ from ] bao_tree:: io:: EncodeError ) ,
78
+ #[ snafu ( display ( "send error: {source}" ) ) ]
79
+ Send { source : irpc:: channel:: SendError } ,
80
+ #[ snafu ( display ( "recv error: {source}" ) ) ]
81
+ Recv { source : irpc:: channel:: RecvError } ,
82
+ #[ snafu ( display ( "request error: {source}" ) ) ]
83
+ Request { source : irpc:: RequestError } ,
84
+ #[ snafu ( display ( "io error: {source}" ) ) ]
85
+ ExportBaoIo { source : io:: Error } ,
86
+ #[ snafu ( display ( "encode error: {source}" ) ) ]
87
+ ExportBaoInner { source : bao_tree:: io:: EncodeError } ,
77
88
}
78
89
79
90
impl From < ExportBaoError > for Error {
80
91
fn from ( e : ExportBaoError ) -> Self {
81
92
match e {
82
- ExportBaoError :: Send ( e ) => Self :: Io ( e . into ( ) ) ,
83
- ExportBaoError :: Recv ( e ) => Self :: Io ( e . into ( ) ) ,
84
- ExportBaoError :: Request ( e ) => Self :: Io ( e . into ( ) ) ,
85
- ExportBaoError :: Io ( e ) => Self :: Io ( e ) ,
86
- ExportBaoError :: Inner ( e ) => Self :: Io ( e . into ( ) ) ,
93
+ ExportBaoError :: Send { source , .. } => Self :: Io ( source . into ( ) ) ,
94
+ ExportBaoError :: Recv { source , .. } => Self :: Io ( source . into ( ) ) ,
95
+ ExportBaoError :: Request { source , .. } => Self :: Io ( source . into ( ) ) ,
96
+ ExportBaoError :: ExportBaoIo { source , .. } => Self :: Io ( source ) ,
97
+ ExportBaoError :: ExportBaoInner { source , .. } => Self :: Io ( source . into ( ) ) ,
87
98
}
88
99
}
89
100
}
90
101
91
102
impl From < irpc:: Error > for ExportBaoError {
92
103
fn from ( e : irpc:: Error ) -> Self {
93
104
match e {
94
- irpc:: Error :: Recv ( e) => Self :: Recv ( e) ,
95
- irpc:: Error :: Send ( e) => Self :: Send ( e) ,
96
- irpc:: Error :: Request ( e) => Self :: Request ( e) ,
97
- irpc:: Error :: Write ( e) => Self :: Io ( e. into ( ) ) ,
105
+ irpc:: Error :: Recv ( e) => RecvSnafu . into_error ( e) ,
106
+ irpc:: Error :: Send ( e) => SendSnafu . into_error ( e) ,
107
+ irpc:: Error :: Request ( e) => RequestSnafu . into_error ( e) ,
108
+ irpc:: Error :: Write ( e) => ExportBaoIoSnafu . into_error ( e. into ( ) ) ,
98
109
}
99
110
}
100
111
}
101
112
113
+ impl From < io:: Error > for ExportBaoError {
114
+ fn from ( value : io:: Error ) -> Self {
115
+ ExportBaoIoSnafu . into_error ( value)
116
+ }
117
+ }
118
+
119
+ impl From < irpc:: channel:: RecvError > for ExportBaoError {
120
+ fn from ( value : irpc:: channel:: RecvError ) -> Self {
121
+ RecvSnafu . into_error ( value)
122
+ }
123
+ }
124
+
125
+ impl From < irpc:: channel:: SendError > for ExportBaoError {
126
+ fn from ( value : irpc:: channel:: SendError ) -> Self {
127
+ SendSnafu . into_error ( value)
128
+ }
129
+ }
130
+
131
+ impl From < irpc:: RequestError > for ExportBaoError {
132
+ fn from ( value : irpc:: RequestError ) -> Self {
133
+ RequestSnafu . into_error ( value)
134
+ }
135
+ }
136
+
137
+ impl From < bao_tree:: io:: EncodeError > for ExportBaoError {
138
+ fn from ( value : bao_tree:: io:: EncodeError ) -> Self {
139
+ ExportBaoInnerSnafu . into_error ( value)
140
+ }
141
+ }
142
+
102
143
pub type ExportBaoResult < T > = std:: result:: Result < T , ExportBaoError > ;
103
144
104
145
#[ derive( Debug , derive_more:: Display , derive_more:: From , Serialize , Deserialize ) ]
@@ -132,8 +173,8 @@ impl From<irpc::Error> for Error {
132
173
impl From < RequestError > for Error {
133
174
fn from ( e : RequestError ) -> Self {
134
175
match e {
135
- RequestError :: Rpc ( e ) => Self :: Io ( e . into ( ) ) ,
136
- RequestError :: Inner ( e ) => e ,
176
+ RequestError :: Rpc { source , .. } => Self :: Io ( source . into ( ) ) ,
177
+ RequestError :: Inner { source , .. } => source ,
137
178
}
138
179
}
139
180
}
0 commit comments