1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package batch 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/batch/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpCancelJob struct { 14} 15 16func (*validateOpCancelJob) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpCancelJob) 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.(*CancelJobInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpCancelJobInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCreateComputeEnvironment struct { 34} 35 36func (*validateOpCreateComputeEnvironment) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCreateComputeEnvironment) 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.(*CreateComputeEnvironmentInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCreateComputeEnvironmentInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateJobQueue struct { 54} 55 56func (*validateOpCreateJobQueue) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateJobQueue) 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.(*CreateJobQueueInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateJobQueueInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpDeleteComputeEnvironment struct { 74} 75 76func (*validateOpDeleteComputeEnvironment) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpDeleteComputeEnvironment) 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.(*DeleteComputeEnvironmentInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpDeleteComputeEnvironmentInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpDeleteJobQueue struct { 94} 95 96func (*validateOpDeleteJobQueue) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpDeleteJobQueue) 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.(*DeleteJobQueueInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpDeleteJobQueueInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeregisterJobDefinition struct { 114} 115 116func (*validateOpDeregisterJobDefinition) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeregisterJobDefinition) 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.(*DeregisterJobDefinitionInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeregisterJobDefinitionInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDescribeJobs struct { 134} 135 136func (*validateOpDescribeJobs) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDescribeJobs) 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.(*DescribeJobsInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDescribeJobsInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpListTagsForResource struct { 154} 155 156func (*validateOpListTagsForResource) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpListTagsForResourceInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpRegisterJobDefinition struct { 174} 175 176func (*validateOpRegisterJobDefinition) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpRegisterJobDefinition) 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.(*RegisterJobDefinitionInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpRegisterJobDefinitionInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpSubmitJob struct { 194} 195 196func (*validateOpSubmitJob) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpSubmitJob) 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.(*SubmitJobInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpSubmitJobInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpTagResource struct { 214} 215 216func (*validateOpTagResource) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 221 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 222) { 223 input, ok := in.Parameters.(*TagResourceInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpTagResourceInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpTerminateJob struct { 234} 235 236func (*validateOpTerminateJob) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpTerminateJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 241 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 242) { 243 input, ok := in.Parameters.(*TerminateJobInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpTerminateJobInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpUntagResource struct { 254} 255 256func (*validateOpUntagResource) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 261 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 262) { 263 input, ok := in.Parameters.(*UntagResourceInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpUntagResourceInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpUpdateComputeEnvironment struct { 274} 275 276func (*validateOpUpdateComputeEnvironment) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpUpdateComputeEnvironment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 281 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 282) { 283 input, ok := in.Parameters.(*UpdateComputeEnvironmentInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpUpdateComputeEnvironmentInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpUpdateJobQueue struct { 294} 295 296func (*validateOpUpdateJobQueue) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpUpdateJobQueue) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 301 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 302) { 303 input, ok := in.Parameters.(*UpdateJobQueueInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpUpdateJobQueueInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313func addOpCancelJobValidationMiddleware(stack *middleware.Stack) error { 314 return stack.Initialize.Add(&validateOpCancelJob{}, middleware.After) 315} 316 317func addOpCreateComputeEnvironmentValidationMiddleware(stack *middleware.Stack) error { 318 return stack.Initialize.Add(&validateOpCreateComputeEnvironment{}, middleware.After) 319} 320 321func addOpCreateJobQueueValidationMiddleware(stack *middleware.Stack) error { 322 return stack.Initialize.Add(&validateOpCreateJobQueue{}, middleware.After) 323} 324 325func addOpDeleteComputeEnvironmentValidationMiddleware(stack *middleware.Stack) error { 326 return stack.Initialize.Add(&validateOpDeleteComputeEnvironment{}, middleware.After) 327} 328 329func addOpDeleteJobQueueValidationMiddleware(stack *middleware.Stack) error { 330 return stack.Initialize.Add(&validateOpDeleteJobQueue{}, middleware.After) 331} 332 333func addOpDeregisterJobDefinitionValidationMiddleware(stack *middleware.Stack) error { 334 return stack.Initialize.Add(&validateOpDeregisterJobDefinition{}, middleware.After) 335} 336 337func addOpDescribeJobsValidationMiddleware(stack *middleware.Stack) error { 338 return stack.Initialize.Add(&validateOpDescribeJobs{}, middleware.After) 339} 340 341func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 342 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 343} 344 345func addOpRegisterJobDefinitionValidationMiddleware(stack *middleware.Stack) error { 346 return stack.Initialize.Add(&validateOpRegisterJobDefinition{}, middleware.After) 347} 348 349func addOpSubmitJobValidationMiddleware(stack *middleware.Stack) error { 350 return stack.Initialize.Add(&validateOpSubmitJob{}, middleware.After) 351} 352 353func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 354 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 355} 356 357func addOpTerminateJobValidationMiddleware(stack *middleware.Stack) error { 358 return stack.Initialize.Add(&validateOpTerminateJob{}, middleware.After) 359} 360 361func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 362 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 363} 364 365func addOpUpdateComputeEnvironmentValidationMiddleware(stack *middleware.Stack) error { 366 return stack.Initialize.Add(&validateOpUpdateComputeEnvironment{}, middleware.After) 367} 368 369func addOpUpdateJobQueueValidationMiddleware(stack *middleware.Stack) error { 370 return stack.Initialize.Add(&validateOpUpdateJobQueue{}, middleware.After) 371} 372 373func validateComputeEnvironmentOrder(v *types.ComputeEnvironmentOrder) error { 374 if v == nil { 375 return nil 376 } 377 invalidParams := smithy.InvalidParamsError{Context: "ComputeEnvironmentOrder"} 378 if v.ComputeEnvironment == nil { 379 invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironment")) 380 } 381 if invalidParams.Len() > 0 { 382 return invalidParams 383 } else { 384 return nil 385 } 386} 387 388func validateComputeEnvironmentOrders(v []types.ComputeEnvironmentOrder) error { 389 if v == nil { 390 return nil 391 } 392 invalidParams := smithy.InvalidParamsError{Context: "ComputeEnvironmentOrders"} 393 for i := range v { 394 if err := validateComputeEnvironmentOrder(&v[i]); err != nil { 395 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 396 } 397 } 398 if invalidParams.Len() > 0 { 399 return invalidParams 400 } else { 401 return nil 402 } 403} 404 405func validateComputeResource(v *types.ComputeResource) error { 406 if v == nil { 407 return nil 408 } 409 invalidParams := smithy.InvalidParamsError{Context: "ComputeResource"} 410 if len(v.Type) == 0 { 411 invalidParams.Add(smithy.NewErrParamRequired("Type")) 412 } 413 if v.Subnets == nil { 414 invalidParams.Add(smithy.NewErrParamRequired("Subnets")) 415 } 416 if v.Ec2Configuration != nil { 417 if err := validateEc2ConfigurationList(v.Ec2Configuration); err != nil { 418 invalidParams.AddNested("Ec2Configuration", err.(smithy.InvalidParamsError)) 419 } 420 } 421 if invalidParams.Len() > 0 { 422 return invalidParams 423 } else { 424 return nil 425 } 426} 427 428func validateContainerOverrides(v *types.ContainerOverrides) error { 429 if v == nil { 430 return nil 431 } 432 invalidParams := smithy.InvalidParamsError{Context: "ContainerOverrides"} 433 if v.ResourceRequirements != nil { 434 if err := validateResourceRequirements(v.ResourceRequirements); err != nil { 435 invalidParams.AddNested("ResourceRequirements", err.(smithy.InvalidParamsError)) 436 } 437 } 438 if invalidParams.Len() > 0 { 439 return invalidParams 440 } else { 441 return nil 442 } 443} 444 445func validateContainerProperties(v *types.ContainerProperties) error { 446 if v == nil { 447 return nil 448 } 449 invalidParams := smithy.InvalidParamsError{Context: "ContainerProperties"} 450 if v.Ulimits != nil { 451 if err := validateUlimits(v.Ulimits); err != nil { 452 invalidParams.AddNested("Ulimits", err.(smithy.InvalidParamsError)) 453 } 454 } 455 if v.ResourceRequirements != nil { 456 if err := validateResourceRequirements(v.ResourceRequirements); err != nil { 457 invalidParams.AddNested("ResourceRequirements", err.(smithy.InvalidParamsError)) 458 } 459 } 460 if v.LinuxParameters != nil { 461 if err := validateLinuxParameters(v.LinuxParameters); err != nil { 462 invalidParams.AddNested("LinuxParameters", err.(smithy.InvalidParamsError)) 463 } 464 } 465 if v.LogConfiguration != nil { 466 if err := validateLogConfiguration(v.LogConfiguration); err != nil { 467 invalidParams.AddNested("LogConfiguration", err.(smithy.InvalidParamsError)) 468 } 469 } 470 if v.Secrets != nil { 471 if err := validateSecretList(v.Secrets); err != nil { 472 invalidParams.AddNested("Secrets", err.(smithy.InvalidParamsError)) 473 } 474 } 475 if invalidParams.Len() > 0 { 476 return invalidParams 477 } else { 478 return nil 479 } 480} 481 482func validateDevice(v *types.Device) error { 483 if v == nil { 484 return nil 485 } 486 invalidParams := smithy.InvalidParamsError{Context: "Device"} 487 if v.HostPath == nil { 488 invalidParams.Add(smithy.NewErrParamRequired("HostPath")) 489 } 490 if invalidParams.Len() > 0 { 491 return invalidParams 492 } else { 493 return nil 494 } 495} 496 497func validateDevicesList(v []types.Device) error { 498 if v == nil { 499 return nil 500 } 501 invalidParams := smithy.InvalidParamsError{Context: "DevicesList"} 502 for i := range v { 503 if err := validateDevice(&v[i]); err != nil { 504 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 505 } 506 } 507 if invalidParams.Len() > 0 { 508 return invalidParams 509 } else { 510 return nil 511 } 512} 513 514func validateEc2Configuration(v *types.Ec2Configuration) error { 515 if v == nil { 516 return nil 517 } 518 invalidParams := smithy.InvalidParamsError{Context: "Ec2Configuration"} 519 if v.ImageType == nil { 520 invalidParams.Add(smithy.NewErrParamRequired("ImageType")) 521 } 522 if invalidParams.Len() > 0 { 523 return invalidParams 524 } else { 525 return nil 526 } 527} 528 529func validateEc2ConfigurationList(v []types.Ec2Configuration) error { 530 if v == nil { 531 return nil 532 } 533 invalidParams := smithy.InvalidParamsError{Context: "Ec2ConfigurationList"} 534 for i := range v { 535 if err := validateEc2Configuration(&v[i]); err != nil { 536 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 537 } 538 } 539 if invalidParams.Len() > 0 { 540 return invalidParams 541 } else { 542 return nil 543 } 544} 545 546func validateEvaluateOnExit(v *types.EvaluateOnExit) error { 547 if v == nil { 548 return nil 549 } 550 invalidParams := smithy.InvalidParamsError{Context: "EvaluateOnExit"} 551 if len(v.Action) == 0 { 552 invalidParams.Add(smithy.NewErrParamRequired("Action")) 553 } 554 if invalidParams.Len() > 0 { 555 return invalidParams 556 } else { 557 return nil 558 } 559} 560 561func validateEvaluateOnExitList(v []types.EvaluateOnExit) error { 562 if v == nil { 563 return nil 564 } 565 invalidParams := smithy.InvalidParamsError{Context: "EvaluateOnExitList"} 566 for i := range v { 567 if err := validateEvaluateOnExit(&v[i]); err != nil { 568 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 569 } 570 } 571 if invalidParams.Len() > 0 { 572 return invalidParams 573 } else { 574 return nil 575 } 576} 577 578func validateLinuxParameters(v *types.LinuxParameters) error { 579 if v == nil { 580 return nil 581 } 582 invalidParams := smithy.InvalidParamsError{Context: "LinuxParameters"} 583 if v.Devices != nil { 584 if err := validateDevicesList(v.Devices); err != nil { 585 invalidParams.AddNested("Devices", err.(smithy.InvalidParamsError)) 586 } 587 } 588 if v.Tmpfs != nil { 589 if err := validateTmpfsList(v.Tmpfs); err != nil { 590 invalidParams.AddNested("Tmpfs", err.(smithy.InvalidParamsError)) 591 } 592 } 593 if invalidParams.Len() > 0 { 594 return invalidParams 595 } else { 596 return nil 597 } 598} 599 600func validateLogConfiguration(v *types.LogConfiguration) error { 601 if v == nil { 602 return nil 603 } 604 invalidParams := smithy.InvalidParamsError{Context: "LogConfiguration"} 605 if len(v.LogDriver) == 0 { 606 invalidParams.Add(smithy.NewErrParamRequired("LogDriver")) 607 } 608 if v.SecretOptions != nil { 609 if err := validateSecretList(v.SecretOptions); err != nil { 610 invalidParams.AddNested("SecretOptions", err.(smithy.InvalidParamsError)) 611 } 612 } 613 if invalidParams.Len() > 0 { 614 return invalidParams 615 } else { 616 return nil 617 } 618} 619 620func validateNodeOverrides(v *types.NodeOverrides) error { 621 if v == nil { 622 return nil 623 } 624 invalidParams := smithy.InvalidParamsError{Context: "NodeOverrides"} 625 if v.NodePropertyOverrides != nil { 626 if err := validateNodePropertyOverrides(v.NodePropertyOverrides); err != nil { 627 invalidParams.AddNested("NodePropertyOverrides", err.(smithy.InvalidParamsError)) 628 } 629 } 630 if invalidParams.Len() > 0 { 631 return invalidParams 632 } else { 633 return nil 634 } 635} 636 637func validateNodeProperties(v *types.NodeProperties) error { 638 if v == nil { 639 return nil 640 } 641 invalidParams := smithy.InvalidParamsError{Context: "NodeProperties"} 642 if v.NodeRangeProperties == nil { 643 invalidParams.Add(smithy.NewErrParamRequired("NodeRangeProperties")) 644 } else if v.NodeRangeProperties != nil { 645 if err := validateNodeRangeProperties(v.NodeRangeProperties); err != nil { 646 invalidParams.AddNested("NodeRangeProperties", err.(smithy.InvalidParamsError)) 647 } 648 } 649 if invalidParams.Len() > 0 { 650 return invalidParams 651 } else { 652 return nil 653 } 654} 655 656func validateNodePropertyOverride(v *types.NodePropertyOverride) error { 657 if v == nil { 658 return nil 659 } 660 invalidParams := smithy.InvalidParamsError{Context: "NodePropertyOverride"} 661 if v.TargetNodes == nil { 662 invalidParams.Add(smithy.NewErrParamRequired("TargetNodes")) 663 } 664 if v.ContainerOverrides != nil { 665 if err := validateContainerOverrides(v.ContainerOverrides); err != nil { 666 invalidParams.AddNested("ContainerOverrides", err.(smithy.InvalidParamsError)) 667 } 668 } 669 if invalidParams.Len() > 0 { 670 return invalidParams 671 } else { 672 return nil 673 } 674} 675 676func validateNodePropertyOverrides(v []types.NodePropertyOverride) error { 677 if v == nil { 678 return nil 679 } 680 invalidParams := smithy.InvalidParamsError{Context: "NodePropertyOverrides"} 681 for i := range v { 682 if err := validateNodePropertyOverride(&v[i]); err != nil { 683 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 684 } 685 } 686 if invalidParams.Len() > 0 { 687 return invalidParams 688 } else { 689 return nil 690 } 691} 692 693func validateNodeRangeProperties(v []types.NodeRangeProperty) error { 694 if v == nil { 695 return nil 696 } 697 invalidParams := smithy.InvalidParamsError{Context: "NodeRangeProperties"} 698 for i := range v { 699 if err := validateNodeRangeProperty(&v[i]); err != nil { 700 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 701 } 702 } 703 if invalidParams.Len() > 0 { 704 return invalidParams 705 } else { 706 return nil 707 } 708} 709 710func validateNodeRangeProperty(v *types.NodeRangeProperty) error { 711 if v == nil { 712 return nil 713 } 714 invalidParams := smithy.InvalidParamsError{Context: "NodeRangeProperty"} 715 if v.TargetNodes == nil { 716 invalidParams.Add(smithy.NewErrParamRequired("TargetNodes")) 717 } 718 if v.Container != nil { 719 if err := validateContainerProperties(v.Container); err != nil { 720 invalidParams.AddNested("Container", err.(smithy.InvalidParamsError)) 721 } 722 } 723 if invalidParams.Len() > 0 { 724 return invalidParams 725 } else { 726 return nil 727 } 728} 729 730func validateResourceRequirement(v *types.ResourceRequirement) error { 731 if v == nil { 732 return nil 733 } 734 invalidParams := smithy.InvalidParamsError{Context: "ResourceRequirement"} 735 if v.Value == nil { 736 invalidParams.Add(smithy.NewErrParamRequired("Value")) 737 } 738 if len(v.Type) == 0 { 739 invalidParams.Add(smithy.NewErrParamRequired("Type")) 740 } 741 if invalidParams.Len() > 0 { 742 return invalidParams 743 } else { 744 return nil 745 } 746} 747 748func validateResourceRequirements(v []types.ResourceRequirement) error { 749 if v == nil { 750 return nil 751 } 752 invalidParams := smithy.InvalidParamsError{Context: "ResourceRequirements"} 753 for i := range v { 754 if err := validateResourceRequirement(&v[i]); err != nil { 755 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 756 } 757 } 758 if invalidParams.Len() > 0 { 759 return invalidParams 760 } else { 761 return nil 762 } 763} 764 765func validateRetryStrategy(v *types.RetryStrategy) error { 766 if v == nil { 767 return nil 768 } 769 invalidParams := smithy.InvalidParamsError{Context: "RetryStrategy"} 770 if v.EvaluateOnExit != nil { 771 if err := validateEvaluateOnExitList(v.EvaluateOnExit); err != nil { 772 invalidParams.AddNested("EvaluateOnExit", err.(smithy.InvalidParamsError)) 773 } 774 } 775 if invalidParams.Len() > 0 { 776 return invalidParams 777 } else { 778 return nil 779 } 780} 781 782func validateSecret(v *types.Secret) error { 783 if v == nil { 784 return nil 785 } 786 invalidParams := smithy.InvalidParamsError{Context: "Secret"} 787 if v.Name == nil { 788 invalidParams.Add(smithy.NewErrParamRequired("Name")) 789 } 790 if v.ValueFrom == nil { 791 invalidParams.Add(smithy.NewErrParamRequired("ValueFrom")) 792 } 793 if invalidParams.Len() > 0 { 794 return invalidParams 795 } else { 796 return nil 797 } 798} 799 800func validateSecretList(v []types.Secret) error { 801 if v == nil { 802 return nil 803 } 804 invalidParams := smithy.InvalidParamsError{Context: "SecretList"} 805 for i := range v { 806 if err := validateSecret(&v[i]); err != nil { 807 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 808 } 809 } 810 if invalidParams.Len() > 0 { 811 return invalidParams 812 } else { 813 return nil 814 } 815} 816 817func validateTmpfs(v *types.Tmpfs) error { 818 if v == nil { 819 return nil 820 } 821 invalidParams := smithy.InvalidParamsError{Context: "Tmpfs"} 822 if v.ContainerPath == nil { 823 invalidParams.Add(smithy.NewErrParamRequired("ContainerPath")) 824 } 825 if invalidParams.Len() > 0 { 826 return invalidParams 827 } else { 828 return nil 829 } 830} 831 832func validateTmpfsList(v []types.Tmpfs) error { 833 if v == nil { 834 return nil 835 } 836 invalidParams := smithy.InvalidParamsError{Context: "TmpfsList"} 837 for i := range v { 838 if err := validateTmpfs(&v[i]); err != nil { 839 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 840 } 841 } 842 if invalidParams.Len() > 0 { 843 return invalidParams 844 } else { 845 return nil 846 } 847} 848 849func validateUlimit(v *types.Ulimit) error { 850 if v == nil { 851 return nil 852 } 853 invalidParams := smithy.InvalidParamsError{Context: "Ulimit"} 854 if v.Name == nil { 855 invalidParams.Add(smithy.NewErrParamRequired("Name")) 856 } 857 if invalidParams.Len() > 0 { 858 return invalidParams 859 } else { 860 return nil 861 } 862} 863 864func validateUlimits(v []types.Ulimit) error { 865 if v == nil { 866 return nil 867 } 868 invalidParams := smithy.InvalidParamsError{Context: "Ulimits"} 869 for i := range v { 870 if err := validateUlimit(&v[i]); err != nil { 871 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 872 } 873 } 874 if invalidParams.Len() > 0 { 875 return invalidParams 876 } else { 877 return nil 878 } 879} 880 881func validateOpCancelJobInput(v *CancelJobInput) error { 882 if v == nil { 883 return nil 884 } 885 invalidParams := smithy.InvalidParamsError{Context: "CancelJobInput"} 886 if v.JobId == nil { 887 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 888 } 889 if v.Reason == nil { 890 invalidParams.Add(smithy.NewErrParamRequired("Reason")) 891 } 892 if invalidParams.Len() > 0 { 893 return invalidParams 894 } else { 895 return nil 896 } 897} 898 899func validateOpCreateComputeEnvironmentInput(v *CreateComputeEnvironmentInput) error { 900 if v == nil { 901 return nil 902 } 903 invalidParams := smithy.InvalidParamsError{Context: "CreateComputeEnvironmentInput"} 904 if v.ComputeEnvironmentName == nil { 905 invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironmentName")) 906 } 907 if len(v.Type) == 0 { 908 invalidParams.Add(smithy.NewErrParamRequired("Type")) 909 } 910 if v.ComputeResources != nil { 911 if err := validateComputeResource(v.ComputeResources); err != nil { 912 invalidParams.AddNested("ComputeResources", err.(smithy.InvalidParamsError)) 913 } 914 } 915 if v.ServiceRole == nil { 916 invalidParams.Add(smithy.NewErrParamRequired("ServiceRole")) 917 } 918 if invalidParams.Len() > 0 { 919 return invalidParams 920 } else { 921 return nil 922 } 923} 924 925func validateOpCreateJobQueueInput(v *CreateJobQueueInput) error { 926 if v == nil { 927 return nil 928 } 929 invalidParams := smithy.InvalidParamsError{Context: "CreateJobQueueInput"} 930 if v.JobQueueName == nil { 931 invalidParams.Add(smithy.NewErrParamRequired("JobQueueName")) 932 } 933 if v.ComputeEnvironmentOrder == nil { 934 invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironmentOrder")) 935 } else if v.ComputeEnvironmentOrder != nil { 936 if err := validateComputeEnvironmentOrders(v.ComputeEnvironmentOrder); err != nil { 937 invalidParams.AddNested("ComputeEnvironmentOrder", err.(smithy.InvalidParamsError)) 938 } 939 } 940 if invalidParams.Len() > 0 { 941 return invalidParams 942 } else { 943 return nil 944 } 945} 946 947func validateOpDeleteComputeEnvironmentInput(v *DeleteComputeEnvironmentInput) error { 948 if v == nil { 949 return nil 950 } 951 invalidParams := smithy.InvalidParamsError{Context: "DeleteComputeEnvironmentInput"} 952 if v.ComputeEnvironment == nil { 953 invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironment")) 954 } 955 if invalidParams.Len() > 0 { 956 return invalidParams 957 } else { 958 return nil 959 } 960} 961 962func validateOpDeleteJobQueueInput(v *DeleteJobQueueInput) error { 963 if v == nil { 964 return nil 965 } 966 invalidParams := smithy.InvalidParamsError{Context: "DeleteJobQueueInput"} 967 if v.JobQueue == nil { 968 invalidParams.Add(smithy.NewErrParamRequired("JobQueue")) 969 } 970 if invalidParams.Len() > 0 { 971 return invalidParams 972 } else { 973 return nil 974 } 975} 976 977func validateOpDeregisterJobDefinitionInput(v *DeregisterJobDefinitionInput) error { 978 if v == nil { 979 return nil 980 } 981 invalidParams := smithy.InvalidParamsError{Context: "DeregisterJobDefinitionInput"} 982 if v.JobDefinition == nil { 983 invalidParams.Add(smithy.NewErrParamRequired("JobDefinition")) 984 } 985 if invalidParams.Len() > 0 { 986 return invalidParams 987 } else { 988 return nil 989 } 990} 991 992func validateOpDescribeJobsInput(v *DescribeJobsInput) error { 993 if v == nil { 994 return nil 995 } 996 invalidParams := smithy.InvalidParamsError{Context: "DescribeJobsInput"} 997 if v.Jobs == nil { 998 invalidParams.Add(smithy.NewErrParamRequired("Jobs")) 999 } 1000 if invalidParams.Len() > 0 { 1001 return invalidParams 1002 } else { 1003 return nil 1004 } 1005} 1006 1007func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1008 if v == nil { 1009 return nil 1010 } 1011 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1012 if v.ResourceArn == nil { 1013 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1014 } 1015 if invalidParams.Len() > 0 { 1016 return invalidParams 1017 } else { 1018 return nil 1019 } 1020} 1021 1022func validateOpRegisterJobDefinitionInput(v *RegisterJobDefinitionInput) error { 1023 if v == nil { 1024 return nil 1025 } 1026 invalidParams := smithy.InvalidParamsError{Context: "RegisterJobDefinitionInput"} 1027 if v.JobDefinitionName == nil { 1028 invalidParams.Add(smithy.NewErrParamRequired("JobDefinitionName")) 1029 } 1030 if len(v.Type) == 0 { 1031 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1032 } 1033 if v.ContainerProperties != nil { 1034 if err := validateContainerProperties(v.ContainerProperties); err != nil { 1035 invalidParams.AddNested("ContainerProperties", err.(smithy.InvalidParamsError)) 1036 } 1037 } 1038 if v.NodeProperties != nil { 1039 if err := validateNodeProperties(v.NodeProperties); err != nil { 1040 invalidParams.AddNested("NodeProperties", err.(smithy.InvalidParamsError)) 1041 } 1042 } 1043 if v.RetryStrategy != nil { 1044 if err := validateRetryStrategy(v.RetryStrategy); err != nil { 1045 invalidParams.AddNested("RetryStrategy", err.(smithy.InvalidParamsError)) 1046 } 1047 } 1048 if invalidParams.Len() > 0 { 1049 return invalidParams 1050 } else { 1051 return nil 1052 } 1053} 1054 1055func validateOpSubmitJobInput(v *SubmitJobInput) error { 1056 if v == nil { 1057 return nil 1058 } 1059 invalidParams := smithy.InvalidParamsError{Context: "SubmitJobInput"} 1060 if v.JobName == nil { 1061 invalidParams.Add(smithy.NewErrParamRequired("JobName")) 1062 } 1063 if v.JobQueue == nil { 1064 invalidParams.Add(smithy.NewErrParamRequired("JobQueue")) 1065 } 1066 if v.JobDefinition == nil { 1067 invalidParams.Add(smithy.NewErrParamRequired("JobDefinition")) 1068 } 1069 if v.ContainerOverrides != nil { 1070 if err := validateContainerOverrides(v.ContainerOverrides); err != nil { 1071 invalidParams.AddNested("ContainerOverrides", err.(smithy.InvalidParamsError)) 1072 } 1073 } 1074 if v.NodeOverrides != nil { 1075 if err := validateNodeOverrides(v.NodeOverrides); err != nil { 1076 invalidParams.AddNested("NodeOverrides", err.(smithy.InvalidParamsError)) 1077 } 1078 } 1079 if v.RetryStrategy != nil { 1080 if err := validateRetryStrategy(v.RetryStrategy); err != nil { 1081 invalidParams.AddNested("RetryStrategy", err.(smithy.InvalidParamsError)) 1082 } 1083 } 1084 if invalidParams.Len() > 0 { 1085 return invalidParams 1086 } else { 1087 return nil 1088 } 1089} 1090 1091func validateOpTagResourceInput(v *TagResourceInput) error { 1092 if v == nil { 1093 return nil 1094 } 1095 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1096 if v.ResourceArn == nil { 1097 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1098 } 1099 if v.Tags == nil { 1100 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1101 } 1102 if invalidParams.Len() > 0 { 1103 return invalidParams 1104 } else { 1105 return nil 1106 } 1107} 1108 1109func validateOpTerminateJobInput(v *TerminateJobInput) error { 1110 if v == nil { 1111 return nil 1112 } 1113 invalidParams := smithy.InvalidParamsError{Context: "TerminateJobInput"} 1114 if v.JobId == nil { 1115 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 1116 } 1117 if v.Reason == nil { 1118 invalidParams.Add(smithy.NewErrParamRequired("Reason")) 1119 } 1120 if invalidParams.Len() > 0 { 1121 return invalidParams 1122 } else { 1123 return nil 1124 } 1125} 1126 1127func validateOpUntagResourceInput(v *UntagResourceInput) error { 1128 if v == nil { 1129 return nil 1130 } 1131 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1132 if v.ResourceArn == nil { 1133 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1134 } 1135 if v.TagKeys == nil { 1136 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1137 } 1138 if invalidParams.Len() > 0 { 1139 return invalidParams 1140 } else { 1141 return nil 1142 } 1143} 1144 1145func validateOpUpdateComputeEnvironmentInput(v *UpdateComputeEnvironmentInput) error { 1146 if v == nil { 1147 return nil 1148 } 1149 invalidParams := smithy.InvalidParamsError{Context: "UpdateComputeEnvironmentInput"} 1150 if v.ComputeEnvironment == nil { 1151 invalidParams.Add(smithy.NewErrParamRequired("ComputeEnvironment")) 1152 } 1153 if invalidParams.Len() > 0 { 1154 return invalidParams 1155 } else { 1156 return nil 1157 } 1158} 1159 1160func validateOpUpdateJobQueueInput(v *UpdateJobQueueInput) error { 1161 if v == nil { 1162 return nil 1163 } 1164 invalidParams := smithy.InvalidParamsError{Context: "UpdateJobQueueInput"} 1165 if v.JobQueue == nil { 1166 invalidParams.Add(smithy.NewErrParamRequired("JobQueue")) 1167 } 1168 if v.ComputeEnvironmentOrder != nil { 1169 if err := validateComputeEnvironmentOrders(v.ComputeEnvironmentOrder); err != nil { 1170 invalidParams.AddNested("ComputeEnvironmentOrder", err.(smithy.InvalidParamsError)) 1171 } 1172 } 1173 if invalidParams.Len() > 0 { 1174 return invalidParams 1175 } else { 1176 return nil 1177 } 1178} 1179