com.amazonaws.services.sqs.AmazonSQSAsync Maven / Gradle / Ivy
Show all versions of aws-java-sdk-sqs Show documentation
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.sqs;
import javax.annotation.Generated;
import com.amazonaws.services.sqs.model.*;
/**
* Interface for accessing Amazon SQS asynchronously. Each asynchronous method will return a Java Future object
* representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
* notification when an asynchronous operation completes.
*
* Note: Do not directly implement this interface, new methods are added to it regularly. Extend from
* {@link com.amazonaws.services.sqs.AbstractAmazonSQSAsync} instead.
*
*
*
* 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
*
*
* -
*
*
* -
*
* Amazon SQS Developer Guide
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* -
*
*
* -
*
* Amazon Web Services General Reference
*
*
* -
*
*
*
*
*
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public interface AmazonSQSAsync extends AmazonSQS {
/**
*
* 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 seven actions per statement.
*
*
* -
*
* To remove the ability to change queue permissions, you must deny permission to the AddPermission,
* RemovePermission, and SetQueueAttributes actions in your IAM policy.
*
*
* -
*
* Amazon SQS AddPermission does not support adding a non-account principal.
*
*
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param addPermissionRequest
* @return A Java Future containing the result of the AddPermission operation returned by the service.
* @sample AmazonSQSAsync.AddPermission
* @see AWS API
* Documentation
*/
java.util.concurrent.Future addPermissionAsync(AddPermissionRequest addPermissionRequest);
/**
*
* 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 seven actions per statement.
*
*
* -
*
* To remove the ability to change queue permissions, you must deny permission to the AddPermission,
* RemovePermission, and SetQueueAttributes actions in your IAM policy.
*
*
* -
*
* Amazon SQS AddPermission does not support adding a non-account principal.
*
*
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param addPermissionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the AddPermission operation returned by the service.
* @sample AmazonSQSAsyncHandler.AddPermission
* @see AWS API
* Documentation
*/
java.util.concurrent.Future addPermissionAsync(AddPermissionRequest addPermissionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the AddPermission operation.
*
* @see #addPermissionAsync(AddPermissionRequest)
*/
java.util.concurrent.Future addPermissionAsync(String queueUrl, String label, java.util.List aWSAccountIds,
java.util.List actions);
/**
* Simplified method form for invoking the AddPermission operation with an AsyncHandler.
*
* @see #addPermissionAsync(AddPermissionRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future addPermissionAsync(String queueUrl, String label, java.util.List aWSAccountIds,
java.util.List actions, com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Cancels a specified message movement task. A message movement can only be cancelled when the current status is
* RUNNING. Cancelling a message movement task does not revert the messages that have already been moved. It can
* only stop the messages that have not been moved yet.
*
*
*
* -
*
* This action is currently limited to supporting message redrive from dead-letter queues (DLQs) only. In this context, the source queue is the dead-letter queue (DLQ), while the
* destination queue can be the original source queue (from which the messages were driven to the
* dead-letter-queue), or a custom destination queue.
*
*
* -
*
* Only one active message movement task is supported per queue at any given time.
*
*
*
*
*
* @param cancelMessageMoveTaskRequest
* @return A Java Future containing the result of the CancelMessageMoveTask operation returned by the service.
* @sample AmazonSQSAsync.CancelMessageMoveTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future cancelMessageMoveTaskAsync(CancelMessageMoveTaskRequest cancelMessageMoveTaskRequest);
/**
*
* Cancels a specified message movement task. A message movement can only be cancelled when the current status is
* RUNNING. Cancelling a message movement task does not revert the messages that have already been moved. It can
* only stop the messages that have not been moved yet.
*
*
*
* -
*
* This action is currently limited to supporting message redrive from dead-letter queues (DLQs) only. In this context, the source queue is the dead-letter queue (DLQ), while the
* destination queue can be the original source queue (from which the messages were driven to the
* dead-letter-queue), or a custom destination queue.
*
*
* -
*
* Only one active message movement task is supported per queue at any given time.
*
*
*
*
*
* @param cancelMessageMoveTaskRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CancelMessageMoveTask operation returned by the service.
* @sample AmazonSQSAsyncHandler.CancelMessageMoveTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future cancelMessageMoveTaskAsync(CancelMessageMoveTaskRequest cancelMessageMoveTaskRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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, if the default timeout for a queue is 60 seconds, 15 seconds have elapsed since you received the
* message, and you send a ChangeMessageVisibility call with VisibilityTimeout set to 10 seconds, the
* 10 seconds begin to count from the time that you make the ChangeMessageVisibility call. Thus, any
* attempt to change the visibility timeout or to delete that message 10 seconds after you initially change the
* visibility timeout (a total of 25 seconds) might result in an error.
*
*
* An Amazon SQS message has three basic states:
*
*
* -
*
* Sent to a queue by a producer.
*
*
* -
*
* Received from the queue by a consumer.
*
*
* -
*
* 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 in flight messages.
*
*
* Limits that apply to in flight 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 in flight 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 in flight 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.
*
*
*
* @param changeMessageVisibilityRequest
* @return A Java Future containing the result of the ChangeMessageVisibility operation returned by the service.
* @sample AmazonSQSAsync.ChangeMessageVisibility
* @see AWS
* API Documentation
*/
java.util.concurrent.Future changeMessageVisibilityAsync(ChangeMessageVisibilityRequest changeMessageVisibilityRequest);
/**
*
* 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, if the default timeout for a queue is 60 seconds, 15 seconds have elapsed since you received the
* message, and you send a ChangeMessageVisibility call with VisibilityTimeout set to 10 seconds, the
* 10 seconds begin to count from the time that you make the ChangeMessageVisibility call. Thus, any
* attempt to change the visibility timeout or to delete that message 10 seconds after you initially change the
* visibility timeout (a total of 25 seconds) might result in an error.
*
*
* An Amazon SQS message has three basic states:
*
*
* -
*
* Sent to a queue by a producer.
*
*
* -
*
* Received from the queue by a consumer.
*
*
* -
*
* 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 in flight messages.
*
*
* Limits that apply to in flight 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 in flight 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 in flight 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.
*
*
*
* @param changeMessageVisibilityRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ChangeMessageVisibility operation returned by the service.
* @sample AmazonSQSAsyncHandler.ChangeMessageVisibility
* @see AWS
* API Documentation
*/
java.util.concurrent.Future changeMessageVisibilityAsync(ChangeMessageVisibilityRequest changeMessageVisibilityRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ChangeMessageVisibility operation.
*
* @see #changeMessageVisibilityAsync(ChangeMessageVisibilityRequest)
*/
java.util.concurrent.Future changeMessageVisibilityAsync(String queueUrl, String receiptHandle, Integer visibilityTimeout);
/**
* Simplified method form for invoking the ChangeMessageVisibility operation with an AsyncHandler.
*
* @see #changeMessageVisibilityAsync(ChangeMessageVisibilityRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future changeMessageVisibilityAsync(String queueUrl, String receiptHandle, Integer visibilityTimeout,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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.
*
*
*
* @param changeMessageVisibilityBatchRequest
* @return A Java Future containing the result of the ChangeMessageVisibilityBatch operation returned by the
* service.
* @sample AmazonSQSAsync.ChangeMessageVisibilityBatch
* @see AWS API Documentation
*/
java.util.concurrent.Future changeMessageVisibilityBatchAsync(
ChangeMessageVisibilityBatchRequest changeMessageVisibilityBatchRequest);
/**
*
* 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.
*
*
*
* @param changeMessageVisibilityBatchRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ChangeMessageVisibilityBatch operation returned by the
* service.
* @sample AmazonSQSAsyncHandler.ChangeMessageVisibilityBatch
* @see AWS API Documentation
*/
java.util.concurrent.Future changeMessageVisibilityBatchAsync(
ChangeMessageVisibilityBatchRequest changeMessageVisibilityBatchRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ChangeMessageVisibilityBatch operation.
*
* @see #changeMessageVisibilityBatchAsync(ChangeMessageVisibilityBatchRequest)
*/
java.util.concurrent.Future changeMessageVisibilityBatchAsync(String queueUrl,
java.util.List entries);
/**
* Simplified method form for invoking the ChangeMessageVisibilityBatch operation with an AsyncHandler.
*
* @see #changeMessageVisibilityBatchAsync(ChangeMessageVisibilityBatchRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future changeMessageVisibilityBatchAsync(String queueUrl,
java.util.List entries,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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.
*
*
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param createQueueRequest
* @return A Java Future containing the result of the CreateQueue operation returned by the service.
* @sample AmazonSQSAsync.CreateQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createQueueAsync(CreateQueueRequest createQueueRequest);
/**
*
* 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.
*
*
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param createQueueRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the CreateQueue operation returned by the service.
* @sample AmazonSQSAsyncHandler.CreateQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future createQueueAsync(CreateQueueRequest createQueueRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the CreateQueue operation.
*
* @see #createQueueAsync(CreateQueueRequest)
*/
java.util.concurrent.Future createQueueAsync(String queueName);
/**
* Simplified method form for invoking the CreateQueue operation with an AsyncHandler.
*
* @see #createQueueAsync(CreateQueueRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future createQueueAsync(String queueName,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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 will 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.
*
*
*
* @param deleteMessageRequest
* @return A Java Future containing the result of the DeleteMessage operation returned by the service.
* @sample AmazonSQSAsync.DeleteMessage
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteMessageAsync(DeleteMessageRequest deleteMessageRequest);
/**
*
* 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 will 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.
*
*
*
* @param deleteMessageRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteMessage operation returned by the service.
* @sample AmazonSQSAsyncHandler.DeleteMessage
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteMessageAsync(DeleteMessageRequest deleteMessageRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the DeleteMessage operation.
*
* @see #deleteMessageAsync(DeleteMessageRequest)
*/
java.util.concurrent.Future deleteMessageAsync(String queueUrl, String receiptHandle);
/**
* Simplified method form for invoking the DeleteMessage operation with an AsyncHandler.
*
* @see #deleteMessageAsync(DeleteMessageRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future deleteMessageAsync(String queueUrl, String receiptHandle,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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.
*
*
*
* @param deleteMessageBatchRequest
* @return A Java Future containing the result of the DeleteMessageBatch operation returned by the service.
* @sample AmazonSQSAsync.DeleteMessageBatch
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteMessageBatchAsync(DeleteMessageBatchRequest deleteMessageBatchRequest);
/**
*
* 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.
*
*
*
* @param deleteMessageBatchRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteMessageBatch operation returned by the service.
* @sample AmazonSQSAsyncHandler.DeleteMessageBatch
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteMessageBatchAsync(DeleteMessageBatchRequest deleteMessageBatchRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the DeleteMessageBatch operation.
*
* @see #deleteMessageBatchAsync(DeleteMessageBatchRequest)
*/
java.util.concurrent.Future deleteMessageBatchAsync(String queueUrl, java.util.List entries);
/**
* Simplified method form for invoking the DeleteMessageBatch operation with an AsyncHandler.
*
* @see #deleteMessageBatchAsync(DeleteMessageBatchRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future deleteMessageBatchAsync(String queueUrl, java.util.List entries,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
* The delete operation uses the HTTP GET verb.
*
*
*
* @param deleteQueueRequest
* @return A Java Future containing the result of the DeleteQueue operation returned by the service.
* @sample AmazonSQSAsync.DeleteQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteQueueAsync(DeleteQueueRequest deleteQueueRequest);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
* The delete operation uses the HTTP GET verb.
*
*
*
* @param deleteQueueRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the DeleteQueue operation returned by the service.
* @sample AmazonSQSAsyncHandler.DeleteQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future deleteQueueAsync(DeleteQueueRequest deleteQueueRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the DeleteQueue operation.
*
* @see #deleteQueueAsync(DeleteQueueRequest)
*/
java.util.concurrent.Future deleteQueueAsync(String queueUrl);
/**
* Simplified method form for invoking the DeleteQueue operation with an AsyncHandler.
*
* @see #deleteQueueAsync(DeleteQueueRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future deleteQueueAsync(String queueUrl,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Gets attributes for the specified queue.
*
*
*
* To determine whether a queue is FIFO, you
* can check whether QueueName ends with the .fifo suffix.
*
*
*
* @param getQueueAttributesRequest
* @return A Java Future containing the result of the GetQueueAttributes operation returned by the service.
* @sample AmazonSQSAsync.GetQueueAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getQueueAttributesAsync(GetQueueAttributesRequest getQueueAttributesRequest);
/**
*
* Gets attributes for the specified queue.
*
*
*
* To determine whether a queue is FIFO, you
* can check whether QueueName ends with the .fifo suffix.
*
*
*
* @param getQueueAttributesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetQueueAttributes operation returned by the service.
* @sample AmazonSQSAsyncHandler.GetQueueAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getQueueAttributesAsync(GetQueueAttributesRequest getQueueAttributesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the GetQueueAttributes operation.
*
* @see #getQueueAttributesAsync(GetQueueAttributesRequest)
*/
java.util.concurrent.Future getQueueAttributesAsync(String queueUrl, java.util.List attributeNames);
/**
* Simplified method form for invoking the GetQueueAttributes operation with an AsyncHandler.
*
* @see #getQueueAttributesAsync(GetQueueAttributesRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future getQueueAttributesAsync(String queueUrl, java.util.List attributeNames,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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.
*
*
* @param getQueueUrlRequest
* @return A Java Future containing the result of the GetQueueUrl operation returned by the service.
* @sample AmazonSQSAsync.GetQueueUrl
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getQueueUrlAsync(GetQueueUrlRequest getQueueUrlRequest);
/**
*
* 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.
*
*
* @param getQueueUrlRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the GetQueueUrl operation returned by the service.
* @sample AmazonSQSAsyncHandler.GetQueueUrl
* @see AWS API
* Documentation
*/
java.util.concurrent.Future getQueueUrlAsync(GetQueueUrlRequest getQueueUrlRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the GetQueueUrl operation.
*
* @see #getQueueUrlAsync(GetQueueUrlRequest)
*/
java.util.concurrent.Future getQueueUrlAsync(String queueName);
/**
* Simplified method form for invoking the GetQueueUrl operation with an AsyncHandler.
*
* @see #getQueueUrlAsync(GetQueueUrlRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future getQueueUrlAsync(String queueName,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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.
*
*
* @param listDeadLetterSourceQueuesRequest
* @return A Java Future containing the result of the ListDeadLetterSourceQueues operation returned by the service.
* @sample AmazonSQSAsync.ListDeadLetterSourceQueues
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listDeadLetterSourceQueuesAsync(
ListDeadLetterSourceQueuesRequest listDeadLetterSourceQueuesRequest);
/**
*
* 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.
*
*
* @param listDeadLetterSourceQueuesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListDeadLetterSourceQueues operation returned by the service.
* @sample AmazonSQSAsyncHandler.ListDeadLetterSourceQueues
* @see AWS
* API Documentation
*/
java.util.concurrent.Future listDeadLetterSourceQueuesAsync(
ListDeadLetterSourceQueuesRequest listDeadLetterSourceQueuesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Gets the most recent message movement tasks (up to 10) under a specific source queue.
*
*
*
* -
*
* This action is currently limited to supporting message redrive from dead-letter queues (DLQs) only. In this context, the source queue is the dead-letter queue (DLQ), while the
* destination queue can be the original source queue (from which the messages were driven to the
* dead-letter-queue), or a custom destination queue.
*
*
* -
*
* Only one active message movement task is supported per queue at any given time.
*
*
*
*
*
* @param listMessageMoveTasksRequest
* @return A Java Future containing the result of the ListMessageMoveTasks operation returned by the service.
* @sample AmazonSQSAsync.ListMessageMoveTasks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listMessageMoveTasksAsync(ListMessageMoveTasksRequest listMessageMoveTasksRequest);
/**
*
* Gets the most recent message movement tasks (up to 10) under a specific source queue.
*
*
*
* -
*
* This action is currently limited to supporting message redrive from dead-letter queues (DLQs) only. In this context, the source queue is the dead-letter queue (DLQ), while the
* destination queue can be the original source queue (from which the messages were driven to the
* dead-letter-queue), or a custom destination queue.
*
*
* -
*
* Only one active message movement task is supported per queue at any given time.
*
*
*
*
*
* @param listMessageMoveTasksRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListMessageMoveTasks operation returned by the service.
* @sample AmazonSQSAsyncHandler.ListMessageMoveTasks
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listMessageMoveTasksAsync(ListMessageMoveTasksRequest listMessageMoveTasksRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
*
* @param listQueueTagsRequest
* @return A Java Future containing the result of the ListQueueTags operation returned by the service.
* @sample AmazonSQSAsync.ListQueueTags
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listQueueTagsAsync(ListQueueTagsRequest listQueueTagsRequest);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
*
* @param listQueueTagsRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListQueueTags operation returned by the service.
* @sample AmazonSQSAsyncHandler.ListQueueTags
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listQueueTagsAsync(ListQueueTagsRequest listQueueTagsRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListQueueTags operation.
*
* @see #listQueueTagsAsync(ListQueueTagsRequest)
*/
java.util.concurrent.Future listQueueTagsAsync(String queueUrl);
/**
* Simplified method form for invoking the ListQueueTags operation with an AsyncHandler.
*
* @see #listQueueTagsAsync(ListQueueTagsRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listQueueTagsAsync(String queueUrl,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
*
* @param listQueuesRequest
* @return A Java Future containing the result of the ListQueues operation returned by the service.
* @sample AmazonSQSAsync.ListQueues
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listQueuesAsync(ListQueuesRequest listQueuesRequest);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
*
* @param listQueuesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ListQueues operation returned by the service.
* @sample AmazonSQSAsyncHandler.ListQueues
* @see AWS API
* Documentation
*/
java.util.concurrent.Future listQueuesAsync(ListQueuesRequest listQueuesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListQueues operation.
*
* @see #listQueuesAsync(ListQueuesRequest)
*/
java.util.concurrent.Future listQueuesAsync();
/**
* Simplified method form for invoking the ListQueues operation with an AsyncHandler.
*
* @see #listQueuesAsync(ListQueuesRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listQueuesAsync(com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ListQueues operation.
*
* @see #listQueuesAsync(ListQueuesRequest)
*/
java.util.concurrent.Future listQueuesAsync(String queueNamePrefix);
/**
* Simplified method form for invoking the ListQueues operation with an AsyncHandler.
*
* @see #listQueuesAsync(ListQueuesRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future listQueuesAsync(String queueNamePrefix,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Deletes available messages in a queue (including in-flight messages) 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.
*
*
* @param purgeQueueRequest
* @return A Java Future containing the result of the PurgeQueue operation returned by the service.
* @sample AmazonSQSAsync.PurgeQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future purgeQueueAsync(PurgeQueueRequest purgeQueueRequest);
/**
*
* Deletes available messages in a queue (including in-flight messages) 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.
*
*
* @param purgeQueueRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the PurgeQueue operation returned by the service.
* @sample AmazonSQSAsyncHandler.PurgeQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future purgeQueueAsync(PurgeQueueRequest purgeQueueRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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.
*
*
*
* @param receiveMessageRequest
* @return A Java Future containing the result of the ReceiveMessage operation returned by the service.
* @sample AmazonSQSAsync.ReceiveMessage
* @see AWS API
* Documentation
*/
java.util.concurrent.Future receiveMessageAsync(ReceiveMessageRequest receiveMessageRequest);
/**
*
* 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.
*
*
*
* @param receiveMessageRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the ReceiveMessage operation returned by the service.
* @sample AmazonSQSAsyncHandler.ReceiveMessage
* @see AWS API
* Documentation
*/
java.util.concurrent.Future receiveMessageAsync(ReceiveMessageRequest receiveMessageRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the ReceiveMessage operation.
*
* @see #receiveMessageAsync(ReceiveMessageRequest)
*/
java.util.concurrent.Future receiveMessageAsync(String queueUrl);
/**
* Simplified method form for invoking the ReceiveMessage operation with an AsyncHandler.
*
* @see #receiveMessageAsync(ReceiveMessageRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future receiveMessageAsync(String queueUrl,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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 username 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.
*
*
*
*
*
* @param removePermissionRequest
* @return A Java Future containing the result of the RemovePermission operation returned by the service.
* @sample AmazonSQSAsync.RemovePermission
* @see AWS API
* Documentation
*/
java.util.concurrent.Future removePermissionAsync(RemovePermissionRequest removePermissionRequest);
/**
*
* 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 username 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.
*
*
*
*
*
* @param removePermissionRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the RemovePermission operation returned by the service.
* @sample AmazonSQSAsyncHandler.RemovePermission
* @see AWS API
* Documentation
*/
java.util.concurrent.Future removePermissionAsync(RemovePermissionRequest removePermissionRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the RemovePermission operation.
*
* @see #removePermissionAsync(RemovePermissionRequest)
*/
java.util.concurrent.Future removePermissionAsync(String queueUrl, String label);
/**
* Simplified method form for invoking the RemovePermission operation with an AsyncHandler.
*
* @see #removePermissionAsync(RemovePermissionRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future removePermissionAsync(String queueUrl, String label,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Delivers a message to the specified queue.
*
*
*
* A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed. For
* more information, see the W3C specification for characters.
*
*
* #x9 | #xA | #xD | #x20 to #xD7FF |
* #xE000 to #xFFFD | #x10000 to #x10FFFF
*
*
* Amazon SQS does not throw an exception or completely reject the message if it contains invalid characters.
* Instead, it replaces those invalid characters with U+FFFD before storing the message in the queue,
* as long as the message body contains at least one valid character.
*
*
*
* @param sendMessageRequest
* @return A Java Future containing the result of the SendMessage operation returned by the service.
* @sample AmazonSQSAsync.SendMessage
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendMessageAsync(SendMessageRequest sendMessageRequest);
/**
*
* Delivers a message to the specified queue.
*
*
*
* A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed. For
* more information, see the W3C specification for characters.
*
*
* #x9 | #xA | #xD | #x20 to #xD7FF |
* #xE000 to #xFFFD | #x10000 to #x10FFFF
*
*
* Amazon SQS does not throw an exception or completely reject the message if it contains invalid characters.
* Instead, it replaces those invalid characters with U+FFFD before storing the message in the queue,
* as long as the message body contains at least one valid character.
*
*
*
* @param sendMessageRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the SendMessage operation returned by the service.
* @sample AmazonSQSAsyncHandler.SendMessage
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendMessageAsync(SendMessageRequest sendMessageRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the SendMessage operation.
*
* @see #sendMessageAsync(SendMessageRequest)
*/
java.util.concurrent.Future sendMessageAsync(String queueUrl, String messageBody);
/**
* Simplified method form for invoking the SendMessage operation with an AsyncHandler.
*
* @see #sendMessageAsync(SendMessageRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future sendMessageAsync(String queueUrl, String messageBody,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* You can use SendMessageBatch to send up to 10 messages to the specified queue by assigning either
* identical or different values to each message (or by not assigning values at all). 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 KiB (262,144 bytes).
*
*
*
* A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed. For
* more information, see the W3C specification for characters.
*
*
* #x9 | #xA | #xD | #x20 to #xD7FF |
* #xE000 to #xFFFD | #x10000 to #x10FFFF
*
*
* Amazon SQS does not throw an exception or completely reject the message if it contains invalid characters.
* Instead, it replaces those invalid characters with U+FFFD before storing the message in the queue,
* as long as the message body contains at least one valid character.
*
*
*
* If you don't specify the DelaySeconds parameter for an entry, Amazon SQS uses the default value for
* the queue.
*
*
* @param sendMessageBatchRequest
* @return A Java Future containing the result of the SendMessageBatch operation returned by the service.
* @sample AmazonSQSAsync.SendMessageBatch
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendMessageBatchAsync(SendMessageBatchRequest sendMessageBatchRequest);
/**
*
* You can use SendMessageBatch to send up to 10 messages to the specified queue by assigning either
* identical or different values to each message (or by not assigning values at all). 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 KiB (262,144 bytes).
*
*
*
* A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed. For
* more information, see the W3C specification for characters.
*
*
* #x9 | #xA | #xD | #x20 to #xD7FF |
* #xE000 to #xFFFD | #x10000 to #x10FFFF
*
*
* Amazon SQS does not throw an exception or completely reject the message if it contains invalid characters.
* Instead, it replaces those invalid characters with U+FFFD before storing the message in the queue,
* as long as the message body contains at least one valid character.
*
*
*
* If you don't specify the DelaySeconds parameter for an entry, Amazon SQS uses the default value for
* the queue.
*
*
* @param sendMessageBatchRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the SendMessageBatch operation returned by the service.
* @sample AmazonSQSAsyncHandler.SendMessageBatch
* @see AWS API
* Documentation
*/
java.util.concurrent.Future sendMessageBatchAsync(SendMessageBatchRequest sendMessageBatchRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the SendMessageBatch operation.
*
* @see #sendMessageBatchAsync(SendMessageBatchRequest)
*/
java.util.concurrent.Future sendMessageBatchAsync(String queueUrl, java.util.List entries);
/**
* Simplified method form for invoking the SendMessageBatch operation with an AsyncHandler.
*
* @see #sendMessageBatchAsync(SendMessageBatchRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future sendMessageBatchAsync(String queueUrl, java.util.List entries,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Sets the value of one or more queue attributes, like a policy. 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 and will impact existing messages
* in the queue potentially causing them to be expired and deleted if the MessageRetentionPeriod is
* reduced below the age of existing messages.
*
*
*
* -
*
* 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 username 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.
*
*
*
*
*
* @param setQueueAttributesRequest
* @return A Java Future containing the result of the SetQueueAttributes operation returned by the service.
* @sample AmazonSQSAsync.SetQueueAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future setQueueAttributesAsync(SetQueueAttributesRequest setQueueAttributesRequest);
/**
*
* Sets the value of one or more queue attributes, like a policy. 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 and will impact existing messages
* in the queue potentially causing them to be expired and deleted if the MessageRetentionPeriod is
* reduced below the age of existing messages.
*
*
*
* -
*
* 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 username 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.
*
*
*
*
*
* @param setQueueAttributesRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the SetQueueAttributes operation returned by the service.
* @sample AmazonSQSAsyncHandler.SetQueueAttributes
* @see AWS API
* Documentation
*/
java.util.concurrent.Future setQueueAttributesAsync(SetQueueAttributesRequest setQueueAttributesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the SetQueueAttributes operation.
*
* @see #setQueueAttributesAsync(SetQueueAttributesRequest)
*/
java.util.concurrent.Future setQueueAttributesAsync(String queueUrl, java.util.Map attributes);
/**
* Simplified method form for invoking the SetQueueAttributes operation with an AsyncHandler.
*
* @see #setQueueAttributesAsync(SetQueueAttributesRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future setQueueAttributesAsync(String queueUrl, java.util.Map attributes,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Starts an asynchronous task to move messages from a specified source queue to a specified destination queue.
*
*
*
* -
*
* This action is currently limited to supporting message redrive from queues that are configured as dead-letter queues (DLQs) of other Amazon SQS queues only. Non-SQS queue sources of dead-letter queues, such
* as Lambda or Amazon SNS topics, are currently not supported.
*
*
* -
*
* In dead-letter queues redrive context, the StartMessageMoveTask the source queue is the DLQ, while
* the destination queue can be the original source queue (from which the messages were driven to the
* dead-letter-queue), or a custom destination queue.
*
*
* -
*
* Only one active message movement task is supported per queue at any given time.
*
*
*
*
*
* @param startMessageMoveTaskRequest
* @return A Java Future containing the result of the StartMessageMoveTask operation returned by the service.
* @sample AmazonSQSAsync.StartMessageMoveTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future startMessageMoveTaskAsync(StartMessageMoveTaskRequest startMessageMoveTaskRequest);
/**
*
* Starts an asynchronous task to move messages from a specified source queue to a specified destination queue.
*
*
*
* -
*
* This action is currently limited to supporting message redrive from queues that are configured as dead-letter queues (DLQs) of other Amazon SQS queues only. Non-SQS queue sources of dead-letter queues, such
* as Lambda or Amazon SNS topics, are currently not supported.
*
*
* -
*
* In dead-letter queues redrive context, the StartMessageMoveTask the source queue is the DLQ, while
* the destination queue can be the original source queue (from which the messages were driven to the
* dead-letter-queue), or a custom destination queue.
*
*
* -
*
* Only one active message movement task is supported per queue at any given time.
*
*
*
*
*
* @param startMessageMoveTaskRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the StartMessageMoveTask operation returned by the service.
* @sample AmazonSQSAsyncHandler.StartMessageMoveTask
* @see AWS API
* Documentation
*/
java.util.concurrent.Future startMessageMoveTaskAsync(StartMessageMoveTaskRequest startMessageMoveTaskRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
*
* @param tagQueueRequest
* @return A Java Future containing the result of the TagQueue operation returned by the service.
* @sample AmazonSQSAsync.TagQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future tagQueueAsync(TagQueueRequest tagQueueRequest);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
*
* @param tagQueueRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the TagQueue operation returned by the service.
* @sample AmazonSQSAsyncHandler.TagQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future tagQueueAsync(TagQueueRequest tagQueueRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the TagQueue operation.
*
* @see #tagQueueAsync(TagQueueRequest)
*/
java.util.concurrent.Future tagQueueAsync(String queueUrl, java.util.Map tags);
/**
* Simplified method form for invoking the TagQueue operation with an AsyncHandler.
*
* @see #tagQueueAsync(TagQueueRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future tagQueueAsync(String queueUrl, java.util.Map tags,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
*
* @param untagQueueRequest
* @return A Java Future containing the result of the UntagQueue operation returned by the service.
* @sample AmazonSQSAsync.UntagQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future untagQueueAsync(UntagQueueRequest untagQueueRequest);
/**
*
* 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 username in the Amazon SQS Developer Guide.
*
*
*
* @param untagQueueRequest
* @param asyncHandler
* Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
* implementation of the callback methods in this interface to receive notification of successful or
* unsuccessful completion of the operation.
* @return A Java Future containing the result of the UntagQueue operation returned by the service.
* @sample AmazonSQSAsyncHandler.UntagQueue
* @see AWS API
* Documentation
*/
java.util.concurrent.Future untagQueueAsync(UntagQueueRequest untagQueueRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
* Simplified method form for invoking the UntagQueue operation.
*
* @see #untagQueueAsync(UntagQueueRequest)
*/
java.util.concurrent.Future untagQueueAsync(String queueUrl, java.util.List tagKeys);
/**
* Simplified method form for invoking the UntagQueue operation with an AsyncHandler.
*
* @see #untagQueueAsync(UntagQueueRequest, com.amazonaws.handlers.AsyncHandler)
*/
java.util.concurrent.Future untagQueueAsync(String queueUrl, java.util.List tagKeys,
com.amazonaws.handlers.AsyncHandler asyncHandler);
}