commonerrors

Documentation

Overview

Package commonerrors defines typical errors which can happen.

Index

• Constants
• Variables
• func Any(target error, err ...error) bool
• func ConvertContextError(err error) error
• func CorrespondTo(target error, description ...string) bool
• func DeserialiseError(text []byte) (deserialisedError, err error)
• func Ignore(target error, ignore ...error) error
• func IsCommonError(target error) bool
• func IsEmpty(err error) bool
• func IsWarning(target error) bool
• func NewWarning(target error) (ok bool, err error)
• func None(target error, err ...error) bool
• func ParseWarning(target error) (ok bool, err error)
• func RelatesTo(target string, errors ...error) bool
• func SerialiseError(err error) ([]byte, error)

Constants

const (
	TypeReasonErrorSeparator = ':'
	MultipleErrorSeparator   = '\n'
)

Variables

var (
	ErrNotImplemented     = errors.New("not implemented")
	ErrNoExtension        = errors.New("missing extension")
	ErrNoLogger           = errors.New("missing logger")
	ErrNoLoggerSource     = errors.New("missing logger source")
	ErrNoLogSource        = errors.New("missing log source")
	ErrUndefined          = errors.New("undefined")
	ErrInvalidDestination = errors.New("invalid destination")
	ErrTimeout            = errors.New("timeout")
	ErrLocked             = errors.New("locked")
	ErrStaleLock          = errors.New("stale lock")
	ErrExists             = errors.New("already exists")
	ErrNotFound           = errors.New("not found")
	ErrUnsupported        = errors.New("unsupported")
	ErrUnavailable        = errors.New("unavailable")
	ErrWrongUser          = errors.New("wrong user")
	ErrUnauthorised       = errors.New("unauthorised")
	ErrUnknown            = errors.New("unknown")
	ErrInvalid            = errors.New("invalid")
	ErrConflict           = errors.New("conflict")
	ErrMarshalling        = errors.New("unserialisable")
	ErrCancelled          = errors.New("cancelled")
	ErrEmpty              = errors.New("empty")
	ErrUnexpected         = errors.New("unexpected")
	ErrTooLarge           = errors.New("too large")
	ErrForbidden          = errors.New("forbidden")
	ErrCondition          = errors.New("failed condition")
	ErrEOF                = errors.New("end of file")
	ErrMalicious          = errors.New("suspected malicious intent")
	// ErrWarning is a generic error that can be used when an error should be raised but it shouldn't necessary be
	// passed up the chain, for example in cases where an error should be logged but the program should continue. In
	// these situations it should be handled immediately and then ignored/set to nil.
	ErrWarning = errors.New(warningStr)
)

List of common errors used to qualify and categorise go errors Note: if adding error types to this list, ensure mapping functions (below) are also updated.

Functions

func Any

func Any(target error, err ...error) bool

Any determines whether the target error is of the same type as any of the errors `err`

func ConvertContextError

func ConvertContextError(err error) error

ConvertContextError converts a context error into common errors.

func CorrespondTo

func CorrespondTo(target error, description ...string) bool

CorrespondTo determines whether a `target` error corresponds to a specific error described by `description` It will check whether the error contains the string in its description. It is not case-sensitive. ```code

  CorrespondTo(errors.New("feature a is not supported"), "not supported") = True
```

func DeserialiseError

func DeserialiseError(text []byte) (deserialisedError, err error)

DeserialiseError unmarshals text into an error. It tries to determine the error type.

func Ignore

func Ignore(target error, ignore ...error) error

Ignore will return nil if the target error matches one of the errors to ignore

func IsCommonError

func IsCommonError(target error) bool

IsCommonError returns whether an error is a commonerror

func IsEmpty

func IsEmpty(err error) bool

IsEmpty states whether an error is empty or not. An error is considered empty if it is `nil` or has no description.

func IsWarning

func IsWarning(target error) bool

IsWarning will return whether an error is actually a warning

func NewWarning

func NewWarning(target error) (ok bool, err error)

NewWarning will create a warning wrapper around an existing commonerror so that it can be easily recovered. If the underlying error is not a commonerror then ok will be set to false

func None

func None(target error, err ...error) bool

None determines whether the target error is of none of the types of the errors `err`

func ParseWarning

func ParseWarning(target error) (ok bool, err error)

ParseWarning will extract the error that has been wrapped by ErrWarning. It will return nil if the error was not one of ErrWarning with ok set to false. It will also set ok to false if the underlying error cannot be parsed

func RelatesTo

func RelatesTo(target string, errors ...error) bool

RelatesTo determines whether an error description string could relate to a particular set of common errors This assumes that the error description follows the convention of placing the type of errors at the start of the string.

func SerialiseError

func SerialiseError(err error) ([]byte, error)

SerialiseError marshals an error following a certain convention: `error type: reason`.