/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace GlobalAccelerator { /** * Global Accelerator

This is the Global Accelerator API * Reference. This guide is for developers who need detailed information about * Global Accelerator API actions, data types, and errors. For more information * about Global Accelerator features, see the Global * Accelerator Developer Guide.

Global Accelerator is a service in which * you create accelerators to improve the performance of your applications * for local and global users. Depending on the type of accelerator you choose, you * can gain additional benefits.

  • By using a standard accelerator, * you can improve availability of your internet applications that are used by a * global audience. With a standard accelerator, Global Accelerator directs traffic * to optimal endpoints over the Amazon Web Services global network.

    • *

  • For other scenarios, you might choose a custom routing accelerator. With * a custom routing accelerator, you can use application logic to directly map one * or more users to a specific endpoint among many endpoints.

*

Global Accelerator is a global service that supports endpoints in * multiple Amazon Web Services Regions but you must specify the US West (Oregon) * Region to create, update, or otherwise work with accelerators. That is, for * example, specify --region us-west-2 on AWS CLI commands.

*

By default, Global Accelerator provides you with static IP * addresses that you associate with your accelerator. The static IP addresses are * anycast from the Amazon Web Services edge network. For IPv4, Global Accelerator * provides two static IPv4 addresses. For dual-stack, Global Accelerator provides * a total of four addresses: two static IPv4 addresses and two static IPv6 * addresses. With a standard accelerator for IPv4, instead of using the addresses * that Global Accelerator provides, you can configure these entry points to be * IPv4 addresses from your own IP address ranges that you bring toGlobal * Accelerator (BYOIP).

For a standard accelerator, they distribute * incoming application traffic across multiple endpoint resources in multiple * Amazon Web Services Regions , which increases the availability of your * applications. Endpoints for standard accelerators can be Network Load Balancers, * Application Load Balancers, Amazon EC2 instances, or Elastic IP addresses that * are located in one Amazon Web Services Region or multiple Amazon Web Services * Regions. For custom routing accelerators, you map traffic that arrives to the * static IP addresses to specific Amazon EC2 servers in endpoints that are virtual * private cloud (VPC) subnets.

The static IP addresses remain * assigned to your accelerator for as long as it exists, even if you disable the * accelerator and it no longer accepts or routes traffic. However, when you * delete an accelerator, you lose the static IP addresses that are assigned * to it, so you can no longer route traffic by using them. You can use IAM * policies like tag-based permissions with Global Accelerator to limit the users * who have permissions to delete an accelerator. For more information, see Tag-based * policies.

For standard accelerators, Global Accelerator * uses the Amazon Web Services global network to route traffic to the optimal * regional endpoint based on health, client location, and policies that you * configure. The service reacts instantly to changes in health or configuration to * ensure that internet traffic from clients is always directed to healthy * endpoints.

For more information about understanding and using Global * Accelerator, see the Global * Accelerator Developer Guide.

*/ class AWS_GLOBALACCELERATOR_API GlobalAcceleratorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef GlobalAcceleratorClientConfiguration ClientConfigurationType; typedef GlobalAcceleratorEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ GlobalAcceleratorClient(const Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration& clientConfiguration = Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ GlobalAcceleratorClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration& clientConfiguration = Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ GlobalAcceleratorClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration& clientConfiguration = Aws::GlobalAccelerator::GlobalAcceleratorClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ GlobalAcceleratorClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ GlobalAcceleratorClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ GlobalAcceleratorClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~GlobalAcceleratorClient(); /** *

Associate a virtual private cloud (VPC) subnet endpoint with your custom * routing accelerator.

The listener port range must be large enough to * support the number of IP addresses that can be specified in your subnet. The * number of ports required is: subnet size times the number of ports per * destination EC2 instances. For example, a subnet defined as /24 requires a * listener port range of at least 255 ports.

Note: You must have enough * remaining listener ports available to map to the subnet ports, or the call will * fail with a LimitExceededException.

By default, all destinations in a * subnet in a custom routing accelerator cannot receive traffic. To enable all * destinations to receive traffic, or to specify individual port mappings that can * receive traffic, see the * AllowCustomRoutingTraffic operation.

See Also:

AWS * API Reference

*/ virtual Model::AddCustomRoutingEndpointsOutcome AddCustomRoutingEndpoints(const Model::AddCustomRoutingEndpointsRequest& request) const; /** * A Callable wrapper for AddCustomRoutingEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddCustomRoutingEndpointsOutcomeCallable AddCustomRoutingEndpointsCallable(const AddCustomRoutingEndpointsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::AddCustomRoutingEndpoints, request); } /** * An Async wrapper for AddCustomRoutingEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddCustomRoutingEndpointsAsync(const AddCustomRoutingEndpointsRequestT& request, const AddCustomRoutingEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::AddCustomRoutingEndpoints, request, handler, context); } /** *

Add endpoints to an endpoint group. The AddEndpoints API * operation is the recommended option for adding endpoints. The alternative * options are to add endpoints when you create an endpoint group (with the CreateEndpointGroup * API) or when you update an endpoint group (with the UpdateEndpointGroup * API).

There are two advantages to using AddEndpoints to add * endpoints:

  • It's faster, because Global Accelerator only has to * resolve the new endpoints that you're adding.

  • It's more * convenient, because you don't need to specify all of the current endpoints that * are already in the endpoint group in addition to the new endpoints that you want * to add.

See Also:

AWS * API Reference

*/ virtual Model::AddEndpointsOutcome AddEndpoints(const Model::AddEndpointsRequest& request) const; /** * A Callable wrapper for AddEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddEndpointsOutcomeCallable AddEndpointsCallable(const AddEndpointsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::AddEndpoints, request); } /** * An Async wrapper for AddEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddEndpointsAsync(const AddEndpointsRequestT& request, const AddEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::AddEndpoints, request, handler, context); } /** *

Advertises an IPv4 address range that is provisioned for use with your Amazon * Web Services resources through bring your own IP addresses (BYOIP). It can take * a few minutes before traffic to the specified addresses starts routing to Amazon * Web Services because of propagation delays.

To stop advertising the * BYOIP address range, use * WithdrawByoipCidr.

For more information, see Bring * your own IP addresses (BYOIP) in the Global Accelerator Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::AdvertiseByoipCidrOutcome AdvertiseByoipCidr(const Model::AdvertiseByoipCidrRequest& request) const; /** * A Callable wrapper for AdvertiseByoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AdvertiseByoipCidrOutcomeCallable AdvertiseByoipCidrCallable(const AdvertiseByoipCidrRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::AdvertiseByoipCidr, request); } /** * An Async wrapper for AdvertiseByoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AdvertiseByoipCidrAsync(const AdvertiseByoipCidrRequestT& request, const AdvertiseByoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::AdvertiseByoipCidr, request, handler, context); } /** *

Specify the Amazon EC2 instance (destination) IP addresses and ports for a * VPC subnet endpoint that can receive traffic for a custom routing accelerator. * You can allow traffic to all destinations in the subnet endpoint, or allow * traffic to a specified list of destination IP addresses and ports in the subnet. * Note that you cannot specify IP addresses or ports outside of the range that you * configured for the endpoint group.

After you make changes, you can verify * that the updates are complete by checking the status of your accelerator: the * status changes from IN_PROGRESS to DEPLOYED.

See Also:

AWS * API Reference

*/ virtual Model::AllowCustomRoutingTrafficOutcome AllowCustomRoutingTraffic(const Model::AllowCustomRoutingTrafficRequest& request) const; /** * A Callable wrapper for AllowCustomRoutingTraffic that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AllowCustomRoutingTrafficOutcomeCallable AllowCustomRoutingTrafficCallable(const AllowCustomRoutingTrafficRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::AllowCustomRoutingTraffic, request); } /** * An Async wrapper for AllowCustomRoutingTraffic that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AllowCustomRoutingTrafficAsync(const AllowCustomRoutingTrafficRequestT& request, const AllowCustomRoutingTrafficResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::AllowCustomRoutingTraffic, request, handler, context); } /** *

Create an accelerator. An accelerator includes one or more listeners that * process inbound connections and direct traffic to one or more endpoint groups, * each of which includes endpoints, such as Network Load Balancers.

*

Global Accelerator is a global service that supports endpoints in * multiple Amazon Web Services Regions but you must specify the US West (Oregon) * Region to create, update, or otherwise work with accelerators. That is, for * example, specify --region us-west-2 on AWS CLI commands.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateAcceleratorOutcome CreateAccelerator(const Model::CreateAcceleratorRequest& request) const; /** * A Callable wrapper for CreateAccelerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAcceleratorOutcomeCallable CreateAcceleratorCallable(const CreateAcceleratorRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::CreateAccelerator, request); } /** * An Async wrapper for CreateAccelerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAcceleratorAsync(const CreateAcceleratorRequestT& request, const CreateAcceleratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::CreateAccelerator, request, handler, context); } /** *

Create a custom routing accelerator. A custom routing accelerator directs * traffic to one of possibly thousands of Amazon EC2 instance destinations running * in a single or multiple virtual private clouds (VPC) subnet endpoints.

Be * aware that, by default, all destination EC2 instances in a VPC subnet endpoint * cannot receive traffic. To enable all destinations to receive traffic, or to * specify individual port mappings that can receive traffic, see the * AllowCustomRoutingTraffic operation.

Global Accelerator * is a global service that supports endpoints in multiple Amazon Web Services * Regions but you must specify the US West (Oregon) Region to create, update, or * otherwise work with accelerators. That is, for example, specify --region * us-west-2 on AWS CLI commands.

See Also:

AWS * API Reference

*/ virtual Model::CreateCustomRoutingAcceleratorOutcome CreateCustomRoutingAccelerator(const Model::CreateCustomRoutingAcceleratorRequest& request) const; /** * A Callable wrapper for CreateCustomRoutingAccelerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCustomRoutingAcceleratorOutcomeCallable CreateCustomRoutingAcceleratorCallable(const CreateCustomRoutingAcceleratorRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::CreateCustomRoutingAccelerator, request); } /** * An Async wrapper for CreateCustomRoutingAccelerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCustomRoutingAcceleratorAsync(const CreateCustomRoutingAcceleratorRequestT& request, const CreateCustomRoutingAcceleratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::CreateCustomRoutingAccelerator, request, handler, context); } /** *

Create an endpoint group for the specified listener for a custom routing * accelerator. An endpoint group is a collection of endpoints in one Amazon Web * Services Region.

See Also:

AWS * API Reference

*/ virtual Model::CreateCustomRoutingEndpointGroupOutcome CreateCustomRoutingEndpointGroup(const Model::CreateCustomRoutingEndpointGroupRequest& request) const; /** * A Callable wrapper for CreateCustomRoutingEndpointGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCustomRoutingEndpointGroupOutcomeCallable CreateCustomRoutingEndpointGroupCallable(const CreateCustomRoutingEndpointGroupRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::CreateCustomRoutingEndpointGroup, request); } /** * An Async wrapper for CreateCustomRoutingEndpointGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCustomRoutingEndpointGroupAsync(const CreateCustomRoutingEndpointGroupRequestT& request, const CreateCustomRoutingEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::CreateCustomRoutingEndpointGroup, request, handler, context); } /** *

Create a listener to process inbound connections from clients to a custom * routing accelerator. Connections arrive to assigned static IP addresses on the * port range that you specify.

See Also:

AWS * API Reference

*/ virtual Model::CreateCustomRoutingListenerOutcome CreateCustomRoutingListener(const Model::CreateCustomRoutingListenerRequest& request) const; /** * A Callable wrapper for CreateCustomRoutingListener that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCustomRoutingListenerOutcomeCallable CreateCustomRoutingListenerCallable(const CreateCustomRoutingListenerRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::CreateCustomRoutingListener, request); } /** * An Async wrapper for CreateCustomRoutingListener that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCustomRoutingListenerAsync(const CreateCustomRoutingListenerRequestT& request, const CreateCustomRoutingListenerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::CreateCustomRoutingListener, request, handler, context); } /** *

Create an endpoint group for the specified listener. An endpoint group is a * collection of endpoints in one Amazon Web Services Region. A resource must be * valid and active when you add it as an endpoint.

See Also:

AWS * API Reference

*/ virtual Model::CreateEndpointGroupOutcome CreateEndpointGroup(const Model::CreateEndpointGroupRequest& request) const; /** * A Callable wrapper for CreateEndpointGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEndpointGroupOutcomeCallable CreateEndpointGroupCallable(const CreateEndpointGroupRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::CreateEndpointGroup, request); } /** * An Async wrapper for CreateEndpointGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEndpointGroupAsync(const CreateEndpointGroupRequestT& request, const CreateEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::CreateEndpointGroup, request, handler, context); } /** *

Create a listener to process inbound connections from clients to an * accelerator. Connections arrive to assigned static IP addresses on a port, port * range, or list of port ranges that you specify.

See Also:

AWS * API Reference

*/ virtual Model::CreateListenerOutcome CreateListener(const Model::CreateListenerRequest& request) const; /** * A Callable wrapper for CreateListener that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateListenerOutcomeCallable CreateListenerCallable(const CreateListenerRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::CreateListener, request); } /** * An Async wrapper for CreateListener that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateListenerAsync(const CreateListenerRequestT& request, const CreateListenerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::CreateListener, request, handler, context); } /** *

Delete an accelerator. Before you can delete an accelerator, you must disable * it and remove all dependent resources (listeners and endpoint groups). To * disable the accelerator, update the accelerator to set Enabled to * false.

When you create an accelerator, by default, Global * Accelerator provides you with a set of two static IP addresses. Alternatively, * you can bring your own IP address ranges to Global Accelerator and assign IP * addresses from those ranges.

The IP addresses are assigned to your * accelerator for as long as it exists, even if you disable the accelerator and it * no longer accepts or routes traffic. However, when you delete an * accelerator, you lose the static IP addresses that are assigned to the * accelerator, so you can no longer route traffic by using them. As a best * practice, ensure that you have permissions in place to avoid inadvertently * deleting accelerators. You can use IAM policies with Global Accelerator to limit * the users who have permissions to delete an accelerator. For more information, * see Identity * and access management in the Global Accelerator Developer Guide.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteAcceleratorOutcome DeleteAccelerator(const Model::DeleteAcceleratorRequest& request) const; /** * A Callable wrapper for DeleteAccelerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAcceleratorOutcomeCallable DeleteAcceleratorCallable(const DeleteAcceleratorRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DeleteAccelerator, request); } /** * An Async wrapper for DeleteAccelerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAcceleratorAsync(const DeleteAcceleratorRequestT& request, const DeleteAcceleratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DeleteAccelerator, request, handler, context); } /** *

Delete a custom routing accelerator. Before you can delete an accelerator, * you must disable it and remove all dependent resources (listeners and endpoint * groups). To disable the accelerator, update the accelerator to set * Enabled to false.

When you create a custom * routing accelerator, by default, Global Accelerator provides you with a set of * two static IP addresses.

The IP addresses are assigned to your * accelerator for as long as it exists, even if you disable the accelerator and it * no longer accepts or routes traffic. However, when you delete an * accelerator, you lose the static IP addresses that are assigned to the * accelerator, so you can no longer route traffic by using them. As a best * practice, ensure that you have permissions in place to avoid inadvertently * deleting accelerators. You can use IAM policies with Global Accelerator to limit * the users who have permissions to delete an accelerator. For more information, * see Identity * and access management in the Global Accelerator Developer Guide.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteCustomRoutingAcceleratorOutcome DeleteCustomRoutingAccelerator(const Model::DeleteCustomRoutingAcceleratorRequest& request) const; /** * A Callable wrapper for DeleteCustomRoutingAccelerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCustomRoutingAcceleratorOutcomeCallable DeleteCustomRoutingAcceleratorCallable(const DeleteCustomRoutingAcceleratorRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DeleteCustomRoutingAccelerator, request); } /** * An Async wrapper for DeleteCustomRoutingAccelerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCustomRoutingAcceleratorAsync(const DeleteCustomRoutingAcceleratorRequestT& request, const DeleteCustomRoutingAcceleratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DeleteCustomRoutingAccelerator, request, handler, context); } /** *

Delete an endpoint group from a listener for a custom routing * accelerator.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCustomRoutingEndpointGroupOutcome DeleteCustomRoutingEndpointGroup(const Model::DeleteCustomRoutingEndpointGroupRequest& request) const; /** * A Callable wrapper for DeleteCustomRoutingEndpointGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCustomRoutingEndpointGroupOutcomeCallable DeleteCustomRoutingEndpointGroupCallable(const DeleteCustomRoutingEndpointGroupRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DeleteCustomRoutingEndpointGroup, request); } /** * An Async wrapper for DeleteCustomRoutingEndpointGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCustomRoutingEndpointGroupAsync(const DeleteCustomRoutingEndpointGroupRequestT& request, const DeleteCustomRoutingEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DeleteCustomRoutingEndpointGroup, request, handler, context); } /** *

Delete a listener for a custom routing accelerator.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteCustomRoutingListenerOutcome DeleteCustomRoutingListener(const Model::DeleteCustomRoutingListenerRequest& request) const; /** * A Callable wrapper for DeleteCustomRoutingListener that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCustomRoutingListenerOutcomeCallable DeleteCustomRoutingListenerCallable(const DeleteCustomRoutingListenerRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DeleteCustomRoutingListener, request); } /** * An Async wrapper for DeleteCustomRoutingListener that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCustomRoutingListenerAsync(const DeleteCustomRoutingListenerRequestT& request, const DeleteCustomRoutingListenerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DeleteCustomRoutingListener, request, handler, context); } /** *

Delete an endpoint group from a listener.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEndpointGroupOutcome DeleteEndpointGroup(const Model::DeleteEndpointGroupRequest& request) const; /** * A Callable wrapper for DeleteEndpointGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEndpointGroupOutcomeCallable DeleteEndpointGroupCallable(const DeleteEndpointGroupRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DeleteEndpointGroup, request); } /** * An Async wrapper for DeleteEndpointGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEndpointGroupAsync(const DeleteEndpointGroupRequestT& request, const DeleteEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DeleteEndpointGroup, request, handler, context); } /** *

Delete a listener from an accelerator.

See Also:

AWS * API Reference

*/ virtual Model::DeleteListenerOutcome DeleteListener(const Model::DeleteListenerRequest& request) const; /** * A Callable wrapper for DeleteListener that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteListenerOutcomeCallable DeleteListenerCallable(const DeleteListenerRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DeleteListener, request); } /** * An Async wrapper for DeleteListener that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteListenerAsync(const DeleteListenerRequestT& request, const DeleteListenerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DeleteListener, request, handler, context); } /** *

Specify the Amazon EC2 instance (destination) IP addresses and ports for a * VPC subnet endpoint that cannot receive traffic for a custom routing * accelerator. You can deny traffic to all destinations in the VPC endpoint, or * deny traffic to a specified list of destination IP addresses and ports. Note * that you cannot specify IP addresses or ports outside of the range that you * configured for the endpoint group.

After you make changes, you can verify * that the updates are complete by checking the status of your accelerator: the * status changes from IN_PROGRESS to DEPLOYED.

See Also:

AWS * API Reference

*/ virtual Model::DenyCustomRoutingTrafficOutcome DenyCustomRoutingTraffic(const Model::DenyCustomRoutingTrafficRequest& request) const; /** * A Callable wrapper for DenyCustomRoutingTraffic that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DenyCustomRoutingTrafficOutcomeCallable DenyCustomRoutingTrafficCallable(const DenyCustomRoutingTrafficRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DenyCustomRoutingTraffic, request); } /** * An Async wrapper for DenyCustomRoutingTraffic that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DenyCustomRoutingTrafficAsync(const DenyCustomRoutingTrafficRequestT& request, const DenyCustomRoutingTrafficResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DenyCustomRoutingTraffic, request, handler, context); } /** *

Releases the specified address range that you provisioned to use with your * Amazon Web Services resources through bring your own IP addresses (BYOIP) and * deletes the corresponding address pool.

Before you can release an * address range, you must stop advertising it by using WithdrawByoipCidr * and you must not have any accelerators that are using static IP addresses * allocated from its address range.

For more information, see Bring * your own IP addresses (BYOIP) in the Global Accelerator Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeprovisionByoipCidrOutcome DeprovisionByoipCidr(const Model::DeprovisionByoipCidrRequest& request) const; /** * A Callable wrapper for DeprovisionByoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeprovisionByoipCidrOutcomeCallable DeprovisionByoipCidrCallable(const DeprovisionByoipCidrRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DeprovisionByoipCidr, request); } /** * An Async wrapper for DeprovisionByoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeprovisionByoipCidrAsync(const DeprovisionByoipCidrRequestT& request, const DeprovisionByoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DeprovisionByoipCidr, request, handler, context); } /** *

Describe an accelerator.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAcceleratorOutcome DescribeAccelerator(const Model::DescribeAcceleratorRequest& request) const; /** * A Callable wrapper for DescribeAccelerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAcceleratorOutcomeCallable DescribeAcceleratorCallable(const DescribeAcceleratorRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DescribeAccelerator, request); } /** * An Async wrapper for DescribeAccelerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAcceleratorAsync(const DescribeAcceleratorRequestT& request, const DescribeAcceleratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DescribeAccelerator, request, handler, context); } /** *

Describe the attributes of an accelerator.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAcceleratorAttributesOutcome DescribeAcceleratorAttributes(const Model::DescribeAcceleratorAttributesRequest& request) const; /** * A Callable wrapper for DescribeAcceleratorAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAcceleratorAttributesOutcomeCallable DescribeAcceleratorAttributesCallable(const DescribeAcceleratorAttributesRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DescribeAcceleratorAttributes, request); } /** * An Async wrapper for DescribeAcceleratorAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAcceleratorAttributesAsync(const DescribeAcceleratorAttributesRequestT& request, const DescribeAcceleratorAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DescribeAcceleratorAttributes, request, handler, context); } /** *

Describe a custom routing accelerator.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCustomRoutingAcceleratorOutcome DescribeCustomRoutingAccelerator(const Model::DescribeCustomRoutingAcceleratorRequest& request) const; /** * A Callable wrapper for DescribeCustomRoutingAccelerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCustomRoutingAcceleratorOutcomeCallable DescribeCustomRoutingAcceleratorCallable(const DescribeCustomRoutingAcceleratorRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DescribeCustomRoutingAccelerator, request); } /** * An Async wrapper for DescribeCustomRoutingAccelerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCustomRoutingAcceleratorAsync(const DescribeCustomRoutingAcceleratorRequestT& request, const DescribeCustomRoutingAcceleratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DescribeCustomRoutingAccelerator, request, handler, context); } /** *

Describe the attributes of a custom routing accelerator.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeCustomRoutingAcceleratorAttributesOutcome DescribeCustomRoutingAcceleratorAttributes(const Model::DescribeCustomRoutingAcceleratorAttributesRequest& request) const; /** * A Callable wrapper for DescribeCustomRoutingAcceleratorAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCustomRoutingAcceleratorAttributesOutcomeCallable DescribeCustomRoutingAcceleratorAttributesCallable(const DescribeCustomRoutingAcceleratorAttributesRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DescribeCustomRoutingAcceleratorAttributes, request); } /** * An Async wrapper for DescribeCustomRoutingAcceleratorAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCustomRoutingAcceleratorAttributesAsync(const DescribeCustomRoutingAcceleratorAttributesRequestT& request, const DescribeCustomRoutingAcceleratorAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DescribeCustomRoutingAcceleratorAttributes, request, handler, context); } /** *

Describe an endpoint group for a custom routing accelerator.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeCustomRoutingEndpointGroupOutcome DescribeCustomRoutingEndpointGroup(const Model::DescribeCustomRoutingEndpointGroupRequest& request) const; /** * A Callable wrapper for DescribeCustomRoutingEndpointGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCustomRoutingEndpointGroupOutcomeCallable DescribeCustomRoutingEndpointGroupCallable(const DescribeCustomRoutingEndpointGroupRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DescribeCustomRoutingEndpointGroup, request); } /** * An Async wrapper for DescribeCustomRoutingEndpointGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCustomRoutingEndpointGroupAsync(const DescribeCustomRoutingEndpointGroupRequestT& request, const DescribeCustomRoutingEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DescribeCustomRoutingEndpointGroup, request, handler, context); } /** *

The description of a listener for a custom routing accelerator.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeCustomRoutingListenerOutcome DescribeCustomRoutingListener(const Model::DescribeCustomRoutingListenerRequest& request) const; /** * A Callable wrapper for DescribeCustomRoutingListener that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCustomRoutingListenerOutcomeCallable DescribeCustomRoutingListenerCallable(const DescribeCustomRoutingListenerRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DescribeCustomRoutingListener, request); } /** * An Async wrapper for DescribeCustomRoutingListener that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCustomRoutingListenerAsync(const DescribeCustomRoutingListenerRequestT& request, const DescribeCustomRoutingListenerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DescribeCustomRoutingListener, request, handler, context); } /** *

Describe an endpoint group.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEndpointGroupOutcome DescribeEndpointGroup(const Model::DescribeEndpointGroupRequest& request) const; /** * A Callable wrapper for DescribeEndpointGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEndpointGroupOutcomeCallable DescribeEndpointGroupCallable(const DescribeEndpointGroupRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DescribeEndpointGroup, request); } /** * An Async wrapper for DescribeEndpointGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEndpointGroupAsync(const DescribeEndpointGroupRequestT& request, const DescribeEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DescribeEndpointGroup, request, handler, context); } /** *

Describe a listener.

See Also:

AWS * API Reference

*/ virtual Model::DescribeListenerOutcome DescribeListener(const Model::DescribeListenerRequest& request) const; /** * A Callable wrapper for DescribeListener that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeListenerOutcomeCallable DescribeListenerCallable(const DescribeListenerRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::DescribeListener, request); } /** * An Async wrapper for DescribeListener that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeListenerAsync(const DescribeListenerRequestT& request, const DescribeListenerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::DescribeListener, request, handler, context); } /** *

List the accelerators for an Amazon Web Services account.

See * Also:

AWS * API Reference

*/ virtual Model::ListAcceleratorsOutcome ListAccelerators(const Model::ListAcceleratorsRequest& request) const; /** * A Callable wrapper for ListAccelerators that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAcceleratorsOutcomeCallable ListAcceleratorsCallable(const ListAcceleratorsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListAccelerators, request); } /** * An Async wrapper for ListAccelerators that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAcceleratorsAsync(const ListAcceleratorsRequestT& request, const ListAcceleratorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListAccelerators, request, handler, context); } /** *

Lists the IP address ranges that were specified in calls to ProvisionByoipCidr, * including the current state and a history of state changes.

See * Also:

AWS * API Reference

*/ virtual Model::ListByoipCidrsOutcome ListByoipCidrs(const Model::ListByoipCidrsRequest& request) const; /** * A Callable wrapper for ListByoipCidrs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListByoipCidrsOutcomeCallable ListByoipCidrsCallable(const ListByoipCidrsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListByoipCidrs, request); } /** * An Async wrapper for ListByoipCidrs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListByoipCidrsAsync(const ListByoipCidrsRequestT& request, const ListByoipCidrsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListByoipCidrs, request, handler, context); } /** *

List the custom routing accelerators for an Amazon Web Services account. *

See Also:

AWS * API Reference

*/ virtual Model::ListCustomRoutingAcceleratorsOutcome ListCustomRoutingAccelerators(const Model::ListCustomRoutingAcceleratorsRequest& request) const; /** * A Callable wrapper for ListCustomRoutingAccelerators that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCustomRoutingAcceleratorsOutcomeCallable ListCustomRoutingAcceleratorsCallable(const ListCustomRoutingAcceleratorsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingAccelerators, request); } /** * An Async wrapper for ListCustomRoutingAccelerators that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCustomRoutingAcceleratorsAsync(const ListCustomRoutingAcceleratorsRequestT& request, const ListCustomRoutingAcceleratorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingAccelerators, request, handler, context); } /** *

List the endpoint groups that are associated with a listener for a custom * routing accelerator.

See Also:

AWS * API Reference

*/ virtual Model::ListCustomRoutingEndpointGroupsOutcome ListCustomRoutingEndpointGroups(const Model::ListCustomRoutingEndpointGroupsRequest& request) const; /** * A Callable wrapper for ListCustomRoutingEndpointGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCustomRoutingEndpointGroupsOutcomeCallable ListCustomRoutingEndpointGroupsCallable(const ListCustomRoutingEndpointGroupsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingEndpointGroups, request); } /** * An Async wrapper for ListCustomRoutingEndpointGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCustomRoutingEndpointGroupsAsync(const ListCustomRoutingEndpointGroupsRequestT& request, const ListCustomRoutingEndpointGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingEndpointGroups, request, handler, context); } /** *

List the listeners for a custom routing accelerator.

See * Also:

AWS * API Reference

*/ virtual Model::ListCustomRoutingListenersOutcome ListCustomRoutingListeners(const Model::ListCustomRoutingListenersRequest& request) const; /** * A Callable wrapper for ListCustomRoutingListeners that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCustomRoutingListenersOutcomeCallable ListCustomRoutingListenersCallable(const ListCustomRoutingListenersRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingListeners, request); } /** * An Async wrapper for ListCustomRoutingListeners that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCustomRoutingListenersAsync(const ListCustomRoutingListenersRequestT& request, const ListCustomRoutingListenersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingListeners, request, handler, context); } /** *

Provides a complete mapping from the public accelerator IP address and port * to destination EC2 instance IP addresses and ports in the virtual public cloud * (VPC) subnet endpoint for a custom routing accelerator. For each subnet endpoint * that you add, Global Accelerator creates a new static port mapping for the * accelerator. The port mappings don't change after Global Accelerator generates * them, so you can retrieve and cache the full mapping on your servers.

If * you remove a subnet from your accelerator, Global Accelerator removes (reclaims) * the port mappings. If you add a subnet to your accelerator, Global Accelerator * creates new port mappings (the existing ones don't change). If you add or remove * EC2 instances in your subnet, the port mappings don't change, because the * mappings are created when you add the subnet to Global Accelerator.

The * mappings also include a flag for each destination denoting which destination IP * addresses and ports are allowed or denied traffic.

See Also:

AWS * API Reference

*/ virtual Model::ListCustomRoutingPortMappingsOutcome ListCustomRoutingPortMappings(const Model::ListCustomRoutingPortMappingsRequest& request) const; /** * A Callable wrapper for ListCustomRoutingPortMappings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCustomRoutingPortMappingsOutcomeCallable ListCustomRoutingPortMappingsCallable(const ListCustomRoutingPortMappingsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingPortMappings, request); } /** * An Async wrapper for ListCustomRoutingPortMappings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCustomRoutingPortMappingsAsync(const ListCustomRoutingPortMappingsRequestT& request, const ListCustomRoutingPortMappingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingPortMappings, request, handler, context); } /** *

List the port mappings for a specific EC2 instance (destination) in a VPC * subnet endpoint. The response is the mappings for one destination IP address. * This is useful when your subnet endpoint has mappings that span multiple custom * routing accelerators in your account, or for scenarios where you only want to * list the port mappings for a specific destination instance.

See * Also:

AWS * API Reference

*/ virtual Model::ListCustomRoutingPortMappingsByDestinationOutcome ListCustomRoutingPortMappingsByDestination(const Model::ListCustomRoutingPortMappingsByDestinationRequest& request) const; /** * A Callable wrapper for ListCustomRoutingPortMappingsByDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCustomRoutingPortMappingsByDestinationOutcomeCallable ListCustomRoutingPortMappingsByDestinationCallable(const ListCustomRoutingPortMappingsByDestinationRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListCustomRoutingPortMappingsByDestination, request); } /** * An Async wrapper for ListCustomRoutingPortMappingsByDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCustomRoutingPortMappingsByDestinationAsync(const ListCustomRoutingPortMappingsByDestinationRequestT& request, const ListCustomRoutingPortMappingsByDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListCustomRoutingPortMappingsByDestination, request, handler, context); } /** *

List the endpoint groups that are associated with a listener.

See * Also:

AWS * API Reference

*/ virtual Model::ListEndpointGroupsOutcome ListEndpointGroups(const Model::ListEndpointGroupsRequest& request) const; /** * A Callable wrapper for ListEndpointGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEndpointGroupsOutcomeCallable ListEndpointGroupsCallable(const ListEndpointGroupsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListEndpointGroups, request); } /** * An Async wrapper for ListEndpointGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEndpointGroupsAsync(const ListEndpointGroupsRequestT& request, const ListEndpointGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListEndpointGroups, request, handler, context); } /** *

List the listeners for an accelerator.

See Also:

AWS * API Reference

*/ virtual Model::ListListenersOutcome ListListeners(const Model::ListListenersRequest& request) const; /** * A Callable wrapper for ListListeners that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListListenersOutcomeCallable ListListenersCallable(const ListListenersRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListListeners, request); } /** * An Async wrapper for ListListeners that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListListenersAsync(const ListListenersRequestT& request, const ListListenersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListListeners, request, handler, context); } /** *

List all tags for an accelerator.

For more information, see Tagging * in Global Accelerator in the Global Accelerator Developer Guide. *

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ListTagsForResource, request, handler, context); } /** *

Provisions an IP address range to use with your Amazon Web Services resources * through bring your own IP addresses (BYOIP) and creates a corresponding address * pool. After the address range is provisioned, it is ready to be advertised using * * AdvertiseByoipCidr.

For more information, see Bring * your own IP addresses (BYOIP) in the Global Accelerator Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ProvisionByoipCidrOutcome ProvisionByoipCidr(const Model::ProvisionByoipCidrRequest& request) const; /** * A Callable wrapper for ProvisionByoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ProvisionByoipCidrOutcomeCallable ProvisionByoipCidrCallable(const ProvisionByoipCidrRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::ProvisionByoipCidr, request); } /** * An Async wrapper for ProvisionByoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ProvisionByoipCidrAsync(const ProvisionByoipCidrRequestT& request, const ProvisionByoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::ProvisionByoipCidr, request, handler, context); } /** *

Remove endpoints from a custom routing accelerator.

See Also:

* AWS * API Reference

*/ virtual Model::RemoveCustomRoutingEndpointsOutcome RemoveCustomRoutingEndpoints(const Model::RemoveCustomRoutingEndpointsRequest& request) const; /** * A Callable wrapper for RemoveCustomRoutingEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveCustomRoutingEndpointsOutcomeCallable RemoveCustomRoutingEndpointsCallable(const RemoveCustomRoutingEndpointsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::RemoveCustomRoutingEndpoints, request); } /** * An Async wrapper for RemoveCustomRoutingEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveCustomRoutingEndpointsAsync(const RemoveCustomRoutingEndpointsRequestT& request, const RemoveCustomRoutingEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::RemoveCustomRoutingEndpoints, request, handler, context); } /** *

Remove endpoints from an endpoint group.

The * RemoveEndpoints API operation is the recommended option for * removing endpoints. The alternative is to remove endpoints by updating an * endpoint group by using the UpdateEndpointGroup * API operation. There are two advantages to using AddEndpoints to * remove endpoints instead:

  • It's more convenient, because you * only need to specify the endpoints that you want to remove. With the * UpdateEndpointGroup API operation, you must specify all of the * endpoints in the endpoint group except the ones that you want to remove from the * group.

  • It's faster, because Global Accelerator doesn't need to * resolve any endpoints. With the UpdateEndpointGroup API operation, * Global Accelerator must resolve all of the endpoints that remain in the * group.

See Also:

AWS * API Reference

*/ virtual Model::RemoveEndpointsOutcome RemoveEndpoints(const Model::RemoveEndpointsRequest& request) const; /** * A Callable wrapper for RemoveEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveEndpointsOutcomeCallable RemoveEndpointsCallable(const RemoveEndpointsRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::RemoveEndpoints, request); } /** * An Async wrapper for RemoveEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveEndpointsAsync(const RemoveEndpointsRequestT& request, const RemoveEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::RemoveEndpoints, request, handler, context); } /** *

Add tags to an accelerator resource.

For more information, see Tagging * in Global Accelerator in the Global Accelerator Developer Guide. *

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::TagResource, request, handler, context); } /** *

Remove tags from a Global Accelerator resource. When you specify a tag key, * the action removes both that key and its associated value. The operation * succeeds even if you attempt to remove tags from an accelerator that was already * removed.

For more information, see Tagging * in Global Accelerator in the Global Accelerator Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::UntagResource, request, handler, context); } /** *

Update an accelerator.

Global Accelerator is a global * service that supports endpoints in multiple Amazon Web Services Regions but you * must specify the US West (Oregon) Region to create, update, or otherwise work * with accelerators. That is, for example, specify --region us-west-2 * on AWS CLI commands.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAcceleratorOutcome UpdateAccelerator(const Model::UpdateAcceleratorRequest& request) const; /** * A Callable wrapper for UpdateAccelerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAcceleratorOutcomeCallable UpdateAcceleratorCallable(const UpdateAcceleratorRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::UpdateAccelerator, request); } /** * An Async wrapper for UpdateAccelerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAcceleratorAsync(const UpdateAcceleratorRequestT& request, const UpdateAcceleratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::UpdateAccelerator, request, handler, context); } /** *

Update the attributes for an accelerator.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAcceleratorAttributesOutcome UpdateAcceleratorAttributes(const Model::UpdateAcceleratorAttributesRequest& request) const; /** * A Callable wrapper for UpdateAcceleratorAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAcceleratorAttributesOutcomeCallable UpdateAcceleratorAttributesCallable(const UpdateAcceleratorAttributesRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::UpdateAcceleratorAttributes, request); } /** * An Async wrapper for UpdateAcceleratorAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAcceleratorAttributesAsync(const UpdateAcceleratorAttributesRequestT& request, const UpdateAcceleratorAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::UpdateAcceleratorAttributes, request, handler, context); } /** *

Update a custom routing accelerator.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCustomRoutingAcceleratorOutcome UpdateCustomRoutingAccelerator(const Model::UpdateCustomRoutingAcceleratorRequest& request) const; /** * A Callable wrapper for UpdateCustomRoutingAccelerator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCustomRoutingAcceleratorOutcomeCallable UpdateCustomRoutingAcceleratorCallable(const UpdateCustomRoutingAcceleratorRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::UpdateCustomRoutingAccelerator, request); } /** * An Async wrapper for UpdateCustomRoutingAccelerator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCustomRoutingAcceleratorAsync(const UpdateCustomRoutingAcceleratorRequestT& request, const UpdateCustomRoutingAcceleratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::UpdateCustomRoutingAccelerator, request, handler, context); } /** *

Update the attributes for a custom routing accelerator.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateCustomRoutingAcceleratorAttributesOutcome UpdateCustomRoutingAcceleratorAttributes(const Model::UpdateCustomRoutingAcceleratorAttributesRequest& request) const; /** * A Callable wrapper for UpdateCustomRoutingAcceleratorAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCustomRoutingAcceleratorAttributesOutcomeCallable UpdateCustomRoutingAcceleratorAttributesCallable(const UpdateCustomRoutingAcceleratorAttributesRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::UpdateCustomRoutingAcceleratorAttributes, request); } /** * An Async wrapper for UpdateCustomRoutingAcceleratorAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCustomRoutingAcceleratorAttributesAsync(const UpdateCustomRoutingAcceleratorAttributesRequestT& request, const UpdateCustomRoutingAcceleratorAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::UpdateCustomRoutingAcceleratorAttributes, request, handler, context); } /** *

Update a listener for a custom routing accelerator.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateCustomRoutingListenerOutcome UpdateCustomRoutingListener(const Model::UpdateCustomRoutingListenerRequest& request) const; /** * A Callable wrapper for UpdateCustomRoutingListener that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCustomRoutingListenerOutcomeCallable UpdateCustomRoutingListenerCallable(const UpdateCustomRoutingListenerRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::UpdateCustomRoutingListener, request); } /** * An Async wrapper for UpdateCustomRoutingListener that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCustomRoutingListenerAsync(const UpdateCustomRoutingListenerRequestT& request, const UpdateCustomRoutingListenerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::UpdateCustomRoutingListener, request, handler, context); } /** *

Update an endpoint group. A resource must be valid and active when you add it * as an endpoint.

See Also:

AWS * API Reference

*/ virtual Model::UpdateEndpointGroupOutcome UpdateEndpointGroup(const Model::UpdateEndpointGroupRequest& request) const; /** * A Callable wrapper for UpdateEndpointGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEndpointGroupOutcomeCallable UpdateEndpointGroupCallable(const UpdateEndpointGroupRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::UpdateEndpointGroup, request); } /** * An Async wrapper for UpdateEndpointGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEndpointGroupAsync(const UpdateEndpointGroupRequestT& request, const UpdateEndpointGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::UpdateEndpointGroup, request, handler, context); } /** *

Update a listener.

See Also:

AWS * API Reference

*/ virtual Model::UpdateListenerOutcome UpdateListener(const Model::UpdateListenerRequest& request) const; /** * A Callable wrapper for UpdateListener that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateListenerOutcomeCallable UpdateListenerCallable(const UpdateListenerRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::UpdateListener, request); } /** * An Async wrapper for UpdateListener that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateListenerAsync(const UpdateListenerRequestT& request, const UpdateListenerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::UpdateListener, request, handler, context); } /** *

Stops advertising an address range that is provisioned as an address pool. * You can perform this operation at most once every 10 seconds, even if you * specify different address ranges each time.

It can take a few minutes * before traffic to the specified addresses stops routing to Amazon Web Services * because of propagation delays.

For more information, see Bring * your own IP addresses (BYOIP) in the Global Accelerator Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::WithdrawByoipCidrOutcome WithdrawByoipCidr(const Model::WithdrawByoipCidrRequest& request) const; /** * A Callable wrapper for WithdrawByoipCidr that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::WithdrawByoipCidrOutcomeCallable WithdrawByoipCidrCallable(const WithdrawByoipCidrRequestT& request) const { return SubmitCallable(&GlobalAcceleratorClient::WithdrawByoipCidr, request); } /** * An Async wrapper for WithdrawByoipCidr that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void WithdrawByoipCidrAsync(const WithdrawByoipCidrRequestT& request, const WithdrawByoipCidrResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&GlobalAcceleratorClient::WithdrawByoipCidr, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const GlobalAcceleratorClientConfiguration& clientConfiguration); GlobalAcceleratorClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace GlobalAccelerator } // namespace Aws