/
errors.go
168 lines (136 loc) · 3.18 KB
/
errors.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
package oss
import (
"encoding/xml"
"fmt"
"strings"
"time"
)
type ServiceError struct {
XMLName xml.Name `xml:"Error"`
Code string `xml:"Code"`
Message string `xml:"Message"`
RequestID string `xml:"RequestId"`
EC string `xml:"EC"`
StatusCode int
Snapshot []byte
Timestamp time.Time
RequestTarget string
}
func (e *ServiceError) Error() string {
return fmt.Sprintf(
`Error returned by Service.
Http Status Code: %d.
Error Code: %s.
Request Id: %s.
Message: %s.
EC: %s.
Timestamp: %s.
Request Endpoint: %s.`,
e.StatusCode, e.Code, e.RequestID, e.Message, e.EC, e.Timestamp, e.RequestTarget)
}
func (e *ServiceError) HttpStatusCode() int {
return e.StatusCode
}
func (e *ServiceError) ErrorCode() string {
return e.Code
}
type ClientError struct {
Code string
Message string
Err error
}
func (e *ClientError) Unwrap() error { return e.Err }
func (e *ClientError) Error() string {
return fmt.Sprintf("client error: %v, %v", e.Message, e.Err)
}
type OperationError struct {
name string
err error
}
func (e *OperationError) Operation() string { return e.name }
func (e *OperationError) Unwrap() error { return e.err }
func (e *OperationError) Error() string {
return fmt.Sprintf("operation error %s: %v", e.name, e.err)
}
type DeserializationError struct {
Err error
Snapshot []byte
}
func (e *DeserializationError) Error() string {
const msg = "deserialization failed"
if e.Err == nil {
return msg
}
return fmt.Sprintf("%s, %v", msg, e.Err)
}
func (e *DeserializationError) Unwrap() error { return e.Err }
type SerializationError struct {
Err error
}
func (e *SerializationError) Error() string {
const msg = "serialization failed"
if e.Err == nil {
return msg
}
return fmt.Sprintf("%s: %v", msg, e.Err)
}
func (e *SerializationError) Unwrap() error { return e.Err }
type CanceledError struct {
Err error
}
func (*CanceledError) CanceledError() bool { return true }
func (e *CanceledError) Unwrap() error {
return e.Err
}
func (e *CanceledError) Error() string {
return fmt.Sprintf("canceled, %v", e.Err)
}
type InvalidParamError interface {
error
Field() string
SetContext(string)
}
type invalidParamError struct {
context string
field string
reason string
}
func (e invalidParamError) Error() string {
return fmt.Sprintf("%s, %s.", e.reason, e.Field())
}
func (e invalidParamError) Field() string {
sb := &strings.Builder{}
sb.WriteString(e.context)
if sb.Len() > 0 {
sb.WriteRune('.')
}
sb.WriteString(e.field)
return sb.String()
}
func (e *invalidParamError) SetContext(ctx string) {
e.context = ctx
}
func NewErrParamRequired(field string) InvalidParamError {
return &invalidParamError{
field: field,
reason: fmt.Sprintf("missing required field"),
}
}
func NewErrParamInvalid(field string) InvalidParamError {
return &invalidParamError{
field: field,
reason: fmt.Sprintf("invalid field"),
}
}
func NewErrParamNull(field string) InvalidParamError {
return &invalidParamError{
field: field,
reason: fmt.Sprintf("null field"),
}
}
func NewErrParamTypeNotSupport(field string) InvalidParamError {
return &invalidParamError{
field: field,
reason: fmt.Sprintf("type not support"),
}
}