mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-09-07 09:36:44 +00:00
170 lines
4.3 KiB
Go
170 lines
4.3 KiB
Go
![]() |
// Package errwrap implements methods to formalize error wrapping in Go.
|
||
|
//
|
||
|
// All of the top-level functions that take an `error` are built to be able
|
||
|
// to take any error, not just wrapped errors. This allows you to use errwrap
|
||
|
// without having to type-check and type-cast everywhere.
|
||
|
package errwrap
|
||
|
|
||
|
import (
|
||
|
"errors"
|
||
|
"reflect"
|
||
|
"strings"
|
||
|
)
|
||
|
|
||
|
// WalkFunc is the callback called for Walk.
|
||
|
type WalkFunc func(error)
|
||
|
|
||
|
// Wrapper is an interface that can be implemented by custom types to
|
||
|
// have all the Contains, Get, etc. functions in errwrap work.
|
||
|
//
|
||
|
// When Walk reaches a Wrapper, it will call the callback for every
|
||
|
// wrapped error in addition to the wrapper itself. Since all the top-level
|
||
|
// functions in errwrap use Walk, this means that all those functions work
|
||
|
// with your custom type.
|
||
|
type Wrapper interface {
|
||
|
WrappedErrors() []error
|
||
|
}
|
||
|
|
||
|
// Wrap defines that outer wraps inner, returning an error type that
|
||
|
// can be cleanly used with the other methods in this package, such as
|
||
|
// Contains, GetAll, etc.
|
||
|
//
|
||
|
// This function won't modify the error message at all (the outer message
|
||
|
// will be used).
|
||
|
func Wrap(outer, inner error) error {
|
||
|
return &wrappedError{
|
||
|
Outer: outer,
|
||
|
Inner: inner,
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Wrapf wraps an error with a formatting message. This is similar to using
|
||
|
// `fmt.Errorf` to wrap an error. If you're using `fmt.Errorf` to wrap
|
||
|
// errors, you should replace it with this.
|
||
|
//
|
||
|
// format is the format of the error message. The string '{{err}}' will
|
||
|
// be replaced with the original error message.
|
||
|
func Wrapf(format string, err error) error {
|
||
|
outerMsg := "<nil>"
|
||
|
if err != nil {
|
||
|
outerMsg = err.Error()
|
||
|
}
|
||
|
|
||
|
outer := errors.New(strings.Replace(
|
||
|
format, "{{err}}", outerMsg, -1))
|
||
|
|
||
|
return Wrap(outer, err)
|
||
|
}
|
||
|
|
||
|
// Contains checks if the given error contains an error with the
|
||
|
// message msg. If err is not a wrapped error, this will always return
|
||
|
// false unless the error itself happens to match this msg.
|
||
|
func Contains(err error, msg string) bool {
|
||
|
return len(GetAll(err, msg)) > 0
|
||
|
}
|
||
|
|
||
|
// ContainsType checks if the given error contains an error with
|
||
|
// the same concrete type as v. If err is not a wrapped error, this will
|
||
|
// check the err itself.
|
||
|
func ContainsType(err error, v interface{}) bool {
|
||
|
return len(GetAllType(err, v)) > 0
|
||
|
}
|
||
|
|
||
|
// Get is the same as GetAll but returns the deepest matching error.
|
||
|
func Get(err error, msg string) error {
|
||
|
es := GetAll(err, msg)
|
||
|
if len(es) > 0 {
|
||
|
return es[len(es)-1]
|
||
|
}
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// GetType is the same as GetAllType but returns the deepest matching error.
|
||
|
func GetType(err error, v interface{}) error {
|
||
|
es := GetAllType(err, v)
|
||
|
if len(es) > 0 {
|
||
|
return es[len(es)-1]
|
||
|
}
|
||
|
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// GetAll gets all the errors that might be wrapped in err with the
|
||
|
// given message. The order of the errors is such that the outermost
|
||
|
// matching error (the most recent wrap) is index zero, and so on.
|
||
|
func GetAll(err error, msg string) []error {
|
||
|
var result []error
|
||
|
|
||
|
Walk(err, func(err error) {
|
||
|
if err.Error() == msg {
|
||
|
result = append(result, err)
|
||
|
}
|
||
|
})
|
||
|
|
||
|
return result
|
||
|
}
|
||
|
|
||
|
// GetAllType gets all the errors that are the same type as v.
|
||
|
//
|
||
|
// The order of the return value is the same as described in GetAll.
|
||
|
func GetAllType(err error, v interface{}) []error {
|
||
|
var result []error
|
||
|
|
||
|
var search string
|
||
|
if v != nil {
|
||
|
search = reflect.TypeOf(v).String()
|
||
|
}
|
||
|
Walk(err, func(err error) {
|
||
|
var needle string
|
||
|
if err != nil {
|
||
|
needle = reflect.TypeOf(err).String()
|
||
|
}
|
||
|
|
||
|
if needle == search {
|
||
|
result = append(result, err)
|
||
|
}
|
||
|
})
|
||
|
|
||
|
return result
|
||
|
}
|
||
|
|
||
|
// Walk walks all the wrapped errors in err and calls the callback. If
|
||
|
// err isn't a wrapped error, this will be called once for err. If err
|
||
|
// is a wrapped error, the callback will be called for both the wrapper
|
||
|
// that implements error as well as the wrapped error itself.
|
||
|
func Walk(err error, cb WalkFunc) {
|
||
|
if err == nil {
|
||
|
return
|
||
|
}
|
||
|
|
||
|
switch e := err.(type) {
|
||
|
case *wrappedError:
|
||
|
cb(e.Outer)
|
||
|
Walk(e.Inner, cb)
|
||
|
case Wrapper:
|
||
|
cb(err)
|
||
|
|
||
|
for _, err := range e.WrappedErrors() {
|
||
|
Walk(err, cb)
|
||
|
}
|
||
|
default:
|
||
|
cb(err)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// wrappedError is an implementation of error that has both the
|
||
|
// outer and inner errors.
|
||
|
type wrappedError struct {
|
||
|
Outer error
|
||
|
Inner error
|
||
|
}
|
||
|
|
||
|
func (w *wrappedError) Error() string {
|
||
|
return w.Outer.Error()
|
||
|
}
|
||
|
|
||
|
func (w *wrappedError) WrappedErrors() []error {
|
||
|
return []error{w.Outer, w.Inner}
|
||
|
}
|