Debian Codegraph @

envoy/config/cluster/redis/redis_cluster.pb.validate.go

raw
1 //go:build !disable_pgv
2 // Code generated by protoc-gen-validate. DO NOT EDIT.
3 // source: envoy/config/cluster/redis/redis_cluster.proto
4
5 package redis
6
7 import (
8 "bytes"
9 "errors"
10 "fmt"
11 "net"
12 "net/mail"
13 "net/url"
14 "regexp"
15 "sort"
16 "strings"
17 "time"
18 "unicode/utf8"
19
20 "google.golang.org/protobuf/types/known/anypb"
21 )
22
23 // ensure the imports are used
24 var (
25 _ = bytes.MinRead
26 _ = errors.New("")
27 _ = fmt.Print
28 _ = utf8.UTFMax
29 _ = (*regexp.Regexp)(nil)
30 _ = (*strings.Reader)(nil)
31 _ = net.IPv4len
32 _ = time.Duration(0)
33 _ = (*url.URL)(nil)
34 _ = (*mail.Address)(nil)
35 _ = anypb.Any{}
36 _ = sort.Sort
37 )
38
39 // Validate checks the field values on RedisClusterConfig with the rules
40 // defined in the proto definition for this message. If any rules are
41 // violated, the first error encountered is returned, or nil if there are no violations.
42 func (m *RedisClusterConfig) Validate() error {
43 return m.validate(false)
44 }
45
46 // ValidateAll checks the field values on RedisClusterConfig with the rules
47 // defined in the proto definition for this message. If any rules are
48 // violated, the result is a list of violation errors wrapped in
49 // RedisClusterConfigMultiError, or nil if none found.
50 func (m *RedisClusterConfig) ValidateAll() error {
51 return m.validate(true)
52 }
53
54 func (m *RedisClusterConfig) validate(all bool) error {
55 if m == nil {
56 return nil
57 }
58
59 var errors []error
60
61 if d := m.GetClusterRefreshRate(); d != nil {
62 dur, err := d.AsDuration(), d.CheckValid()
63 if err != nil {
64 err = RedisClusterConfigValidationError{
65 field: "ClusterRefreshRate",
66 reason: "value is not a valid duration",
67 cause: err,
68 }
69 if !all {
70 return err
71 }
72 errors = append(errors, err)
73 } else {
74
75 gt := time.Duration(0*time.Second + 0*time.Nanosecond)
76
77 if dur <= gt {
78 err := RedisClusterConfigValidationError{
79 field: "ClusterRefreshRate",
80 reason: "value must be greater than 0s",
81 }
82 if !all {
83 return err
84 }
85 errors = append(errors, err)
86 }
87
88 }
89 }
90
91 if d := m.GetClusterRefreshTimeout(); d != nil {
92 dur, err := d.AsDuration(), d.CheckValid()
93 if err != nil {
94 err = RedisClusterConfigValidationError{
95 field: "ClusterRefreshTimeout",
96 reason: "value is not a valid duration",
97 cause: err,
98 }
99 if !all {
100 return err
101 }
102 errors = append(errors, err)
103 } else {
104
105 gt := time.Duration(0*time.Second + 0*time.Nanosecond)
106
107 if dur <= gt {
108 err := RedisClusterConfigValidationError{
109 field: "ClusterRefreshTimeout",
110 reason: "value must be greater than 0s",
111 }
112 if !all {
113 return err
114 }
115 errors = append(errors, err)
116 }
117
118 }
119 }
120
121 if all {
122 switch v := interface{}(m.GetRedirectRefreshInterval()).(type) {
123 case interface{ ValidateAll() error }:
124 if err := v.ValidateAll(); err != nil {
125 errors = append(errors, RedisClusterConfigValidationError{
126 field: "RedirectRefreshInterval",
127 reason: "embedded message failed validation",
128 cause: err,
129 })
130 }
131 case interface{ Validate() error }:
132 if err := v.Validate(); err != nil {
133 errors = append(errors, RedisClusterConfigValidationError{
134 field: "RedirectRefreshInterval",
135 reason: "embedded message failed validation",
136 cause: err,
137 })
138 }
139 }
140 } else if v, ok := interface{}(m.GetRedirectRefreshInterval()).(interface{ Validate() error }); ok {
141 if err := v.Validate(); err != nil {
142 return RedisClusterConfigValidationError{
143 field: "RedirectRefreshInterval",
144 reason: "embedded message failed validation",
145 cause: err,
146 }
147 }
148 }
149
150 if all {
151 switch v := interface{}(m.GetRedirectRefreshThreshold()).(type) {
152 case interface{ ValidateAll() error }:
153 if err := v.ValidateAll(); err != nil {
154 errors = append(errors, RedisClusterConfigValidationError{
155 field: "RedirectRefreshThreshold",
156 reason: "embedded message failed validation",
157 cause: err,
158 })
159 }
160 case interface{ Validate() error }:
161 if err := v.Validate(); err != nil {
162 errors = append(errors, RedisClusterConfigValidationError{
163 field: "RedirectRefreshThreshold",
164 reason: "embedded message failed validation",
165 cause: err,
166 })
167 }
168 }
169 } else if v, ok := interface{}(m.GetRedirectRefreshThreshold()).(interface{ Validate() error }); ok {
170 if err := v.Validate(); err != nil {
171 return RedisClusterConfigValidationError{
172 field: "RedirectRefreshThreshold",
173 reason: "embedded message failed validation",
174 cause: err,
175 }
176 }
177 }
178
179 // no validation rules for FailureRefreshThreshold
180
181 // no validation rules for HostDegradedRefreshThreshold
182
183 if len(errors) > 0 {
184 return RedisClusterConfigMultiError(errors)
185 }
186
187 return nil
188 }
189
190 // RedisClusterConfigMultiError is an error wrapping multiple validation errors
191 // returned by RedisClusterConfig.ValidateAll() if the designated constraints
192 // aren't met.
193 type RedisClusterConfigMultiError []error
194
195 // Error returns a concatenation of all the error messages it wraps.
196 func (m RedisClusterConfigMultiError) Error() string {
197 var msgs []string
198 for _, err := range m {
199 msgs = append(msgs, err.Error())
200 }
201 return strings.Join(msgs, "; ")
202 }
203
204 // AllErrors returns a list of validation violation errors.
205 func (m RedisClusterConfigMultiError) AllErrors() []error { return m }
206
207 // RedisClusterConfigValidationError is the validation error returned by
208 // RedisClusterConfig.Validate if the designated constraints aren't met.
209 type RedisClusterConfigValidationError struct {
210 field string
211 reason string
212 cause error
213 key bool
214 }
215
216 // Field function returns field value.
217 func (e RedisClusterConfigValidationError) Field() string { return e.field }
218
219 // Reason function returns reason value.
220 func (e RedisClusterConfigValidationError) Reason() string { return e.reason }
221
222 // Cause function returns cause value.
223 func (e RedisClusterConfigValidationError) Cause() error { return e.cause }
224
225 // Key function returns key value.
226 func (e RedisClusterConfigValidationError) Key() bool { return e.key }
227
228 // ErrorName returns error name.
229 func (e RedisClusterConfigValidationError) ErrorName() string {
230 return "RedisClusterConfigValidationError"
231 }
232
233 // Error satisfies the builtin error interface
234 func (e RedisClusterConfigValidationError) Error() string {
235 cause := ""
236 if e.cause != nil {
237 cause = fmt.Sprintf(" | caused by: %v", e.cause)
238 }
239
240 key := ""
241 if e.key {
242 key = "key for "
243 }
244
245 return fmt.Sprintf(
246 "invalid %sRedisClusterConfig.%s: %s%s",
247 key,
248 e.field,
249 e.reason,
250 cause)
251 }
252
253 var _ error = RedisClusterConfigValidationError{}
254
255 var _ interface {
256 Field() string
257 Reason() string
258 Key() bool
259 Cause() error
260 ErrorName() string
261 } = RedisClusterConfigValidationError{}