You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
172 lines
4.2 KiB
172 lines
4.2 KiB
package common
|
|
|
|
import (
|
|
"fmt"
|
|
"runtime"
|
|
)
|
|
|
|
//----------------------------------------
|
|
// Error & cmnError
|
|
|
|
type Error interface {
|
|
Error() string
|
|
Trace(format string, a ...interface{}) Error
|
|
TraceCause(cause error, format string, a ...interface{}) Error
|
|
Cause() error
|
|
Type() interface{}
|
|
WithType(t interface{}) Error
|
|
}
|
|
|
|
// New Error with no cause where the type is the format string of the message..
|
|
func NewError(format string, a ...interface{}) Error {
|
|
msg := Fmt(format, a...)
|
|
return newError(msg, nil, format)
|
|
|
|
}
|
|
|
|
// New Error with cause where the type is the cause, with message..
|
|
func NewErrorWithCause(cause error, format string, a ...interface{}) Error {
|
|
msg := Fmt(format, a...)
|
|
return newError(msg, cause, cause)
|
|
}
|
|
|
|
// New Error with specified type and message.
|
|
func NewErrorWithType(type_ interface{}, format string, a ...interface{}) Error {
|
|
msg := Fmt(format, a...)
|
|
return newError(msg, nil, type_)
|
|
}
|
|
|
|
type traceItem struct {
|
|
msg string
|
|
filename string
|
|
lineno int
|
|
}
|
|
|
|
func (ti traceItem) String() string {
|
|
return fmt.Sprintf("%v:%v %v", ti.filename, ti.lineno, ti.msg)
|
|
}
|
|
|
|
type cmnError struct {
|
|
msg string
|
|
cause error
|
|
type_ interface{}
|
|
traces []traceItem
|
|
}
|
|
|
|
// NOTE: Do not expose, it's not very friendly.
|
|
func newError(msg string, cause error, type_ interface{}) *cmnError {
|
|
return &cmnError{
|
|
msg: msg,
|
|
cause: cause,
|
|
type_: type_,
|
|
traces: nil,
|
|
}
|
|
}
|
|
|
|
func (err *cmnError) Error() string {
|
|
return fmt.Sprintf("Error{%v:%s,%v,%v}", err.type_, err.msg, err.cause, len(err.traces))
|
|
}
|
|
|
|
// Add tracing information with msg.
|
|
func (err *cmnError) Trace(format string, a ...interface{}) Error {
|
|
msg := Fmt(format, a...)
|
|
return err.doTrace(msg, 2)
|
|
}
|
|
|
|
// Add tracing information with cause and msg.
|
|
// If a cause was already set before, it is overwritten.
|
|
func (err *cmnError) TraceCause(cause error, format string, a ...interface{}) Error {
|
|
msg := Fmt(format, a...)
|
|
err.cause = cause
|
|
return err.doTrace(msg, 2)
|
|
}
|
|
|
|
// Return the "type" of this message, primarily for switching
|
|
// to handle this error.
|
|
func (err *cmnError) Type() interface{} {
|
|
return err.type_
|
|
}
|
|
|
|
// Overwrites the error's type.
|
|
func (err *cmnError) WithType(type_ interface{}) Error {
|
|
err.type_ = type_
|
|
return err
|
|
}
|
|
|
|
func (err *cmnError) doTrace(msg string, n int) Error {
|
|
_, fn, line, ok := runtime.Caller(n)
|
|
if !ok {
|
|
if fn == "" {
|
|
fn = "<unknown>"
|
|
}
|
|
if line <= 0 {
|
|
line = -1
|
|
}
|
|
}
|
|
// Include file & line number & msg.
|
|
// Do not include the whole stack trace.
|
|
err.traces = append(err.traces, traceItem{
|
|
filename: fn,
|
|
lineno: line,
|
|
msg: msg,
|
|
})
|
|
return err
|
|
}
|
|
|
|
// Return last known cause.
|
|
// NOTE: The meaning of "cause" is left for the caller to define.
|
|
// There exists to canonical definition of "cause".
|
|
// Instead of blaming, try to handle-or-organize it.
|
|
func (err *cmnError) Cause() error {
|
|
return err.cause
|
|
}
|
|
|
|
//----------------------------------------
|
|
// StackError
|
|
|
|
// NOTE: Used by Tendermint p2p upon recovery.
|
|
// Err could be "Reason", since it isn't an error type.
|
|
type StackError struct {
|
|
Err interface{}
|
|
Stack []byte
|
|
}
|
|
|
|
func (se StackError) String() string {
|
|
return fmt.Sprintf("Error: %v\nStack: %s", se.Err, se.Stack)
|
|
}
|
|
|
|
func (se StackError) Error() string {
|
|
return se.String()
|
|
}
|
|
|
|
//----------------------------------------
|
|
// Panic wrappers
|
|
// XXX DEPRECATED
|
|
|
|
// A panic resulting from a sanity check means there is a programmer error
|
|
// and some guarantee is not satisfied.
|
|
// XXX DEPRECATED
|
|
func PanicSanity(v interface{}) {
|
|
panic(Fmt("Panicked on a Sanity Check: %v", v))
|
|
}
|
|
|
|
// A panic here means something has gone horribly wrong, in the form of data corruption or
|
|
// failure of the operating system. In a correct/healthy system, these should never fire.
|
|
// If they do, it's indicative of a much more serious problem.
|
|
// XXX DEPRECATED
|
|
func PanicCrisis(v interface{}) {
|
|
panic(Fmt("Panicked on a Crisis: %v", v))
|
|
}
|
|
|
|
// Indicates a failure of consensus. Someone was malicious or something has
|
|
// gone horribly wrong. These should really boot us into an "emergency-recover" mode
|
|
// XXX DEPRECATED
|
|
func PanicConsensus(v interface{}) {
|
|
panic(Fmt("Panicked on a Consensus Failure: %v", v))
|
|
}
|
|
|
|
// For those times when we're not sure if we should panic
|
|
// XXX DEPRECATED
|
|
func PanicQ(v interface{}) {
|
|
panic(Fmt("Panicked questionably: %v", v))
|
|
}
|