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