/
error.go
210 lines (168 loc) · 5.78 KB
/
error.go
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
package services
import (
"fmt"
"github.com/fastone-open/go-storage/types"
)
type InternalError interface {
// IsInternalError SHOULD and SHOULD ONLY be implemented by error definitions in go-storage & go-service-*.
// We depends on the InternalError interface to distinguish our errors.
// There's no need for user code to implement or use this function and interface.
IsInternalError()
}
// NewErrorCode creates a new error code.
//
// Developers SHOULD use this function to define error codes (sentinel errors), instead of `NewErrorCode`
//
// Users SHOULD NOT call this function. Use defined error codes instead.
func NewErrorCode(text string) error {
return errorCode{text}
}
type errorCode struct {
s string
}
func (e errorCode) Error() string {
return e.s
}
// IsInternalError implements InternalError
func (e errorCode) IsInternalError() {}
var (
// ErrUnexpected means this is an unexpected error which go-storage can't handle
ErrUnexpected = NewErrorCode("unexpected")
// ErrCapabilityInsufficient means this service doesn't have this capability
ErrCapabilityInsufficient = NewErrorCode("capability insufficient")
// ErrRestrictionDissatisfied means this operation doesn't meat service's restriction.
ErrRestrictionDissatisfied = NewErrorCode("restriction dissatisfied")
// ErrObjectNotExist means the object to be operated is not exist.
ErrObjectNotExist = NewErrorCode("object not exist")
// ErrObjectModeInvalid means the provided object mode is invalid.
ErrObjectModeInvalid = NewErrorCode("object mode invalid")
// ErrPermissionDenied means this operation doesn't have enough permission.
ErrPermissionDenied = NewErrorCode("permission denied")
// ErrListModeInvalid means the provided list mode is invalid.
ErrListModeInvalid = NewErrorCode("list mode invalid")
// ErrServiceNotRegistered means this service is not registered.
ErrServiceNotRegistered = NewErrorCode("service not registered")
// ErrServiceInternal means this service has an internal error.
ErrServiceInternal = NewErrorCode("service internal")
// ErrRequestThrottled means there are too many requests.
ErrRequestThrottled = NewErrorCode("request throttled")
)
// InitError means this service init failed.
//
// Only returned in New
type InitError struct {
Op string
Type string
Err error
Pairs []types.Pair
}
func (e InitError) Error() string {
return fmt.Sprintf("%s %s: %v: %s", e.Type, e.Op, e.Pairs, e.Err.Error())
}
// Unwrap implements xerrors.Wrapper
func (e InitError) Unwrap() error {
return e.Err
}
// ServiceError represent errors related to service.
//
// Only returned in Servicer related operations
type ServiceError struct {
Op string
Err error
types.Servicer
Name string
}
func (e ServiceError) Error() string {
if e.Name == "" {
return fmt.Sprintf("%s: %s: %s", e.Op, e.Servicer, e.Err.Error())
}
return fmt.Sprintf("%s: %s, %s: %s", e.Op, e.Servicer, e.Name, e.Err.Error())
}
// Unwrap implements xerrors.Wrapper
func (e ServiceError) Unwrap() error {
return e.Err
}
// StorageError represent errors related to storage.
//
// Only returned in Storager related operations
type StorageError struct {
Op string
Err error
types.Storager
Path []string
}
func (e StorageError) Error() string {
if e.Path == nil {
return fmt.Sprintf("%s: %s: %s", e.Op, e.Storager, e.Err.Error())
}
return fmt.Sprintf("%s: %s, %s: %s", e.Op, e.Storager, e.Path, e.Err.Error())
}
// Unwrap implements xerrors.Wrapper
func (e StorageError) Unwrap() error {
return e.Err
}
// MetadataUnrecognizedError means this operation meets unrecognized metadata.
type MetadataUnrecognizedError struct {
Key string
Value interface{}
}
func (e MetadataUnrecognizedError) Error() string {
return fmt.Sprintf("metadata unrecognized, %s, %v: %s", e.Key, e.Value, ErrCapabilityInsufficient.Error())
}
// Unwrap implements xerrors.Wrapper
func (e MetadataUnrecognizedError) Unwrap() error {
return ErrCapabilityInsufficient
}
// IsInternalError implements InternalError
func (e MetadataUnrecognizedError) IsInternalError() {}
// PairUnsupportedError means this operation has unsupported pair.
type PairUnsupportedError struct {
Pair types.Pair
}
func (e PairUnsupportedError) Error() string {
return fmt.Sprintf("pair unsupported, %s: %s", e.Pair, ErrCapabilityInsufficient.Error())
}
// Unwrap implements xerrors.Wrapper
func (e PairUnsupportedError) Unwrap() error {
return ErrCapabilityInsufficient
}
// IsInternalError implements InternalError
func (e PairUnsupportedError) IsInternalError() {}
// PairRequiredError means this operation has required pair but missing.
type PairRequiredError struct {
Keys []string
}
func (e PairRequiredError) Error() string {
return fmt.Sprintf("pair required, %v: %s", e.Keys, ErrRestrictionDissatisfied.Error())
}
// Unwrap implements xerrors.Wrapper
func (e PairRequiredError) Unwrap() error {
return ErrRestrictionDissatisfied
}
// IsInternalError implements InternalError
func (e PairRequiredError) IsInternalError() {}
// ObjectModeInvalidError means the provided object mode is invalid.
type ObjectModeInvalidError struct {
Expected types.ObjectMode
Actual types.ObjectMode
}
func (e ObjectModeInvalidError) Error() string {
return fmt.Sprintf("object mode invalid, expected %v, actual %v", e.Expected, e.Actual)
}
func (e ObjectModeInvalidError) Unwrap() error {
return ErrObjectModeInvalid
}
// IsInternalError implements InternalError
func (e ObjectModeInvalidError) IsInternalError() {}
// ListModeInvalidError means the provided list mode is invalid.
type ListModeInvalidError struct {
Actual types.ListMode
}
func (e ListModeInvalidError) Error() string {
return fmt.Sprintf("list mode invalid, actual %v", e.Actual)
}
func (e ListModeInvalidError) Unwrap() error {
return ErrListModeInvalid
}
// IsInternalError implements InternalError
func (e ListModeInvalidError) IsInternalError() {}