1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-23 02:26:49 -05:00
v2fly/common/errors/errors.go

208 lines
3.7 KiB
Go
Raw Normal View History

2017-02-08 04:01:22 -05:00
// Package errors is a drop-in replacement for Golang lib 'errors'.
2018-04-03 16:34:59 -04:00
package errors // import "v2ray.com/core/common/errors"
2016-12-04 03:10:47 -05:00
import (
2018-02-22 09:26:00 -05:00
"context"
2018-04-13 05:25:41 -04:00
"os"
2017-04-06 09:13:09 -04:00
"strings"
2016-12-15 05:05:32 -05:00
2017-12-10 17:33:23 -05:00
"v2ray.com/core/common/log"
2016-12-04 03:10:47 -05:00
"v2ray.com/core/common/serial"
2018-02-22 09:26:00 -05:00
"v2ray.com/core/common/session"
2016-12-04 03:10:47 -05:00
)
2017-02-08 04:01:22 -05:00
type hasInnerError interface {
// Inner returns the underlying error of this one.
2016-12-04 03:10:47 -05:00
Inner() error
}
2017-04-06 09:13:09 -04:00
type hasSeverity interface {
2017-12-10 17:33:23 -05:00
Severity() log.Severity
2017-02-21 17:14:07 -05:00
}
2018-02-22 09:26:00 -05:00
type hasContext interface {
Context() context.Context
}
2017-02-08 04:01:22 -05:00
// Error is an error object with underlying error.
2016-12-04 03:10:47 -05:00
type Error struct {
2017-04-08 15:18:13 -04:00
message []interface{}
2017-04-06 09:13:09 -04:00
inner error
2017-12-10 17:33:23 -05:00
severity log.Severity
2017-04-06 09:13:09 -04:00
path []string
2018-02-22 09:26:00 -05:00
ctx context.Context
2016-12-04 03:10:47 -05:00
}
2017-02-08 04:01:22 -05:00
// Error implements error.Error().
2017-04-06 09:13:09 -04:00
func (v *Error) Error() string {
2017-04-08 18:31:06 -04:00
msg := serial.Concat(v.message...)
2017-02-23 19:05:02 -05:00
if v.inner != nil {
msg += " > " + v.inner.Error()
}
2017-04-06 09:13:09 -04:00
if len(v.path) > 0 {
msg = strings.Join(v.path, "|") + ": " + msg
}
2017-02-23 19:05:02 -05:00
return msg
2016-12-04 03:10:47 -05:00
}
2017-02-08 04:01:22 -05:00
// Inner implements hasInnerError.Inner()
2017-04-06 09:13:09 -04:00
func (v *Error) Inner() error {
2016-12-04 03:10:47 -05:00
if v.inner == nil {
return nil
}
return v.inner
}
2017-04-06 09:13:09 -04:00
func (v *Error) Base(err error) *Error {
v.inner = err
return v
2017-02-21 17:14:07 -05:00
}
2018-02-22 09:26:00 -05:00
func (v *Error) WithContext(ctx context.Context) *Error {
v.ctx = ctx
return v
}
2018-05-25 17:20:24 -04:00
// Context returns the context that associated with the Error.
2018-02-22 09:26:00 -05:00
func (v *Error) Context() context.Context {
if v.ctx != nil {
return v.ctx
}
if v.inner == nil {
return nil
}
if c, ok := v.inner.(hasContext); ok {
return c.Context()
}
return nil
}
2017-12-10 17:33:23 -05:00
func (v *Error) atSeverity(s log.Severity) *Error {
2017-04-06 09:13:09 -04:00
v.severity = s
return v
}
2017-12-10 17:33:23 -05:00
func (v *Error) Severity() log.Severity {
2017-04-06 09:13:09 -04:00
if v.inner == nil {
return v.severity
}
2017-04-06 09:13:09 -04:00
if s, ok := v.inner.(hasSeverity); ok {
as := s.Severity()
2017-12-10 17:33:23 -05:00
if as < v.severity {
2017-04-06 09:13:09 -04:00
return as
}
}
return v.severity
}
2017-04-10 08:56:08 -04:00
// AtDebug sets the severity to debug.
2017-04-06 09:13:09 -04:00
func (v *Error) AtDebug() *Error {
2017-12-10 17:33:23 -05:00
return v.atSeverity(log.Severity_Debug)
}
2017-04-10 08:56:08 -04:00
// AtInfo sets the severity to info.
2017-04-06 09:13:09 -04:00
func (v *Error) AtInfo() *Error {
2017-12-10 17:33:23 -05:00
return v.atSeverity(log.Severity_Info)
2017-04-06 09:13:09 -04:00
}
2017-04-10 08:56:08 -04:00
// AtWarning sets the severity to warning.
2017-04-06 09:13:09 -04:00
func (v *Error) AtWarning() *Error {
2017-12-10 17:33:23 -05:00
return v.atSeverity(log.Severity_Warning)
2017-04-06 09:13:09 -04:00
}
2017-04-10 08:56:08 -04:00
// AtError sets the severity to error.
2017-04-06 09:13:09 -04:00
func (v *Error) AtError() *Error {
2017-12-10 17:33:23 -05:00
return v.atSeverity(log.Severity_Error)
2016-12-04 03:10:47 -05:00
}
2017-04-10 08:56:08 -04:00
// Path sets the path to the location where this error happens.
2017-04-06 09:13:09 -04:00
func (v *Error) Path(path ...string) *Error {
v.path = path
return v
}
2017-12-19 15:28:12 -05:00
// String returns the string representation of this error.
func (v *Error) String() string {
return v.Error()
}
// WriteToLog writes current error into log.
func (v *Error) WriteToLog() {
2018-02-22 09:26:00 -05:00
ctx := v.Context()
var sid session.ID
if ctx != nil {
sid = session.IDFromContext(ctx)
}
var c interface{} = v
if sid > 0 {
c = sessionLog{
id: sid,
content: v,
}
}
2017-12-19 15:28:12 -05:00
log.Record(&log.GeneralMessage{
Severity: GetSeverity(v),
2018-02-22 09:26:00 -05:00
Content: c,
2017-12-19 15:28:12 -05:00
})
}
2017-04-06 09:13:09 -04:00
// New returns a new error object with message formed from given arguments.
func New(msg ...interface{}) *Error {
return &Error{
2017-04-08 15:18:13 -04:00
message: msg,
2017-12-10 17:33:23 -05:00
severity: log.Severity_Info,
2016-12-04 03:10:47 -05:00
}
}
2016-12-15 05:05:32 -05:00
// Cause returns the root cause of this error.
2016-12-04 03:10:47 -05:00
func Cause(err error) error {
if err == nil {
return nil
}
2018-04-13 05:25:41 -04:00
L:
2016-12-04 03:10:47 -05:00
for {
2018-04-13 05:25:41 -04:00
switch inner := err.(type) {
case hasInnerError:
if inner.Inner() == nil {
break L
}
err = inner.Inner()
case *os.PathError:
if inner.Err == nil {
break L
}
err = inner.Err
case *os.SyscallError:
if inner.Err == nil {
break L
}
err = inner.Err
default:
break L
2016-12-04 03:10:47 -05:00
}
2017-02-21 17:14:07 -05:00
}
return err
}
2017-12-19 15:28:12 -05:00
// GetSeverity returns the actual severity of the error, including inner errors.
2017-12-10 17:33:23 -05:00
func GetSeverity(err error) log.Severity {
2017-04-06 09:13:09 -04:00
if s, ok := err.(hasSeverity); ok {
return s.Severity()
2016-12-04 03:10:47 -05:00
}
2017-12-10 17:33:23 -05:00
return log.Severity_Info
2016-12-04 03:10:47 -05:00
}
2018-02-22 09:26:00 -05:00
type sessionLog struct {
id session.ID
content interface{}
}
func (s sessionLog) String() string {
return serial.Concat("[", s.id, "] ", s.content)
}