1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package mwaa
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/mwaa/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateCliToken struct {
14}
15
16func (*validateOpCreateCliToken) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateCliToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
21	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
22) {
23	input, ok := in.Parameters.(*CreateCliTokenInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateCliTokenInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateEnvironment struct {
34}
35
36func (*validateOpCreateEnvironment) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateEnvironment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
41	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
42) {
43	input, ok := in.Parameters.(*CreateEnvironmentInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateEnvironmentInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateWebLoginToken struct {
54}
55
56func (*validateOpCreateWebLoginToken) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateWebLoginToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
61	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
62) {
63	input, ok := in.Parameters.(*CreateWebLoginTokenInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateWebLoginTokenInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDeleteEnvironment struct {
74}
75
76func (*validateOpDeleteEnvironment) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDeleteEnvironment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
81	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
82) {
83	input, ok := in.Parameters.(*DeleteEnvironmentInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDeleteEnvironmentInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpGetEnvironment struct {
94}
95
96func (*validateOpGetEnvironment) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpGetEnvironment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
102) {
103	input, ok := in.Parameters.(*GetEnvironmentInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpGetEnvironmentInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpListTagsForResource struct {
114}
115
116func (*validateOpListTagsForResource) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
122) {
123	input, ok := in.Parameters.(*ListTagsForResourceInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpListTagsForResourceInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpPublishMetrics struct {
134}
135
136func (*validateOpPublishMetrics) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpPublishMetrics) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
142) {
143	input, ok := in.Parameters.(*PublishMetricsInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpPublishMetricsInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpTagResource struct {
154}
155
156func (*validateOpTagResource) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
162) {
163	input, ok := in.Parameters.(*TagResourceInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpTagResourceInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpUntagResource struct {
174}
175
176func (*validateOpUntagResource) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
182) {
183	input, ok := in.Parameters.(*UntagResourceInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpUntagResourceInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpUpdateEnvironment struct {
194}
195
196func (*validateOpUpdateEnvironment) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpUpdateEnvironment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
202) {
203	input, ok := in.Parameters.(*UpdateEnvironmentInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpUpdateEnvironmentInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213func addOpCreateCliTokenValidationMiddleware(stack *middleware.Stack) error {
214	return stack.Initialize.Add(&validateOpCreateCliToken{}, middleware.After)
215}
216
217func addOpCreateEnvironmentValidationMiddleware(stack *middleware.Stack) error {
218	return stack.Initialize.Add(&validateOpCreateEnvironment{}, middleware.After)
219}
220
221func addOpCreateWebLoginTokenValidationMiddleware(stack *middleware.Stack) error {
222	return stack.Initialize.Add(&validateOpCreateWebLoginToken{}, middleware.After)
223}
224
225func addOpDeleteEnvironmentValidationMiddleware(stack *middleware.Stack) error {
226	return stack.Initialize.Add(&validateOpDeleteEnvironment{}, middleware.After)
227}
228
229func addOpGetEnvironmentValidationMiddleware(stack *middleware.Stack) error {
230	return stack.Initialize.Add(&validateOpGetEnvironment{}, middleware.After)
231}
232
233func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
234	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
235}
236
237func addOpPublishMetricsValidationMiddleware(stack *middleware.Stack) error {
238	return stack.Initialize.Add(&validateOpPublishMetrics{}, middleware.After)
239}
240
241func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
242	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
243}
244
245func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
246	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
247}
248
249func addOpUpdateEnvironmentValidationMiddleware(stack *middleware.Stack) error {
250	return stack.Initialize.Add(&validateOpUpdateEnvironment{}, middleware.After)
251}
252
253func validateDimension(v *types.Dimension) error {
254	if v == nil {
255		return nil
256	}
257	invalidParams := smithy.InvalidParamsError{Context: "Dimension"}
258	if v.Name == nil {
259		invalidParams.Add(smithy.NewErrParamRequired("Name"))
260	}
261	if v.Value == nil {
262		invalidParams.Add(smithy.NewErrParamRequired("Value"))
263	}
264	if invalidParams.Len() > 0 {
265		return invalidParams
266	} else {
267		return nil
268	}
269}
270
271func validateDimensions(v []types.Dimension) error {
272	if v == nil {
273		return nil
274	}
275	invalidParams := smithy.InvalidParamsError{Context: "Dimensions"}
276	for i := range v {
277		if err := validateDimension(&v[i]); err != nil {
278			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
279		}
280	}
281	if invalidParams.Len() > 0 {
282		return invalidParams
283	} else {
284		return nil
285	}
286}
287
288func validateLoggingConfigurationInput(v *types.LoggingConfigurationInput) error {
289	if v == nil {
290		return nil
291	}
292	invalidParams := smithy.InvalidParamsError{Context: "LoggingConfigurationInput"}
293	if v.DagProcessingLogs != nil {
294		if err := validateModuleLoggingConfigurationInput(v.DagProcessingLogs); err != nil {
295			invalidParams.AddNested("DagProcessingLogs", err.(smithy.InvalidParamsError))
296		}
297	}
298	if v.SchedulerLogs != nil {
299		if err := validateModuleLoggingConfigurationInput(v.SchedulerLogs); err != nil {
300			invalidParams.AddNested("SchedulerLogs", err.(smithy.InvalidParamsError))
301		}
302	}
303	if v.WebserverLogs != nil {
304		if err := validateModuleLoggingConfigurationInput(v.WebserverLogs); err != nil {
305			invalidParams.AddNested("WebserverLogs", err.(smithy.InvalidParamsError))
306		}
307	}
308	if v.WorkerLogs != nil {
309		if err := validateModuleLoggingConfigurationInput(v.WorkerLogs); err != nil {
310			invalidParams.AddNested("WorkerLogs", err.(smithy.InvalidParamsError))
311		}
312	}
313	if v.TaskLogs != nil {
314		if err := validateModuleLoggingConfigurationInput(v.TaskLogs); err != nil {
315			invalidParams.AddNested("TaskLogs", err.(smithy.InvalidParamsError))
316		}
317	}
318	if invalidParams.Len() > 0 {
319		return invalidParams
320	} else {
321		return nil
322	}
323}
324
325func validateMetricData(v []types.MetricDatum) error {
326	if v == nil {
327		return nil
328	}
329	invalidParams := smithy.InvalidParamsError{Context: "MetricData"}
330	for i := range v {
331		if err := validateMetricDatum(&v[i]); err != nil {
332			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
333		}
334	}
335	if invalidParams.Len() > 0 {
336		return invalidParams
337	} else {
338		return nil
339	}
340}
341
342func validateMetricDatum(v *types.MetricDatum) error {
343	if v == nil {
344		return nil
345	}
346	invalidParams := smithy.InvalidParamsError{Context: "MetricDatum"}
347	if v.MetricName == nil {
348		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
349	}
350	if v.Timestamp == nil {
351		invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
352	}
353	if v.Dimensions != nil {
354		if err := validateDimensions(v.Dimensions); err != nil {
355			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
356		}
357	}
358	if invalidParams.Len() > 0 {
359		return invalidParams
360	} else {
361		return nil
362	}
363}
364
365func validateModuleLoggingConfigurationInput(v *types.ModuleLoggingConfigurationInput) error {
366	if v == nil {
367		return nil
368	}
369	invalidParams := smithy.InvalidParamsError{Context: "ModuleLoggingConfigurationInput"}
370	if v.Enabled == nil {
371		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
372	}
373	if len(v.LogLevel) == 0 {
374		invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
375	}
376	if invalidParams.Len() > 0 {
377		return invalidParams
378	} else {
379		return nil
380	}
381}
382
383func validateUpdateNetworkConfigurationInput(v *types.UpdateNetworkConfigurationInput) error {
384	if v == nil {
385		return nil
386	}
387	invalidParams := smithy.InvalidParamsError{Context: "UpdateNetworkConfigurationInput"}
388	if v.SecurityGroupIds == nil {
389		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
390	}
391	if invalidParams.Len() > 0 {
392		return invalidParams
393	} else {
394		return nil
395	}
396}
397
398func validateOpCreateCliTokenInput(v *CreateCliTokenInput) error {
399	if v == nil {
400		return nil
401	}
402	invalidParams := smithy.InvalidParamsError{Context: "CreateCliTokenInput"}
403	if v.Name == nil {
404		invalidParams.Add(smithy.NewErrParamRequired("Name"))
405	}
406	if invalidParams.Len() > 0 {
407		return invalidParams
408	} else {
409		return nil
410	}
411}
412
413func validateOpCreateEnvironmentInput(v *CreateEnvironmentInput) error {
414	if v == nil {
415		return nil
416	}
417	invalidParams := smithy.InvalidParamsError{Context: "CreateEnvironmentInput"}
418	if v.Name == nil {
419		invalidParams.Add(smithy.NewErrParamRequired("Name"))
420	}
421	if v.ExecutionRoleArn == nil {
422		invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
423	}
424	if v.SourceBucketArn == nil {
425		invalidParams.Add(smithy.NewErrParamRequired("SourceBucketArn"))
426	}
427	if v.DagS3Path == nil {
428		invalidParams.Add(smithy.NewErrParamRequired("DagS3Path"))
429	}
430	if v.NetworkConfiguration == nil {
431		invalidParams.Add(smithy.NewErrParamRequired("NetworkConfiguration"))
432	}
433	if v.LoggingConfiguration != nil {
434		if err := validateLoggingConfigurationInput(v.LoggingConfiguration); err != nil {
435			invalidParams.AddNested("LoggingConfiguration", err.(smithy.InvalidParamsError))
436		}
437	}
438	if invalidParams.Len() > 0 {
439		return invalidParams
440	} else {
441		return nil
442	}
443}
444
445func validateOpCreateWebLoginTokenInput(v *CreateWebLoginTokenInput) error {
446	if v == nil {
447		return nil
448	}
449	invalidParams := smithy.InvalidParamsError{Context: "CreateWebLoginTokenInput"}
450	if v.Name == nil {
451		invalidParams.Add(smithy.NewErrParamRequired("Name"))
452	}
453	if invalidParams.Len() > 0 {
454		return invalidParams
455	} else {
456		return nil
457	}
458}
459
460func validateOpDeleteEnvironmentInput(v *DeleteEnvironmentInput) error {
461	if v == nil {
462		return nil
463	}
464	invalidParams := smithy.InvalidParamsError{Context: "DeleteEnvironmentInput"}
465	if v.Name == nil {
466		invalidParams.Add(smithy.NewErrParamRequired("Name"))
467	}
468	if invalidParams.Len() > 0 {
469		return invalidParams
470	} else {
471		return nil
472	}
473}
474
475func validateOpGetEnvironmentInput(v *GetEnvironmentInput) error {
476	if v == nil {
477		return nil
478	}
479	invalidParams := smithy.InvalidParamsError{Context: "GetEnvironmentInput"}
480	if v.Name == nil {
481		invalidParams.Add(smithy.NewErrParamRequired("Name"))
482	}
483	if invalidParams.Len() > 0 {
484		return invalidParams
485	} else {
486		return nil
487	}
488}
489
490func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
491	if v == nil {
492		return nil
493	}
494	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
495	if v.ResourceArn == nil {
496		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
497	}
498	if invalidParams.Len() > 0 {
499		return invalidParams
500	} else {
501		return nil
502	}
503}
504
505func validateOpPublishMetricsInput(v *PublishMetricsInput) error {
506	if v == nil {
507		return nil
508	}
509	invalidParams := smithy.InvalidParamsError{Context: "PublishMetricsInput"}
510	if v.EnvironmentName == nil {
511		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
512	}
513	if v.MetricData == nil {
514		invalidParams.Add(smithy.NewErrParamRequired("MetricData"))
515	} else if v.MetricData != nil {
516		if err := validateMetricData(v.MetricData); err != nil {
517			invalidParams.AddNested("MetricData", err.(smithy.InvalidParamsError))
518		}
519	}
520	if invalidParams.Len() > 0 {
521		return invalidParams
522	} else {
523		return nil
524	}
525}
526
527func validateOpTagResourceInput(v *TagResourceInput) error {
528	if v == nil {
529		return nil
530	}
531	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
532	if v.ResourceArn == nil {
533		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
534	}
535	if v.Tags == nil {
536		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
537	}
538	if invalidParams.Len() > 0 {
539		return invalidParams
540	} else {
541		return nil
542	}
543}
544
545func validateOpUntagResourceInput(v *UntagResourceInput) error {
546	if v == nil {
547		return nil
548	}
549	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
550	if v.ResourceArn == nil {
551		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
552	}
553	if v.TagKeys == nil {
554		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
555	}
556	if invalidParams.Len() > 0 {
557		return invalidParams
558	} else {
559		return nil
560	}
561}
562
563func validateOpUpdateEnvironmentInput(v *UpdateEnvironmentInput) error {
564	if v == nil {
565		return nil
566	}
567	invalidParams := smithy.InvalidParamsError{Context: "UpdateEnvironmentInput"}
568	if v.Name == nil {
569		invalidParams.Add(smithy.NewErrParamRequired("Name"))
570	}
571	if v.NetworkConfiguration != nil {
572		if err := validateUpdateNetworkConfigurationInput(v.NetworkConfiguration); err != nil {
573			invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError))
574		}
575	}
576	if v.LoggingConfiguration != nil {
577		if err := validateLoggingConfigurationInput(v.LoggingConfiguration); err != nil {
578			invalidParams.AddNested("LoggingConfiguration", err.(smithy.InvalidParamsError))
579		}
580	}
581	if invalidParams.Len() > 0 {
582		return invalidParams
583	} else {
584		return nil
585	}
586}
587