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

Welcome to the Amazon SQS API Reference.

Amazon SQS is a * reliable, highly-scalable hosted queue for storing messages as they travel * between applications or microservices. Amazon SQS moves data between distributed * application components and helps you decouple these components.

For * information on the permissions you need to use this API, see Identity * and access management in the Amazon SQS Developer Guide.

You * can use Amazon Web Services SDKs * to access Amazon SQS using your favorite programming language. The SDKs perform * tasks such as the following automatically:

  • Cryptographically * sign your service requests

  • Retry requests

  • *

    Handle error responses

Additional information

* */ class AWS_SQS_API SQSClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; /** * 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. */ SQSClient(const Aws::SQS::SQSClientConfiguration& clientConfiguration = Aws::SQS::SQSClientConfiguration(), 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. */ SQSClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SQS::SQSClientConfiguration& clientConfiguration = Aws::SQS::SQSClientConfiguration()); /** * 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 */ SQSClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SQS::SQSClientConfiguration& clientConfiguration = Aws::SQS::SQSClientConfiguration()); /* 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. */ SQSClient(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. */ SQSClient(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 */ SQSClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~SQSClient(); /** * Converts any request object to a presigned URL with the GET method, using region for the signer and a timeout of 15 minutes. */ Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const; /** *

Adds a permission to a queue for a specific principal. * This allows sharing access to the queue.

When you create a queue, you * have full control access rights for the queue. Only you, the owner of the queue, * can grant or deny permissions to the queue. For more information about these * permissions, see Allow * Developers to Write Messages to a Shared Queue in the Amazon SQS * Developer Guide.

  • AddPermission * generates a policy for you. You can use SetQueueAttributes * to upload your policy. For more information, see Using * Custom Policies with the Amazon SQS Access Policy Language in the Amazon * SQS Developer Guide.

  • An Amazon SQS policy can have a * maximum of 7 actions.

  • To remove the ability to change queue * permissions, you must deny permission to the AddPermission, * RemovePermission, and SetQueueAttributes actions in * your IAM policy.

Some actions take lists of * parameters. These lists are specified using the param.n notation. * Values of n are integers starting from 1. For example, a parameter * list with two elements looks like this:

* &AttributeName.1=first

* &AttributeName.2=second

Cross-account * permissions don't apply to this action. For more information, see Grant * cross-account permissions to a role and a user name in the Amazon SQS * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::AddPermissionOutcome AddPermission(const Model::AddPermissionRequest& request) const; /** * A Callable wrapper for AddPermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddPermissionOutcomeCallable AddPermissionCallable(const AddPermissionRequestT& request) const { return SubmitCallable(&SQSClient::AddPermission, request); } /** * An Async wrapper for AddPermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddPermissionAsync(const AddPermissionRequestT& request, const AddPermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::AddPermission, request, handler, context); } /** *

Changes the visibility timeout of a specified message in a queue to a new * value. The default visibility timeout for a message is 30 seconds. The minimum * is 0 seconds. The maximum is 12 hours. For more information, see Visibility * Timeout in the Amazon SQS Developer Guide.

For example, you * have a message with a visibility timeout of 5 minutes. After 3 minutes, you call * ChangeMessageVisibility with a timeout of 10 minutes. You can * continue to call ChangeMessageVisibility to extend the visibility * timeout to the maximum allowed time. If you try to extend the visibility timeout * beyond the maximum, your request is rejected.

An Amazon SQS message has * three basic states:

  1. Sent to a queue by a producer.

    2. *

  2. Received from the queue by a consumer.

  3. Deleted from * the queue.

A message is considered to be stored after * it is sent to a queue by a producer, but not yet received from the queue by a * consumer (that is, between states 1 and 2). There is no limit to the number of * stored messages. A message is considered to be in flight after it is * received from a queue by a consumer, but not yet deleted from the queue (that * is, between states 2 and 3). There is a limit to the number of inflight * messages.

Limits that apply to inflight messages are unrelated to the * unlimited number of stored messages.

For most standard queues * (depending on queue traffic and message backlog), there can be a maximum of * approximately 120,000 inflight messages (received from a queue by a consumer, * but not yet deleted from the queue). If you reach this limit, Amazon SQS returns * the OverLimit error message. To avoid reaching the limit, you * should delete messages from the queue after they're processed. You can also * increase the number of queues you use to process your messages. To request a * limit increase, file * a support request.

For FIFO queues, there can be a maximum of 20,000 * inflight messages (received from a queue by a consumer, but not yet deleted from * the queue). If you reach this limit, Amazon SQS returns no error messages.

*

If you attempt to set the VisibilityTimeout to a * value greater than the maximum time left, Amazon SQS returns an error. Amazon * SQS doesn't automatically recalculate and increase the timeout to the maximum * remaining time.

Unlike with a queue, when you change the visibility * timeout for a specific message the timeout value is applied immediately but * isn't saved in memory for that message. If you don't delete a message after it * is received, the visibility timeout for the message reverts to the original * timeout value (not to the value you set using the * ChangeMessageVisibility action) the next time the message is * received.

See Also:

AWS * API Reference

*/ virtual Model::ChangeMessageVisibilityOutcome ChangeMessageVisibility(const Model::ChangeMessageVisibilityRequest& request) const; /** * A Callable wrapper for ChangeMessageVisibility that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ChangeMessageVisibilityOutcomeCallable ChangeMessageVisibilityCallable(const ChangeMessageVisibilityRequestT& request) const { return SubmitCallable(&SQSClient::ChangeMessageVisibility, request); } /** * An Async wrapper for ChangeMessageVisibility that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ChangeMessageVisibilityAsync(const ChangeMessageVisibilityRequestT& request, const ChangeMessageVisibilityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::ChangeMessageVisibility, request, handler, context); } /** *

Changes the visibility timeout of multiple messages. This is a batch version * of ChangeMessageVisibility. The result of the action on * each message is reported individually in the response. You can send up to 10 * ChangeMessageVisibility requests with each * ChangeMessageVisibilityBatch action.

Because the * batch request can result in a combination of successful and unsuccessful * actions, you should check for batch errors even when the call returns an HTTP * status code of 200.

Some actions take lists of * parameters. These lists are specified using the param.n notation. * Values of n are integers starting from 1. For example, a parameter * list with two elements looks like this:

* &AttributeName.1=first

* &AttributeName.2=second

See Also:

AWS * API Reference

*/ virtual Model::ChangeMessageVisibilityBatchOutcome ChangeMessageVisibilityBatch(const Model::ChangeMessageVisibilityBatchRequest& request) const; /** * A Callable wrapper for ChangeMessageVisibilityBatch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ChangeMessageVisibilityBatchOutcomeCallable ChangeMessageVisibilityBatchCallable(const ChangeMessageVisibilityBatchRequestT& request) const { return SubmitCallable(&SQSClient::ChangeMessageVisibilityBatch, request); } /** * An Async wrapper for ChangeMessageVisibilityBatch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ChangeMessageVisibilityBatchAsync(const ChangeMessageVisibilityBatchRequestT& request, const ChangeMessageVisibilityBatchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::ChangeMessageVisibilityBatch, request, handler, context); } /** *

Creates a new standard or FIFO queue. You can pass one or more attributes in * the request. Keep the following in mind:

  • If you don't specify * the FifoQueue attribute, Amazon SQS creates a standard queue.

    *

    You can't change the queue type after you create it and you can't * convert an existing standard queue into a FIFO queue. You must either create a * new FIFO queue for your application or delete your existing standard queue and * recreate it as a FIFO queue. For more information, see Moving * From a Standard Queue to a FIFO Queue in the Amazon SQS Developer * Guide.

  • If you don't provide a value for an * attribute, the queue is created with the default value for the attribute.

    *

  • If you delete a queue, you must wait at least 60 seconds before * creating a queue with the same name.

To successfully create a * new queue, you must provide a queue name that adheres to the limits * related to queues and is unique within the scope of your queues.

*

After you create a queue, you must wait at least one second after the queue * is created to be able to use the queue.

To get the queue URL, use * the GetQueueUrl action. GetQueueUrl * requires only the QueueName parameter. be aware of existing queue * names:

  • If you provide the name of an existing queue along with * the exact names and values of all the queue's attributes, * CreateQueue returns the queue URL for the existing queue.

    • *

  • If the queue name, attribute names, or attribute values don't match an * existing queue, CreateQueue returns an error.

*

Some actions take lists of parameters. These lists are specified using the * param.n notation. Values of n are integers starting * from 1. For example, a parameter list with two elements looks like this:

* &AttributeName.1=first

* &AttributeName.2=second

Cross-account * permissions don't apply to this action. For more information, see Grant * cross-account permissions to a role and a user name in the Amazon SQS * Developer Guide.

See Also:

AWS API * Reference

*/ virtual Model::CreateQueueOutcome CreateQueue(const Model::CreateQueueRequest& request) const; /** * A Callable wrapper for CreateQueue that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateQueueOutcomeCallable CreateQueueCallable(const CreateQueueRequestT& request) const { return SubmitCallable(&SQSClient::CreateQueue, request); } /** * An Async wrapper for CreateQueue that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateQueueAsync(const CreateQueueRequestT& request, const CreateQueueResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::CreateQueue, request, handler, context); } /** *

Deletes the specified message from the specified queue. To select the message * to delete, use the ReceiptHandle of the message (not the * MessageId which you receive when you send the message). Amazon SQS * can delete a message from a queue even if a visibility timeout setting causes * the message to be locked by another consumer. Amazon SQS automatically deletes * messages left in a queue longer than the retention period configured for the * queue.

The ReceiptHandle is associated with a * specific instance of receiving a message. If you receive a message more * than once, the ReceiptHandle is different each time you receive a * message. When you use the DeleteMessage action, you must provide * the most recently received ReceiptHandle for the message * (otherwise, the request succeeds, but the message might not be deleted).

*

For standard queues, it is possible to receive a message even after you * delete it. This might happen on rare occasions if one of the servers which * stores a copy of the message is unavailable when you send the request to delete * the message. The copy remains on the server and might be returned to you during * a subsequent receive request. You should ensure that your application is * idempotent, so that receiving a message more than once does not cause * issues.

See Also:

AWS * API Reference

*/ virtual Model::DeleteMessageOutcome DeleteMessage(const Model::DeleteMessageRequest& request) const; /** * A Callable wrapper for DeleteMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMessageOutcomeCallable DeleteMessageCallable(const DeleteMessageRequestT& request) const { return SubmitCallable(&SQSClient::DeleteMessage, request); } /** * An Async wrapper for DeleteMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMessageAsync(const DeleteMessageRequestT& request, const DeleteMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::DeleteMessage, request, handler, context); } /** *

Deletes up to ten messages from the specified queue. This is a batch version * of DeleteMessage. The result of the action on each message * is reported individually in the response.

Because the batch * request can result in a combination of successful and unsuccessful actions, you * should check for batch errors even when the call returns an HTTP status code of * 200.

Some actions take lists of parameters. * These lists are specified using the param.n notation. Values of * n are integers starting from 1. For example, a parameter list with * two elements looks like this:

&AttributeName.1=first *

&AttributeName.2=second

See Also:

AWS * API Reference

*/ virtual Model::DeleteMessageBatchOutcome DeleteMessageBatch(const Model::DeleteMessageBatchRequest& request) const; /** * A Callable wrapper for DeleteMessageBatch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMessageBatchOutcomeCallable DeleteMessageBatchCallable(const DeleteMessageBatchRequestT& request) const { return SubmitCallable(&SQSClient::DeleteMessageBatch, request); } /** * An Async wrapper for DeleteMessageBatch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMessageBatchAsync(const DeleteMessageBatchRequestT& request, const DeleteMessageBatchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::DeleteMessageBatch, request, handler, context); } /** *

Deletes the queue specified by the QueueUrl, regardless of the * queue's contents.

Be careful with the * DeleteQueue action: When you delete a queue, any messages in the * queue are no longer available.

When you delete a queue, the * deletion process takes up to 60 seconds. Requests you send involving that queue * during the 60 seconds might succeed. For example, a SendMessage * request might succeed, but after 60 seconds the queue and the message * you sent no longer exist.

When you delete a queue, you must wait at least * 60 seconds before creating a queue with the same name.

*

Cross-account permissions don't apply to this action. For more information, * see Grant * cross-account permissions to a role and a user name in the Amazon SQS * Developer Guide.

See Also:

AWS API * Reference

*/ virtual Model::DeleteQueueOutcome DeleteQueue(const Model::DeleteQueueRequest& request) const; /** * A Callable wrapper for DeleteQueue that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteQueueOutcomeCallable DeleteQueueCallable(const DeleteQueueRequestT& request) const { return SubmitCallable(&SQSClient::DeleteQueue, request); } /** * An Async wrapper for DeleteQueue that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteQueueAsync(const DeleteQueueRequestT& request, const DeleteQueueResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::DeleteQueue, request, handler, context); } /** *

Gets attributes for the specified queue.

To determine whether a * queue is FIFO, * you can check whether QueueName ends with the .fifo * suffix.

See Also:

AWS * API Reference

*/ virtual Model::GetQueueAttributesOutcome GetQueueAttributes(const Model::GetQueueAttributesRequest& request) const; /** * A Callable wrapper for GetQueueAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetQueueAttributesOutcomeCallable GetQueueAttributesCallable(const GetQueueAttributesRequestT& request) const { return SubmitCallable(&SQSClient::GetQueueAttributes, request); } /** * An Async wrapper for GetQueueAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetQueueAttributesAsync(const GetQueueAttributesRequestT& request, const GetQueueAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::GetQueueAttributes, request, handler, context); } /** *

Returns the URL of an existing Amazon SQS queue.

To access a queue * that belongs to another AWS account, use the QueueOwnerAWSAccountId * parameter to specify the account ID of the queue's owner. The queue's owner must * grant you permission to access the queue. For more information about shared * queue access, see AddPermission or see Allow * Developers to Write Messages to a Shared Queue in the Amazon SQS * Developer Guide.

See Also:

AWS API * Reference

*/ virtual Model::GetQueueUrlOutcome GetQueueUrl(const Model::GetQueueUrlRequest& request) const; /** * A Callable wrapper for GetQueueUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetQueueUrlOutcomeCallable GetQueueUrlCallable(const GetQueueUrlRequestT& request) const { return SubmitCallable(&SQSClient::GetQueueUrl, request); } /** * An Async wrapper for GetQueueUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetQueueUrlAsync(const GetQueueUrlRequestT& request, const GetQueueUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::GetQueueUrl, request, handler, context); } /** *

Returns a list of your queues that have the RedrivePolicy queue * attribute configured with a dead-letter queue.

The * ListDeadLetterSourceQueues methods supports pagination. Set * parameter MaxResults in the request to specify the maximum number * of results to be returned in the response. If you do not set * MaxResults, the response includes a maximum of 1,000 results. If * you set MaxResults and there are additional results to display, the * response includes a value for NextToken. Use NextToken * as a parameter in your next request to ListDeadLetterSourceQueues * to receive the next page of results.

For more information about using * dead-letter queues, see Using * Amazon SQS Dead-Letter Queues in the Amazon SQS Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListDeadLetterSourceQueuesOutcome ListDeadLetterSourceQueues(const Model::ListDeadLetterSourceQueuesRequest& request) const; /** * A Callable wrapper for ListDeadLetterSourceQueues that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDeadLetterSourceQueuesOutcomeCallable ListDeadLetterSourceQueuesCallable(const ListDeadLetterSourceQueuesRequestT& request) const { return SubmitCallable(&SQSClient::ListDeadLetterSourceQueues, request); } /** * An Async wrapper for ListDeadLetterSourceQueues that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDeadLetterSourceQueuesAsync(const ListDeadLetterSourceQueuesRequestT& request, const ListDeadLetterSourceQueuesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::ListDeadLetterSourceQueues, request, handler, context); } /** *

List all cost allocation tags added to the specified Amazon SQS queue. For an * overview, see Tagging * Your Amazon SQS Queues in the Amazon SQS Developer Guide.

*

Cross-account permissions don't apply to this action. For more information, * see Grant * cross-account permissions to a role and a user name in the Amazon SQS * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListQueueTagsOutcome ListQueueTags(const Model::ListQueueTagsRequest& request) const; /** * A Callable wrapper for ListQueueTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListQueueTagsOutcomeCallable ListQueueTagsCallable(const ListQueueTagsRequestT& request) const { return SubmitCallable(&SQSClient::ListQueueTags, request); } /** * An Async wrapper for ListQueueTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListQueueTagsAsync(const ListQueueTagsRequestT& request, const ListQueueTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::ListQueueTags, request, handler, context); } /** *

Returns a list of your queues in the current region. The response includes a * maximum of 1,000 results. If you specify a value for the optional * QueueNamePrefix parameter, only queues with a name that begins with * the specified value are returned.

The listQueues methods * supports pagination. Set parameter MaxResults in the request to * specify the maximum number of results to be returned in the response. If you do * not set MaxResults, the response includes a maximum of 1,000 * results. If you set MaxResults and there are additional results to * display, the response includes a value for NextToken. Use * NextToken as a parameter in your next request to * listQueues to receive the next page of results.

*

Cross-account permissions don't apply to this action. For more information, * see Grant * cross-account permissions to a role and a user name in the Amazon SQS * Developer Guide.

See Also:

AWS API * Reference

*/ virtual Model::ListQueuesOutcome ListQueues(const Model::ListQueuesRequest& request) const; /** * A Callable wrapper for ListQueues that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListQueuesOutcomeCallable ListQueuesCallable(const ListQueuesRequestT& request) const { return SubmitCallable(&SQSClient::ListQueues, request); } /** * An Async wrapper for ListQueues that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListQueuesAsync(const ListQueuesRequestT& request, const ListQueuesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::ListQueues, request, handler, context); } /** *

Deletes the messages in a queue specified by the QueueURL * parameter.

When you use the PurgeQueue action, * you can't retrieve any messages deleted from a queue.

The message * deletion process takes up to 60 seconds. We recommend waiting for 60 seconds * regardless of your queue's size.

Messages sent to the queue * before you call PurgeQueue might be received but are deleted * within the next minute.

Messages sent to the queue after you call * PurgeQueue might be deleted while the queue is being * purged.

See Also:

AWS API * Reference

*/ virtual Model::PurgeQueueOutcome PurgeQueue(const Model::PurgeQueueRequest& request) const; /** * A Callable wrapper for PurgeQueue that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PurgeQueueOutcomeCallable PurgeQueueCallable(const PurgeQueueRequestT& request) const { return SubmitCallable(&SQSClient::PurgeQueue, request); } /** * An Async wrapper for PurgeQueue that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PurgeQueueAsync(const PurgeQueueRequestT& request, const PurgeQueueResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::PurgeQueue, request, handler, context); } /** *

Retrieves one or more messages (up to 10), from the specified queue. Using * the WaitTimeSeconds parameter enables long-poll support. For more * information, see Amazon * SQS Long Polling in the Amazon SQS Developer Guide.

Short * poll is the default behavior where a weighted random set of machines is sampled * on a ReceiveMessage call. Thus, only the messages on the sampled * machines are returned. If the number of messages in the queue is small (fewer * than 1,000), you most likely get fewer messages than you requested per * ReceiveMessage call. If the number of messages in the queue is * extremely small, you might not receive any messages in a particular * ReceiveMessage response. If this happens, repeat the request.

*

For each message returned, the response includes the following:

  • *

    The message body.

  • An MD5 digest of the message body. For * information about MD5, see RFC1321.

  • The * MessageId you received when you sent the message to the queue.

    *

  • The receipt handle.

  • The message attributes.

    *

  • An MD5 digest of the message attributes.

The * receipt handle is the identifier you must provide when deleting the message. For * more information, see Queue * and Message Identifiers in the Amazon SQS Developer Guide.

You * can provide the VisibilityTimeout parameter in your request. The * parameter is applied to the messages that Amazon SQS returns in the response. If * you don't include the parameter, the overall visibility timeout for the queue is * used for the returned messages. For more information, see Visibility * Timeout in the Amazon SQS Developer Guide.

A message that * isn't deleted or a message whose visibility isn't extended before the visibility * timeout expires counts as a failed receive. Depending on the configuration of * the queue, the message might be sent to the dead-letter queue.

In * the future, new attributes might be added. If you write code that calls this * action, we recommend that you structure your code so that it can handle new * attributes gracefully.

See Also:

AWS * API Reference

*/ virtual Model::ReceiveMessageOutcome ReceiveMessage(const Model::ReceiveMessageRequest& request) const; /** * A Callable wrapper for ReceiveMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ReceiveMessageOutcomeCallable ReceiveMessageCallable(const ReceiveMessageRequestT& request) const { return SubmitCallable(&SQSClient::ReceiveMessage, request); } /** * An Async wrapper for ReceiveMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ReceiveMessageAsync(const ReceiveMessageRequestT& request, const ReceiveMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::ReceiveMessage, request, handler, context); } /** *

Revokes any permissions in the queue policy that matches the specified * Label parameter.

  • Only the owner of a queue * can remove permissions from it.

  • Cross-account permissions * don't apply to this action. For more information, see Grant * cross-account permissions to a role and a user name in the Amazon SQS * Developer Guide.

  • To remove the ability to change queue * permissions, you must deny permission to the AddPermission, * RemovePermission, and SetQueueAttributes actions in * your IAM policy.

See Also:

AWS * API Reference

*/ virtual Model::RemovePermissionOutcome RemovePermission(const Model::RemovePermissionRequest& request) const; /** * A Callable wrapper for RemovePermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemovePermissionOutcomeCallable RemovePermissionCallable(const RemovePermissionRequestT& request) const { return SubmitCallable(&SQSClient::RemovePermission, request); } /** * An Async wrapper for RemovePermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemovePermissionAsync(const RemovePermissionRequestT& request, const RemovePermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::RemovePermission, request, handler, context); } /** *

Delivers a message to the specified queue.

A message can * include only XML, JSON, and unformatted text. The following Unicode characters * are allowed:

#x9 | #xA | #xD | * #x20 to #xD7FF | #xE000 to * #xFFFD | #x10000 to #x10FFFF

Any * characters not included in this list will be rejected. For more information, see * the W3C specification for * characters.

See Also:

AWS API * Reference

*/ virtual Model::SendMessageOutcome SendMessage(const Model::SendMessageRequest& request) const; /** * A Callable wrapper for SendMessage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendMessageOutcomeCallable SendMessageCallable(const SendMessageRequestT& request) const { return SubmitCallable(&SQSClient::SendMessage, request); } /** * An Async wrapper for SendMessage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendMessageAsync(const SendMessageRequestT& request, const SendMessageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::SendMessage, request, handler, context); } /** *

Delivers up to ten messages to the specified queue. This is a batch version * of SendMessage. For a FIFO queue, multiple messages within * a single batch are enqueued in the order they are sent.

The result of * sending each message is reported individually in the response. Because the batch * request can result in a combination of successful and unsuccessful actions, you * should check for batch errors even when the call returns an HTTP status code of * 200.

The maximum allowed individual message size and the * maximum total payload size (the sum of the individual lengths of all of the * batched messages) are both 256 KB (262,144 bytes).

A message * can include only XML, JSON, and unformatted text. The following Unicode * characters are allowed:

#x9 | #xA | * #xD | #x20 to #xD7FF | * #xE000 to #xFFFD | #x10000 to * #x10FFFF

Any characters not included in this list will be * rejected. For more information, see the W3C specification for * characters.

If you don't specify the * DelaySeconds parameter for an entry, Amazon SQS uses the default * value for the queue.

Some actions take lists of parameters. These lists * are specified using the param.n notation. Values of n * are integers starting from 1. For example, a parameter list with two elements * looks like this:

&AttributeName.1=first

* &AttributeName.2=second

See Also:

AWS * API Reference

*/ virtual Model::SendMessageBatchOutcome SendMessageBatch(const Model::SendMessageBatchRequest& request) const; /** * A Callable wrapper for SendMessageBatch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendMessageBatchOutcomeCallable SendMessageBatchCallable(const SendMessageBatchRequestT& request) const { return SubmitCallable(&SQSClient::SendMessageBatch, request); } /** * An Async wrapper for SendMessageBatch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendMessageBatchAsync(const SendMessageBatchRequestT& request, const SendMessageBatchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::SendMessageBatch, request, handler, context); } /** *

Sets the value of one or more queue attributes. When you change a queue's * attributes, the change can take up to 60 seconds for most of the attributes to * propagate throughout the Amazon SQS system. Changes made to the * MessageRetentionPeriod attribute can take up to 15 minutes.

*

  • In the future, new attributes might be added. If you write * code that calls this action, we recommend that you structure your code so that * it can handle new attributes gracefully.

  • Cross-account * permissions don't apply to this action. For more information, see Grant * cross-account permissions to a role and a user name in the Amazon SQS * Developer Guide.

  • To remove the ability to change queue * permissions, you must deny permission to the AddPermission, * RemovePermission, and SetQueueAttributes actions in * your IAM policy.

See Also:

AWS * API Reference

*/ virtual Model::SetQueueAttributesOutcome SetQueueAttributes(const Model::SetQueueAttributesRequest& request) const; /** * A Callable wrapper for SetQueueAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SetQueueAttributesOutcomeCallable SetQueueAttributesCallable(const SetQueueAttributesRequestT& request) const { return SubmitCallable(&SQSClient::SetQueueAttributes, request); } /** * An Async wrapper for SetQueueAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SetQueueAttributesAsync(const SetQueueAttributesRequestT& request, const SetQueueAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::SetQueueAttributes, request, handler, context); } /** *

Add cost allocation tags to the specified Amazon SQS queue. For an overview, * see Tagging * Your Amazon SQS Queues in the Amazon SQS Developer Guide.

When * you use queue tags, keep the following guidelines in mind:

  • *

    Adding more than 50 tags to a queue isn't recommended.

  • Tags * don't have any semantic meaning. Amazon SQS interprets tags as character * strings.

  • Tags are case-sensitive.

  • A new tag * with a key identical to that of an existing tag overwrites the existing tag.

    *

For a full list of tag restrictions, see Quotas * related to queues in the Amazon SQS Developer Guide.

*

Cross-account permissions don't apply to this action. For more information, * see Grant * cross-account permissions to a role and a user name in the Amazon SQS * Developer Guide.

See Also:

AWS API * Reference

*/ virtual Model::TagQueueOutcome TagQueue(const Model::TagQueueRequest& request) const; /** * A Callable wrapper for TagQueue that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagQueueOutcomeCallable TagQueueCallable(const TagQueueRequestT& request) const { return SubmitCallable(&SQSClient::TagQueue, request); } /** * An Async wrapper for TagQueue that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagQueueAsync(const TagQueueRequestT& request, const TagQueueResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::TagQueue, request, handler, context); } /** *

Remove cost allocation tags from the specified Amazon SQS queue. For an * overview, see Tagging * Your Amazon SQS Queues in the Amazon SQS Developer Guide.

*

Cross-account permissions don't apply to this action. For more information, * see Grant * cross-account permissions to a role and a user name in the Amazon SQS * Developer Guide.

See Also:

AWS API * Reference

*/ virtual Model::UntagQueueOutcome UntagQueue(const Model::UntagQueueRequest& request) const; /** * A Callable wrapper for UntagQueue that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagQueueOutcomeCallable UntagQueueCallable(const UntagQueueRequestT& request) const { return SubmitCallable(&SQSClient::UntagQueue, request); } /** * An Async wrapper for UntagQueue that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagQueueAsync(const UntagQueueRequestT& request, const UntagQueueResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SQSClient::UntagQueue, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const SQSClientConfiguration& clientConfiguration); SQSClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace SQS } // namespace Aws