forked from p9c/pod-archive
-
Notifications
You must be signed in to change notification settings - Fork 0
/
error.go
147 lines (139 loc) · 6.01 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
package database
import "fmt"
// ErrorCode identifies a kind of error.
type ErrorCode int
// These constants are used to identify a specific database DBError.
const (
// ErrDbTypeRegistered indicates two different database drivers attempt to
// register with the name database type.
ErrDbTypeRegistered ErrorCode = iota
// ErrDbUnknownType indicates there is no driver registered for the specified
// database type.
ErrDbUnknownType
// ErrDbDoesNotExist indicates open is called for a database that does not
// exist.
ErrDbDoesNotExist
// ErrDbExists indicates create is called for a database that already exists.
ErrDbExists
// ErrDbNotOpen indicates a database instance is accessed before it is opened
// or after it is closed.
ErrDbNotOpen
// ErrDbAlreadyOpen indicates open was called on a database that is already
// open.
ErrDbAlreadyOpen
// ErrInvalid indicates the specified database is not valid.
ErrInvalid
// ErrCorruption indicates a checksum failure occurred which invariably means
// the database is corrupt.
ErrCorruption
// ErrTxClosed indicates an attempt was made to commit or rollback a
// transaction that has already had one of those operations performed.
ErrTxClosed
// ErrTxNotWritable indicates an operation that requires write access to the
// database was attempted against a read-only transaction.
ErrTxNotWritable
// ErrBucketNotFound indicates an attempt to access a bucket that has not
// been created yet.
ErrBucketNotFound
// ErrBucketExists indicates an attempt to create a bucket that already
// exists.
ErrBucketExists
// ErrBucketNameRequired indicates an attempt to create a bucket with a blank
// name.
ErrBucketNameRequired
// ErrKeyRequired indicates at attempt to insert a zero-length key.
ErrKeyRequired
// ErrKeyTooLarge indicates an attmempt to insert a key that is larger than
// the max allowed key size. The max key size depends on the specific backend
// driver being used. As a general rule, key sizes should be relatively, so
// this should rarely be an issue.
ErrKeyTooLarge
// ErrValueTooLarge indicates an attmpt to insert a value that is larger than
// max allowed value size. The max key size depends on the specific backend
// driver being used.
ErrValueTooLarge
// ErrIncompatibleValue indicates the value in question is invalid for the
// specific requested operation. For example, trying create or delete a
// bucket with an existing non-bucket key, attempting to create or delete a
// non-bucket key with an existing bucket key, or trying to delete a value
// via a cursor when it points to a nested bucket.
ErrIncompatibleValue
// ErrBlockNotFound indicates a block with the provided hash does not exist
// in the database.
ErrBlockNotFound
// ErrBlockExists indicates a block with the provided hash already exists in
// the database.
ErrBlockExists
// ErrBlockRegionInvalid indicates a region that exceeds the bounds of the
// specified block was requested. When the hash provided by the region does
// not correspond to an existing block, the error will be ErrBlockNotFound
// instead.
ErrBlockRegionInvalid
// ErrDriverSpecific indicates the Err field is a driver-specific error. This
// provides a mechanism for drivers to plug-in their own custom errors for
// any situations which aren't already covered by the error codes provided by
// this package.
ErrDriverSpecific
// numErrorCodes is the maximum error code number used in tests.
numErrorCodes
)
// Map of ErrorCode values back to their constant names for pretty printing.
var errorCodeStrings = map[ErrorCode]string{
ErrDbTypeRegistered: "ErrDbTypeRegistered",
ErrDbUnknownType: "ErrDbUnknownType",
ErrDbDoesNotExist: "ErrDbDoesNotExist",
ErrDbExists: "ErrDbExists",
ErrDbNotOpen: "ErrDbNotOpen",
ErrDbAlreadyOpen: "ErrDbAlreadyOpen",
ErrInvalid: "ErrInvalid",
ErrCorruption: "ErrCorruption",
ErrTxClosed: "ErrTxClosed",
ErrTxNotWritable: "ErrTxNotWritable",
ErrBucketNotFound: "ErrBucketNotFound",
ErrBucketExists: "ErrBucketExists",
ErrBucketNameRequired: "ErrBucketNameRequired",
ErrKeyRequired: "ErrKeyRequired",
ErrKeyTooLarge: "ErrKeyTooLarge",
ErrValueTooLarge: "ErrValueTooLarge",
ErrIncompatibleValue: "ErrIncompatibleValue",
ErrBlockNotFound: "ErrBlockNotFound",
ErrBlockExists: "ErrBlockExists",
ErrBlockRegionInvalid: "ErrBlockRegionInvalid",
ErrDriverSpecific: "ErrDriverSpecific",
}
// String returns the ErrorCode as a human-readable name.
func (e ErrorCode) String() string {
if s := errorCodeStrings[e]; s != "" {
return s
}
return fmt.Sprintf("Unknown ErrorCode (%d)", int(e))
}
// DBError provides a single type for errors that can happen during database
// operation. It is used to indicate several types of failures including errors
// with caller requests such as specifying invalid block regions or attempting
// to access data against closed database transactions, driver errors, errors
// retrieving data, and errors communicating with database servers.
//
// The caller can use type assertions to determine if an error is an DBError and
// access the ErrorCode field to ascertain the specific reason for the failure.
//
// The ErrDriverSpecific error code will also have the Err field set with the
// underlying error. Depending on the backend driver, the Err field might be set
// to the underlying error for other error codes as well.
type DBError struct {
ErrorCode ErrorCode // Describes the kind of error
Description string // Human readable description of the issue
Err error // Underlying error
}
// DBError satisfies the error interface and prints human-readable errors.
func (e DBError) Error() string {
if e.Err != nil {
return e.Description + ": " + e.Err.Error()
}
return e.Description
}
// makeError creates an DBError given a set of arguments. The error code must be
// one of the error codes provided by this package.
func makeError(c ErrorCode, desc string, err error) DBError {
return DBError{ErrorCode: c, Description: desc, Err: err}
}