179 lines
3.3 KiB
Go
179 lines
3.3 KiB
Go
package errors
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
)
|
|
|
|
//go:generate stringer -type=Priority
|
|
|
|
// Priority defines how an error should be threaded
|
|
type Priority int
|
|
|
|
// Priorities that can be used to create and list errors
|
|
const (
|
|
Unknown Priority = iota
|
|
Debug
|
|
Info
|
|
Notice
|
|
Warning
|
|
Error
|
|
Critical
|
|
Alert
|
|
Emergency
|
|
)
|
|
|
|
// Config defines the error configuration, currently no configuration options
|
|
// are available.
|
|
type Config struct {
|
|
}
|
|
|
|
// Err contains a single error
|
|
type Err struct {
|
|
p Priority
|
|
msg string
|
|
}
|
|
|
|
// Priority returns the priority of this error
|
|
func (e Err) Priority() Priority {
|
|
return e.p
|
|
}
|
|
|
|
// String returns the message of this error
|
|
func (e Err) Error() string {
|
|
return e.msg
|
|
}
|
|
|
|
// Errors contains a list of Error
|
|
type Errors struct {
|
|
err []Err
|
|
config *Config
|
|
p Priority
|
|
m sync.Mutex
|
|
}
|
|
|
|
// New creates an empty error container
|
|
func New(c *Config) *Errors {
|
|
return &Errors{config: c}
|
|
}
|
|
|
|
// IsError returns true on one or more errors
|
|
func (e *Errors) IsError() bool {
|
|
if len(e.err) > 0 {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Priority returns the priority of this error
|
|
func (e *Errors) Priority() Priority {
|
|
return e.p
|
|
}
|
|
|
|
// List returns all errors of a given priority, if no priority is given all
|
|
// errors are returned.
|
|
func (e *Errors) List(p ...Priority) []Err {
|
|
if len(p) == 0 {
|
|
return e.err
|
|
}
|
|
|
|
// filter errors to given priorities
|
|
var l []Err
|
|
for _, e := range e.err {
|
|
for _, priority := range p {
|
|
if e.p == priority {
|
|
l = append(l, e)
|
|
}
|
|
}
|
|
}
|
|
return l
|
|
}
|
|
|
|
// Append add all Errors to existing Errors
|
|
func (e *Errors) Append(err *Errors) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
|
|
e.m.Lock()
|
|
|
|
// append Errors at the end of the current list
|
|
e.err = append(e.err, err.err...)
|
|
|
|
// set highest priority
|
|
if err.p > e.p {
|
|
e.p = err.p
|
|
}
|
|
|
|
e.m.Unlock()
|
|
return nil
|
|
}
|
|
|
|
// Emerg log an error with severity Emergency
|
|
func (e *Errors) Emerg(format string, a ...interface{}) error {
|
|
return e.add(Emergency, format, a...)
|
|
}
|
|
|
|
// Alert log an error with severity Alert
|
|
func (e *Errors) Alert(format string, a ...interface{}) error {
|
|
return e.add(Alert, format, a...)
|
|
}
|
|
|
|
// Crit log an error with severity Critical
|
|
func (e *Errors) Crit(format string, a ...interface{}) error {
|
|
return e.add(Critical, format, a...)
|
|
}
|
|
|
|
// Err log an error with severity Error
|
|
func (e *Errors) Err(format string, a ...interface{}) error {
|
|
return e.add(Error, format, a...)
|
|
}
|
|
|
|
// Warning log an error with severity Warning
|
|
func (e *Errors) Warning(format string, a ...interface{}) error {
|
|
return e.add(Warning, format, a...)
|
|
}
|
|
|
|
// Notice log an error with severity Notice
|
|
func (e *Errors) Notice(format string, a ...interface{}) error {
|
|
return e.add(Notice, format, a...)
|
|
}
|
|
|
|
// Info log an error with severity Info
|
|
func (e *Errors) Info(format string, a ...interface{}) error {
|
|
return e.add(Info, format, a...)
|
|
}
|
|
|
|
// Debug log an error with severity Debug
|
|
func (e *Errors) Debug(format string, a ...interface{}) error {
|
|
return e.add(Debug, format, a...)
|
|
}
|
|
|
|
func (e *Errors) add(p Priority, format string, a ...interface{}) error {
|
|
// no error in request
|
|
if len(format) == 0 && len(a) == 0 {
|
|
return nil
|
|
}
|
|
|
|
e.m.Lock()
|
|
|
|
msg := format
|
|
if len(a) > 0 {
|
|
msg = fmt.Sprintf(format, a...)
|
|
}
|
|
|
|
// add this priority to the end of the list
|
|
e.err = append(e.err, Err{
|
|
p: p,
|
|
msg: msg,
|
|
})
|
|
|
|
// set highest priority in this list
|
|
if p > e.p {
|
|
e.p = p
|
|
}
|
|
|
|
e.m.Unlock()
|
|
return nil
|
|
}
|