commonerrors

package module
v1.172.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 6, 2026 License: Apache-2.0 Imports: 6 Imported by: 10

Documentation

Overview

Package commonerrors defines typical errors which can happen.

  • Copyright (C) 2020-2026 Arm Limited or its affiliates and Contributors. All rights reserved.
  • SPDX-License-Identifier: Apache-2.0

Index

Constants

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

Variables

View Source
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")
	ErrOutOfRange         = errors.New("out of range")
	ErrInterrupted        = errors.New("interrupted")
	// ErrFailed should be used as a generic error where an error is an expected and valid state.
	// For example a failing command may cause subprocess.Execute to return an error if the command exits with 1 but
	// this wouldn't be a system error, and you might want to distinguish between this and the subprocess wrapper erroring
	// when you pass the message up the stack.
	ErrFailed = errors.New(failureStr)
	// 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 DescribeCircumstance

func DescribeCircumstance(originalError error, circumstance string) error

DescribeCircumstance adds some context to a particular error. If the error is of a known type (as in, a common error), it will be kept. Otherwise, it will be set as Unexpected.

func DescribeCircumstanceAndKeepType

func DescribeCircumstanceAndKeepType(err error, circumstance string) error

DescribeCircumstanceAndKeepType does almost the same as DescribeCircumstance but if the error is not a common error, it won't wrap it but just add the context string to it.

func DescribeCircumstanceAndKeepTypef

func DescribeCircumstanceAndKeepTypef(err error, circumstanceFormat string, args ...any) error

DescribeCircumstanceAndKeepTypef is like DescribeCircumstanceAndKeepType but uses a message format to describe the error context.

func DescribeCircumstancef

func DescribeCircumstancef(err error, circumstanceFormat string, args ...any) error

DescribeCircumstancef is the same as DescribeCircumstance but uses a format for capturing the error context.

func DeserialiseError

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

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

func ErrFromContext

func ErrFromContext(ctx context.Context) error

ErrFromContext extracts the error from the context. If the error has a cause that is a common error then that will be returned over the underlying context error

func Errorf

func Errorf(targetErr error, format string, args ...any) error

Errorf is similar to fmt.Errorf although it will try to follow the error convention we use i.e. `errortype: message` but differs in that the wrapped error will be the targetErr

func GetCommonErrorReason

func GetCommonErrorReason(srcErr error) (reason string, err error)

func GetErrorReason

func GetErrorReason(srcErr error) (reason string, err error)

func GetUnderlyingErrorType

func GetUnderlyingErrorType(srcErr error) (commonerrorType, err error)

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 IgnoreCorrespondTo

func IgnoreCorrespondTo(target error, ignore ...string) error

IgnoreCorrespondTo will return nil if the target error matches one of the descriptions of 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 IsFailure

func IsFailure(target error) bool

IsFailure returns whether an error is unexpected (i.e. deviation from an expected state) but not a system error e.g. test failure

func IsWarning

func IsWarning(target error) bool

IsWarning will return whether an error is actually a warning

func Join

func Join(errs ...error) error

Join is similar to errors.Join but follows the common errors convention when printing

func MarkAsFailure

func MarkAsFailure(err error) error

MarkAsFailure will tent an error as failure. It will retain its original error type but IsFailure should return true.

func New

func New(targetError error, msg string) error

New is similar to errors.New or fmt.Errorf but creates an error of type targetError

func NewFailure

func NewFailure(msgFormat string, args ...any) error

NewFailure creates a failure object.

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 NewWarningMessage

func NewWarningMessage(msgFormat string, args ...any) error

NewWarningMessage creates a warning message.

func Newf

func Newf(targetError error, msgFormat string, args ...any) error

Newf is similar to New but allows to format the message

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 RetrieveCommonError

func RetrieveCommonError(target error) (isCommonError bool, commonError error)

RetrieveCommonError tries to return the common error of an error.

func SerialiseError

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

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

func UndefinedParameter

func UndefinedParameter(msg string) error

UndefinedParameter returns an undefined error with a message

func UndefinedParameterf

func UndefinedParameterf(msgFormat string, args ...any) error

UndefinedParameterf returns an undefined error with a message

func UndefinedVariable

func UndefinedVariable(variableName string) error

UndefinedVariable returns an undefined error related to a variable.

func UndefinedVariableWithMessage

func UndefinedVariableWithMessage(variableName string, msg string) error

UndefinedVariableWithMessage returns an undefined error with a message.

func WrapError

func WrapError(targetError, originalError error, msg string) error

WrapError wraps an error into a particular targetError. However, if the original error has to do with a contextual error (i.e. ErrCancelled or ErrTimeout) or should be considered as a failure rather than an error, it will be passed through without having its type changed. Same is true with warnings. This method should be used to safely wrap errors without losing information about context control information. If the target error is not set, the wrapped error will be of type ErrUnknown.

func WrapErrorf

func WrapErrorf(targetError, originalError error, msgFormat string, args ...any) error

WrapErrorf is similar to WrapError but uses a format for the message

func WrapIfNotCommonError

func WrapIfNotCommonError(targetError, originalError error, msg string) error

WrapIfNotCommonError is similar to WrapError but only wraps an error if it is not a common error.

func WrapIfNotCommonErrorf

func WrapIfNotCommonErrorf(targetError, originalError error, msgFormat string, args ...any) error

WrapIfNotCommonErrorf is similar to WrapError but only wraps an error if it is not a common error.

Types

This section is empty.

Directories

Path Synopsis
errortest module

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL