1// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT. 2 3package servicediscovery 4 5import ( 6 "fmt" 7 "time" 8 9 "github.com/aws/aws-sdk-go/aws" 10 "github.com/aws/aws-sdk-go/aws/awsutil" 11 "github.com/aws/aws-sdk-go/aws/request" 12) 13 14const opCreatePrivateDnsNamespace = "CreatePrivateDnsNamespace" 15 16// CreatePrivateDnsNamespaceRequest generates a "aws/request.Request" representing the 17// client's request for the CreatePrivateDnsNamespace operation. The "output" return 18// value will be populated with the request's response once the request complets 19// successfuly. 20// 21// Use "Send" method on the returned Request to send the API call to the service. 22// the "output" return value is not valid until after Send returns without error. 23// 24// See CreatePrivateDnsNamespace for more information on using the CreatePrivateDnsNamespace 25// API call, and error handling. 26// 27// This method is useful when you want to inject custom logic or configuration 28// into the SDK's request lifecycle. Such as custom headers, or retry logic. 29// 30// 31// // Example sending a request using the CreatePrivateDnsNamespaceRequest method. 32// req, resp := client.CreatePrivateDnsNamespaceRequest(params) 33// 34// err := req.Send() 35// if err == nil { // resp is now filled 36// fmt.Println(resp) 37// } 38// 39// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreatePrivateDnsNamespace 40func (c *ServiceDiscovery) CreatePrivateDnsNamespaceRequest(input *CreatePrivateDnsNamespaceInput) (req *request.Request, output *CreatePrivateDnsNamespaceOutput) { 41 op := &request.Operation{ 42 Name: opCreatePrivateDnsNamespace, 43 HTTPMethod: "POST", 44 HTTPPath: "/", 45 } 46 47 if input == nil { 48 input = &CreatePrivateDnsNamespaceInput{} 49 } 50 51 output = &CreatePrivateDnsNamespaceOutput{} 52 req = c.newRequest(op, input, output) 53 return 54} 55 56// CreatePrivateDnsNamespace API operation for Amazon Route 53 Auto Naming. 57// 58// Creates a private namespace based on DNS, which will be visible only inside 59// a specified Amazon VPC. The namespace defines your service naming scheme. 60// For example, if you name your namespace example.com and name your service 61// backend, the resulting DNS name for the service will be backend.example.com. 62// You can associate more than one service with the same namespace. 63// 64// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 65// with awserr.Error's Code and Message methods to get detailed information about 66// the error. 67// 68// See the AWS API reference guide for Amazon Route 53 Auto Naming's 69// API operation CreatePrivateDnsNamespace for usage and error information. 70// 71// Returned Error Codes: 72// * ErrCodeInvalidInput "InvalidInput" 73// One or more specified values aren't valid. For example, when you're creating 74// a namespace, the value of Name might not be a valid DNS name. 75// 76// * ErrCodeNamespaceAlreadyExists "NamespaceAlreadyExists" 77// The namespace that you're trying to create already exists. 78// 79// * ErrCodeResourceLimitExceeded "ResourceLimitExceeded" 80// The resource can't be created because you've reached the limit on the number 81// of resources. 82// 83// * ErrCodeDuplicateRequest "DuplicateRequest" 84// This request tried to create an object that already exists. 85// 86// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreatePrivateDnsNamespace 87func (c *ServiceDiscovery) CreatePrivateDnsNamespace(input *CreatePrivateDnsNamespaceInput) (*CreatePrivateDnsNamespaceOutput, error) { 88 req, out := c.CreatePrivateDnsNamespaceRequest(input) 89 return out, req.Send() 90} 91 92// CreatePrivateDnsNamespaceWithContext is the same as CreatePrivateDnsNamespace with the addition of 93// the ability to pass a context and additional request options. 94// 95// See CreatePrivateDnsNamespace for details on how to use this API operation. 96// 97// The context must be non-nil and will be used for request cancellation. If 98// the context is nil a panic will occur. In the future the SDK may create 99// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 100// for more information on using Contexts. 101func (c *ServiceDiscovery) CreatePrivateDnsNamespaceWithContext(ctx aws.Context, input *CreatePrivateDnsNamespaceInput, opts ...request.Option) (*CreatePrivateDnsNamespaceOutput, error) { 102 req, out := c.CreatePrivateDnsNamespaceRequest(input) 103 req.SetContext(ctx) 104 req.ApplyOptions(opts...) 105 return out, req.Send() 106} 107 108const opCreatePublicDnsNamespace = "CreatePublicDnsNamespace" 109 110// CreatePublicDnsNamespaceRequest generates a "aws/request.Request" representing the 111// client's request for the CreatePublicDnsNamespace operation. The "output" return 112// value will be populated with the request's response once the request complets 113// successfuly. 114// 115// Use "Send" method on the returned Request to send the API call to the service. 116// the "output" return value is not valid until after Send returns without error. 117// 118// See CreatePublicDnsNamespace for more information on using the CreatePublicDnsNamespace 119// API call, and error handling. 120// 121// This method is useful when you want to inject custom logic or configuration 122// into the SDK's request lifecycle. Such as custom headers, or retry logic. 123// 124// 125// // Example sending a request using the CreatePublicDnsNamespaceRequest method. 126// req, resp := client.CreatePublicDnsNamespaceRequest(params) 127// 128// err := req.Send() 129// if err == nil { // resp is now filled 130// fmt.Println(resp) 131// } 132// 133// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreatePublicDnsNamespace 134func (c *ServiceDiscovery) CreatePublicDnsNamespaceRequest(input *CreatePublicDnsNamespaceInput) (req *request.Request, output *CreatePublicDnsNamespaceOutput) { 135 op := &request.Operation{ 136 Name: opCreatePublicDnsNamespace, 137 HTTPMethod: "POST", 138 HTTPPath: "/", 139 } 140 141 if input == nil { 142 input = &CreatePublicDnsNamespaceInput{} 143 } 144 145 output = &CreatePublicDnsNamespaceOutput{} 146 req = c.newRequest(op, input, output) 147 return 148} 149 150// CreatePublicDnsNamespace API operation for Amazon Route 53 Auto Naming. 151// 152// Creates a public namespace based on DNS, which will be visible on the internet. 153// The namespace defines your service naming scheme. For example, if you name 154// your namespace example.com and name your service backend, the resulting DNS 155// name for the service will be backend.example.com. You can associate more 156// than one service with the same namespace. 157// 158// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 159// with awserr.Error's Code and Message methods to get detailed information about 160// the error. 161// 162// See the AWS API reference guide for Amazon Route 53 Auto Naming's 163// API operation CreatePublicDnsNamespace for usage and error information. 164// 165// Returned Error Codes: 166// * ErrCodeInvalidInput "InvalidInput" 167// One or more specified values aren't valid. For example, when you're creating 168// a namespace, the value of Name might not be a valid DNS name. 169// 170// * ErrCodeNamespaceAlreadyExists "NamespaceAlreadyExists" 171// The namespace that you're trying to create already exists. 172// 173// * ErrCodeResourceLimitExceeded "ResourceLimitExceeded" 174// The resource can't be created because you've reached the limit on the number 175// of resources. 176// 177// * ErrCodeDuplicateRequest "DuplicateRequest" 178// This request tried to create an object that already exists. 179// 180// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreatePublicDnsNamespace 181func (c *ServiceDiscovery) CreatePublicDnsNamespace(input *CreatePublicDnsNamespaceInput) (*CreatePublicDnsNamespaceOutput, error) { 182 req, out := c.CreatePublicDnsNamespaceRequest(input) 183 return out, req.Send() 184} 185 186// CreatePublicDnsNamespaceWithContext is the same as CreatePublicDnsNamespace with the addition of 187// the ability to pass a context and additional request options. 188// 189// See CreatePublicDnsNamespace for details on how to use this API operation. 190// 191// The context must be non-nil and will be used for request cancellation. If 192// the context is nil a panic will occur. In the future the SDK may create 193// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 194// for more information on using Contexts. 195func (c *ServiceDiscovery) CreatePublicDnsNamespaceWithContext(ctx aws.Context, input *CreatePublicDnsNamespaceInput, opts ...request.Option) (*CreatePublicDnsNamespaceOutput, error) { 196 req, out := c.CreatePublicDnsNamespaceRequest(input) 197 req.SetContext(ctx) 198 req.ApplyOptions(opts...) 199 return out, req.Send() 200} 201 202const opCreateService = "CreateService" 203 204// CreateServiceRequest generates a "aws/request.Request" representing the 205// client's request for the CreateService operation. The "output" return 206// value will be populated with the request's response once the request complets 207// successfuly. 208// 209// Use "Send" method on the returned Request to send the API call to the service. 210// the "output" return value is not valid until after Send returns without error. 211// 212// See CreateService for more information on using the CreateService 213// API call, and error handling. 214// 215// This method is useful when you want to inject custom logic or configuration 216// into the SDK's request lifecycle. Such as custom headers, or retry logic. 217// 218// 219// // Example sending a request using the CreateServiceRequest method. 220// req, resp := client.CreateServiceRequest(params) 221// 222// err := req.Send() 223// if err == nil { // resp is now filled 224// fmt.Println(resp) 225// } 226// 227// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreateService 228func (c *ServiceDiscovery) CreateServiceRequest(input *CreateServiceInput) (req *request.Request, output *CreateServiceOutput) { 229 op := &request.Operation{ 230 Name: opCreateService, 231 HTTPMethod: "POST", 232 HTTPPath: "/", 233 } 234 235 if input == nil { 236 input = &CreateServiceInput{} 237 } 238 239 output = &CreateServiceOutput{} 240 req = c.newRequest(op, input, output) 241 return 242} 243 244// CreateService API operation for Amazon Route 53 Auto Naming. 245// 246// Creates a service, which defines a template for the following entities: 247// 248// * One to five resource record sets 249// 250// * Optionally, a health check 251// 252// After you create the service, you can submit a RegisterInstance request, 253// and Amazon Route 53 uses the values in the template to create the specified 254// entities. 255// 256// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 257// with awserr.Error's Code and Message methods to get detailed information about 258// the error. 259// 260// See the AWS API reference guide for Amazon Route 53 Auto Naming's 261// API operation CreateService for usage and error information. 262// 263// Returned Error Codes: 264// * ErrCodeInvalidInput "InvalidInput" 265// One or more specified values aren't valid. For example, when you're creating 266// a namespace, the value of Name might not be a valid DNS name. 267// 268// * ErrCodeResourceLimitExceeded "ResourceLimitExceeded" 269// The resource can't be created because you've reached the limit on the number 270// of resources. 271// 272// * ErrCodeNamespaceNotFound "NamespaceNotFound" 273// No namespace exists with the specified ID. 274// 275// * ErrCodeServiceAlreadyExists "ServiceAlreadyExists" 276// The service can't be created because a service with the same name already 277// exists. 278// 279// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreateService 280func (c *ServiceDiscovery) CreateService(input *CreateServiceInput) (*CreateServiceOutput, error) { 281 req, out := c.CreateServiceRequest(input) 282 return out, req.Send() 283} 284 285// CreateServiceWithContext is the same as CreateService with the addition of 286// the ability to pass a context and additional request options. 287// 288// See CreateService for details on how to use this API operation. 289// 290// The context must be non-nil and will be used for request cancellation. If 291// the context is nil a panic will occur. In the future the SDK may create 292// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 293// for more information on using Contexts. 294func (c *ServiceDiscovery) CreateServiceWithContext(ctx aws.Context, input *CreateServiceInput, opts ...request.Option) (*CreateServiceOutput, error) { 295 req, out := c.CreateServiceRequest(input) 296 req.SetContext(ctx) 297 req.ApplyOptions(opts...) 298 return out, req.Send() 299} 300 301const opDeleteNamespace = "DeleteNamespace" 302 303// DeleteNamespaceRequest generates a "aws/request.Request" representing the 304// client's request for the DeleteNamespace operation. The "output" return 305// value will be populated with the request's response once the request complets 306// successfuly. 307// 308// Use "Send" method on the returned Request to send the API call to the service. 309// the "output" return value is not valid until after Send returns without error. 310// 311// See DeleteNamespace for more information on using the DeleteNamespace 312// API call, and error handling. 313// 314// This method is useful when you want to inject custom logic or configuration 315// into the SDK's request lifecycle. Such as custom headers, or retry logic. 316// 317// 318// // Example sending a request using the DeleteNamespaceRequest method. 319// req, resp := client.DeleteNamespaceRequest(params) 320// 321// err := req.Send() 322// if err == nil { // resp is now filled 323// fmt.Println(resp) 324// } 325// 326// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeleteNamespace 327func (c *ServiceDiscovery) DeleteNamespaceRequest(input *DeleteNamespaceInput) (req *request.Request, output *DeleteNamespaceOutput) { 328 op := &request.Operation{ 329 Name: opDeleteNamespace, 330 HTTPMethod: "POST", 331 HTTPPath: "/", 332 } 333 334 if input == nil { 335 input = &DeleteNamespaceInput{} 336 } 337 338 output = &DeleteNamespaceOutput{} 339 req = c.newRequest(op, input, output) 340 return 341} 342 343// DeleteNamespace API operation for Amazon Route 53 Auto Naming. 344// 345// Deletes a namespace from the current account. If the namespace still contains 346// one or more services, the request fails. 347// 348// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 349// with awserr.Error's Code and Message methods to get detailed information about 350// the error. 351// 352// See the AWS API reference guide for Amazon Route 53 Auto Naming's 353// API operation DeleteNamespace for usage and error information. 354// 355// Returned Error Codes: 356// * ErrCodeInvalidInput "InvalidInput" 357// One or more specified values aren't valid. For example, when you're creating 358// a namespace, the value of Name might not be a valid DNS name. 359// 360// * ErrCodeNamespaceNotFound "NamespaceNotFound" 361// No namespace exists with the specified ID. 362// 363// * ErrCodeResourceInUse "ResourceInUse" 364// The specified resource can't be deleted because it contains other resources. 365// For example, you can't delete a service that contains any instances. 366// 367// * ErrCodeDuplicateRequest "DuplicateRequest" 368// This request tried to create an object that already exists. 369// 370// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeleteNamespace 371func (c *ServiceDiscovery) DeleteNamespace(input *DeleteNamespaceInput) (*DeleteNamespaceOutput, error) { 372 req, out := c.DeleteNamespaceRequest(input) 373 return out, req.Send() 374} 375 376// DeleteNamespaceWithContext is the same as DeleteNamespace with the addition of 377// the ability to pass a context and additional request options. 378// 379// See DeleteNamespace for details on how to use this API operation. 380// 381// The context must be non-nil and will be used for request cancellation. If 382// the context is nil a panic will occur. In the future the SDK may create 383// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 384// for more information on using Contexts. 385func (c *ServiceDiscovery) DeleteNamespaceWithContext(ctx aws.Context, input *DeleteNamespaceInput, opts ...request.Option) (*DeleteNamespaceOutput, error) { 386 req, out := c.DeleteNamespaceRequest(input) 387 req.SetContext(ctx) 388 req.ApplyOptions(opts...) 389 return out, req.Send() 390} 391 392const opDeleteService = "DeleteService" 393 394// DeleteServiceRequest generates a "aws/request.Request" representing the 395// client's request for the DeleteService operation. The "output" return 396// value will be populated with the request's response once the request complets 397// successfuly. 398// 399// Use "Send" method on the returned Request to send the API call to the service. 400// the "output" return value is not valid until after Send returns without error. 401// 402// See DeleteService for more information on using the DeleteService 403// API call, and error handling. 404// 405// This method is useful when you want to inject custom logic or configuration 406// into the SDK's request lifecycle. Such as custom headers, or retry logic. 407// 408// 409// // Example sending a request using the DeleteServiceRequest method. 410// req, resp := client.DeleteServiceRequest(params) 411// 412// err := req.Send() 413// if err == nil { // resp is now filled 414// fmt.Println(resp) 415// } 416// 417// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeleteService 418func (c *ServiceDiscovery) DeleteServiceRequest(input *DeleteServiceInput) (req *request.Request, output *DeleteServiceOutput) { 419 op := &request.Operation{ 420 Name: opDeleteService, 421 HTTPMethod: "POST", 422 HTTPPath: "/", 423 } 424 425 if input == nil { 426 input = &DeleteServiceInput{} 427 } 428 429 output = &DeleteServiceOutput{} 430 req = c.newRequest(op, input, output) 431 return 432} 433 434// DeleteService API operation for Amazon Route 53 Auto Naming. 435// 436// Deletes a specified service. If the service still contains one or more registered 437// instances, the request fails. 438// 439// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 440// with awserr.Error's Code and Message methods to get detailed information about 441// the error. 442// 443// See the AWS API reference guide for Amazon Route 53 Auto Naming's 444// API operation DeleteService for usage and error information. 445// 446// Returned Error Codes: 447// * ErrCodeInvalidInput "InvalidInput" 448// One or more specified values aren't valid. For example, when you're creating 449// a namespace, the value of Name might not be a valid DNS name. 450// 451// * ErrCodeServiceNotFound "ServiceNotFound" 452// No service exists with the specified ID. 453// 454// * ErrCodeResourceInUse "ResourceInUse" 455// The specified resource can't be deleted because it contains other resources. 456// For example, you can't delete a service that contains any instances. 457// 458// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeleteService 459func (c *ServiceDiscovery) DeleteService(input *DeleteServiceInput) (*DeleteServiceOutput, error) { 460 req, out := c.DeleteServiceRequest(input) 461 return out, req.Send() 462} 463 464// DeleteServiceWithContext is the same as DeleteService with the addition of 465// the ability to pass a context and additional request options. 466// 467// See DeleteService for details on how to use this API operation. 468// 469// The context must be non-nil and will be used for request cancellation. If 470// the context is nil a panic will occur. In the future the SDK may create 471// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 472// for more information on using Contexts. 473func (c *ServiceDiscovery) DeleteServiceWithContext(ctx aws.Context, input *DeleteServiceInput, opts ...request.Option) (*DeleteServiceOutput, error) { 474 req, out := c.DeleteServiceRequest(input) 475 req.SetContext(ctx) 476 req.ApplyOptions(opts...) 477 return out, req.Send() 478} 479 480const opDeregisterInstance = "DeregisterInstance" 481 482// DeregisterInstanceRequest generates a "aws/request.Request" representing the 483// client's request for the DeregisterInstance operation. The "output" return 484// value will be populated with the request's response once the request complets 485// successfuly. 486// 487// Use "Send" method on the returned Request to send the API call to the service. 488// the "output" return value is not valid until after Send returns without error. 489// 490// See DeregisterInstance for more information on using the DeregisterInstance 491// API call, and error handling. 492// 493// This method is useful when you want to inject custom logic or configuration 494// into the SDK's request lifecycle. Such as custom headers, or retry logic. 495// 496// 497// // Example sending a request using the DeregisterInstanceRequest method. 498// req, resp := client.DeregisterInstanceRequest(params) 499// 500// err := req.Send() 501// if err == nil { // resp is now filled 502// fmt.Println(resp) 503// } 504// 505// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeregisterInstance 506func (c *ServiceDiscovery) DeregisterInstanceRequest(input *DeregisterInstanceInput) (req *request.Request, output *DeregisterInstanceOutput) { 507 op := &request.Operation{ 508 Name: opDeregisterInstance, 509 HTTPMethod: "POST", 510 HTTPPath: "/", 511 } 512 513 if input == nil { 514 input = &DeregisterInstanceInput{} 515 } 516 517 output = &DeregisterInstanceOutput{} 518 req = c.newRequest(op, input, output) 519 return 520} 521 522// DeregisterInstance API operation for Amazon Route 53 Auto Naming. 523// 524// Deletes the resource record sets and the health check, if any, that Amazon 525// Route 53 created for the specified instance. 526// 527// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 528// with awserr.Error's Code and Message methods to get detailed information about 529// the error. 530// 531// See the AWS API reference guide for Amazon Route 53 Auto Naming's 532// API operation DeregisterInstance for usage and error information. 533// 534// Returned Error Codes: 535// * ErrCodeDuplicateRequest "DuplicateRequest" 536// This request tried to create an object that already exists. 537// 538// * ErrCodeInvalidInput "InvalidInput" 539// One or more specified values aren't valid. For example, when you're creating 540// a namespace, the value of Name might not be a valid DNS name. 541// 542// * ErrCodeInstanceNotFound "InstanceNotFound" 543// No instance exists with the specified ID. 544// 545// * ErrCodeResourceInUse "ResourceInUse" 546// The specified resource can't be deleted because it contains other resources. 547// For example, you can't delete a service that contains any instances. 548// 549// * ErrCodeServiceNotFound "ServiceNotFound" 550// No service exists with the specified ID. 551// 552// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeregisterInstance 553func (c *ServiceDiscovery) DeregisterInstance(input *DeregisterInstanceInput) (*DeregisterInstanceOutput, error) { 554 req, out := c.DeregisterInstanceRequest(input) 555 return out, req.Send() 556} 557 558// DeregisterInstanceWithContext is the same as DeregisterInstance with the addition of 559// the ability to pass a context and additional request options. 560// 561// See DeregisterInstance for details on how to use this API operation. 562// 563// The context must be non-nil and will be used for request cancellation. If 564// the context is nil a panic will occur. In the future the SDK may create 565// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 566// for more information on using Contexts. 567func (c *ServiceDiscovery) DeregisterInstanceWithContext(ctx aws.Context, input *DeregisterInstanceInput, opts ...request.Option) (*DeregisterInstanceOutput, error) { 568 req, out := c.DeregisterInstanceRequest(input) 569 req.SetContext(ctx) 570 req.ApplyOptions(opts...) 571 return out, req.Send() 572} 573 574const opGetInstance = "GetInstance" 575 576// GetInstanceRequest generates a "aws/request.Request" representing the 577// client's request for the GetInstance operation. The "output" return 578// value will be populated with the request's response once the request complets 579// successfuly. 580// 581// Use "Send" method on the returned Request to send the API call to the service. 582// the "output" return value is not valid until after Send returns without error. 583// 584// See GetInstance for more information on using the GetInstance 585// API call, and error handling. 586// 587// This method is useful when you want to inject custom logic or configuration 588// into the SDK's request lifecycle. Such as custom headers, or retry logic. 589// 590// 591// // Example sending a request using the GetInstanceRequest method. 592// req, resp := client.GetInstanceRequest(params) 593// 594// err := req.Send() 595// if err == nil { // resp is now filled 596// fmt.Println(resp) 597// } 598// 599// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetInstance 600func (c *ServiceDiscovery) GetInstanceRequest(input *GetInstanceInput) (req *request.Request, output *GetInstanceOutput) { 601 op := &request.Operation{ 602 Name: opGetInstance, 603 HTTPMethod: "POST", 604 HTTPPath: "/", 605 } 606 607 if input == nil { 608 input = &GetInstanceInput{} 609 } 610 611 output = &GetInstanceOutput{} 612 req = c.newRequest(op, input, output) 613 return 614} 615 616// GetInstance API operation for Amazon Route 53 Auto Naming. 617// 618// Gets information about a specified instance. 619// 620// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 621// with awserr.Error's Code and Message methods to get detailed information about 622// the error. 623// 624// See the AWS API reference guide for Amazon Route 53 Auto Naming's 625// API operation GetInstance for usage and error information. 626// 627// Returned Error Codes: 628// * ErrCodeInstanceNotFound "InstanceNotFound" 629// No instance exists with the specified ID. 630// 631// * ErrCodeInvalidInput "InvalidInput" 632// One or more specified values aren't valid. For example, when you're creating 633// a namespace, the value of Name might not be a valid DNS name. 634// 635// * ErrCodeServiceNotFound "ServiceNotFound" 636// No service exists with the specified ID. 637// 638// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetInstance 639func (c *ServiceDiscovery) GetInstance(input *GetInstanceInput) (*GetInstanceOutput, error) { 640 req, out := c.GetInstanceRequest(input) 641 return out, req.Send() 642} 643 644// GetInstanceWithContext is the same as GetInstance with the addition of 645// the ability to pass a context and additional request options. 646// 647// See GetInstance for details on how to use this API operation. 648// 649// The context must be non-nil and will be used for request cancellation. If 650// the context is nil a panic will occur. In the future the SDK may create 651// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 652// for more information on using Contexts. 653func (c *ServiceDiscovery) GetInstanceWithContext(ctx aws.Context, input *GetInstanceInput, opts ...request.Option) (*GetInstanceOutput, error) { 654 req, out := c.GetInstanceRequest(input) 655 req.SetContext(ctx) 656 req.ApplyOptions(opts...) 657 return out, req.Send() 658} 659 660const opGetInstancesHealthStatus = "GetInstancesHealthStatus" 661 662// GetInstancesHealthStatusRequest generates a "aws/request.Request" representing the 663// client's request for the GetInstancesHealthStatus operation. The "output" return 664// value will be populated with the request's response once the request complets 665// successfuly. 666// 667// Use "Send" method on the returned Request to send the API call to the service. 668// the "output" return value is not valid until after Send returns without error. 669// 670// See GetInstancesHealthStatus for more information on using the GetInstancesHealthStatus 671// API call, and error handling. 672// 673// This method is useful when you want to inject custom logic or configuration 674// into the SDK's request lifecycle. Such as custom headers, or retry logic. 675// 676// 677// // Example sending a request using the GetInstancesHealthStatusRequest method. 678// req, resp := client.GetInstancesHealthStatusRequest(params) 679// 680// err := req.Send() 681// if err == nil { // resp is now filled 682// fmt.Println(resp) 683// } 684// 685// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetInstancesHealthStatus 686func (c *ServiceDiscovery) GetInstancesHealthStatusRequest(input *GetInstancesHealthStatusInput) (req *request.Request, output *GetInstancesHealthStatusOutput) { 687 op := &request.Operation{ 688 Name: opGetInstancesHealthStatus, 689 HTTPMethod: "POST", 690 HTTPPath: "/", 691 Paginator: &request.Paginator{ 692 InputTokens: []string{"NextToken"}, 693 OutputTokens: []string{"NextToken"}, 694 LimitToken: "MaxResults", 695 TruncationToken: "", 696 }, 697 } 698 699 if input == nil { 700 input = &GetInstancesHealthStatusInput{} 701 } 702 703 output = &GetInstancesHealthStatusOutput{} 704 req = c.newRequest(op, input, output) 705 return 706} 707 708// GetInstancesHealthStatus API operation for Amazon Route 53 Auto Naming. 709// 710// Gets the current health status (Healthy, Unhealthy, or Unknown) of one or 711// more instances that are associated with a specified service. 712// 713// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 714// with awserr.Error's Code and Message methods to get detailed information about 715// the error. 716// 717// See the AWS API reference guide for Amazon Route 53 Auto Naming's 718// API operation GetInstancesHealthStatus for usage and error information. 719// 720// Returned Error Codes: 721// * ErrCodeInstanceNotFound "InstanceNotFound" 722// No instance exists with the specified ID. 723// 724// * ErrCodeInvalidInput "InvalidInput" 725// One or more specified values aren't valid. For example, when you're creating 726// a namespace, the value of Name might not be a valid DNS name. 727// 728// * ErrCodeServiceNotFound "ServiceNotFound" 729// No service exists with the specified ID. 730// 731// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetInstancesHealthStatus 732func (c *ServiceDiscovery) GetInstancesHealthStatus(input *GetInstancesHealthStatusInput) (*GetInstancesHealthStatusOutput, error) { 733 req, out := c.GetInstancesHealthStatusRequest(input) 734 return out, req.Send() 735} 736 737// GetInstancesHealthStatusWithContext is the same as GetInstancesHealthStatus with the addition of 738// the ability to pass a context and additional request options. 739// 740// See GetInstancesHealthStatus for details on how to use this API operation. 741// 742// The context must be non-nil and will be used for request cancellation. If 743// the context is nil a panic will occur. In the future the SDK may create 744// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 745// for more information on using Contexts. 746func (c *ServiceDiscovery) GetInstancesHealthStatusWithContext(ctx aws.Context, input *GetInstancesHealthStatusInput, opts ...request.Option) (*GetInstancesHealthStatusOutput, error) { 747 req, out := c.GetInstancesHealthStatusRequest(input) 748 req.SetContext(ctx) 749 req.ApplyOptions(opts...) 750 return out, req.Send() 751} 752 753// GetInstancesHealthStatusPages iterates over the pages of a GetInstancesHealthStatus operation, 754// calling the "fn" function with the response data for each page. To stop 755// iterating, return false from the fn function. 756// 757// See GetInstancesHealthStatus method for more information on how to use this operation. 758// 759// Note: This operation can generate multiple requests to a service. 760// 761// // Example iterating over at most 3 pages of a GetInstancesHealthStatus operation. 762// pageNum := 0 763// err := client.GetInstancesHealthStatusPages(params, 764// func(page *GetInstancesHealthStatusOutput, lastPage bool) bool { 765// pageNum++ 766// fmt.Println(page) 767// return pageNum <= 3 768// }) 769// 770func (c *ServiceDiscovery) GetInstancesHealthStatusPages(input *GetInstancesHealthStatusInput, fn func(*GetInstancesHealthStatusOutput, bool) bool) error { 771 return c.GetInstancesHealthStatusPagesWithContext(aws.BackgroundContext(), input, fn) 772} 773 774// GetInstancesHealthStatusPagesWithContext same as GetInstancesHealthStatusPages except 775// it takes a Context and allows setting request options on the pages. 776// 777// The context must be non-nil and will be used for request cancellation. If 778// the context is nil a panic will occur. In the future the SDK may create 779// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 780// for more information on using Contexts. 781func (c *ServiceDiscovery) GetInstancesHealthStatusPagesWithContext(ctx aws.Context, input *GetInstancesHealthStatusInput, fn func(*GetInstancesHealthStatusOutput, bool) bool, opts ...request.Option) error { 782 p := request.Pagination{ 783 NewRequest: func() (*request.Request, error) { 784 var inCpy *GetInstancesHealthStatusInput 785 if input != nil { 786 tmp := *input 787 inCpy = &tmp 788 } 789 req, _ := c.GetInstancesHealthStatusRequest(inCpy) 790 req.SetContext(ctx) 791 req.ApplyOptions(opts...) 792 return req, nil 793 }, 794 } 795 796 cont := true 797 for p.Next() && cont { 798 cont = fn(p.Page().(*GetInstancesHealthStatusOutput), !p.HasNextPage()) 799 } 800 return p.Err() 801} 802 803const opGetNamespace = "GetNamespace" 804 805// GetNamespaceRequest generates a "aws/request.Request" representing the 806// client's request for the GetNamespace operation. The "output" return 807// value will be populated with the request's response once the request complets 808// successfuly. 809// 810// Use "Send" method on the returned Request to send the API call to the service. 811// the "output" return value is not valid until after Send returns without error. 812// 813// See GetNamespace for more information on using the GetNamespace 814// API call, and error handling. 815// 816// This method is useful when you want to inject custom logic or configuration 817// into the SDK's request lifecycle. Such as custom headers, or retry logic. 818// 819// 820// // Example sending a request using the GetNamespaceRequest method. 821// req, resp := client.GetNamespaceRequest(params) 822// 823// err := req.Send() 824// if err == nil { // resp is now filled 825// fmt.Println(resp) 826// } 827// 828// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetNamespace 829func (c *ServiceDiscovery) GetNamespaceRequest(input *GetNamespaceInput) (req *request.Request, output *GetNamespaceOutput) { 830 op := &request.Operation{ 831 Name: opGetNamespace, 832 HTTPMethod: "POST", 833 HTTPPath: "/", 834 } 835 836 if input == nil { 837 input = &GetNamespaceInput{} 838 } 839 840 output = &GetNamespaceOutput{} 841 req = c.newRequest(op, input, output) 842 return 843} 844 845// GetNamespace API operation for Amazon Route 53 Auto Naming. 846// 847// Gets information about a namespace. 848// 849// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 850// with awserr.Error's Code and Message methods to get detailed information about 851// the error. 852// 853// See the AWS API reference guide for Amazon Route 53 Auto Naming's 854// API operation GetNamespace for usage and error information. 855// 856// Returned Error Codes: 857// * ErrCodeInvalidInput "InvalidInput" 858// One or more specified values aren't valid. For example, when you're creating 859// a namespace, the value of Name might not be a valid DNS name. 860// 861// * ErrCodeNamespaceNotFound "NamespaceNotFound" 862// No namespace exists with the specified ID. 863// 864// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetNamespace 865func (c *ServiceDiscovery) GetNamespace(input *GetNamespaceInput) (*GetNamespaceOutput, error) { 866 req, out := c.GetNamespaceRequest(input) 867 return out, req.Send() 868} 869 870// GetNamespaceWithContext is the same as GetNamespace with the addition of 871// the ability to pass a context and additional request options. 872// 873// See GetNamespace for details on how to use this API operation. 874// 875// The context must be non-nil and will be used for request cancellation. If 876// the context is nil a panic will occur. In the future the SDK may create 877// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 878// for more information on using Contexts. 879func (c *ServiceDiscovery) GetNamespaceWithContext(ctx aws.Context, input *GetNamespaceInput, opts ...request.Option) (*GetNamespaceOutput, error) { 880 req, out := c.GetNamespaceRequest(input) 881 req.SetContext(ctx) 882 req.ApplyOptions(opts...) 883 return out, req.Send() 884} 885 886const opGetOperation = "GetOperation" 887 888// GetOperationRequest generates a "aws/request.Request" representing the 889// client's request for the GetOperation operation. The "output" return 890// value will be populated with the request's response once the request complets 891// successfuly. 892// 893// Use "Send" method on the returned Request to send the API call to the service. 894// the "output" return value is not valid until after Send returns without error. 895// 896// See GetOperation for more information on using the GetOperation 897// API call, and error handling. 898// 899// This method is useful when you want to inject custom logic or configuration 900// into the SDK's request lifecycle. Such as custom headers, or retry logic. 901// 902// 903// // Example sending a request using the GetOperationRequest method. 904// req, resp := client.GetOperationRequest(params) 905// 906// err := req.Send() 907// if err == nil { // resp is now filled 908// fmt.Println(resp) 909// } 910// 911// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetOperation 912func (c *ServiceDiscovery) GetOperationRequest(input *GetOperationInput) (req *request.Request, output *GetOperationOutput) { 913 op := &request.Operation{ 914 Name: opGetOperation, 915 HTTPMethod: "POST", 916 HTTPPath: "/", 917 } 918 919 if input == nil { 920 input = &GetOperationInput{} 921 } 922 923 output = &GetOperationOutput{} 924 req = c.newRequest(op, input, output) 925 return 926} 927 928// GetOperation API operation for Amazon Route 53 Auto Naming. 929// 930// Gets information about any operation that returns an operation ID in the 931// response, such as a CreateService request. To get a list of operations that 932// match specified criteria, see ListOperations. 933// 934// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 935// with awserr.Error's Code and Message methods to get detailed information about 936// the error. 937// 938// See the AWS API reference guide for Amazon Route 53 Auto Naming's 939// API operation GetOperation for usage and error information. 940// 941// Returned Error Codes: 942// * ErrCodeOperationNotFound "OperationNotFound" 943// No operation exists with the specified ID. 944// 945// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetOperation 946func (c *ServiceDiscovery) GetOperation(input *GetOperationInput) (*GetOperationOutput, error) { 947 req, out := c.GetOperationRequest(input) 948 return out, req.Send() 949} 950 951// GetOperationWithContext is the same as GetOperation with the addition of 952// the ability to pass a context and additional request options. 953// 954// See GetOperation for details on how to use this API operation. 955// 956// The context must be non-nil and will be used for request cancellation. If 957// the context is nil a panic will occur. In the future the SDK may create 958// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 959// for more information on using Contexts. 960func (c *ServiceDiscovery) GetOperationWithContext(ctx aws.Context, input *GetOperationInput, opts ...request.Option) (*GetOperationOutput, error) { 961 req, out := c.GetOperationRequest(input) 962 req.SetContext(ctx) 963 req.ApplyOptions(opts...) 964 return out, req.Send() 965} 966 967const opGetService = "GetService" 968 969// GetServiceRequest generates a "aws/request.Request" representing the 970// client's request for the GetService operation. The "output" return 971// value will be populated with the request's response once the request complets 972// successfuly. 973// 974// Use "Send" method on the returned Request to send the API call to the service. 975// the "output" return value is not valid until after Send returns without error. 976// 977// See GetService for more information on using the GetService 978// API call, and error handling. 979// 980// This method is useful when you want to inject custom logic or configuration 981// into the SDK's request lifecycle. Such as custom headers, or retry logic. 982// 983// 984// // Example sending a request using the GetServiceRequest method. 985// req, resp := client.GetServiceRequest(params) 986// 987// err := req.Send() 988// if err == nil { // resp is now filled 989// fmt.Println(resp) 990// } 991// 992// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetService 993func (c *ServiceDiscovery) GetServiceRequest(input *GetServiceInput) (req *request.Request, output *GetServiceOutput) { 994 op := &request.Operation{ 995 Name: opGetService, 996 HTTPMethod: "POST", 997 HTTPPath: "/", 998 } 999 1000 if input == nil { 1001 input = &GetServiceInput{} 1002 } 1003 1004 output = &GetServiceOutput{} 1005 req = c.newRequest(op, input, output) 1006 return 1007} 1008 1009// GetService API operation for Amazon Route 53 Auto Naming. 1010// 1011// Gets the settings for a specified service. 1012// 1013// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1014// with awserr.Error's Code and Message methods to get detailed information about 1015// the error. 1016// 1017// See the AWS API reference guide for Amazon Route 53 Auto Naming's 1018// API operation GetService for usage and error information. 1019// 1020// Returned Error Codes: 1021// * ErrCodeInvalidInput "InvalidInput" 1022// One or more specified values aren't valid. For example, when you're creating 1023// a namespace, the value of Name might not be a valid DNS name. 1024// 1025// * ErrCodeServiceNotFound "ServiceNotFound" 1026// No service exists with the specified ID. 1027// 1028// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetService 1029func (c *ServiceDiscovery) GetService(input *GetServiceInput) (*GetServiceOutput, error) { 1030 req, out := c.GetServiceRequest(input) 1031 return out, req.Send() 1032} 1033 1034// GetServiceWithContext is the same as GetService with the addition of 1035// the ability to pass a context and additional request options. 1036// 1037// See GetService for details on how to use this API operation. 1038// 1039// The context must be non-nil and will be used for request cancellation. If 1040// the context is nil a panic will occur. In the future the SDK may create 1041// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1042// for more information on using Contexts. 1043func (c *ServiceDiscovery) GetServiceWithContext(ctx aws.Context, input *GetServiceInput, opts ...request.Option) (*GetServiceOutput, error) { 1044 req, out := c.GetServiceRequest(input) 1045 req.SetContext(ctx) 1046 req.ApplyOptions(opts...) 1047 return out, req.Send() 1048} 1049 1050const opListInstances = "ListInstances" 1051 1052// ListInstancesRequest generates a "aws/request.Request" representing the 1053// client's request for the ListInstances operation. The "output" return 1054// value will be populated with the request's response once the request complets 1055// successfuly. 1056// 1057// Use "Send" method on the returned Request to send the API call to the service. 1058// the "output" return value is not valid until after Send returns without error. 1059// 1060// See ListInstances for more information on using the ListInstances 1061// API call, and error handling. 1062// 1063// This method is useful when you want to inject custom logic or configuration 1064// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1065// 1066// 1067// // Example sending a request using the ListInstancesRequest method. 1068// req, resp := client.ListInstancesRequest(params) 1069// 1070// err := req.Send() 1071// if err == nil { // resp is now filled 1072// fmt.Println(resp) 1073// } 1074// 1075// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListInstances 1076func (c *ServiceDiscovery) ListInstancesRequest(input *ListInstancesInput) (req *request.Request, output *ListInstancesOutput) { 1077 op := &request.Operation{ 1078 Name: opListInstances, 1079 HTTPMethod: "POST", 1080 HTTPPath: "/", 1081 Paginator: &request.Paginator{ 1082 InputTokens: []string{"NextToken"}, 1083 OutputTokens: []string{"NextToken"}, 1084 LimitToken: "MaxResults", 1085 TruncationToken: "", 1086 }, 1087 } 1088 1089 if input == nil { 1090 input = &ListInstancesInput{} 1091 } 1092 1093 output = &ListInstancesOutput{} 1094 req = c.newRequest(op, input, output) 1095 return 1096} 1097 1098// ListInstances API operation for Amazon Route 53 Auto Naming. 1099// 1100// Gets summary information about the instances that you created by using a 1101// specified service. 1102// 1103// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1104// with awserr.Error's Code and Message methods to get detailed information about 1105// the error. 1106// 1107// See the AWS API reference guide for Amazon Route 53 Auto Naming's 1108// API operation ListInstances for usage and error information. 1109// 1110// Returned Error Codes: 1111// * ErrCodeServiceNotFound "ServiceNotFound" 1112// No service exists with the specified ID. 1113// 1114// * ErrCodeInvalidInput "InvalidInput" 1115// One or more specified values aren't valid. For example, when you're creating 1116// a namespace, the value of Name might not be a valid DNS name. 1117// 1118// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListInstances 1119func (c *ServiceDiscovery) ListInstances(input *ListInstancesInput) (*ListInstancesOutput, error) { 1120 req, out := c.ListInstancesRequest(input) 1121 return out, req.Send() 1122} 1123 1124// ListInstancesWithContext is the same as ListInstances with the addition of 1125// the ability to pass a context and additional request options. 1126// 1127// See ListInstances for details on how to use this API operation. 1128// 1129// The context must be non-nil and will be used for request cancellation. If 1130// the context is nil a panic will occur. In the future the SDK may create 1131// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1132// for more information on using Contexts. 1133func (c *ServiceDiscovery) ListInstancesWithContext(ctx aws.Context, input *ListInstancesInput, opts ...request.Option) (*ListInstancesOutput, error) { 1134 req, out := c.ListInstancesRequest(input) 1135 req.SetContext(ctx) 1136 req.ApplyOptions(opts...) 1137 return out, req.Send() 1138} 1139 1140// ListInstancesPages iterates over the pages of a ListInstances operation, 1141// calling the "fn" function with the response data for each page. To stop 1142// iterating, return false from the fn function. 1143// 1144// See ListInstances method for more information on how to use this operation. 1145// 1146// Note: This operation can generate multiple requests to a service. 1147// 1148// // Example iterating over at most 3 pages of a ListInstances operation. 1149// pageNum := 0 1150// err := client.ListInstancesPages(params, 1151// func(page *ListInstancesOutput, lastPage bool) bool { 1152// pageNum++ 1153// fmt.Println(page) 1154// return pageNum <= 3 1155// }) 1156// 1157func (c *ServiceDiscovery) ListInstancesPages(input *ListInstancesInput, fn func(*ListInstancesOutput, bool) bool) error { 1158 return c.ListInstancesPagesWithContext(aws.BackgroundContext(), input, fn) 1159} 1160 1161// ListInstancesPagesWithContext same as ListInstancesPages except 1162// it takes a Context and allows setting request options on the pages. 1163// 1164// The context must be non-nil and will be used for request cancellation. If 1165// the context is nil a panic will occur. In the future the SDK may create 1166// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1167// for more information on using Contexts. 1168func (c *ServiceDiscovery) ListInstancesPagesWithContext(ctx aws.Context, input *ListInstancesInput, fn func(*ListInstancesOutput, bool) bool, opts ...request.Option) error { 1169 p := request.Pagination{ 1170 NewRequest: func() (*request.Request, error) { 1171 var inCpy *ListInstancesInput 1172 if input != nil { 1173 tmp := *input 1174 inCpy = &tmp 1175 } 1176 req, _ := c.ListInstancesRequest(inCpy) 1177 req.SetContext(ctx) 1178 req.ApplyOptions(opts...) 1179 return req, nil 1180 }, 1181 } 1182 1183 cont := true 1184 for p.Next() && cont { 1185 cont = fn(p.Page().(*ListInstancesOutput), !p.HasNextPage()) 1186 } 1187 return p.Err() 1188} 1189 1190const opListNamespaces = "ListNamespaces" 1191 1192// ListNamespacesRequest generates a "aws/request.Request" representing the 1193// client's request for the ListNamespaces operation. The "output" return 1194// value will be populated with the request's response once the request complets 1195// successfuly. 1196// 1197// Use "Send" method on the returned Request to send the API call to the service. 1198// the "output" return value is not valid until after Send returns without error. 1199// 1200// See ListNamespaces for more information on using the ListNamespaces 1201// API call, and error handling. 1202// 1203// This method is useful when you want to inject custom logic or configuration 1204// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1205// 1206// 1207// // Example sending a request using the ListNamespacesRequest method. 1208// req, resp := client.ListNamespacesRequest(params) 1209// 1210// err := req.Send() 1211// if err == nil { // resp is now filled 1212// fmt.Println(resp) 1213// } 1214// 1215// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListNamespaces 1216func (c *ServiceDiscovery) ListNamespacesRequest(input *ListNamespacesInput) (req *request.Request, output *ListNamespacesOutput) { 1217 op := &request.Operation{ 1218 Name: opListNamespaces, 1219 HTTPMethod: "POST", 1220 HTTPPath: "/", 1221 Paginator: &request.Paginator{ 1222 InputTokens: []string{"NextToken"}, 1223 OutputTokens: []string{"NextToken"}, 1224 LimitToken: "MaxResults", 1225 TruncationToken: "", 1226 }, 1227 } 1228 1229 if input == nil { 1230 input = &ListNamespacesInput{} 1231 } 1232 1233 output = &ListNamespacesOutput{} 1234 req = c.newRequest(op, input, output) 1235 return 1236} 1237 1238// ListNamespaces API operation for Amazon Route 53 Auto Naming. 1239// 1240// Gets information about the namespaces that were created by the current AWS 1241// account. 1242// 1243// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1244// with awserr.Error's Code and Message methods to get detailed information about 1245// the error. 1246// 1247// See the AWS API reference guide for Amazon Route 53 Auto Naming's 1248// API operation ListNamespaces for usage and error information. 1249// 1250// Returned Error Codes: 1251// * ErrCodeInvalidInput "InvalidInput" 1252// One or more specified values aren't valid. For example, when you're creating 1253// a namespace, the value of Name might not be a valid DNS name. 1254// 1255// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListNamespaces 1256func (c *ServiceDiscovery) ListNamespaces(input *ListNamespacesInput) (*ListNamespacesOutput, error) { 1257 req, out := c.ListNamespacesRequest(input) 1258 return out, req.Send() 1259} 1260 1261// ListNamespacesWithContext is the same as ListNamespaces with the addition of 1262// the ability to pass a context and additional request options. 1263// 1264// See ListNamespaces for details on how to use this API operation. 1265// 1266// The context must be non-nil and will be used for request cancellation. If 1267// the context is nil a panic will occur. In the future the SDK may create 1268// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1269// for more information on using Contexts. 1270func (c *ServiceDiscovery) ListNamespacesWithContext(ctx aws.Context, input *ListNamespacesInput, opts ...request.Option) (*ListNamespacesOutput, error) { 1271 req, out := c.ListNamespacesRequest(input) 1272 req.SetContext(ctx) 1273 req.ApplyOptions(opts...) 1274 return out, req.Send() 1275} 1276 1277// ListNamespacesPages iterates over the pages of a ListNamespaces operation, 1278// calling the "fn" function with the response data for each page. To stop 1279// iterating, return false from the fn function. 1280// 1281// See ListNamespaces method for more information on how to use this operation. 1282// 1283// Note: This operation can generate multiple requests to a service. 1284// 1285// // Example iterating over at most 3 pages of a ListNamespaces operation. 1286// pageNum := 0 1287// err := client.ListNamespacesPages(params, 1288// func(page *ListNamespacesOutput, lastPage bool) bool { 1289// pageNum++ 1290// fmt.Println(page) 1291// return pageNum <= 3 1292// }) 1293// 1294func (c *ServiceDiscovery) ListNamespacesPages(input *ListNamespacesInput, fn func(*ListNamespacesOutput, bool) bool) error { 1295 return c.ListNamespacesPagesWithContext(aws.BackgroundContext(), input, fn) 1296} 1297 1298// ListNamespacesPagesWithContext same as ListNamespacesPages except 1299// it takes a Context and allows setting request options on the pages. 1300// 1301// The context must be non-nil and will be used for request cancellation. If 1302// the context is nil a panic will occur. In the future the SDK may create 1303// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1304// for more information on using Contexts. 1305func (c *ServiceDiscovery) ListNamespacesPagesWithContext(ctx aws.Context, input *ListNamespacesInput, fn func(*ListNamespacesOutput, bool) bool, opts ...request.Option) error { 1306 p := request.Pagination{ 1307 NewRequest: func() (*request.Request, error) { 1308 var inCpy *ListNamespacesInput 1309 if input != nil { 1310 tmp := *input 1311 inCpy = &tmp 1312 } 1313 req, _ := c.ListNamespacesRequest(inCpy) 1314 req.SetContext(ctx) 1315 req.ApplyOptions(opts...) 1316 return req, nil 1317 }, 1318 } 1319 1320 cont := true 1321 for p.Next() && cont { 1322 cont = fn(p.Page().(*ListNamespacesOutput), !p.HasNextPage()) 1323 } 1324 return p.Err() 1325} 1326 1327const opListOperations = "ListOperations" 1328 1329// ListOperationsRequest generates a "aws/request.Request" representing the 1330// client's request for the ListOperations operation. The "output" return 1331// value will be populated with the request's response once the request complets 1332// successfuly. 1333// 1334// Use "Send" method on the returned Request to send the API call to the service. 1335// the "output" return value is not valid until after Send returns without error. 1336// 1337// See ListOperations for more information on using the ListOperations 1338// API call, and error handling. 1339// 1340// This method is useful when you want to inject custom logic or configuration 1341// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1342// 1343// 1344// // Example sending a request using the ListOperationsRequest method. 1345// req, resp := client.ListOperationsRequest(params) 1346// 1347// err := req.Send() 1348// if err == nil { // resp is now filled 1349// fmt.Println(resp) 1350// } 1351// 1352// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListOperations 1353func (c *ServiceDiscovery) ListOperationsRequest(input *ListOperationsInput) (req *request.Request, output *ListOperationsOutput) { 1354 op := &request.Operation{ 1355 Name: opListOperations, 1356 HTTPMethod: "POST", 1357 HTTPPath: "/", 1358 Paginator: &request.Paginator{ 1359 InputTokens: []string{"NextToken"}, 1360 OutputTokens: []string{"NextToken"}, 1361 LimitToken: "MaxResults", 1362 TruncationToken: "", 1363 }, 1364 } 1365 1366 if input == nil { 1367 input = &ListOperationsInput{} 1368 } 1369 1370 output = &ListOperationsOutput{} 1371 req = c.newRequest(op, input, output) 1372 return 1373} 1374 1375// ListOperations API operation for Amazon Route 53 Auto Naming. 1376// 1377// Lists operations that match the criteria that you specify. 1378// 1379// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1380// with awserr.Error's Code and Message methods to get detailed information about 1381// the error. 1382// 1383// See the AWS API reference guide for Amazon Route 53 Auto Naming's 1384// API operation ListOperations for usage and error information. 1385// 1386// Returned Error Codes: 1387// * ErrCodeInvalidInput "InvalidInput" 1388// One or more specified values aren't valid. For example, when you're creating 1389// a namespace, the value of Name might not be a valid DNS name. 1390// 1391// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListOperations 1392func (c *ServiceDiscovery) ListOperations(input *ListOperationsInput) (*ListOperationsOutput, error) { 1393 req, out := c.ListOperationsRequest(input) 1394 return out, req.Send() 1395} 1396 1397// ListOperationsWithContext is the same as ListOperations with the addition of 1398// the ability to pass a context and additional request options. 1399// 1400// See ListOperations for details on how to use this API operation. 1401// 1402// The context must be non-nil and will be used for request cancellation. If 1403// the context is nil a panic will occur. In the future the SDK may create 1404// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1405// for more information on using Contexts. 1406func (c *ServiceDiscovery) ListOperationsWithContext(ctx aws.Context, input *ListOperationsInput, opts ...request.Option) (*ListOperationsOutput, error) { 1407 req, out := c.ListOperationsRequest(input) 1408 req.SetContext(ctx) 1409 req.ApplyOptions(opts...) 1410 return out, req.Send() 1411} 1412 1413// ListOperationsPages iterates over the pages of a ListOperations operation, 1414// calling the "fn" function with the response data for each page. To stop 1415// iterating, return false from the fn function. 1416// 1417// See ListOperations method for more information on how to use this operation. 1418// 1419// Note: This operation can generate multiple requests to a service. 1420// 1421// // Example iterating over at most 3 pages of a ListOperations operation. 1422// pageNum := 0 1423// err := client.ListOperationsPages(params, 1424// func(page *ListOperationsOutput, lastPage bool) bool { 1425// pageNum++ 1426// fmt.Println(page) 1427// return pageNum <= 3 1428// }) 1429// 1430func (c *ServiceDiscovery) ListOperationsPages(input *ListOperationsInput, fn func(*ListOperationsOutput, bool) bool) error { 1431 return c.ListOperationsPagesWithContext(aws.BackgroundContext(), input, fn) 1432} 1433 1434// ListOperationsPagesWithContext same as ListOperationsPages except 1435// it takes a Context and allows setting request options on the pages. 1436// 1437// The context must be non-nil and will be used for request cancellation. If 1438// the context is nil a panic will occur. In the future the SDK may create 1439// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1440// for more information on using Contexts. 1441func (c *ServiceDiscovery) ListOperationsPagesWithContext(ctx aws.Context, input *ListOperationsInput, fn func(*ListOperationsOutput, bool) bool, opts ...request.Option) error { 1442 p := request.Pagination{ 1443 NewRequest: func() (*request.Request, error) { 1444 var inCpy *ListOperationsInput 1445 if input != nil { 1446 tmp := *input 1447 inCpy = &tmp 1448 } 1449 req, _ := c.ListOperationsRequest(inCpy) 1450 req.SetContext(ctx) 1451 req.ApplyOptions(opts...) 1452 return req, nil 1453 }, 1454 } 1455 1456 cont := true 1457 for p.Next() && cont { 1458 cont = fn(p.Page().(*ListOperationsOutput), !p.HasNextPage()) 1459 } 1460 return p.Err() 1461} 1462 1463const opListServices = "ListServices" 1464 1465// ListServicesRequest generates a "aws/request.Request" representing the 1466// client's request for the ListServices operation. The "output" return 1467// value will be populated with the request's response once the request complets 1468// successfuly. 1469// 1470// Use "Send" method on the returned Request to send the API call to the service. 1471// the "output" return value is not valid until after Send returns without error. 1472// 1473// See ListServices for more information on using the ListServices 1474// API call, and error handling. 1475// 1476// This method is useful when you want to inject custom logic or configuration 1477// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1478// 1479// 1480// // Example sending a request using the ListServicesRequest method. 1481// req, resp := client.ListServicesRequest(params) 1482// 1483// err := req.Send() 1484// if err == nil { // resp is now filled 1485// fmt.Println(resp) 1486// } 1487// 1488// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListServices 1489func (c *ServiceDiscovery) ListServicesRequest(input *ListServicesInput) (req *request.Request, output *ListServicesOutput) { 1490 op := &request.Operation{ 1491 Name: opListServices, 1492 HTTPMethod: "POST", 1493 HTTPPath: "/", 1494 Paginator: &request.Paginator{ 1495 InputTokens: []string{"NextToken"}, 1496 OutputTokens: []string{"NextToken"}, 1497 LimitToken: "MaxResults", 1498 TruncationToken: "", 1499 }, 1500 } 1501 1502 if input == nil { 1503 input = &ListServicesInput{} 1504 } 1505 1506 output = &ListServicesOutput{} 1507 req = c.newRequest(op, input, output) 1508 return 1509} 1510 1511// ListServices API operation for Amazon Route 53 Auto Naming. 1512// 1513// Gets settings for all the services that are associated with one or more specified 1514// namespaces. 1515// 1516// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1517// with awserr.Error's Code and Message methods to get detailed information about 1518// the error. 1519// 1520// See the AWS API reference guide for Amazon Route 53 Auto Naming's 1521// API operation ListServices for usage and error information. 1522// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListServices 1523func (c *ServiceDiscovery) ListServices(input *ListServicesInput) (*ListServicesOutput, error) { 1524 req, out := c.ListServicesRequest(input) 1525 return out, req.Send() 1526} 1527 1528// ListServicesWithContext is the same as ListServices with the addition of 1529// the ability to pass a context and additional request options. 1530// 1531// See ListServices for details on how to use this API operation. 1532// 1533// The context must be non-nil and will be used for request cancellation. If 1534// the context is nil a panic will occur. In the future the SDK may create 1535// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1536// for more information on using Contexts. 1537func (c *ServiceDiscovery) ListServicesWithContext(ctx aws.Context, input *ListServicesInput, opts ...request.Option) (*ListServicesOutput, error) { 1538 req, out := c.ListServicesRequest(input) 1539 req.SetContext(ctx) 1540 req.ApplyOptions(opts...) 1541 return out, req.Send() 1542} 1543 1544// ListServicesPages iterates over the pages of a ListServices operation, 1545// calling the "fn" function with the response data for each page. To stop 1546// iterating, return false from the fn function. 1547// 1548// See ListServices method for more information on how to use this operation. 1549// 1550// Note: This operation can generate multiple requests to a service. 1551// 1552// // Example iterating over at most 3 pages of a ListServices operation. 1553// pageNum := 0 1554// err := client.ListServicesPages(params, 1555// func(page *ListServicesOutput, lastPage bool) bool { 1556// pageNum++ 1557// fmt.Println(page) 1558// return pageNum <= 3 1559// }) 1560// 1561func (c *ServiceDiscovery) ListServicesPages(input *ListServicesInput, fn func(*ListServicesOutput, bool) bool) error { 1562 return c.ListServicesPagesWithContext(aws.BackgroundContext(), input, fn) 1563} 1564 1565// ListServicesPagesWithContext same as ListServicesPages except 1566// it takes a Context and allows setting request options on the pages. 1567// 1568// The context must be non-nil and will be used for request cancellation. If 1569// the context is nil a panic will occur. In the future the SDK may create 1570// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1571// for more information on using Contexts. 1572func (c *ServiceDiscovery) ListServicesPagesWithContext(ctx aws.Context, input *ListServicesInput, fn func(*ListServicesOutput, bool) bool, opts ...request.Option) error { 1573 p := request.Pagination{ 1574 NewRequest: func() (*request.Request, error) { 1575 var inCpy *ListServicesInput 1576 if input != nil { 1577 tmp := *input 1578 inCpy = &tmp 1579 } 1580 req, _ := c.ListServicesRequest(inCpy) 1581 req.SetContext(ctx) 1582 req.ApplyOptions(opts...) 1583 return req, nil 1584 }, 1585 } 1586 1587 cont := true 1588 for p.Next() && cont { 1589 cont = fn(p.Page().(*ListServicesOutput), !p.HasNextPage()) 1590 } 1591 return p.Err() 1592} 1593 1594const opRegisterInstance = "RegisterInstance" 1595 1596// RegisterInstanceRequest generates a "aws/request.Request" representing the 1597// client's request for the RegisterInstance operation. The "output" return 1598// value will be populated with the request's response once the request complets 1599// successfuly. 1600// 1601// Use "Send" method on the returned Request to send the API call to the service. 1602// the "output" return value is not valid until after Send returns without error. 1603// 1604// See RegisterInstance for more information on using the RegisterInstance 1605// API call, and error handling. 1606// 1607// This method is useful when you want to inject custom logic or configuration 1608// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1609// 1610// 1611// // Example sending a request using the RegisterInstanceRequest method. 1612// req, resp := client.RegisterInstanceRequest(params) 1613// 1614// err := req.Send() 1615// if err == nil { // resp is now filled 1616// fmt.Println(resp) 1617// } 1618// 1619// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/RegisterInstance 1620func (c *ServiceDiscovery) RegisterInstanceRequest(input *RegisterInstanceInput) (req *request.Request, output *RegisterInstanceOutput) { 1621 op := &request.Operation{ 1622 Name: opRegisterInstance, 1623 HTTPMethod: "POST", 1624 HTTPPath: "/", 1625 } 1626 1627 if input == nil { 1628 input = &RegisterInstanceInput{} 1629 } 1630 1631 output = &RegisterInstanceOutput{} 1632 req = c.newRequest(op, input, output) 1633 return 1634} 1635 1636// RegisterInstance API operation for Amazon Route 53 Auto Naming. 1637// 1638// Creates one or more resource record sets and optionally a health check based 1639// on the settings in a specified service. When you submit a RegisterInstance 1640// request, Amazon Route 53 does the following: 1641// 1642// * Creates a resource record set for each resource record set template 1643// in the service 1644// 1645// * Creates a health check based on the settings in the health check template 1646// in the service, if any 1647// 1648// * Associates the health check, if any, with each of the resource record 1649// sets 1650// 1651// One RegisterInstance request must complete before you can submit another 1652// request and specify the same service and instance ID. 1653// 1654// For more information, see CreateService. 1655// 1656// When Amazon Route 53 receives a DNS query for the specified DNS name, it 1657// returns the applicable value: 1658// 1659// * If the health check is healthy: returns all the resource record sets 1660// 1661// * If the health check is unhealthy: returns the IP address of the last 1662// healthy instance 1663// 1664// * If you didn't specify a health check template: returns all the resource 1665// record sets 1666// 1667// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1668// with awserr.Error's Code and Message methods to get detailed information about 1669// the error. 1670// 1671// See the AWS API reference guide for Amazon Route 53 Auto Naming's 1672// API operation RegisterInstance for usage and error information. 1673// 1674// Returned Error Codes: 1675// * ErrCodeDuplicateRequest "DuplicateRequest" 1676// This request tried to create an object that already exists. 1677// 1678// * ErrCodeInvalidInput "InvalidInput" 1679// One or more specified values aren't valid. For example, when you're creating 1680// a namespace, the value of Name might not be a valid DNS name. 1681// 1682// * ErrCodeResourceInUse "ResourceInUse" 1683// The specified resource can't be deleted because it contains other resources. 1684// For example, you can't delete a service that contains any instances. 1685// 1686// * ErrCodeResourceLimitExceeded "ResourceLimitExceeded" 1687// The resource can't be created because you've reached the limit on the number 1688// of resources. 1689// 1690// * ErrCodeServiceNotFound "ServiceNotFound" 1691// No service exists with the specified ID. 1692// 1693// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/RegisterInstance 1694func (c *ServiceDiscovery) RegisterInstance(input *RegisterInstanceInput) (*RegisterInstanceOutput, error) { 1695 req, out := c.RegisterInstanceRequest(input) 1696 return out, req.Send() 1697} 1698 1699// RegisterInstanceWithContext is the same as RegisterInstance with the addition of 1700// the ability to pass a context and additional request options. 1701// 1702// See RegisterInstance for details on how to use this API operation. 1703// 1704// The context must be non-nil and will be used for request cancellation. If 1705// the context is nil a panic will occur. In the future the SDK may create 1706// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1707// for more information on using Contexts. 1708func (c *ServiceDiscovery) RegisterInstanceWithContext(ctx aws.Context, input *RegisterInstanceInput, opts ...request.Option) (*RegisterInstanceOutput, error) { 1709 req, out := c.RegisterInstanceRequest(input) 1710 req.SetContext(ctx) 1711 req.ApplyOptions(opts...) 1712 return out, req.Send() 1713} 1714 1715const opUpdateService = "UpdateService" 1716 1717// UpdateServiceRequest generates a "aws/request.Request" representing the 1718// client's request for the UpdateService operation. The "output" return 1719// value will be populated with the request's response once the request complets 1720// successfuly. 1721// 1722// Use "Send" method on the returned Request to send the API call to the service. 1723// the "output" return value is not valid until after Send returns without error. 1724// 1725// See UpdateService for more information on using the UpdateService 1726// API call, and error handling. 1727// 1728// This method is useful when you want to inject custom logic or configuration 1729// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1730// 1731// 1732// // Example sending a request using the UpdateServiceRequest method. 1733// req, resp := client.UpdateServiceRequest(params) 1734// 1735// err := req.Send() 1736// if err == nil { // resp is now filled 1737// fmt.Println(resp) 1738// } 1739// 1740// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/UpdateService 1741func (c *ServiceDiscovery) UpdateServiceRequest(input *UpdateServiceInput) (req *request.Request, output *UpdateServiceOutput) { 1742 op := &request.Operation{ 1743 Name: opUpdateService, 1744 HTTPMethod: "POST", 1745 HTTPPath: "/", 1746 } 1747 1748 if input == nil { 1749 input = &UpdateServiceInput{} 1750 } 1751 1752 output = &UpdateServiceOutput{} 1753 req = c.newRequest(op, input, output) 1754 return 1755} 1756 1757// UpdateService API operation for Amazon Route 53 Auto Naming. 1758// 1759// Updates the TTL setting for a specified service. You must specify all the 1760// resource record set templates (and, optionally, a health check template) 1761// that you want to appear in the updated service. Any current resource record 1762// set templates (or health check template) that don't appear in an UpdateService 1763// request are deleted. 1764// 1765// When you update the TTL setting for a service, Amazon Route 53 also updates 1766// the corresponding settings in all the resource record sets and health checks 1767// that were created by using the specified service. 1768// 1769// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1770// with awserr.Error's Code and Message methods to get detailed information about 1771// the error. 1772// 1773// See the AWS API reference guide for Amazon Route 53 Auto Naming's 1774// API operation UpdateService for usage and error information. 1775// 1776// Returned Error Codes: 1777// * ErrCodeDuplicateRequest "DuplicateRequest" 1778// This request tried to create an object that already exists. 1779// 1780// * ErrCodeInvalidInput "InvalidInput" 1781// One or more specified values aren't valid. For example, when you're creating 1782// a namespace, the value of Name might not be a valid DNS name. 1783// 1784// * ErrCodeServiceNotFound "ServiceNotFound" 1785// No service exists with the specified ID. 1786// 1787// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/UpdateService 1788func (c *ServiceDiscovery) UpdateService(input *UpdateServiceInput) (*UpdateServiceOutput, error) { 1789 req, out := c.UpdateServiceRequest(input) 1790 return out, req.Send() 1791} 1792 1793// UpdateServiceWithContext is the same as UpdateService with the addition of 1794// the ability to pass a context and additional request options. 1795// 1796// See UpdateService for details on how to use this API operation. 1797// 1798// The context must be non-nil and will be used for request cancellation. If 1799// the context is nil a panic will occur. In the future the SDK may create 1800// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1801// for more information on using Contexts. 1802func (c *ServiceDiscovery) UpdateServiceWithContext(ctx aws.Context, input *UpdateServiceInput, opts ...request.Option) (*UpdateServiceOutput, error) { 1803 req, out := c.UpdateServiceRequest(input) 1804 req.SetContext(ctx) 1805 req.ApplyOptions(opts...) 1806 return out, req.Send() 1807} 1808 1809// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreatePrivateDnsNamespaceRequest 1810type CreatePrivateDnsNamespaceInput struct { 1811 _ struct{} `type:"structure"` 1812 1813 // An optional parameter that you can use to resolve concurrent creation requests. 1814 // CreatorRequestId helps to determine if a specific client owns the namespace. 1815 CreatorRequestId *string `type:"string" idempotencyToken:"true"` 1816 1817 // A description for the namespace. 1818 Description *string `type:"string"` 1819 1820 // The name that you want to assign to this namespace. When you create a namespace, 1821 // Amazon Route 53 automatically creates a hosted zone that has the same name 1822 // as the namespace. 1823 // 1824 // Name is a required field 1825 Name *string `type:"string" required:"true"` 1826 1827 // The ID of the Amazon VPC that you want to associate the namespace with. 1828 // 1829 // Vpc is a required field 1830 Vpc *string `type:"string" required:"true"` 1831} 1832 1833// String returns the string representation 1834func (s CreatePrivateDnsNamespaceInput) String() string { 1835 return awsutil.Prettify(s) 1836} 1837 1838// GoString returns the string representation 1839func (s CreatePrivateDnsNamespaceInput) GoString() string { 1840 return s.String() 1841} 1842 1843// Validate inspects the fields of the type to determine if they are valid. 1844func (s *CreatePrivateDnsNamespaceInput) Validate() error { 1845 invalidParams := request.ErrInvalidParams{Context: "CreatePrivateDnsNamespaceInput"} 1846 if s.Name == nil { 1847 invalidParams.Add(request.NewErrParamRequired("Name")) 1848 } 1849 if s.Vpc == nil { 1850 invalidParams.Add(request.NewErrParamRequired("Vpc")) 1851 } 1852 1853 if invalidParams.Len() > 0 { 1854 return invalidParams 1855 } 1856 return nil 1857} 1858 1859// SetCreatorRequestId sets the CreatorRequestId field's value. 1860func (s *CreatePrivateDnsNamespaceInput) SetCreatorRequestId(v string) *CreatePrivateDnsNamespaceInput { 1861 s.CreatorRequestId = &v 1862 return s 1863} 1864 1865// SetDescription sets the Description field's value. 1866func (s *CreatePrivateDnsNamespaceInput) SetDescription(v string) *CreatePrivateDnsNamespaceInput { 1867 s.Description = &v 1868 return s 1869} 1870 1871// SetName sets the Name field's value. 1872func (s *CreatePrivateDnsNamespaceInput) SetName(v string) *CreatePrivateDnsNamespaceInput { 1873 s.Name = &v 1874 return s 1875} 1876 1877// SetVpc sets the Vpc field's value. 1878func (s *CreatePrivateDnsNamespaceInput) SetVpc(v string) *CreatePrivateDnsNamespaceInput { 1879 s.Vpc = &v 1880 return s 1881} 1882 1883// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreatePrivateDnsNamespaceResponse 1884type CreatePrivateDnsNamespaceOutput struct { 1885 _ struct{} `type:"structure"` 1886 1887 // A value that you can use to determine whether the request completed successfully. 1888 // To get the status of the operation, see GetOperation. 1889 OperationId *string `type:"string"` 1890} 1891 1892// String returns the string representation 1893func (s CreatePrivateDnsNamespaceOutput) String() string { 1894 return awsutil.Prettify(s) 1895} 1896 1897// GoString returns the string representation 1898func (s CreatePrivateDnsNamespaceOutput) GoString() string { 1899 return s.String() 1900} 1901 1902// SetOperationId sets the OperationId field's value. 1903func (s *CreatePrivateDnsNamespaceOutput) SetOperationId(v string) *CreatePrivateDnsNamespaceOutput { 1904 s.OperationId = &v 1905 return s 1906} 1907 1908// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreatePublicDnsNamespaceRequest 1909type CreatePublicDnsNamespaceInput struct { 1910 _ struct{} `type:"structure"` 1911 1912 // An optional parameter that you can use to resolve concurrent creation requests. 1913 // CreatorRequestId helps to determine if a specific client owns the namespace. 1914 CreatorRequestId *string `type:"string" idempotencyToken:"true"` 1915 1916 // A description for the namespace. 1917 Description *string `type:"string"` 1918 1919 // The name that you want to assign to this namespace. 1920 // 1921 // Name is a required field 1922 Name *string `type:"string" required:"true"` 1923} 1924 1925// String returns the string representation 1926func (s CreatePublicDnsNamespaceInput) String() string { 1927 return awsutil.Prettify(s) 1928} 1929 1930// GoString returns the string representation 1931func (s CreatePublicDnsNamespaceInput) GoString() string { 1932 return s.String() 1933} 1934 1935// Validate inspects the fields of the type to determine if they are valid. 1936func (s *CreatePublicDnsNamespaceInput) Validate() error { 1937 invalidParams := request.ErrInvalidParams{Context: "CreatePublicDnsNamespaceInput"} 1938 if s.Name == nil { 1939 invalidParams.Add(request.NewErrParamRequired("Name")) 1940 } 1941 1942 if invalidParams.Len() > 0 { 1943 return invalidParams 1944 } 1945 return nil 1946} 1947 1948// SetCreatorRequestId sets the CreatorRequestId field's value. 1949func (s *CreatePublicDnsNamespaceInput) SetCreatorRequestId(v string) *CreatePublicDnsNamespaceInput { 1950 s.CreatorRequestId = &v 1951 return s 1952} 1953 1954// SetDescription sets the Description field's value. 1955func (s *CreatePublicDnsNamespaceInput) SetDescription(v string) *CreatePublicDnsNamespaceInput { 1956 s.Description = &v 1957 return s 1958} 1959 1960// SetName sets the Name field's value. 1961func (s *CreatePublicDnsNamespaceInput) SetName(v string) *CreatePublicDnsNamespaceInput { 1962 s.Name = &v 1963 return s 1964} 1965 1966// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreatePublicDnsNamespaceResponse 1967type CreatePublicDnsNamespaceOutput struct { 1968 _ struct{} `type:"structure"` 1969 1970 // A value that you can use to determine whether the request completed successfully. 1971 // To get the status of the operation, see GetOperation. 1972 OperationId *string `type:"string"` 1973} 1974 1975// String returns the string representation 1976func (s CreatePublicDnsNamespaceOutput) String() string { 1977 return awsutil.Prettify(s) 1978} 1979 1980// GoString returns the string representation 1981func (s CreatePublicDnsNamespaceOutput) GoString() string { 1982 return s.String() 1983} 1984 1985// SetOperationId sets the OperationId field's value. 1986func (s *CreatePublicDnsNamespaceOutput) SetOperationId(v string) *CreatePublicDnsNamespaceOutput { 1987 s.OperationId = &v 1988 return s 1989} 1990 1991// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreateServiceRequest 1992type CreateServiceInput struct { 1993 _ struct{} `type:"structure"` 1994 1995 // An optional parameter that you can use to resolve concurrent creation requests. 1996 // CreatorRequestId helps to determine if a specific client owns the namespace. 1997 CreatorRequestId *string `type:"string" idempotencyToken:"true"` 1998 1999 // A description for the service. 2000 Description *string `type:"string"` 2001 2002 // A complex type that contains information about the resource record sets that 2003 // you want Amazon Route 53 to create when you register an instance. 2004 // 2005 // DnsConfig is a required field 2006 DnsConfig *DnsConfig `type:"structure" required:"true"` 2007 2008 // Public DNS namespaces only. A complex type that contains settings for an 2009 // optional health check. If you specify settings for a health check, Amazon 2010 // Route 53 associates the health check with all the resource record sets that 2011 // you specify in DnsConfig. 2012 // 2013 // The health check uses 30 seconds as the request interval. This is the number 2014 // of seconds between the time that each Amazon Route 53 health checker gets 2015 // a response from your endpoint and the time that it sends the next health 2016 // check request. A health checker in each data center around the world sends 2017 // your endpoint a health check request every 30 seconds. On average, your endpoint 2018 // receives a health check request about every two seconds. Health checkers 2019 // in different data centers don't coordinate with one another, so you'll sometimes 2020 // see several requests per second followed by a few seconds with no health 2021 // checks at all. 2022 // 2023 // For information about the charges for health checks, see Amazon Route 53 2024 // Pricing (http://aws.amazon.com/route53/pricing). 2025 HealthCheckConfig *HealthCheckConfig `type:"structure"` 2026 2027 // The name that you want to assign to the service. 2028 // 2029 // Name is a required field 2030 Name *string `type:"string" required:"true"` 2031} 2032 2033// String returns the string representation 2034func (s CreateServiceInput) String() string { 2035 return awsutil.Prettify(s) 2036} 2037 2038// GoString returns the string representation 2039func (s CreateServiceInput) GoString() string { 2040 return s.String() 2041} 2042 2043// Validate inspects the fields of the type to determine if they are valid. 2044func (s *CreateServiceInput) Validate() error { 2045 invalidParams := request.ErrInvalidParams{Context: "CreateServiceInput"} 2046 if s.DnsConfig == nil { 2047 invalidParams.Add(request.NewErrParamRequired("DnsConfig")) 2048 } 2049 if s.Name == nil { 2050 invalidParams.Add(request.NewErrParamRequired("Name")) 2051 } 2052 if s.DnsConfig != nil { 2053 if err := s.DnsConfig.Validate(); err != nil { 2054 invalidParams.AddNested("DnsConfig", err.(request.ErrInvalidParams)) 2055 } 2056 } 2057 if s.HealthCheckConfig != nil { 2058 if err := s.HealthCheckConfig.Validate(); err != nil { 2059 invalidParams.AddNested("HealthCheckConfig", err.(request.ErrInvalidParams)) 2060 } 2061 } 2062 2063 if invalidParams.Len() > 0 { 2064 return invalidParams 2065 } 2066 return nil 2067} 2068 2069// SetCreatorRequestId sets the CreatorRequestId field's value. 2070func (s *CreateServiceInput) SetCreatorRequestId(v string) *CreateServiceInput { 2071 s.CreatorRequestId = &v 2072 return s 2073} 2074 2075// SetDescription sets the Description field's value. 2076func (s *CreateServiceInput) SetDescription(v string) *CreateServiceInput { 2077 s.Description = &v 2078 return s 2079} 2080 2081// SetDnsConfig sets the DnsConfig field's value. 2082func (s *CreateServiceInput) SetDnsConfig(v *DnsConfig) *CreateServiceInput { 2083 s.DnsConfig = v 2084 return s 2085} 2086 2087// SetHealthCheckConfig sets the HealthCheckConfig field's value. 2088func (s *CreateServiceInput) SetHealthCheckConfig(v *HealthCheckConfig) *CreateServiceInput { 2089 s.HealthCheckConfig = v 2090 return s 2091} 2092 2093// SetName sets the Name field's value. 2094func (s *CreateServiceInput) SetName(v string) *CreateServiceInput { 2095 s.Name = &v 2096 return s 2097} 2098 2099// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/CreateServiceResponse 2100type CreateServiceOutput struct { 2101 _ struct{} `type:"structure"` 2102 2103 // A complex type that contains information about the new service. 2104 Service *Service `type:"structure"` 2105} 2106 2107// String returns the string representation 2108func (s CreateServiceOutput) String() string { 2109 return awsutil.Prettify(s) 2110} 2111 2112// GoString returns the string representation 2113func (s CreateServiceOutput) GoString() string { 2114 return s.String() 2115} 2116 2117// SetService sets the Service field's value. 2118func (s *CreateServiceOutput) SetService(v *Service) *CreateServiceOutput { 2119 s.Service = v 2120 return s 2121} 2122 2123// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeleteNamespaceRequest 2124type DeleteNamespaceInput struct { 2125 _ struct{} `type:"structure"` 2126 2127 // The ID of the namespace that you want to delete. 2128 // 2129 // Id is a required field 2130 Id *string `type:"string" required:"true"` 2131} 2132 2133// String returns the string representation 2134func (s DeleteNamespaceInput) String() string { 2135 return awsutil.Prettify(s) 2136} 2137 2138// GoString returns the string representation 2139func (s DeleteNamespaceInput) GoString() string { 2140 return s.String() 2141} 2142 2143// Validate inspects the fields of the type to determine if they are valid. 2144func (s *DeleteNamespaceInput) Validate() error { 2145 invalidParams := request.ErrInvalidParams{Context: "DeleteNamespaceInput"} 2146 if s.Id == nil { 2147 invalidParams.Add(request.NewErrParamRequired("Id")) 2148 } 2149 2150 if invalidParams.Len() > 0 { 2151 return invalidParams 2152 } 2153 return nil 2154} 2155 2156// SetId sets the Id field's value. 2157func (s *DeleteNamespaceInput) SetId(v string) *DeleteNamespaceInput { 2158 s.Id = &v 2159 return s 2160} 2161 2162// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeleteNamespaceResponse 2163type DeleteNamespaceOutput struct { 2164 _ struct{} `type:"structure"` 2165 2166 // A value that you can use to determine whether the request completed successfully. 2167 // To get the status of the operation, see GetOperation. 2168 OperationId *string `type:"string"` 2169} 2170 2171// String returns the string representation 2172func (s DeleteNamespaceOutput) String() string { 2173 return awsutil.Prettify(s) 2174} 2175 2176// GoString returns the string representation 2177func (s DeleteNamespaceOutput) GoString() string { 2178 return s.String() 2179} 2180 2181// SetOperationId sets the OperationId field's value. 2182func (s *DeleteNamespaceOutput) SetOperationId(v string) *DeleteNamespaceOutput { 2183 s.OperationId = &v 2184 return s 2185} 2186 2187// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeleteServiceRequest 2188type DeleteServiceInput struct { 2189 _ struct{} `type:"structure"` 2190 2191 // The ID of the service that you want to delete. 2192 // 2193 // Id is a required field 2194 Id *string `type:"string" required:"true"` 2195} 2196 2197// String returns the string representation 2198func (s DeleteServiceInput) String() string { 2199 return awsutil.Prettify(s) 2200} 2201 2202// GoString returns the string representation 2203func (s DeleteServiceInput) GoString() string { 2204 return s.String() 2205} 2206 2207// Validate inspects the fields of the type to determine if they are valid. 2208func (s *DeleteServiceInput) Validate() error { 2209 invalidParams := request.ErrInvalidParams{Context: "DeleteServiceInput"} 2210 if s.Id == nil { 2211 invalidParams.Add(request.NewErrParamRequired("Id")) 2212 } 2213 2214 if invalidParams.Len() > 0 { 2215 return invalidParams 2216 } 2217 return nil 2218} 2219 2220// SetId sets the Id field's value. 2221func (s *DeleteServiceInput) SetId(v string) *DeleteServiceInput { 2222 s.Id = &v 2223 return s 2224} 2225 2226// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeleteServiceResponse 2227type DeleteServiceOutput struct { 2228 _ struct{} `type:"structure"` 2229} 2230 2231// String returns the string representation 2232func (s DeleteServiceOutput) String() string { 2233 return awsutil.Prettify(s) 2234} 2235 2236// GoString returns the string representation 2237func (s DeleteServiceOutput) GoString() string { 2238 return s.String() 2239} 2240 2241// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeregisterInstanceRequest 2242type DeregisterInstanceInput struct { 2243 _ struct{} `type:"structure"` 2244 2245 // The value that you specified for Id in the RegisterInstance request. 2246 // 2247 // InstanceId is a required field 2248 InstanceId *string `type:"string" required:"true"` 2249 2250 // The ID of the service that the instance is associated with. 2251 // 2252 // ServiceId is a required field 2253 ServiceId *string `type:"string" required:"true"` 2254} 2255 2256// String returns the string representation 2257func (s DeregisterInstanceInput) String() string { 2258 return awsutil.Prettify(s) 2259} 2260 2261// GoString returns the string representation 2262func (s DeregisterInstanceInput) GoString() string { 2263 return s.String() 2264} 2265 2266// Validate inspects the fields of the type to determine if they are valid. 2267func (s *DeregisterInstanceInput) Validate() error { 2268 invalidParams := request.ErrInvalidParams{Context: "DeregisterInstanceInput"} 2269 if s.InstanceId == nil { 2270 invalidParams.Add(request.NewErrParamRequired("InstanceId")) 2271 } 2272 if s.ServiceId == nil { 2273 invalidParams.Add(request.NewErrParamRequired("ServiceId")) 2274 } 2275 2276 if invalidParams.Len() > 0 { 2277 return invalidParams 2278 } 2279 return nil 2280} 2281 2282// SetInstanceId sets the InstanceId field's value. 2283func (s *DeregisterInstanceInput) SetInstanceId(v string) *DeregisterInstanceInput { 2284 s.InstanceId = &v 2285 return s 2286} 2287 2288// SetServiceId sets the ServiceId field's value. 2289func (s *DeregisterInstanceInput) SetServiceId(v string) *DeregisterInstanceInput { 2290 s.ServiceId = &v 2291 return s 2292} 2293 2294// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DeregisterInstanceResponse 2295type DeregisterInstanceOutput struct { 2296 _ struct{} `type:"structure"` 2297 2298 // A value that you can use to determine whether the request completed successfully. 2299 // For more information, see GetOperation. 2300 OperationId *string `type:"string"` 2301} 2302 2303// String returns the string representation 2304func (s DeregisterInstanceOutput) String() string { 2305 return awsutil.Prettify(s) 2306} 2307 2308// GoString returns the string representation 2309func (s DeregisterInstanceOutput) GoString() string { 2310 return s.String() 2311} 2312 2313// SetOperationId sets the OperationId field's value. 2314func (s *DeregisterInstanceOutput) SetOperationId(v string) *DeregisterInstanceOutput { 2315 s.OperationId = &v 2316 return s 2317} 2318 2319// A complex type that contains information about the resource record sets that 2320// you want Amazon Route 53 to create when you register an instance. 2321// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DnsConfig 2322type DnsConfig struct { 2323 _ struct{} `type:"structure"` 2324 2325 // An array that contains one DnsRecord object for each resource record set 2326 // that you want Amazon Route 53 to create when you register an instance. 2327 // 2328 // DnsRecords is a required field 2329 DnsRecords []*DnsRecord `type:"list" required:"true"` 2330 2331 // The ID of the namespace to use for DNS configuration. 2332 // 2333 // NamespaceId is a required field 2334 NamespaceId *string `type:"string" required:"true"` 2335} 2336 2337// String returns the string representation 2338func (s DnsConfig) String() string { 2339 return awsutil.Prettify(s) 2340} 2341 2342// GoString returns the string representation 2343func (s DnsConfig) GoString() string { 2344 return s.String() 2345} 2346 2347// Validate inspects the fields of the type to determine if they are valid. 2348func (s *DnsConfig) Validate() error { 2349 invalidParams := request.ErrInvalidParams{Context: "DnsConfig"} 2350 if s.DnsRecords == nil { 2351 invalidParams.Add(request.NewErrParamRequired("DnsRecords")) 2352 } 2353 if s.NamespaceId == nil { 2354 invalidParams.Add(request.NewErrParamRequired("NamespaceId")) 2355 } 2356 if s.DnsRecords != nil { 2357 for i, v := range s.DnsRecords { 2358 if v == nil { 2359 continue 2360 } 2361 if err := v.Validate(); err != nil { 2362 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "DnsRecords", i), err.(request.ErrInvalidParams)) 2363 } 2364 } 2365 } 2366 2367 if invalidParams.Len() > 0 { 2368 return invalidParams 2369 } 2370 return nil 2371} 2372 2373// SetDnsRecords sets the DnsRecords field's value. 2374func (s *DnsConfig) SetDnsRecords(v []*DnsRecord) *DnsConfig { 2375 s.DnsRecords = v 2376 return s 2377} 2378 2379// SetNamespaceId sets the NamespaceId field's value. 2380func (s *DnsConfig) SetNamespaceId(v string) *DnsConfig { 2381 s.NamespaceId = &v 2382 return s 2383} 2384 2385// A complex type that contains information about changes to the resource record 2386// sets that Amazon Route 53 creates when you register an instance. 2387// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DnsConfigChange 2388type DnsConfigChange struct { 2389 _ struct{} `type:"structure"` 2390 2391 // An array that contains one DnsRecord object for each resource record set 2392 // that you want Amazon Route 53 to create when you register an instance. 2393 // 2394 // DnsRecords is a required field 2395 DnsRecords []*DnsRecord `type:"list" required:"true"` 2396} 2397 2398// String returns the string representation 2399func (s DnsConfigChange) String() string { 2400 return awsutil.Prettify(s) 2401} 2402 2403// GoString returns the string representation 2404func (s DnsConfigChange) GoString() string { 2405 return s.String() 2406} 2407 2408// Validate inspects the fields of the type to determine if they are valid. 2409func (s *DnsConfigChange) Validate() error { 2410 invalidParams := request.ErrInvalidParams{Context: "DnsConfigChange"} 2411 if s.DnsRecords == nil { 2412 invalidParams.Add(request.NewErrParamRequired("DnsRecords")) 2413 } 2414 if s.DnsRecords != nil { 2415 for i, v := range s.DnsRecords { 2416 if v == nil { 2417 continue 2418 } 2419 if err := v.Validate(); err != nil { 2420 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "DnsRecords", i), err.(request.ErrInvalidParams)) 2421 } 2422 } 2423 } 2424 2425 if invalidParams.Len() > 0 { 2426 return invalidParams 2427 } 2428 return nil 2429} 2430 2431// SetDnsRecords sets the DnsRecords field's value. 2432func (s *DnsConfigChange) SetDnsRecords(v []*DnsRecord) *DnsConfigChange { 2433 s.DnsRecords = v 2434 return s 2435} 2436 2437// A complex type that contains the ID for the hosted zone that Amazon Route 2438// 53 creates when you create a namespace. 2439// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DnsProperties 2440type DnsProperties struct { 2441 _ struct{} `type:"structure"` 2442 2443 // The ID for the hosted zone that Amazon Route 53 creates when you create a 2444 // namespace. 2445 HostedZoneId *string `type:"string"` 2446} 2447 2448// String returns the string representation 2449func (s DnsProperties) String() string { 2450 return awsutil.Prettify(s) 2451} 2452 2453// GoString returns the string representation 2454func (s DnsProperties) GoString() string { 2455 return s.String() 2456} 2457 2458// SetHostedZoneId sets the HostedZoneId field's value. 2459func (s *DnsProperties) SetHostedZoneId(v string) *DnsProperties { 2460 s.HostedZoneId = &v 2461 return s 2462} 2463 2464// A complex type that contains information about the resource record sets that 2465// you want Amazon Route 53 to create when you register an instance. 2466// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/DnsRecord 2467type DnsRecord struct { 2468 _ struct{} `type:"structure"` 2469 2470 // The amount of time, in seconds, that you want DNS resolvers to cache the 2471 // settings for this resource record set. 2472 // 2473 // TTL is a required field 2474 TTL *int64 `type:"long" required:"true"` 2475 2476 // The type of the resource, which indicates the value that Amazon Route 53 2477 // returns in response to DNS queries. The following values are supported: 2478 // 2479 // * A: Amazon Route 53 returns the IP address of the resource in IPv4 format, 2480 // such as 192.0.2.44. 2481 // 2482 // * AAAA: Amazon Route 53 returns the IP address of the resource in IPv6 2483 // format, such as 2001:0db8:85a3:0000:0000:abcd:0001:2345. 2484 // 2485 // * SRV: Amazon Route 53 returns the value for an SRV record. The value 2486 // for an SRV record uses the following template, which can't be changed: 2487 // 2488 // priority weight port resource-record-set-name 2489 // 2490 // The values of priority and weight are both set to 1. The value of port comes 2491 // from the value that you specify for Port when you submit a RegisterInstance 2492 // request. 2493 // 2494 // Type is a required field 2495 Type *string `type:"string" required:"true" enum:"RecordType"` 2496} 2497 2498// String returns the string representation 2499func (s DnsRecord) String() string { 2500 return awsutil.Prettify(s) 2501} 2502 2503// GoString returns the string representation 2504func (s DnsRecord) GoString() string { 2505 return s.String() 2506} 2507 2508// Validate inspects the fields of the type to determine if they are valid. 2509func (s *DnsRecord) Validate() error { 2510 invalidParams := request.ErrInvalidParams{Context: "DnsRecord"} 2511 if s.TTL == nil { 2512 invalidParams.Add(request.NewErrParamRequired("TTL")) 2513 } 2514 if s.Type == nil { 2515 invalidParams.Add(request.NewErrParamRequired("Type")) 2516 } 2517 2518 if invalidParams.Len() > 0 { 2519 return invalidParams 2520 } 2521 return nil 2522} 2523 2524// SetTTL sets the TTL field's value. 2525func (s *DnsRecord) SetTTL(v int64) *DnsRecord { 2526 s.TTL = &v 2527 return s 2528} 2529 2530// SetType sets the Type field's value. 2531func (s *DnsRecord) SetType(v string) *DnsRecord { 2532 s.Type = &v 2533 return s 2534} 2535 2536// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetInstanceRequest 2537type GetInstanceInput struct { 2538 _ struct{} `type:"structure"` 2539 2540 // The ID of the instance that you want to get information about. 2541 // 2542 // InstanceId is a required field 2543 InstanceId *string `type:"string" required:"true"` 2544 2545 // The ID of the service that the instance is associated with. 2546 // 2547 // ServiceId is a required field 2548 ServiceId *string `type:"string" required:"true"` 2549} 2550 2551// String returns the string representation 2552func (s GetInstanceInput) String() string { 2553 return awsutil.Prettify(s) 2554} 2555 2556// GoString returns the string representation 2557func (s GetInstanceInput) GoString() string { 2558 return s.String() 2559} 2560 2561// Validate inspects the fields of the type to determine if they are valid. 2562func (s *GetInstanceInput) Validate() error { 2563 invalidParams := request.ErrInvalidParams{Context: "GetInstanceInput"} 2564 if s.InstanceId == nil { 2565 invalidParams.Add(request.NewErrParamRequired("InstanceId")) 2566 } 2567 if s.ServiceId == nil { 2568 invalidParams.Add(request.NewErrParamRequired("ServiceId")) 2569 } 2570 2571 if invalidParams.Len() > 0 { 2572 return invalidParams 2573 } 2574 return nil 2575} 2576 2577// SetInstanceId sets the InstanceId field's value. 2578func (s *GetInstanceInput) SetInstanceId(v string) *GetInstanceInput { 2579 s.InstanceId = &v 2580 return s 2581} 2582 2583// SetServiceId sets the ServiceId field's value. 2584func (s *GetInstanceInput) SetServiceId(v string) *GetInstanceInput { 2585 s.ServiceId = &v 2586 return s 2587} 2588 2589// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetInstanceResponse 2590type GetInstanceOutput struct { 2591 _ struct{} `type:"structure"` 2592 2593 // A complex type that contains information about a specified instance. 2594 Instance *Instance `type:"structure"` 2595} 2596 2597// String returns the string representation 2598func (s GetInstanceOutput) String() string { 2599 return awsutil.Prettify(s) 2600} 2601 2602// GoString returns the string representation 2603func (s GetInstanceOutput) GoString() string { 2604 return s.String() 2605} 2606 2607// SetInstance sets the Instance field's value. 2608func (s *GetInstanceOutput) SetInstance(v *Instance) *GetInstanceOutput { 2609 s.Instance = v 2610 return s 2611} 2612 2613// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetInstancesHealthStatusRequest 2614type GetInstancesHealthStatusInput struct { 2615 _ struct{} `type:"structure"` 2616 2617 // An array that contains the IDs of all the instances that you want to get 2618 // the health status for. To get the IDs for the instances that you've created 2619 // by using a specified service, submit a ListInstances request. 2620 // 2621 // If you omit Instances, Amazon Route 53 returns the health status for all 2622 // the instances that are associated with the specified service. 2623 Instances []*string `min:"1" type:"list"` 2624 2625 // The maximum number of instances that you want Amazon Route 53 to return in 2626 // the response to a GetInstancesHealthStatus request. If you don't specify 2627 // a value for MaxResults, Amazon Route 53 returns up to 100 instances. 2628 MaxResults *int64 `min:"1" type:"integer"` 2629 2630 // For the first GetInstancesHealthStatus request, omit this value. 2631 // 2632 // If more than MaxResults instances match the specified criteria, you can submit 2633 // another GetInstancesHealthStatus request to get the next group of results. 2634 // Specify the value of NextToken from the previous response in the next request. 2635 NextToken *string `type:"string"` 2636 2637 // The ID of the service that the instance is associated with. 2638 // 2639 // ServiceId is a required field 2640 ServiceId *string `type:"string" required:"true"` 2641} 2642 2643// String returns the string representation 2644func (s GetInstancesHealthStatusInput) String() string { 2645 return awsutil.Prettify(s) 2646} 2647 2648// GoString returns the string representation 2649func (s GetInstancesHealthStatusInput) GoString() string { 2650 return s.String() 2651} 2652 2653// Validate inspects the fields of the type to determine if they are valid. 2654func (s *GetInstancesHealthStatusInput) Validate() error { 2655 invalidParams := request.ErrInvalidParams{Context: "GetInstancesHealthStatusInput"} 2656 if s.Instances != nil && len(s.Instances) < 1 { 2657 invalidParams.Add(request.NewErrParamMinLen("Instances", 1)) 2658 } 2659 if s.MaxResults != nil && *s.MaxResults < 1 { 2660 invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) 2661 } 2662 if s.ServiceId == nil { 2663 invalidParams.Add(request.NewErrParamRequired("ServiceId")) 2664 } 2665 2666 if invalidParams.Len() > 0 { 2667 return invalidParams 2668 } 2669 return nil 2670} 2671 2672// SetInstances sets the Instances field's value. 2673func (s *GetInstancesHealthStatusInput) SetInstances(v []*string) *GetInstancesHealthStatusInput { 2674 s.Instances = v 2675 return s 2676} 2677 2678// SetMaxResults sets the MaxResults field's value. 2679func (s *GetInstancesHealthStatusInput) SetMaxResults(v int64) *GetInstancesHealthStatusInput { 2680 s.MaxResults = &v 2681 return s 2682} 2683 2684// SetNextToken sets the NextToken field's value. 2685func (s *GetInstancesHealthStatusInput) SetNextToken(v string) *GetInstancesHealthStatusInput { 2686 s.NextToken = &v 2687 return s 2688} 2689 2690// SetServiceId sets the ServiceId field's value. 2691func (s *GetInstancesHealthStatusInput) SetServiceId(v string) *GetInstancesHealthStatusInput { 2692 s.ServiceId = &v 2693 return s 2694} 2695 2696// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetInstancesHealthStatusResponse 2697type GetInstancesHealthStatusOutput struct { 2698 _ struct{} `type:"structure"` 2699 2700 // If more than MaxResults instances match the specified criteria, you can submit 2701 // another GetInstancesHealthStatus request to get the next group of results. 2702 // Specify the value of NextToken from the previous response in the next request. 2703 NextToken *string `type:"string"` 2704 2705 // A complex type that contains the IDs and the health status of the instances 2706 // that you specified in the GetInstancesHealthStatus request. 2707 Status map[string]*string `type:"map"` 2708} 2709 2710// String returns the string representation 2711func (s GetInstancesHealthStatusOutput) String() string { 2712 return awsutil.Prettify(s) 2713} 2714 2715// GoString returns the string representation 2716func (s GetInstancesHealthStatusOutput) GoString() string { 2717 return s.String() 2718} 2719 2720// SetNextToken sets the NextToken field's value. 2721func (s *GetInstancesHealthStatusOutput) SetNextToken(v string) *GetInstancesHealthStatusOutput { 2722 s.NextToken = &v 2723 return s 2724} 2725 2726// SetStatus sets the Status field's value. 2727func (s *GetInstancesHealthStatusOutput) SetStatus(v map[string]*string) *GetInstancesHealthStatusOutput { 2728 s.Status = v 2729 return s 2730} 2731 2732// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetNamespaceRequest 2733type GetNamespaceInput struct { 2734 _ struct{} `type:"structure"` 2735 2736 // The ID of the namespace that you want to get information about. 2737 // 2738 // Id is a required field 2739 Id *string `type:"string" required:"true"` 2740} 2741 2742// String returns the string representation 2743func (s GetNamespaceInput) String() string { 2744 return awsutil.Prettify(s) 2745} 2746 2747// GoString returns the string representation 2748func (s GetNamespaceInput) GoString() string { 2749 return s.String() 2750} 2751 2752// Validate inspects the fields of the type to determine if they are valid. 2753func (s *GetNamespaceInput) Validate() error { 2754 invalidParams := request.ErrInvalidParams{Context: "GetNamespaceInput"} 2755 if s.Id == nil { 2756 invalidParams.Add(request.NewErrParamRequired("Id")) 2757 } 2758 2759 if invalidParams.Len() > 0 { 2760 return invalidParams 2761 } 2762 return nil 2763} 2764 2765// SetId sets the Id field's value. 2766func (s *GetNamespaceInput) SetId(v string) *GetNamespaceInput { 2767 s.Id = &v 2768 return s 2769} 2770 2771// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetNamespaceResponse 2772type GetNamespaceOutput struct { 2773 _ struct{} `type:"structure"` 2774 2775 // A complex type that contains information about the specified namespace. 2776 Namespace *Namespace `type:"structure"` 2777} 2778 2779// String returns the string representation 2780func (s GetNamespaceOutput) String() string { 2781 return awsutil.Prettify(s) 2782} 2783 2784// GoString returns the string representation 2785func (s GetNamespaceOutput) GoString() string { 2786 return s.String() 2787} 2788 2789// SetNamespace sets the Namespace field's value. 2790func (s *GetNamespaceOutput) SetNamespace(v *Namespace) *GetNamespaceOutput { 2791 s.Namespace = v 2792 return s 2793} 2794 2795// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetOperationRequest 2796type GetOperationInput struct { 2797 _ struct{} `type:"structure"` 2798 2799 // The ID of the operation that you want to get more information about. 2800 // 2801 // OperationId is a required field 2802 OperationId *string `type:"string" required:"true"` 2803} 2804 2805// String returns the string representation 2806func (s GetOperationInput) String() string { 2807 return awsutil.Prettify(s) 2808} 2809 2810// GoString returns the string representation 2811func (s GetOperationInput) GoString() string { 2812 return s.String() 2813} 2814 2815// Validate inspects the fields of the type to determine if they are valid. 2816func (s *GetOperationInput) Validate() error { 2817 invalidParams := request.ErrInvalidParams{Context: "GetOperationInput"} 2818 if s.OperationId == nil { 2819 invalidParams.Add(request.NewErrParamRequired("OperationId")) 2820 } 2821 2822 if invalidParams.Len() > 0 { 2823 return invalidParams 2824 } 2825 return nil 2826} 2827 2828// SetOperationId sets the OperationId field's value. 2829func (s *GetOperationInput) SetOperationId(v string) *GetOperationInput { 2830 s.OperationId = &v 2831 return s 2832} 2833 2834// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetOperationResponse 2835type GetOperationOutput struct { 2836 _ struct{} `type:"structure"` 2837 2838 // A complex type that contains information about the operation. 2839 Operation *Operation `type:"structure"` 2840} 2841 2842// String returns the string representation 2843func (s GetOperationOutput) String() string { 2844 return awsutil.Prettify(s) 2845} 2846 2847// GoString returns the string representation 2848func (s GetOperationOutput) GoString() string { 2849 return s.String() 2850} 2851 2852// SetOperation sets the Operation field's value. 2853func (s *GetOperationOutput) SetOperation(v *Operation) *GetOperationOutput { 2854 s.Operation = v 2855 return s 2856} 2857 2858// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetServiceRequest 2859type GetServiceInput struct { 2860 _ struct{} `type:"structure"` 2861 2862 // The ID of the service that you want to get settings for. 2863 // 2864 // Id is a required field 2865 Id *string `type:"string" required:"true"` 2866} 2867 2868// String returns the string representation 2869func (s GetServiceInput) String() string { 2870 return awsutil.Prettify(s) 2871} 2872 2873// GoString returns the string representation 2874func (s GetServiceInput) GoString() string { 2875 return s.String() 2876} 2877 2878// Validate inspects the fields of the type to determine if they are valid. 2879func (s *GetServiceInput) Validate() error { 2880 invalidParams := request.ErrInvalidParams{Context: "GetServiceInput"} 2881 if s.Id == nil { 2882 invalidParams.Add(request.NewErrParamRequired("Id")) 2883 } 2884 2885 if invalidParams.Len() > 0 { 2886 return invalidParams 2887 } 2888 return nil 2889} 2890 2891// SetId sets the Id field's value. 2892func (s *GetServiceInput) SetId(v string) *GetServiceInput { 2893 s.Id = &v 2894 return s 2895} 2896 2897// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/GetServiceResponse 2898type GetServiceOutput struct { 2899 _ struct{} `type:"structure"` 2900 2901 // A complex type that contains information about the service. 2902 Service *Service `type:"structure"` 2903} 2904 2905// String returns the string representation 2906func (s GetServiceOutput) String() string { 2907 return awsutil.Prettify(s) 2908} 2909 2910// GoString returns the string representation 2911func (s GetServiceOutput) GoString() string { 2912 return s.String() 2913} 2914 2915// SetService sets the Service field's value. 2916func (s *GetServiceOutput) SetService(v *Service) *GetServiceOutput { 2917 s.Service = v 2918 return s 2919} 2920 2921// Public DNS namespaces only. A complex type that contains settings for an 2922// optional health check. If you specify settings for a health check, Amazon 2923// Route 53 associates the health check with all the resource record sets that 2924// you specify in DnsConfig. 2925// 2926// The health check uses 30 seconds as the request interval. This is the number 2927// of seconds between the time that each Amazon Route 53 health checker gets 2928// a response from your endpoint and the time that it sends the next health 2929// check request. A health checker in each data center around the world sends 2930// your endpoint a health check request every 30 seconds. On average, your endpoint 2931// receives a health check request about every two seconds. Health checkers 2932// in different data centers don't coordinate with one another, so you'll sometimes 2933// see several requests per second followed by a few seconds with no health 2934// checks at all. 2935// 2936// For information about the charges for health checks, see Amazon Route 53 2937// Pricing (http://aws.amazon.com/route53/pricing). 2938// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/HealthCheckConfig 2939type HealthCheckConfig struct { 2940 _ struct{} `type:"structure"` 2941 2942 // The number of consecutive health checks that an endpoint must pass or fail 2943 // for Amazon Route 53 to change the current status of the endpoint from unhealthy 2944 // to healthy or vice versa. For more information, see How Amazon Route 53 Determines 2945 // Whether an Endpoint Is Healthy (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-determining-health-of-endpoints.html) 2946 // in the Amazon Route 53 Developer Guide. 2947 FailureThreshold *int64 `min:"1" type:"integer"` 2948 2949 // The path that you want Amazon Route 53 to request when performing health 2950 // checks. The path can be any value for which your endpoint will return an 2951 // HTTP status code of 2xx or 3xx when the endpoint is healthy, such as the 2952 // file /docs/route53-health-check.html. Amazon Route 53 automatically adds 2953 // the DNS name for the service and a leading forward slash (/) character. 2954 ResourcePath *string `type:"string"` 2955 2956 // The type of health check that you want to create, which indicates how Amazon 2957 // Route 53 determines whether an endpoint is healthy. 2958 // 2959 // You can't change the value of Type after you create a health check. 2960 // 2961 // You can create the following types of health checks: 2962 // 2963 // * HTTP: Amazon Route 53 tries to establish a TCP connection. If successful, 2964 // Amazon Route 53 submits an HTTP request and waits for an HTTP status code 2965 // of 200 or greater and less than 400. 2966 // 2967 // * HTTPS: Amazon Route 53 tries to establish a TCP connection. If successful, 2968 // Amazon Route 53 submits an HTTPS request and waits for an HTTP status 2969 // code of 200 or greater and less than 400. 2970 // 2971 // If you specify HTTPS for the value of Type, the endpoint must support TLS 2972 // v1.0 or later. 2973 // 2974 // * TCP: Amazon Route 53 tries to establish a TCP connection. 2975 // 2976 // For more information, see How Amazon Route 53 Determines Whether an Endpoint 2977 // Is Healthy (http://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-determining-health-of-endpoints.html) 2978 // in the Amazon Route 53 Developer Guide. 2979 Type *string `type:"string" enum:"HealthCheckType"` 2980} 2981 2982// String returns the string representation 2983func (s HealthCheckConfig) String() string { 2984 return awsutil.Prettify(s) 2985} 2986 2987// GoString returns the string representation 2988func (s HealthCheckConfig) GoString() string { 2989 return s.String() 2990} 2991 2992// Validate inspects the fields of the type to determine if they are valid. 2993func (s *HealthCheckConfig) Validate() error { 2994 invalidParams := request.ErrInvalidParams{Context: "HealthCheckConfig"} 2995 if s.FailureThreshold != nil && *s.FailureThreshold < 1 { 2996 invalidParams.Add(request.NewErrParamMinValue("FailureThreshold", 1)) 2997 } 2998 2999 if invalidParams.Len() > 0 { 3000 return invalidParams 3001 } 3002 return nil 3003} 3004 3005// SetFailureThreshold sets the FailureThreshold field's value. 3006func (s *HealthCheckConfig) SetFailureThreshold(v int64) *HealthCheckConfig { 3007 s.FailureThreshold = &v 3008 return s 3009} 3010 3011// SetResourcePath sets the ResourcePath field's value. 3012func (s *HealthCheckConfig) SetResourcePath(v string) *HealthCheckConfig { 3013 s.ResourcePath = &v 3014 return s 3015} 3016 3017// SetType sets the Type field's value. 3018func (s *HealthCheckConfig) SetType(v string) *HealthCheckConfig { 3019 s.Type = &v 3020 return s 3021} 3022 3023// A complex type that contains information about an instance that Amazon Route 3024// 53 creates when you submit a RegisterInstance request. 3025// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/Instance 3026type Instance struct { 3027 _ struct{} `type:"structure"` 3028 3029 // A string map that contains attribute keys and values. Supported attribute 3030 // keys include the following: 3031 // 3032 // * AWS_INSTANCE_PORT: The port on the endpoint that you want Amazon Route 3033 // 53 to perform health checks on. This value is also used for the port value 3034 // in an SRV record if the service that you specify includes an SRV record. 3035 // For more information, see CreateService. 3036 // 3037 // * AWS_INSTANCE_IP: If the service that you specify contains a resource 3038 // record set template for an A or AAAA record, the IP address that you want 3039 // Amazon Route 53 to use for the value of the A record. 3040 // 3041 // * AWS_INSTANCE_WEIGHT: The weight value in an SRV record if the service 3042 // that you specify includes an SRV record. You can also specify a default 3043 // weight that is applied to all instances in the Service configuration. 3044 // For more information, see CreateService. 3045 // 3046 // * AWS_INSTANCE_PRIORITY: The priority value in an SRV record if the service 3047 // that you specify includes an SRV record. 3048 Attributes map[string]*string `type:"map"` 3049 3050 // An optional parameter that you can use to resolve concurrent creation requests. 3051 // CreatorRequestId helps to determine if a specific client owns the namespace. 3052 CreatorRequestId *string `type:"string"` 3053 3054 // An identifier that you want to associate with the instance. Note the following: 3055 // 3056 // * You can use this value to update an existing instance. 3057 // 3058 // * To associate a new instance, you must specify a value that is unique 3059 // among instances that you associate by using the same service. 3060 // 3061 // Id is a required field 3062 Id *string `type:"string" required:"true"` 3063} 3064 3065// String returns the string representation 3066func (s Instance) String() string { 3067 return awsutil.Prettify(s) 3068} 3069 3070// GoString returns the string representation 3071func (s Instance) GoString() string { 3072 return s.String() 3073} 3074 3075// SetAttributes sets the Attributes field's value. 3076func (s *Instance) SetAttributes(v map[string]*string) *Instance { 3077 s.Attributes = v 3078 return s 3079} 3080 3081// SetCreatorRequestId sets the CreatorRequestId field's value. 3082func (s *Instance) SetCreatorRequestId(v string) *Instance { 3083 s.CreatorRequestId = &v 3084 return s 3085} 3086 3087// SetId sets the Id field's value. 3088func (s *Instance) SetId(v string) *Instance { 3089 s.Id = &v 3090 return s 3091} 3092 3093// A complex type that contains information about the instances that you created 3094// by using a specified service. 3095// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/InstanceSummary 3096type InstanceSummary struct { 3097 _ struct{} `type:"structure"` 3098 3099 // A string map that contain attribute keys and values for an instance. Supported 3100 // attribute keys include the following: 3101 // 3102 // * AWS_INSTANCE_PORT: The port on the endpoint that you want Amazon Route 3103 // 53 to perform health checks on. This value is also used for the port value 3104 // in an SRV record if the service that you specify includes an SRV record. 3105 // For more information, see CreateService. 3106 // 3107 // * AWS_INSTANCE_IP: If the service that you specify contains a resource 3108 // record set template for an A or AAAA record, the IP address that you want 3109 // Amazon Route 53 to use for the value of the A record. 3110 Attributes map[string]*string `type:"map"` 3111 3112 // The ID for an instance that you created by using a specified service. 3113 Id *string `type:"string"` 3114} 3115 3116// String returns the string representation 3117func (s InstanceSummary) String() string { 3118 return awsutil.Prettify(s) 3119} 3120 3121// GoString returns the string representation 3122func (s InstanceSummary) GoString() string { 3123 return s.String() 3124} 3125 3126// SetAttributes sets the Attributes field's value. 3127func (s *InstanceSummary) SetAttributes(v map[string]*string) *InstanceSummary { 3128 s.Attributes = v 3129 return s 3130} 3131 3132// SetId sets the Id field's value. 3133func (s *InstanceSummary) SetId(v string) *InstanceSummary { 3134 s.Id = &v 3135 return s 3136} 3137 3138// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListInstancesRequest 3139type ListInstancesInput struct { 3140 _ struct{} `type:"structure"` 3141 3142 // The maximum number of instances that you want Amazon Route 53 to return in 3143 // the response to a ListInstances request. If you don't specify a value for 3144 // MaxResults, Amazon Route 53 returns up to 100 instances. 3145 MaxResults *int64 `min:"1" type:"integer"` 3146 3147 // For the first ListInstances request, omit this value. 3148 // 3149 // If more than MaxResults instances match the specified criteria, you can submit 3150 // another ListInstances request to get the next group of results. Specify the 3151 // value of NextToken from the previous response in the next request. 3152 NextToken *string `type:"string"` 3153 3154 // The ID of the service that you want to list instances for. 3155 // 3156 // ServiceId is a required field 3157 ServiceId *string `type:"string" required:"true"` 3158} 3159 3160// String returns the string representation 3161func (s ListInstancesInput) String() string { 3162 return awsutil.Prettify(s) 3163} 3164 3165// GoString returns the string representation 3166func (s ListInstancesInput) GoString() string { 3167 return s.String() 3168} 3169 3170// Validate inspects the fields of the type to determine if they are valid. 3171func (s *ListInstancesInput) Validate() error { 3172 invalidParams := request.ErrInvalidParams{Context: "ListInstancesInput"} 3173 if s.MaxResults != nil && *s.MaxResults < 1 { 3174 invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) 3175 } 3176 if s.ServiceId == nil { 3177 invalidParams.Add(request.NewErrParamRequired("ServiceId")) 3178 } 3179 3180 if invalidParams.Len() > 0 { 3181 return invalidParams 3182 } 3183 return nil 3184} 3185 3186// SetMaxResults sets the MaxResults field's value. 3187func (s *ListInstancesInput) SetMaxResults(v int64) *ListInstancesInput { 3188 s.MaxResults = &v 3189 return s 3190} 3191 3192// SetNextToken sets the NextToken field's value. 3193func (s *ListInstancesInput) SetNextToken(v string) *ListInstancesInput { 3194 s.NextToken = &v 3195 return s 3196} 3197 3198// SetServiceId sets the ServiceId field's value. 3199func (s *ListInstancesInput) SetServiceId(v string) *ListInstancesInput { 3200 s.ServiceId = &v 3201 return s 3202} 3203 3204// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListInstancesResponse 3205type ListInstancesOutput struct { 3206 _ struct{} `type:"structure"` 3207 3208 // Summary information about the instances that are associated with the specified 3209 // service. 3210 Instances []*InstanceSummary `type:"list"` 3211 3212 // If more than MaxResults instances match the specified criteria, you can submit 3213 // another ListInstances request to get the next group of results. Specify the 3214 // value of NextToken from the previous response in the next request. 3215 NextToken *string `type:"string"` 3216} 3217 3218// String returns the string representation 3219func (s ListInstancesOutput) String() string { 3220 return awsutil.Prettify(s) 3221} 3222 3223// GoString returns the string representation 3224func (s ListInstancesOutput) GoString() string { 3225 return s.String() 3226} 3227 3228// SetInstances sets the Instances field's value. 3229func (s *ListInstancesOutput) SetInstances(v []*InstanceSummary) *ListInstancesOutput { 3230 s.Instances = v 3231 return s 3232} 3233 3234// SetNextToken sets the NextToken field's value. 3235func (s *ListInstancesOutput) SetNextToken(v string) *ListInstancesOutput { 3236 s.NextToken = &v 3237 return s 3238} 3239 3240// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListNamespacesRequest 3241type ListNamespacesInput struct { 3242 _ struct{} `type:"structure"` 3243 3244 // A complex type that contains specifications for the namespaces that you want 3245 // to list. 3246 // 3247 // If you specify more than one filter, an operation must match all filters 3248 // to be returned by ListNamespaces. 3249 Filters []*NamespaceFilter `type:"list"` 3250 3251 // The maximum number of namespaces that you want Amazon Route 53 to return 3252 // in the response to a ListNamespaces request. If you don't specify a value 3253 // for MaxResults, Amazon Route 53 returns up to 100 namespaces. 3254 MaxResults *int64 `min:"1" type:"integer"` 3255 3256 // For the first ListNamespaces request, omit this value. 3257 // 3258 // If more than MaxResults namespaces match the specified criteria, you can 3259 // submit another ListNamespaces request to get the next group of results. Specify 3260 // the value of NextToken from the previous response in the next request. 3261 NextToken *string `type:"string"` 3262} 3263 3264// String returns the string representation 3265func (s ListNamespacesInput) String() string { 3266 return awsutil.Prettify(s) 3267} 3268 3269// GoString returns the string representation 3270func (s ListNamespacesInput) GoString() string { 3271 return s.String() 3272} 3273 3274// Validate inspects the fields of the type to determine if they are valid. 3275func (s *ListNamespacesInput) Validate() error { 3276 invalidParams := request.ErrInvalidParams{Context: "ListNamespacesInput"} 3277 if s.MaxResults != nil && *s.MaxResults < 1 { 3278 invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) 3279 } 3280 if s.Filters != nil { 3281 for i, v := range s.Filters { 3282 if v == nil { 3283 continue 3284 } 3285 if err := v.Validate(); err != nil { 3286 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(request.ErrInvalidParams)) 3287 } 3288 } 3289 } 3290 3291 if invalidParams.Len() > 0 { 3292 return invalidParams 3293 } 3294 return nil 3295} 3296 3297// SetFilters sets the Filters field's value. 3298func (s *ListNamespacesInput) SetFilters(v []*NamespaceFilter) *ListNamespacesInput { 3299 s.Filters = v 3300 return s 3301} 3302 3303// SetMaxResults sets the MaxResults field's value. 3304func (s *ListNamespacesInput) SetMaxResults(v int64) *ListNamespacesInput { 3305 s.MaxResults = &v 3306 return s 3307} 3308 3309// SetNextToken sets the NextToken field's value. 3310func (s *ListNamespacesInput) SetNextToken(v string) *ListNamespacesInput { 3311 s.NextToken = &v 3312 return s 3313} 3314 3315// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListNamespacesResponse 3316type ListNamespacesOutput struct { 3317 _ struct{} `type:"structure"` 3318 3319 // An array that contains one NamespaceSummary object for each namespace that 3320 // matches the specified filter criteria. 3321 Namespaces []*NamespaceSummary `type:"list"` 3322 3323 // If more than MaxResults namespaces match the specified criteria, you can 3324 // submit another ListNamespaces request to get the next group of results. Specify 3325 // the value of NextToken from the previous response in the next request. 3326 NextToken *string `type:"string"` 3327} 3328 3329// String returns the string representation 3330func (s ListNamespacesOutput) String() string { 3331 return awsutil.Prettify(s) 3332} 3333 3334// GoString returns the string representation 3335func (s ListNamespacesOutput) GoString() string { 3336 return s.String() 3337} 3338 3339// SetNamespaces sets the Namespaces field's value. 3340func (s *ListNamespacesOutput) SetNamespaces(v []*NamespaceSummary) *ListNamespacesOutput { 3341 s.Namespaces = v 3342 return s 3343} 3344 3345// SetNextToken sets the NextToken field's value. 3346func (s *ListNamespacesOutput) SetNextToken(v string) *ListNamespacesOutput { 3347 s.NextToken = &v 3348 return s 3349} 3350 3351// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListOperationsRequest 3352type ListOperationsInput struct { 3353 _ struct{} `type:"structure"` 3354 3355 // A complex type that contains specifications for the operations that you want 3356 // to list, for example, operations that you started between a specified start 3357 // date and end date. 3358 // 3359 // If you specify more than one filter, an operation must match all filters 3360 // to be returned by ListOperations. 3361 Filters []*OperationFilter `type:"list"` 3362 3363 // The maximum number of items that you want Amazon Route 53 to return in the 3364 // response to a ListOperations request. If you don't specify a value for MaxResults, 3365 // Amazon Route 53 returns up to 100 operations. 3366 MaxResults *int64 `min:"1" type:"integer"` 3367 3368 // For the first ListOperations request, omit this value. 3369 // 3370 // If more than MaxResults operations match the specified criteria, you can 3371 // submit another ListOperations request to get the next group of results. Specify 3372 // the value of NextToken from the previous response in the next request. 3373 NextToken *string `type:"string"` 3374} 3375 3376// String returns the string representation 3377func (s ListOperationsInput) String() string { 3378 return awsutil.Prettify(s) 3379} 3380 3381// GoString returns the string representation 3382func (s ListOperationsInput) GoString() string { 3383 return s.String() 3384} 3385 3386// Validate inspects the fields of the type to determine if they are valid. 3387func (s *ListOperationsInput) Validate() error { 3388 invalidParams := request.ErrInvalidParams{Context: "ListOperationsInput"} 3389 if s.MaxResults != nil && *s.MaxResults < 1 { 3390 invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) 3391 } 3392 if s.Filters != nil { 3393 for i, v := range s.Filters { 3394 if v == nil { 3395 continue 3396 } 3397 if err := v.Validate(); err != nil { 3398 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(request.ErrInvalidParams)) 3399 } 3400 } 3401 } 3402 3403 if invalidParams.Len() > 0 { 3404 return invalidParams 3405 } 3406 return nil 3407} 3408 3409// SetFilters sets the Filters field's value. 3410func (s *ListOperationsInput) SetFilters(v []*OperationFilter) *ListOperationsInput { 3411 s.Filters = v 3412 return s 3413} 3414 3415// SetMaxResults sets the MaxResults field's value. 3416func (s *ListOperationsInput) SetMaxResults(v int64) *ListOperationsInput { 3417 s.MaxResults = &v 3418 return s 3419} 3420 3421// SetNextToken sets the NextToken field's value. 3422func (s *ListOperationsInput) SetNextToken(v string) *ListOperationsInput { 3423 s.NextToken = &v 3424 return s 3425} 3426 3427// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListOperationsResponse 3428type ListOperationsOutput struct { 3429 _ struct{} `type:"structure"` 3430 3431 // If more than MaxResults operations match the specified criteria, you can 3432 // submit another ListOperations request to get the next group of results. Specify 3433 // the value of NextToken from the previous response in the next request. 3434 NextToken *string `type:"string"` 3435 3436 // Summary information about the operations that match the specified criteria. 3437 Operations []*OperationSummary `type:"list"` 3438} 3439 3440// String returns the string representation 3441func (s ListOperationsOutput) String() string { 3442 return awsutil.Prettify(s) 3443} 3444 3445// GoString returns the string representation 3446func (s ListOperationsOutput) GoString() string { 3447 return s.String() 3448} 3449 3450// SetNextToken sets the NextToken field's value. 3451func (s *ListOperationsOutput) SetNextToken(v string) *ListOperationsOutput { 3452 s.NextToken = &v 3453 return s 3454} 3455 3456// SetOperations sets the Operations field's value. 3457func (s *ListOperationsOutput) SetOperations(v []*OperationSummary) *ListOperationsOutput { 3458 s.Operations = v 3459 return s 3460} 3461 3462// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListServicesRequest 3463type ListServicesInput struct { 3464 _ struct{} `type:"structure"` 3465 3466 // A complex type that contains specifications for the namespaces that you want 3467 // to list services for. 3468 // 3469 // If you specify more than one filter, an operation must match all filters 3470 // to be returned by ListServices. 3471 Filters []*ServiceFilter `type:"list"` 3472 3473 // The maximum number of services that you want Amazon Route 53 to return in 3474 // the response to a ListServices request. If you don't specify a value for 3475 // MaxResults, Amazon Route 53 returns up to 100 services. 3476 MaxResults *int64 `min:"1" type:"integer"` 3477 3478 // For the first ListServices request, omit this value. 3479 // 3480 // If more than MaxResults services match the specified criteria, you can submit 3481 // another ListServices request to get the next group of results. Specify the 3482 // value of NextToken from the previous response in the next request. 3483 NextToken *string `type:"string"` 3484} 3485 3486// String returns the string representation 3487func (s ListServicesInput) String() string { 3488 return awsutil.Prettify(s) 3489} 3490 3491// GoString returns the string representation 3492func (s ListServicesInput) GoString() string { 3493 return s.String() 3494} 3495 3496// Validate inspects the fields of the type to determine if they are valid. 3497func (s *ListServicesInput) Validate() error { 3498 invalidParams := request.ErrInvalidParams{Context: "ListServicesInput"} 3499 if s.MaxResults != nil && *s.MaxResults < 1 { 3500 invalidParams.Add(request.NewErrParamMinValue("MaxResults", 1)) 3501 } 3502 if s.Filters != nil { 3503 for i, v := range s.Filters { 3504 if v == nil { 3505 continue 3506 } 3507 if err := v.Validate(); err != nil { 3508 invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Filters", i), err.(request.ErrInvalidParams)) 3509 } 3510 } 3511 } 3512 3513 if invalidParams.Len() > 0 { 3514 return invalidParams 3515 } 3516 return nil 3517} 3518 3519// SetFilters sets the Filters field's value. 3520func (s *ListServicesInput) SetFilters(v []*ServiceFilter) *ListServicesInput { 3521 s.Filters = v 3522 return s 3523} 3524 3525// SetMaxResults sets the MaxResults field's value. 3526func (s *ListServicesInput) SetMaxResults(v int64) *ListServicesInput { 3527 s.MaxResults = &v 3528 return s 3529} 3530 3531// SetNextToken sets the NextToken field's value. 3532func (s *ListServicesInput) SetNextToken(v string) *ListServicesInput { 3533 s.NextToken = &v 3534 return s 3535} 3536 3537// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ListServicesResponse 3538type ListServicesOutput struct { 3539 _ struct{} `type:"structure"` 3540 3541 // If more than MaxResults operations match the specified criteria, the value 3542 // of NextToken is the first service in the next group of services that were 3543 // created by the current AWS account. To get the next group, specify the value 3544 // of NextToken from the previous response in the next request. 3545 NextToken *string `type:"string"` 3546 3547 // An array that contains one ServiceSummary object for each service that matches 3548 // the specified filter criteria. 3549 Services []*ServiceSummary `type:"list"` 3550} 3551 3552// String returns the string representation 3553func (s ListServicesOutput) String() string { 3554 return awsutil.Prettify(s) 3555} 3556 3557// GoString returns the string representation 3558func (s ListServicesOutput) GoString() string { 3559 return s.String() 3560} 3561 3562// SetNextToken sets the NextToken field's value. 3563func (s *ListServicesOutput) SetNextToken(v string) *ListServicesOutput { 3564 s.NextToken = &v 3565 return s 3566} 3567 3568// SetServices sets the Services field's value. 3569func (s *ListServicesOutput) SetServices(v []*ServiceSummary) *ListServicesOutput { 3570 s.Services = v 3571 return s 3572} 3573 3574// A complex type that contains information about a specified namespace. 3575// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/Namespace 3576type Namespace struct { 3577 _ struct{} `type:"structure"` 3578 3579 // The Amazon Resource Name (ARN) that Amazon Route 53 assigns to the namespace 3580 // when you create it. 3581 Arn *string `type:"string"` 3582 3583 // The date that the namespace was created, in Unix date/time format and Coordinated 3584 // Universal Time (UTC). 3585 CreateDate *time.Time `type:"timestamp" timestampFormat:"unix"` 3586 3587 // An optional parameter that you can use to resolve concurrent creation requests. 3588 // CreatorRequestId helps to determine if a specific client owns the namespace. 3589 CreatorRequestId *string `type:"string"` 3590 3591 // The description that you specify for the namespace when you create it. 3592 Description *string `type:"string"` 3593 3594 // The ID of a namespace. 3595 Id *string `type:"string"` 3596 3597 // The name of the namespace, such as example.com. 3598 Name *string `type:"string"` 3599 3600 // A complex type that contains information that's specific to the type of the 3601 // namespace. 3602 Properties *NamespaceProperties `type:"structure"` 3603 3604 // The number of services that are associated with the namespace. 3605 ServiceCount *int64 `type:"integer"` 3606 3607 // The type of the namespace. Valid values are DNS_PUBLIC and DNS_PRIVATE. 3608 Type *string `type:"string" enum:"NamespaceType"` 3609} 3610 3611// String returns the string representation 3612func (s Namespace) String() string { 3613 return awsutil.Prettify(s) 3614} 3615 3616// GoString returns the string representation 3617func (s Namespace) GoString() string { 3618 return s.String() 3619} 3620 3621// SetArn sets the Arn field's value. 3622func (s *Namespace) SetArn(v string) *Namespace { 3623 s.Arn = &v 3624 return s 3625} 3626 3627// SetCreateDate sets the CreateDate field's value. 3628func (s *Namespace) SetCreateDate(v time.Time) *Namespace { 3629 s.CreateDate = &v 3630 return s 3631} 3632 3633// SetCreatorRequestId sets the CreatorRequestId field's value. 3634func (s *Namespace) SetCreatorRequestId(v string) *Namespace { 3635 s.CreatorRequestId = &v 3636 return s 3637} 3638 3639// SetDescription sets the Description field's value. 3640func (s *Namespace) SetDescription(v string) *Namespace { 3641 s.Description = &v 3642 return s 3643} 3644 3645// SetId sets the Id field's value. 3646func (s *Namespace) SetId(v string) *Namespace { 3647 s.Id = &v 3648 return s 3649} 3650 3651// SetName sets the Name field's value. 3652func (s *Namespace) SetName(v string) *Namespace { 3653 s.Name = &v 3654 return s 3655} 3656 3657// SetProperties sets the Properties field's value. 3658func (s *Namespace) SetProperties(v *NamespaceProperties) *Namespace { 3659 s.Properties = v 3660 return s 3661} 3662 3663// SetServiceCount sets the ServiceCount field's value. 3664func (s *Namespace) SetServiceCount(v int64) *Namespace { 3665 s.ServiceCount = &v 3666 return s 3667} 3668 3669// SetType sets the Type field's value. 3670func (s *Namespace) SetType(v string) *Namespace { 3671 s.Type = &v 3672 return s 3673} 3674 3675// A complex type that identifies the namespaces that you want to list. You 3676// can choose to list public or private namespaces. 3677// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/NamespaceFilter 3678type NamespaceFilter struct { 3679 _ struct{} `type:"structure"` 3680 3681 // The operator that you want to use to determine whether ListNamespaces returns 3682 // a namespace. Valid values for condition include: 3683 // 3684 // * EQ: When you specify EQ for the condition, you can choose to list only 3685 // public namespaces or private namespaces, but not both. EQ is the default 3686 // condition and can be omitted. 3687 // 3688 // * IN: When you specify IN for the condition, you can choose to list public 3689 // namespaces, private namespaces, or both. 3690 Condition *string `type:"string" enum:"FilterCondition"` 3691 3692 // Specify TYPE. 3693 // 3694 // Name is a required field 3695 Name *string `type:"string" required:"true" enum:"NamespaceFilterName"` 3696 3697 // If you specify EQ for Condition, specify either DNS_PUBLIC or DNS_PRIVATE. 3698 // 3699 // If you specify IN for Condition, you can specify DNS_PUBLIC, DNS_PRIVATE, 3700 // or both. 3701 // 3702 // Values is a required field 3703 Values []*string `type:"list" required:"true"` 3704} 3705 3706// String returns the string representation 3707func (s NamespaceFilter) String() string { 3708 return awsutil.Prettify(s) 3709} 3710 3711// GoString returns the string representation 3712func (s NamespaceFilter) GoString() string { 3713 return s.String() 3714} 3715 3716// Validate inspects the fields of the type to determine if they are valid. 3717func (s *NamespaceFilter) Validate() error { 3718 invalidParams := request.ErrInvalidParams{Context: "NamespaceFilter"} 3719 if s.Name == nil { 3720 invalidParams.Add(request.NewErrParamRequired("Name")) 3721 } 3722 if s.Values == nil { 3723 invalidParams.Add(request.NewErrParamRequired("Values")) 3724 } 3725 3726 if invalidParams.Len() > 0 { 3727 return invalidParams 3728 } 3729 return nil 3730} 3731 3732// SetCondition sets the Condition field's value. 3733func (s *NamespaceFilter) SetCondition(v string) *NamespaceFilter { 3734 s.Condition = &v 3735 return s 3736} 3737 3738// SetName sets the Name field's value. 3739func (s *NamespaceFilter) SetName(v string) *NamespaceFilter { 3740 s.Name = &v 3741 return s 3742} 3743 3744// SetValues sets the Values field's value. 3745func (s *NamespaceFilter) SetValues(v []*string) *NamespaceFilter { 3746 s.Values = v 3747 return s 3748} 3749 3750// A complex type that contains information that is specific to the namespace 3751// type. 3752// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/NamespaceProperties 3753type NamespaceProperties struct { 3754 _ struct{} `type:"structure"` 3755 3756 // A complex type that contains the ID for the hosted zone that Amazon Route 3757 // 53 creates when you create a namespace. 3758 DnsProperties *DnsProperties `type:"structure"` 3759} 3760 3761// String returns the string representation 3762func (s NamespaceProperties) String() string { 3763 return awsutil.Prettify(s) 3764} 3765 3766// GoString returns the string representation 3767func (s NamespaceProperties) GoString() string { 3768 return s.String() 3769} 3770 3771// SetDnsProperties sets the DnsProperties field's value. 3772func (s *NamespaceProperties) SetDnsProperties(v *DnsProperties) *NamespaceProperties { 3773 s.DnsProperties = v 3774 return s 3775} 3776 3777// A complex type that contains information about a namespace. 3778// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/NamespaceSummary 3779type NamespaceSummary struct { 3780 _ struct{} `type:"structure"` 3781 3782 // The Amazon Resource Name (ARN) that Amazon Route 53 assigns to the namespace 3783 // when you create it. 3784 Arn *string `type:"string"` 3785 3786 // The ID of the namespace. 3787 Id *string `type:"string"` 3788 3789 // The name of the namespace. When you create a namespace, Amazon Route 53 automatically 3790 // creates a hosted zone that has the same name as the namespace. 3791 Name *string `type:"string"` 3792 3793 // The type of the namespace, either public or private. 3794 Type *string `type:"string" enum:"NamespaceType"` 3795} 3796 3797// String returns the string representation 3798func (s NamespaceSummary) String() string { 3799 return awsutil.Prettify(s) 3800} 3801 3802// GoString returns the string representation 3803func (s NamespaceSummary) GoString() string { 3804 return s.String() 3805} 3806 3807// SetArn sets the Arn field's value. 3808func (s *NamespaceSummary) SetArn(v string) *NamespaceSummary { 3809 s.Arn = &v 3810 return s 3811} 3812 3813// SetId sets the Id field's value. 3814func (s *NamespaceSummary) SetId(v string) *NamespaceSummary { 3815 s.Id = &v 3816 return s 3817} 3818 3819// SetName sets the Name field's value. 3820func (s *NamespaceSummary) SetName(v string) *NamespaceSummary { 3821 s.Name = &v 3822 return s 3823} 3824 3825// SetType sets the Type field's value. 3826func (s *NamespaceSummary) SetType(v string) *NamespaceSummary { 3827 s.Type = &v 3828 return s 3829} 3830 3831// A complex type that contains information about a specified operation. 3832// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/Operation 3833type Operation struct { 3834 _ struct{} `type:"structure"` 3835 3836 // The date and time that the request was submitted, in Unix date/time format 3837 // and Coordinated Universal Time (UTC). 3838 CreateDate *time.Time `type:"timestamp" timestampFormat:"unix"` 3839 3840 // The code associated with ErrorMessage. 3841 ErrorCode *string `type:"string"` 3842 3843 // If the value of Status is FAIL, the reason that the operation failed. 3844 ErrorMessage *string `type:"string"` 3845 3846 // The ID of the operation that you want to get information about. 3847 Id *string `type:"string"` 3848 3849 // The status of the operation. Values include the following: 3850 // 3851 // * SUBMITTED: This is the initial state immediately after you submit a 3852 // request. 3853 // 3854 // * PENDING: Amazon Route 53 is performing the operation. 3855 // 3856 // * SUCCESS: The operation succeeded. 3857 // 3858 // * FAIL: The operation failed. For the failure reason, see ErrorMessage. 3859 Status *string `type:"string" enum:"OperationStatus"` 3860 3861 // The name of the target entity that is associated with the operation: 3862 // 3863 // * NAMESPACE: The namespace ID is returned in the ResourceId property. 3864 // 3865 // * SERVICE: The service ID is returned in the ResourceId property. 3866 // 3867 // * INSTANCE: The instance ID is returned in the ResourceId property. 3868 Targets map[string]*string `type:"map"` 3869 3870 // The name of the operation that is associated with the specified ID. 3871 Type *string `type:"string" enum:"OperationType"` 3872 3873 // The date and time that the value of Status changed to the current value, 3874 // in Unix date/time format and Coordinated Universal Time (UTC). 3875 UpdateDate *time.Time `type:"timestamp" timestampFormat:"unix"` 3876} 3877 3878// String returns the string representation 3879func (s Operation) String() string { 3880 return awsutil.Prettify(s) 3881} 3882 3883// GoString returns the string representation 3884func (s Operation) GoString() string { 3885 return s.String() 3886} 3887 3888// SetCreateDate sets the CreateDate field's value. 3889func (s *Operation) SetCreateDate(v time.Time) *Operation { 3890 s.CreateDate = &v 3891 return s 3892} 3893 3894// SetErrorCode sets the ErrorCode field's value. 3895func (s *Operation) SetErrorCode(v string) *Operation { 3896 s.ErrorCode = &v 3897 return s 3898} 3899 3900// SetErrorMessage sets the ErrorMessage field's value. 3901func (s *Operation) SetErrorMessage(v string) *Operation { 3902 s.ErrorMessage = &v 3903 return s 3904} 3905 3906// SetId sets the Id field's value. 3907func (s *Operation) SetId(v string) *Operation { 3908 s.Id = &v 3909 return s 3910} 3911 3912// SetStatus sets the Status field's value. 3913func (s *Operation) SetStatus(v string) *Operation { 3914 s.Status = &v 3915 return s 3916} 3917 3918// SetTargets sets the Targets field's value. 3919func (s *Operation) SetTargets(v map[string]*string) *Operation { 3920 s.Targets = v 3921 return s 3922} 3923 3924// SetType sets the Type field's value. 3925func (s *Operation) SetType(v string) *Operation { 3926 s.Type = &v 3927 return s 3928} 3929 3930// SetUpdateDate sets the UpdateDate field's value. 3931func (s *Operation) SetUpdateDate(v time.Time) *Operation { 3932 s.UpdateDate = &v 3933 return s 3934} 3935 3936// A complex type that lets you select the operations that you want to list. 3937// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/OperationFilter 3938type OperationFilter struct { 3939 _ struct{} `type:"structure"` 3940 3941 // The operator that you want to use to determine whether an operation matches 3942 // the specified value. Valid values for condition include: 3943 // 3944 // * EQ: When you specify EQ for the condition, you can specify only one 3945 // value. EQ is supported for NAMESPACE_ID, SERVICE_ID, STATUS, and TYPE. 3946 // EQ is the default condition and can be omitted. 3947 // 3948 // * IN: When you specify IN for the condition, you can specify a list of 3949 // one or more values. IN is supported for STATUS and TYPE. An operation 3950 // must match one of the specified values to be returned in the response. 3951 // 3952 // * BETWEEN: Specify two values, a start date and an end date. The start 3953 // date must be the first value. BETWEEN is supported for U. 3954 Condition *string `type:"string" enum:"FilterCondition"` 3955 3956 // Specify the operations that you want to get: 3957 // 3958 // * NAMESPACE_ID: Gets operations related to specified namespaces. 3959 // 3960 // * SERVICE_ID: Gets operations related to specified services. 3961 // 3962 // * STATUS: Gets operations based on the status of the operations: SUBMITTED, 3963 // PENDING, SUCCEED, or FAIL. 3964 // 3965 // * TYPE: Gets specified types of operation. 3966 // 3967 // * UPDATE_DATE: Gets operations that changed status during a specified 3968 // date/time range. 3969 // 3970 // Name is a required field 3971 Name *string `type:"string" required:"true" enum:"OperationFilterName"` 3972 3973 // Specify values that are applicable to the value that you specify for Name: 3974 // 3975 // * NAMESPACE_ID: Specify one namespace ID. 3976 // 3977 // * SERVICE_ID: Specify one service ID. 3978 // 3979 // * STATUS: Specify one or more statuses: SUBMITTED, PENDING, SUCCEED, or 3980 // FAIL. 3981 // 3982 // * TYPE: Specify one or more of the following types: CREATE_NAMESPACE, 3983 // DELETE_NAMESPACE, UPDATE_SERVICE, REGISTER_INSTANCE, or DEREGISTER_INSTANCE. 3984 // 3985 // * UPDATE_DATE: Specify a start date and an end date in Unix date/time 3986 // format and Coordinated Universal Time (UTC). The start date must be the 3987 // first value. 3988 // 3989 // Values is a required field 3990 Values []*string `type:"list" required:"true"` 3991} 3992 3993// String returns the string representation 3994func (s OperationFilter) String() string { 3995 return awsutil.Prettify(s) 3996} 3997 3998// GoString returns the string representation 3999func (s OperationFilter) GoString() string { 4000 return s.String() 4001} 4002 4003// Validate inspects the fields of the type to determine if they are valid. 4004func (s *OperationFilter) Validate() error { 4005 invalidParams := request.ErrInvalidParams{Context: "OperationFilter"} 4006 if s.Name == nil { 4007 invalidParams.Add(request.NewErrParamRequired("Name")) 4008 } 4009 if s.Values == nil { 4010 invalidParams.Add(request.NewErrParamRequired("Values")) 4011 } 4012 4013 if invalidParams.Len() > 0 { 4014 return invalidParams 4015 } 4016 return nil 4017} 4018 4019// SetCondition sets the Condition field's value. 4020func (s *OperationFilter) SetCondition(v string) *OperationFilter { 4021 s.Condition = &v 4022 return s 4023} 4024 4025// SetName sets the Name field's value. 4026func (s *OperationFilter) SetName(v string) *OperationFilter { 4027 s.Name = &v 4028 return s 4029} 4030 4031// SetValues sets the Values field's value. 4032func (s *OperationFilter) SetValues(v []*string) *OperationFilter { 4033 s.Values = v 4034 return s 4035} 4036 4037// A complex type that contains information about an operation that matches 4038// the criteria that you specified in a ListOperations request. 4039// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/OperationSummary 4040type OperationSummary struct { 4041 _ struct{} `type:"structure"` 4042 4043 // The ID for an operation. 4044 Id *string `type:"string"` 4045 4046 // The status of the operation. Values include the following: 4047 // 4048 // * SUBMITTED: This is the initial state immediately after you submit a 4049 // request. 4050 // 4051 // * PENDING: Amazon Route 53 is performing the operation. 4052 // 4053 // * SUCCESS: The operation succeeded. 4054 // 4055 // * FAIL: The operation failed. For the failure reason, see ErrorMessage. 4056 Status *string `type:"string" enum:"OperationStatus"` 4057} 4058 4059// String returns the string representation 4060func (s OperationSummary) String() string { 4061 return awsutil.Prettify(s) 4062} 4063 4064// GoString returns the string representation 4065func (s OperationSummary) GoString() string { 4066 return s.String() 4067} 4068 4069// SetId sets the Id field's value. 4070func (s *OperationSummary) SetId(v string) *OperationSummary { 4071 s.Id = &v 4072 return s 4073} 4074 4075// SetStatus sets the Status field's value. 4076func (s *OperationSummary) SetStatus(v string) *OperationSummary { 4077 s.Status = &v 4078 return s 4079} 4080 4081// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/RegisterInstanceRequest 4082type RegisterInstanceInput struct { 4083 _ struct{} `type:"structure"` 4084 4085 // A string map that contain attribute keys and values. Supported attribute 4086 // keys include the following: 4087 // 4088 // * AWS_INSTANCE_PORT: The port on the endpoint that you want Amazon Route 4089 // 53 to perform health checks on. This value is also used for the port value 4090 // in an SRV record if the service that you specify includes an SRV record. 4091 // For more information, see CreateService. 4092 // 4093 // * AWS_INSTANCE_IPV4: If the service that you specify contains a resource 4094 // record set template for an A record, the IPv4 address that you want Amazon 4095 // Route 53 to use for the value of the A record. 4096 // 4097 // * AWS_INSTANCE_IPV6: If the service that you specify contains a resource 4098 // record set template for an AAAA record, the IPv6 address that you want 4099 // Amazon Route 53 to use for the value of the AAAA record. 4100 // 4101 // Attributes is a required field 4102 Attributes map[string]*string `type:"map" required:"true"` 4103 4104 // An optional parameter that you can use to resolve concurrent creation requests. 4105 // CreatorRequestId helps to determine if a specific client owns the namespace. 4106 CreatorRequestId *string `type:"string" idempotencyToken:"true"` 4107 4108 // An identifier that you want to associate with the instance. Note the following: 4109 // 4110 // * You can use this value to update an existing instance. 4111 // 4112 // * To register a new instance, you must specify a value that is unique 4113 // among instances that you register by using the same service. 4114 // 4115 // InstanceId is a required field 4116 InstanceId *string `type:"string" required:"true"` 4117 4118 // The ID of the service that you want to use for settings for the resource 4119 // record sets and health check that Amazon Route 53 will create. 4120 // 4121 // ServiceId is a required field 4122 ServiceId *string `type:"string" required:"true"` 4123} 4124 4125// String returns the string representation 4126func (s RegisterInstanceInput) String() string { 4127 return awsutil.Prettify(s) 4128} 4129 4130// GoString returns the string representation 4131func (s RegisterInstanceInput) GoString() string { 4132 return s.String() 4133} 4134 4135// Validate inspects the fields of the type to determine if they are valid. 4136func (s *RegisterInstanceInput) Validate() error { 4137 invalidParams := request.ErrInvalidParams{Context: "RegisterInstanceInput"} 4138 if s.Attributes == nil { 4139 invalidParams.Add(request.NewErrParamRequired("Attributes")) 4140 } 4141 if s.InstanceId == nil { 4142 invalidParams.Add(request.NewErrParamRequired("InstanceId")) 4143 } 4144 if s.ServiceId == nil { 4145 invalidParams.Add(request.NewErrParamRequired("ServiceId")) 4146 } 4147 4148 if invalidParams.Len() > 0 { 4149 return invalidParams 4150 } 4151 return nil 4152} 4153 4154// SetAttributes sets the Attributes field's value. 4155func (s *RegisterInstanceInput) SetAttributes(v map[string]*string) *RegisterInstanceInput { 4156 s.Attributes = v 4157 return s 4158} 4159 4160// SetCreatorRequestId sets the CreatorRequestId field's value. 4161func (s *RegisterInstanceInput) SetCreatorRequestId(v string) *RegisterInstanceInput { 4162 s.CreatorRequestId = &v 4163 return s 4164} 4165 4166// SetInstanceId sets the InstanceId field's value. 4167func (s *RegisterInstanceInput) SetInstanceId(v string) *RegisterInstanceInput { 4168 s.InstanceId = &v 4169 return s 4170} 4171 4172// SetServiceId sets the ServiceId field's value. 4173func (s *RegisterInstanceInput) SetServiceId(v string) *RegisterInstanceInput { 4174 s.ServiceId = &v 4175 return s 4176} 4177 4178// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/RegisterInstanceResponse 4179type RegisterInstanceOutput struct { 4180 _ struct{} `type:"structure"` 4181 4182 // A value that you can use to determine whether the request completed successfully. 4183 // To get the status of the operation, see GetOperation. 4184 OperationId *string `type:"string"` 4185} 4186 4187// String returns the string representation 4188func (s RegisterInstanceOutput) String() string { 4189 return awsutil.Prettify(s) 4190} 4191 4192// GoString returns the string representation 4193func (s RegisterInstanceOutput) GoString() string { 4194 return s.String() 4195} 4196 4197// SetOperationId sets the OperationId field's value. 4198func (s *RegisterInstanceOutput) SetOperationId(v string) *RegisterInstanceOutput { 4199 s.OperationId = &v 4200 return s 4201} 4202 4203// A complex type that contains information about the specified service. 4204// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/Service 4205type Service struct { 4206 _ struct{} `type:"structure"` 4207 4208 // The Amazon Resource Name (ARN) that Amazon Route 53 assigns to the service 4209 // when you create it. 4210 Arn *string `type:"string"` 4211 4212 // The date and time that the service was created, in Unix format and Coordinated 4213 // Universal Time (UTC). 4214 CreateDate *time.Time `type:"timestamp" timestampFormat:"unix"` 4215 4216 // An optional parameter that you can use to resolve concurrent creation requests. 4217 // CreatorRequestId helps to determine if a specific client owns the namespace. 4218 CreatorRequestId *string `type:"string"` 4219 4220 // The description of the service. 4221 Description *string `type:"string"` 4222 4223 // A complex type that contains information about the resource record sets that 4224 // you want Amazon Route 53 to create when you register an instance. 4225 DnsConfig *DnsConfig `type:"structure"` 4226 4227 // Public DNS namespaces only. A complex type that contains settings for an 4228 // optional health check. If you specify settings for a health check, Amazon 4229 // Route 53 associates the health check with all the resource record sets that 4230 // you specify in DnsConfig. 4231 // 4232 // The health check uses 30 seconds as the request interval. This is the number 4233 // of seconds between the time that each Amazon Route 53 health checker gets 4234 // a response from your endpoint and the time that it sends the next health 4235 // check request. A health checker in each data center around the world sends 4236 // your endpoint a health check request every 30 seconds. On average, your endpoint 4237 // receives a health check request about every two seconds. Health checkers 4238 // in different data centers don't coordinate with one another, so you'll sometimes 4239 // see several requests per second followed by a few seconds with no health 4240 // checks at all. 4241 // 4242 // For information about the charges for health checks, see Amazon Route 53 4243 // Pricing (http://aws.amazon.com/route53/pricing). 4244 HealthCheckConfig *HealthCheckConfig `type:"structure"` 4245 4246 // The ID that Amazon Route 53 assigned to the service when you created it. 4247 Id *string `type:"string"` 4248 4249 // The number of instances that are currently associated with the service. Instances 4250 // that were previously associated with the service but that have been deleted 4251 // are not included in the count. 4252 InstanceCount *int64 `type:"integer"` 4253 4254 // The name of the service. 4255 Name *string `type:"string"` 4256} 4257 4258// String returns the string representation 4259func (s Service) String() string { 4260 return awsutil.Prettify(s) 4261} 4262 4263// GoString returns the string representation 4264func (s Service) GoString() string { 4265 return s.String() 4266} 4267 4268// SetArn sets the Arn field's value. 4269func (s *Service) SetArn(v string) *Service { 4270 s.Arn = &v 4271 return s 4272} 4273 4274// SetCreateDate sets the CreateDate field's value. 4275func (s *Service) SetCreateDate(v time.Time) *Service { 4276 s.CreateDate = &v 4277 return s 4278} 4279 4280// SetCreatorRequestId sets the CreatorRequestId field's value. 4281func (s *Service) SetCreatorRequestId(v string) *Service { 4282 s.CreatorRequestId = &v 4283 return s 4284} 4285 4286// SetDescription sets the Description field's value. 4287func (s *Service) SetDescription(v string) *Service { 4288 s.Description = &v 4289 return s 4290} 4291 4292// SetDnsConfig sets the DnsConfig field's value. 4293func (s *Service) SetDnsConfig(v *DnsConfig) *Service { 4294 s.DnsConfig = v 4295 return s 4296} 4297 4298// SetHealthCheckConfig sets the HealthCheckConfig field's value. 4299func (s *Service) SetHealthCheckConfig(v *HealthCheckConfig) *Service { 4300 s.HealthCheckConfig = v 4301 return s 4302} 4303 4304// SetId sets the Id field's value. 4305func (s *Service) SetId(v string) *Service { 4306 s.Id = &v 4307 return s 4308} 4309 4310// SetInstanceCount sets the InstanceCount field's value. 4311func (s *Service) SetInstanceCount(v int64) *Service { 4312 s.InstanceCount = &v 4313 return s 4314} 4315 4316// SetName sets the Name field's value. 4317func (s *Service) SetName(v string) *Service { 4318 s.Name = &v 4319 return s 4320} 4321 4322// A complex type that contains changes to an existing service. 4323// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ServiceChange 4324type ServiceChange struct { 4325 _ struct{} `type:"structure"` 4326 4327 // A description for the service. 4328 Description *string `type:"string"` 4329 4330 // A complex type that contains information about the resource record sets that 4331 // you want Amazon Route 53 to create when you register an instance. 4332 // 4333 // DnsConfig is a required field 4334 DnsConfig *DnsConfigChange `type:"structure" required:"true"` 4335 4336 // Public DNS namespaces only. A complex type that contains settings for an 4337 // optional health check. If you specify settings for a health check, Amazon 4338 // Route 53 associates the health check with all the resource record sets that 4339 // you specify in DnsConfig. 4340 // 4341 // The health check uses 30 seconds as the request interval. This is the number 4342 // of seconds between the time that each Amazon Route 53 health checker gets 4343 // a response from your endpoint and the time that it sends the next health 4344 // check request. A health checker in each data center around the world sends 4345 // your endpoint a health check request every 30 seconds. On average, your endpoint 4346 // receives a health check request about every two seconds. Health checkers 4347 // in different data centers don't coordinate with one another, so you'll sometimes 4348 // see several requests per second followed by a few seconds with no health 4349 // checks at all. 4350 // 4351 // For information about the charges for health checks, see Amazon Route 53 4352 // Pricing (http://aws.amazon.com/route53/pricing). 4353 HealthCheckConfig *HealthCheckConfig `type:"structure"` 4354} 4355 4356// String returns the string representation 4357func (s ServiceChange) String() string { 4358 return awsutil.Prettify(s) 4359} 4360 4361// GoString returns the string representation 4362func (s ServiceChange) GoString() string { 4363 return s.String() 4364} 4365 4366// Validate inspects the fields of the type to determine if they are valid. 4367func (s *ServiceChange) Validate() error { 4368 invalidParams := request.ErrInvalidParams{Context: "ServiceChange"} 4369 if s.DnsConfig == nil { 4370 invalidParams.Add(request.NewErrParamRequired("DnsConfig")) 4371 } 4372 if s.DnsConfig != nil { 4373 if err := s.DnsConfig.Validate(); err != nil { 4374 invalidParams.AddNested("DnsConfig", err.(request.ErrInvalidParams)) 4375 } 4376 } 4377 if s.HealthCheckConfig != nil { 4378 if err := s.HealthCheckConfig.Validate(); err != nil { 4379 invalidParams.AddNested("HealthCheckConfig", err.(request.ErrInvalidParams)) 4380 } 4381 } 4382 4383 if invalidParams.Len() > 0 { 4384 return invalidParams 4385 } 4386 return nil 4387} 4388 4389// SetDescription sets the Description field's value. 4390func (s *ServiceChange) SetDescription(v string) *ServiceChange { 4391 s.Description = &v 4392 return s 4393} 4394 4395// SetDnsConfig sets the DnsConfig field's value. 4396func (s *ServiceChange) SetDnsConfig(v *DnsConfigChange) *ServiceChange { 4397 s.DnsConfig = v 4398 return s 4399} 4400 4401// SetHealthCheckConfig sets the HealthCheckConfig field's value. 4402func (s *ServiceChange) SetHealthCheckConfig(v *HealthCheckConfig) *ServiceChange { 4403 s.HealthCheckConfig = v 4404 return s 4405} 4406 4407// A complex type that lets you specify the namespaces that you want to list 4408// services for. 4409// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ServiceFilter 4410type ServiceFilter struct { 4411 _ struct{} `type:"structure"` 4412 4413 // The operator that you want to use to determine whether a service is returned 4414 // by ListServices. Valid values for Condition include the following: 4415 // 4416 // * EQ: When you specify EQ, specify one namespace ID for Values. EQ is 4417 // the default condition and can be omitted. 4418 // 4419 // * IN: When you specify IN, specify a list of the IDs for the namespaces 4420 // that you want ListServices to return a list of services for. 4421 Condition *string `type:"string" enum:"FilterCondition"` 4422 4423 // Specify NAMESPACE_ID. 4424 // 4425 // Name is a required field 4426 Name *string `type:"string" required:"true" enum:"ServiceFilterName"` 4427 4428 // The values that are applicable to the value that you specify for Condition 4429 // to filter the list of services. 4430 // 4431 // Values is a required field 4432 Values []*string `type:"list" required:"true"` 4433} 4434 4435// String returns the string representation 4436func (s ServiceFilter) String() string { 4437 return awsutil.Prettify(s) 4438} 4439 4440// GoString returns the string representation 4441func (s ServiceFilter) GoString() string { 4442 return s.String() 4443} 4444 4445// Validate inspects the fields of the type to determine if they are valid. 4446func (s *ServiceFilter) Validate() error { 4447 invalidParams := request.ErrInvalidParams{Context: "ServiceFilter"} 4448 if s.Name == nil { 4449 invalidParams.Add(request.NewErrParamRequired("Name")) 4450 } 4451 if s.Values == nil { 4452 invalidParams.Add(request.NewErrParamRequired("Values")) 4453 } 4454 4455 if invalidParams.Len() > 0 { 4456 return invalidParams 4457 } 4458 return nil 4459} 4460 4461// SetCondition sets the Condition field's value. 4462func (s *ServiceFilter) SetCondition(v string) *ServiceFilter { 4463 s.Condition = &v 4464 return s 4465} 4466 4467// SetName sets the Name field's value. 4468func (s *ServiceFilter) SetName(v string) *ServiceFilter { 4469 s.Name = &v 4470 return s 4471} 4472 4473// SetValues sets the Values field's value. 4474func (s *ServiceFilter) SetValues(v []*string) *ServiceFilter { 4475 s.Values = v 4476 return s 4477} 4478 4479// A complex type that contains information about a specified service. 4480// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/ServiceSummary 4481type ServiceSummary struct { 4482 _ struct{} `type:"structure"` 4483 4484 // The Amazon Resource Name (ARN) that Amazon Route 53 assigns to the service 4485 // when you create it. 4486 Arn *string `type:"string"` 4487 4488 // The description that you specify when you create the service. 4489 Description *string `type:"string"` 4490 4491 // The ID that Amazon Route 53 assigned to the service when you created it. 4492 Id *string `type:"string"` 4493 4494 // The number of instances that are currently associated with the service. Instances 4495 // that were previously associated with the service but that have been deleted 4496 // are not included in the count. 4497 InstanceCount *int64 `type:"integer"` 4498 4499 // The name of the service. 4500 Name *string `type:"string"` 4501} 4502 4503// String returns the string representation 4504func (s ServiceSummary) String() string { 4505 return awsutil.Prettify(s) 4506} 4507 4508// GoString returns the string representation 4509func (s ServiceSummary) GoString() string { 4510 return s.String() 4511} 4512 4513// SetArn sets the Arn field's value. 4514func (s *ServiceSummary) SetArn(v string) *ServiceSummary { 4515 s.Arn = &v 4516 return s 4517} 4518 4519// SetDescription sets the Description field's value. 4520func (s *ServiceSummary) SetDescription(v string) *ServiceSummary { 4521 s.Description = &v 4522 return s 4523} 4524 4525// SetId sets the Id field's value. 4526func (s *ServiceSummary) SetId(v string) *ServiceSummary { 4527 s.Id = &v 4528 return s 4529} 4530 4531// SetInstanceCount sets the InstanceCount field's value. 4532func (s *ServiceSummary) SetInstanceCount(v int64) *ServiceSummary { 4533 s.InstanceCount = &v 4534 return s 4535} 4536 4537// SetName sets the Name field's value. 4538func (s *ServiceSummary) SetName(v string) *ServiceSummary { 4539 s.Name = &v 4540 return s 4541} 4542 4543// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/UpdateServiceRequest 4544type UpdateServiceInput struct { 4545 _ struct{} `type:"structure"` 4546 4547 // The ID of the service that you want to update. 4548 // 4549 // Id is a required field 4550 Id *string `type:"string" required:"true"` 4551 4552 // A complex type that contains the new settings for the service. 4553 // 4554 // Service is a required field 4555 Service *ServiceChange `type:"structure" required:"true"` 4556} 4557 4558// String returns the string representation 4559func (s UpdateServiceInput) String() string { 4560 return awsutil.Prettify(s) 4561} 4562 4563// GoString returns the string representation 4564func (s UpdateServiceInput) GoString() string { 4565 return s.String() 4566} 4567 4568// Validate inspects the fields of the type to determine if they are valid. 4569func (s *UpdateServiceInput) Validate() error { 4570 invalidParams := request.ErrInvalidParams{Context: "UpdateServiceInput"} 4571 if s.Id == nil { 4572 invalidParams.Add(request.NewErrParamRequired("Id")) 4573 } 4574 if s.Service == nil { 4575 invalidParams.Add(request.NewErrParamRequired("Service")) 4576 } 4577 if s.Service != nil { 4578 if err := s.Service.Validate(); err != nil { 4579 invalidParams.AddNested("Service", err.(request.ErrInvalidParams)) 4580 } 4581 } 4582 4583 if invalidParams.Len() > 0 { 4584 return invalidParams 4585 } 4586 return nil 4587} 4588 4589// SetId sets the Id field's value. 4590func (s *UpdateServiceInput) SetId(v string) *UpdateServiceInput { 4591 s.Id = &v 4592 return s 4593} 4594 4595// SetService sets the Service field's value. 4596func (s *UpdateServiceInput) SetService(v *ServiceChange) *UpdateServiceInput { 4597 s.Service = v 4598 return s 4599} 4600 4601// See also, https://docs.aws.amazon.com/goto/WebAPI/servicediscovery-2017-03-14/UpdateServiceResponse 4602type UpdateServiceOutput struct { 4603 _ struct{} `type:"structure"` 4604 4605 // A value that you can use to determine whether the request completed successfully. 4606 // To get the status of the operation, see GetOperation. 4607 OperationId *string `type:"string"` 4608} 4609 4610// String returns the string representation 4611func (s UpdateServiceOutput) String() string { 4612 return awsutil.Prettify(s) 4613} 4614 4615// GoString returns the string representation 4616func (s UpdateServiceOutput) GoString() string { 4617 return s.String() 4618} 4619 4620// SetOperationId sets the OperationId field's value. 4621func (s *UpdateServiceOutput) SetOperationId(v string) *UpdateServiceOutput { 4622 s.OperationId = &v 4623 return s 4624} 4625 4626const ( 4627 // FilterConditionEq is a FilterCondition enum value 4628 FilterConditionEq = "EQ" 4629 4630 // FilterConditionIn is a FilterCondition enum value 4631 FilterConditionIn = "IN" 4632 4633 // FilterConditionBetween is a FilterCondition enum value 4634 FilterConditionBetween = "BETWEEN" 4635) 4636 4637const ( 4638 // HealthCheckTypeHttp is a HealthCheckType enum value 4639 HealthCheckTypeHttp = "HTTP" 4640 4641 // HealthCheckTypeHttps is a HealthCheckType enum value 4642 HealthCheckTypeHttps = "HTTPS" 4643 4644 // HealthCheckTypeTcp is a HealthCheckType enum value 4645 HealthCheckTypeTcp = "TCP" 4646) 4647 4648const ( 4649 // HealthStatusHealthy is a HealthStatus enum value 4650 HealthStatusHealthy = "HEALTHY" 4651 4652 // HealthStatusUnhealthy is a HealthStatus enum value 4653 HealthStatusUnhealthy = "UNHEALTHY" 4654 4655 // HealthStatusUnknown is a HealthStatus enum value 4656 HealthStatusUnknown = "UNKNOWN" 4657) 4658 4659const ( 4660 // NamespaceFilterNameType is a NamespaceFilterName enum value 4661 NamespaceFilterNameType = "TYPE" 4662) 4663 4664const ( 4665 // NamespaceTypeDnsPublic is a NamespaceType enum value 4666 NamespaceTypeDnsPublic = "DNS_PUBLIC" 4667 4668 // NamespaceTypeDnsPrivate is a NamespaceType enum value 4669 NamespaceTypeDnsPrivate = "DNS_PRIVATE" 4670) 4671 4672const ( 4673 // OperationFilterNameNamespaceId is a OperationFilterName enum value 4674 OperationFilterNameNamespaceId = "NAMESPACE_ID" 4675 4676 // OperationFilterNameServiceId is a OperationFilterName enum value 4677 OperationFilterNameServiceId = "SERVICE_ID" 4678 4679 // OperationFilterNameStatus is a OperationFilterName enum value 4680 OperationFilterNameStatus = "STATUS" 4681 4682 // OperationFilterNameType is a OperationFilterName enum value 4683 OperationFilterNameType = "TYPE" 4684 4685 // OperationFilterNameUpdateDate is a OperationFilterName enum value 4686 OperationFilterNameUpdateDate = "UPDATE_DATE" 4687) 4688 4689const ( 4690 // OperationStatusSubmitted is a OperationStatus enum value 4691 OperationStatusSubmitted = "SUBMITTED" 4692 4693 // OperationStatusPending is a OperationStatus enum value 4694 OperationStatusPending = "PENDING" 4695 4696 // OperationStatusSuccess is a OperationStatus enum value 4697 OperationStatusSuccess = "SUCCESS" 4698 4699 // OperationStatusFail is a OperationStatus enum value 4700 OperationStatusFail = "FAIL" 4701) 4702 4703const ( 4704 // OperationTargetTypeNamespace is a OperationTargetType enum value 4705 OperationTargetTypeNamespace = "NAMESPACE" 4706 4707 // OperationTargetTypeService is a OperationTargetType enum value 4708 OperationTargetTypeService = "SERVICE" 4709 4710 // OperationTargetTypeInstance is a OperationTargetType enum value 4711 OperationTargetTypeInstance = "INSTANCE" 4712) 4713 4714const ( 4715 // OperationTypeCreateNamespace is a OperationType enum value 4716 OperationTypeCreateNamespace = "CREATE_NAMESPACE" 4717 4718 // OperationTypeDeleteNamespace is a OperationType enum value 4719 OperationTypeDeleteNamespace = "DELETE_NAMESPACE" 4720 4721 // OperationTypeUpdateService is a OperationType enum value 4722 OperationTypeUpdateService = "UPDATE_SERVICE" 4723 4724 // OperationTypeRegisterInstance is a OperationType enum value 4725 OperationTypeRegisterInstance = "REGISTER_INSTANCE" 4726 4727 // OperationTypeDeregisterInstance is a OperationType enum value 4728 OperationTypeDeregisterInstance = "DEREGISTER_INSTANCE" 4729) 4730 4731const ( 4732 // RecordTypeSrv is a RecordType enum value 4733 RecordTypeSrv = "SRV" 4734 4735 // RecordTypeA is a RecordType enum value 4736 RecordTypeA = "A" 4737 4738 // RecordTypeAaaa is a RecordType enum value 4739 RecordTypeAaaa = "AAAA" 4740) 4741 4742const ( 4743 // ServiceFilterNameNamespaceId is a ServiceFilterName enum value 4744 ServiceFilterNameNamespaceId = "NAMESPACE_ID" 4745) 4746