-
Notifications
You must be signed in to change notification settings - Fork 0
/
errors.go
148 lines (130 loc) · 3.63 KB
/
errors.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
package azcfg
import (
"errors"
"strings"
)
var (
// errRequired is returned when a secret/setting is required.
errRequired = errors.New("required")
)
var (
// ErrSetValue is returned when a value cannot be set.
ErrSetValue = errors.New("set value error")
// ErrCredential is returned when a credential error occurs.
ErrCredential = errors.New("credential error")
// ErrSecretClient is returned when a secret client error occurs.
ErrSecretClient = errors.New("secret client error")
// ErrSecretRetrieval is returned when a secret retrieval error occurs.
ErrSecretRetrieval = errors.New("secret retrieval error")
// ErrSettingClient is returned when a setting client error occurs.
ErrSettingClient = errors.New("setting client error")
// ErrSettingRetrieval is returned when a setting retrieval error occurs.
ErrSettingRetrieval = errors.New("setting retrieval error")
)
// Error represents a general error type that can contain multiple errors
// for azcfg.
type Error struct {
errors []error
}
// Error returns the combined error messages from the errors
// contained in Error.
func (e *Error) Error() string {
var errs []string
for _, err := range e.errors {
errs = append(errs, err.Error())
}
return strings.Join(errs, "\n")
}
// Errors returns the errors contained in Error.
func (e *Error) Errors() []error {
return e.errors
}
// Len returns the number of errors contained in Error.
func (e *Error) Len() int {
return len(e.errors)
}
// Has returns true if the provided error type is found in the errors.
// If found, the first error of the provided type is returned.
func (e *Error) Has(err error) (error, bool) {
for _, e := range e.errors {
if errors.Is(e, err) {
return e, true
}
}
return nil, false
}
// newError creates a new Error with the provided errors.
func newError(errs ...error) *Error {
if len(errs) == 0 {
return nil
}
e := &Error{}
e.errors = append(e.errors, errs...)
return e
}
// RequiredFieldsError represents an error when either secrets or settings
// are required but not set.
type RequiredFieldsError struct {
message string
required []string
missing []string
}
// Error returns the combined error messages from the errors
// contained in RequiredFieldsError.
func (e *RequiredFieldsError) Error() string {
return e.message
}
// Required returns the fields that are required.
func (e *RequiredFieldsError) Required() []string {
return e.required
}
// Missing returns the fields that are missing the required values.
func (e *RequiredFieldsError) Missing() []string {
return e.missing
}
// newRequiredFieldsError creates a new RequiredFieldsError.
func newRequiredFieldsError(values map[string]string, requiredFields ...requiredFields) *RequiredFieldsError {
if len(requiredFields) == 0 {
return nil
}
var messages []string
var required []string
var missing []string
for _, rfs := range requiredFields {
if len(rfs.f) == 0 {
continue
}
required = append(required, rfs.f...)
l := 0
mfs := make([]string, 0)
for _, r := range rfs.f {
if len(values[r]) == 0 {
mfs = append(mfs, r)
l++
}
}
missing = append(missing, mfs...)
var message strings.Builder
if l == 1 {
message.WriteString(rfs.t + ": " + mfs[0] + " is required")
} else {
message.WriteString(rfs.t + "s: ")
for i, r := range mfs {
message.WriteString(r)
if i < l-1 && l > 2 && i != l-2 {
message.WriteString(", ")
}
if i == l-2 {
message.WriteString(" and ")
}
}
message.WriteString(" are required")
}
messages = append(messages, message.String())
}
return &RequiredFieldsError{
message: strings.Join(messages, "\n"),
required: required,
missing: missing,
}
}