mirror of https://github.com/status-im/consul.git
167 lines
4.2 KiB
Go
167 lines
4.2 KiB
Go
// Copyright (c) HashiCorp, Inc.
|
|
// SPDX-License-Identifier: BUSL-1.1
|
|
|
|
package resource
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"google.golang.org/protobuf/reflect/protoreflect"
|
|
|
|
"github.com/hashicorp/consul/proto-public/pbresource"
|
|
)
|
|
|
|
var (
|
|
ErrMissing = NewConstError("missing required field")
|
|
ErrEmpty = NewConstError("cannot be empty")
|
|
ErrReferenceTenancyNotEqual = NewConstError("resource tenancy and reference tenancy differ")
|
|
ErrUnsupported = NewConstError("field is currently not supported")
|
|
)
|
|
|
|
// ConstError is more or less equivalent to the stdlib errors.errorstring. However, having
|
|
// our own exported type allows us to more accurately compare error values in tests.
|
|
//
|
|
// - go-cmp will not compared unexported fields by default.
|
|
// - cmp.AllowUnexported(<type>) requires a concrete struct type and due to the stdlib not
|
|
// exporting the errorstring type there doesn't seem to be a way to get at the type.
|
|
// - cmpopts.EquateErrors has issues with protobuf types within other error structs.
|
|
//
|
|
// Due to these factors the easiest thing to do is to create a custom comparer for
|
|
// the ConstError type and use it where necessary.
|
|
type ConstError struct {
|
|
message string
|
|
}
|
|
|
|
func NewConstError(msg string) ConstError {
|
|
return ConstError{message: msg}
|
|
}
|
|
|
|
func (e ConstError) Error() string {
|
|
return e.message
|
|
}
|
|
|
|
type ErrDataParse struct {
|
|
TypeName string
|
|
Wrapped error
|
|
}
|
|
|
|
func NewErrDataParse(msg protoreflect.ProtoMessage, err error) ErrDataParse {
|
|
return ErrDataParse{
|
|
TypeName: string(msg.ProtoReflect().Descriptor().FullName()),
|
|
Wrapped: err,
|
|
}
|
|
}
|
|
|
|
func (err ErrDataParse) Error() string {
|
|
return fmt.Sprintf("error parsing resource data as type %q: %s", err.TypeName, err.Wrapped.Error())
|
|
}
|
|
|
|
func (err ErrDataParse) Unwrap() error {
|
|
return err.Wrapped
|
|
}
|
|
|
|
type ErrInvalidField struct {
|
|
Name string
|
|
Wrapped error
|
|
}
|
|
|
|
func (err ErrInvalidField) Error() string {
|
|
return fmt.Sprintf("invalid %q field: %v", err.Name, err.Wrapped)
|
|
}
|
|
|
|
func (err ErrInvalidField) Unwrap() error {
|
|
return err.Wrapped
|
|
}
|
|
|
|
type ErrInvalidListElement struct {
|
|
Name string
|
|
Index int
|
|
Wrapped error
|
|
}
|
|
|
|
func (err ErrInvalidListElement) Error() string {
|
|
return fmt.Sprintf("invalid element at index %d of list %q: %v", err.Index, err.Name, err.Wrapped)
|
|
}
|
|
|
|
func (err ErrInvalidListElement) Unwrap() error {
|
|
return err.Wrapped
|
|
}
|
|
|
|
type ErrInvalidMapValue struct {
|
|
Map string
|
|
Key string
|
|
Wrapped error
|
|
}
|
|
|
|
func (err ErrInvalidMapValue) Error() string {
|
|
return fmt.Sprintf("invalid value of key %q within %s: %v", err.Key, err.Map, err.Wrapped)
|
|
}
|
|
|
|
func (err ErrInvalidMapValue) Unwrap() error {
|
|
return err.Wrapped
|
|
}
|
|
|
|
type ErrInvalidMapKey struct {
|
|
Map string
|
|
Key string
|
|
Wrapped error
|
|
}
|
|
|
|
func (err ErrInvalidMapKey) Error() string {
|
|
return fmt.Sprintf("map %s contains an invalid key - %q: %v", err.Map, err.Key, err.Wrapped)
|
|
}
|
|
|
|
func (err ErrInvalidMapKey) Unwrap() error {
|
|
return err.Wrapped
|
|
}
|
|
|
|
type ErrOwnerTypeInvalid struct {
|
|
ResourceType *pbresource.Type
|
|
OwnerType *pbresource.Type
|
|
}
|
|
|
|
func (err ErrOwnerTypeInvalid) Error() string {
|
|
return fmt.Sprintf(
|
|
"resources of type %s cannot be owned by resources with type %s",
|
|
ToGVK(err.ResourceType),
|
|
ToGVK(err.OwnerType),
|
|
)
|
|
}
|
|
|
|
type ErrOwnerTenantInvalid struct {
|
|
ResourceType *pbresource.Type
|
|
ResourceTenancy *pbresource.Tenancy
|
|
OwnerTenancy *pbresource.Tenancy
|
|
}
|
|
|
|
func (err ErrOwnerTenantInvalid) Error() string {
|
|
return fmt.Sprintf(
|
|
"resource in partition %s, namespace %s and peer %s cannot be owned by a resource in partition %s, namespace %s and peer %s",
|
|
err.ResourceTenancy.Partition, err.ResourceTenancy.Namespace, err.ResourceTenancy.PeerName,
|
|
err.OwnerTenancy.Partition, err.OwnerTenancy.Namespace, err.OwnerTenancy.PeerName,
|
|
)
|
|
}
|
|
|
|
type ErrInvalidReferenceType struct {
|
|
AllowedType *pbresource.Type
|
|
}
|
|
|
|
func (err ErrInvalidReferenceType) Error() string {
|
|
return fmt.Sprintf("reference must have type %s", ToGVK(err.AllowedType))
|
|
}
|
|
|
|
type ErrInvalidFields struct {
|
|
Names []string
|
|
Wrapped error
|
|
}
|
|
|
|
func (err ErrInvalidFields) Error() string {
|
|
allFields := strings.Join(err.Names, ",")
|
|
return fmt.Sprintf("invalid %q fields: %v", allFields, err.Wrapped)
|
|
}
|
|
|
|
func (err ErrInvalidFields) Unwrap() error {
|
|
return err.Wrapped
|
|
}
|