com.amazonaws.services.sqs.AmazonSQSAsync Maven / Gradle / Ivy
Show all versions of aws-java-sdk-sqs Show documentation
/*
* Copyright 2011-2016 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 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.
*
*
* Welcome to the Amazon Simple Queue Service API Reference. This section describes who should read this guide,
* how the guide is organized, and other resources related to the Amazon Simple Queue Service (Amazon SQS).
*
*
* Amazon SQS offers reliable and scalable hosted queues for storing messages as they travel between computers. By using
* Amazon SQS, you can move data between distributed components of your applications that perform different tasks
* without losing messages or requiring each component to be always available.
*
*
* Helpful Links:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* We also provide SDKs that enable you to access Amazon SQS from your preferred programming language. The SDKs contain
* functionality that automatically takes care of tasks such as:
*
*
* -
*
* Cryptographically signing your service requests
*
*
* -
*
* Retrying requests
*
*
* -
*
* Handling error responses
*
*
*
*
* For a list of available SDKs, go to Tools for Amazon Web Services.
*
*/
public interface AmazonSQSAsync extends AmazonSQS {
/**
*
* Adds a permission to a queue for a specific principal. This allows for sharing
* access to the queue.
*
*
* When you create a queue, you have full control access rights for the queue. Only you (as owner of the queue) can
* grant or deny permissions to the queue. For more information about these permissions, see Shared
* Queues in the Amazon SQS Developer Guide.
*
*
*
* AddPermission writes an Amazon SQS-generated policy. If you want to write your own policy, use
* SetQueueAttributes to upload your policy. For more information about writing your own policy, see Using
* The Access Policy Language in the Amazon SQS Developer Guide.
*
*
*
* Some API 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:
*
*
*
*
*
*
*
* @param addPermissionRequest
* @return A Java Future containing the result of the AddPermission operation returned by the service.
* @sample AmazonSQSAsync.AddPermission
*/
java.util.concurrent.Future addPermissionAsync(AddPermissionRequest addPermissionRequest);
/**
*
* Adds a permission to a queue for a specific principal. This allows for sharing
* access to the queue.
*
*
* When you create a queue, you have full control access rights for the queue. Only you (as owner of the queue) can
* grant or deny permissions to the queue. For more information about these permissions, see Shared
* Queues in the Amazon SQS Developer Guide.
*
*
*
* AddPermission writes an Amazon SQS-generated policy. If you want to write your own policy, use
* SetQueueAttributes to upload your policy. For more information about writing your own policy, see Using
* The Access Policy Language in the Amazon SQS Developer Guide.
*
*
*
* Some API 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:
*
*
*
*
*
*
*
* @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
*/
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);
/**
*
* Changes the visibility timeout of a specified message in a queue to a new value. The maximum allowed timeout
* value you can set the value to is 12 hours. This means you can't extend the timeout of a message in an existing
* queue to more than a total visibility timeout of 12 hours. (For more information visibility timeout, see Visibility
* Timeout in the Amazon SQS Developer Guide.)
*
*
* For example, let's say you have a message and its default message visibility timeout is 5 minutes. After 3
* minutes, you call ChangeMessageVisiblity with a timeout of 10 minutes. At that time, the timeout for
* the message would be extended by 10 minutes beyond the time of the ChangeMessageVisibility call. This results in
* a total visibility timeout of 13 minutes. You can continue to call ChangeMessageVisibility to extend the
* visibility timeout to a maximum of 12 hours. If you try to extend beyond 12 hours, the request will be rejected.
*
*
*
* There is a 120,000 limit for the number of inflight messages per queue. Messages are inflight after they have
* been received from the queue by a consuming component, but have not yet been deleted from the queue. If you reach
* the 120,000 limit, you will receive an OverLimit error message from Amazon SQS. To help avoid reaching the limit,
* you should delete the messages from the queue after they have been processed. You can also increase the number of
* queues you use to process the messages.
*
*
*
* If you attempt to set the VisibilityTimeout to an amount more than the maximum time left, Amazon SQS
* returns an error. It will not automatically recalculate and increase the timeout to the maximum time remaining.
*
*
*
* Unlike with a queue, when you change the visibility timeout for a specific message, that timeout value is applied
* immediately but is not saved in memory for that message. If you don't delete a message after it is received, the
* visibility timeout for the message the next time it is received reverts to the original timeout value, not the
* value you set with the ChangeMessageVisibility action.
*
*
*
* @param changeMessageVisibilityRequest
* @return A Java Future containing the result of the ChangeMessageVisibility operation returned by the service.
* @sample AmazonSQSAsync.ChangeMessageVisibility
*/
java.util.concurrent.Future changeMessageVisibilityAsync(ChangeMessageVisibilityRequest changeMessageVisibilityRequest);
/**
*
* Changes the visibility timeout of a specified message in a queue to a new value. The maximum allowed timeout
* value you can set the value to is 12 hours. This means you can't extend the timeout of a message in an existing
* queue to more than a total visibility timeout of 12 hours. (For more information visibility timeout, see Visibility
* Timeout in the Amazon SQS Developer Guide.)
*
*
* For example, let's say you have a message and its default message visibility timeout is 5 minutes. After 3
* minutes, you call ChangeMessageVisiblity with a timeout of 10 minutes. At that time, the timeout for
* the message would be extended by 10 minutes beyond the time of the ChangeMessageVisibility call. This results in
* a total visibility timeout of 13 minutes. You can continue to call ChangeMessageVisibility to extend the
* visibility timeout to a maximum of 12 hours. If you try to extend beyond 12 hours, the request will be rejected.
*
*
*
* There is a 120,000 limit for the number of inflight messages per queue. Messages are inflight after they have
* been received from the queue by a consuming component, but have not yet been deleted from the queue. If you reach
* the 120,000 limit, you will receive an OverLimit error message from Amazon SQS. To help avoid reaching the limit,
* you should delete the messages from the queue after they have been processed. You can also increase the number of
* queues you use to process the messages.
*
*
*
* If you attempt to set the VisibilityTimeout to an amount more than the maximum time left, Amazon SQS
* returns an error. It will not automatically recalculate and increase the timeout to the maximum time remaining.
*
*
*
* Unlike with a queue, when you change the visibility timeout for a specific message, that timeout value is applied
* immediately but is not saved in memory for that message. If you don't delete a message after it is received, the
* visibility timeout for the message the next time it is received reverts to the original timeout value, not the
* value you set with the ChangeMessageVisibility action.
*
*
*
* @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
*/
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.
*
*
*
* Some API 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:
*
*
*
*
*
*
*
* @param changeMessageVisibilityBatchRequest
* @return A Java Future containing the result of the ChangeMessageVisibilityBatch operation returned by the
* service.
* @sample AmazonSQSAsync.ChangeMessageVisibilityBatch
*/
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.
*
*
*
* Some API 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:
*
*
*
*
*
*
*
* @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
*/
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 queue, or returns the URL of an existing one. When you request CreateQueue, you
* provide a name for the queue. To successfully create a new queue, you must provide a name that is unique within
* the scope of your own queues.
*
*
*
* If you delete a queue, you must wait at least 60 seconds before creating a queue with the same name.
*
*
*
* You may pass one or more attributes in the request. If you do not provide a value for any attribute, the queue
* will have the default value for that attribute.
*
*
*
* Use GetQueueUrl to get a queue's URL. GetQueueUrl requires only the QueueName
* parameter.
*
*
*
* 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 do not match an existing queue, CreateQueue returns an error.
*
*
*
* Some API 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:
*
*
*
*
*
*
*
* @param createQueueRequest
* @return A Java Future containing the result of the CreateQueue operation returned by the service.
* @sample AmazonSQSAsync.CreateQueue
*/
java.util.concurrent.Future createQueueAsync(CreateQueueRequest createQueueRequest);
/**
*
* Creates a new queue, or returns the URL of an existing one. When you request CreateQueue, you
* provide a name for the queue. To successfully create a new queue, you must provide a name that is unique within
* the scope of your own queues.
*
*
*
* If you delete a queue, you must wait at least 60 seconds before creating a queue with the same name.
*
*
*
* You may pass one or more attributes in the request. If you do not provide a value for any attribute, the queue
* will have the default value for that attribute.
*
*
*
* Use GetQueueUrl to get a queue's URL. GetQueueUrl requires only the QueueName
* parameter.
*
*
*
* 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 do not match an existing queue, CreateQueue returns an error.
*
*
*
* Some API 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:
*
*
*
*
*
*
*
* @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
*/
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. You specify the message by using the message's
* receipt handle and not the message ID you received when you sent the message. Even if
* the message is locked by another reader due to the visibility timeout setting, it is still deleted from the
* queue. If you leave a message in the queue for longer than the queue's configured retention period, Amazon SQS
* automatically deletes it.
*
*
*
* The receipt handle is associated with a specific instance of receiving the message. If you receive a message more
* than once, the receipt handle you get each time you receive the message is different. When you request
* DeleteMessage, if you don't provide the most recently received receipt handle for the message, the
* request will still succeed, but the message might not be deleted.
*
*
*
* It is possible you will receive a message even after you have deleted it. This might happen on rare occasions if
* one of the servers storing a copy of the message is unavailable when you request to delete the message. The copy
* remains on the server and might be returned to you again on a subsequent receive request. You should create your
* system to be idempotent so that receiving a particular message more than once is not a problem.
*
*
*
* @param deleteMessageRequest
* @return A Java Future containing the result of the DeleteMessage operation returned by the service.
* @sample AmazonSQSAsync.DeleteMessage
*/
java.util.concurrent.Future deleteMessageAsync(DeleteMessageRequest deleteMessageRequest);
/**
*
* Deletes the specified message from the specified queue. You specify the message by using the message's
* receipt handle and not the message ID you received when you sent the message. Even if
* the message is locked by another reader due to the visibility timeout setting, it is still deleted from the
* queue. If you leave a message in the queue for longer than the queue's configured retention period, Amazon SQS
* automatically deletes it.
*
*
*
* The receipt handle is associated with a specific instance of receiving the message. If you receive a message more
* than once, the receipt handle you get each time you receive the message is different. When you request
* DeleteMessage, if you don't provide the most recently received receipt handle for the message, the
* request will still succeed, but the message might not be deleted.
*
*
*
* It is possible you will receive a message even after you have deleted it. This might happen on rare occasions if
* one of the servers storing a copy of the message is unavailable when you request to delete the message. The copy
* remains on the server and might be returned to you again on a subsequent receive request. You should create your
* system to be idempotent so that receiving a particular message more than once is not a problem.
*
*
*
* @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
*/
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 delete 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 API 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:
*
*
*
*
*
*
*
* @param deleteMessageBatchRequest
* @return A Java Future containing the result of the DeleteMessageBatch operation returned by the service.
* @sample AmazonSQSAsync.DeleteMessageBatch
*/
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 delete 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 API 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:
*
*
*
*
*
*
*
* @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
*/
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 queue URL, regardless of whether the queue is empty. If the specified
* queue does not exist, Amazon SQS returns a successful response.
*
*
*
* Use DeleteQueue with care; once you delete your 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 the 60
* seconds, the queue and that message you sent no longer exist. Also, when you delete a queue, you must wait at
* least 60 seconds before creating a queue with the same name.
*
*
* We reserve the right to delete queues that have had no activity for more than 30 days. For more information, see
* How Amazon
* SQS Queues Work in the Amazon SQS Developer Guide.
*
*
* @param deleteQueueRequest
* @return A Java Future containing the result of the DeleteQueue operation returned by the service.
* @sample AmazonSQSAsync.DeleteQueue
*/
java.util.concurrent.Future deleteQueueAsync(DeleteQueueRequest deleteQueueRequest);
/**
*
* Deletes the queue specified by the queue URL, regardless of whether the queue is empty. If the specified
* queue does not exist, Amazon SQS returns a successful response.
*
*
*
* Use DeleteQueue with care; once you delete your 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 the 60
* seconds, the queue and that message you sent no longer exist. Also, when you delete a queue, you must wait at
* least 60 seconds before creating a queue with the same name.
*
*
* We reserve the right to delete queues that have had no activity for more than 30 days. For more information, see
* How Amazon
* SQS Queues Work in the Amazon SQS Developer Guide.
*
*
* @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
*/
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.
*
*
*
* Some API 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:
*
*
*
*
*
*
*
* @param getQueueAttributesRequest
* @return A Java Future containing the result of the GetQueueAttributes operation returned by the service.
* @sample AmazonSQSAsync.GetQueueAttributes
*/
java.util.concurrent.Future getQueueAttributesAsync(GetQueueAttributesRequest getQueueAttributesRequest);
/**
*
* Gets attributes for the specified queue.
*
*
*
* Some API 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:
*
*
*
*
*
*
*
* @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
*/
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 queue. This action provides a simple way to retrieve the URL of an 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 go to Shared
* Queues 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
*/
java.util.concurrent.Future getQueueUrlAsync(GetQueueUrlRequest getQueueUrlRequest);
/**
*
* Returns the URL of an existing queue. This action provides a simple way to retrieve the URL of an 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 go to Shared
* Queues 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
*/
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.
*
*
* For more information about using dead letter queues, see Using
* Amazon SQS Dead Letter Queues.
*
*
* @param listDeadLetterSourceQueuesRequest
* @return A Java Future containing the result of the ListDeadLetterSourceQueues operation returned by the service.
* @sample AmazonSQSAsync.ListDeadLetterSourceQueues
*/
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.
*
*
* For more information about using dead letter queues, see Using
* Amazon SQS Dead Letter Queues.
*
*
* @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
*/
java.util.concurrent.Future listDeadLetterSourceQueuesAsync(
ListDeadLetterSourceQueuesRequest listDeadLetterSourceQueuesRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Returns a list of your queues. The maximum number of queues that can be returned is 1000. If you specify a value
* for the optional QueueNamePrefix parameter, only queues with a name beginning with the specified
* value are returned.
*
*
* @param listQueuesRequest
* @return A Java Future containing the result of the ListQueues operation returned by the service.
* @sample AmazonSQSAsync.ListQueues
*/
java.util.concurrent.Future listQueuesAsync(ListQueuesRequest listQueuesRequest);
/**
*
* Returns a list of your queues. The maximum number of queues that can be returned is 1000. If you specify a value
* for the optional QueueNamePrefix parameter, only queues with a name beginning with the specified
* value are returned.
*
*
* @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
*/
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 the messages in a queue specified by the queue URL.
*
*
*
* When you use the PurgeQueue API, the deleted messages in the queue cannot be retrieved.
*
*
*
* When you purge a queue, the message deletion process takes up to 60 seconds. All messages sent to the queue
* before calling PurgeQueue will be deleted; messages sent to the queue while it is being purged may
* be deleted. While the queue is being purged, messages sent to the queue before PurgeQueue was called
* may be received, but will be deleted within the next minute.
*
*
* @param purgeQueueRequest
* @return A Java Future containing the result of the PurgeQueue operation returned by the service.
* @sample AmazonSQSAsync.PurgeQueue
*/
java.util.concurrent.Future purgeQueueAsync(PurgeQueueRequest purgeQueueRequest);
/**
*
* Deletes the messages in a queue specified by the queue URL.
*
*
*
* When you use the PurgeQueue API, the deleted messages in the queue cannot be retrieved.
*
*
*
* When you purge a queue, the message deletion process takes up to 60 seconds. All messages sent to the queue
* before calling PurgeQueue will be deleted; messages sent to the queue while it is being purged may
* be deleted. While the queue is being purged, messages sent to the queue before PurgeQueue was called
* may be received, but will be deleted within the next minute.
*
*
* @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
*/
java.util.concurrent.Future purgeQueueAsync(PurgeQueueRequest purgeQueueRequest,
com.amazonaws.handlers.AsyncHandler asyncHandler);
/**
*
* Retrieves one or more messages, with a maximum limit of 10 messages, from the specified queue. Long poll support
* is enabled by using the WaitTimeSeconds parameter. For more information, see Amazon SQS
* Long Poll 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. This means only the messages on the sampled machines are returned. If the
* number of messages in the queue is small (less than 1000), it is likely you will 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; in which case you should
* repeat the request.
*
*
* For each message returned, the response includes the following:
*
*
* -
*
* Message body
*
*
* -
*
* MD5 digest of the message body. For information about MD5, go to http://www.faqs.org/rfcs/rfc1321.html.
*
*
* -
*
* Message ID you received when you sent the message to the queue.
*
*
* -
*
* Receipt handle.
*
*
* -
*
* Message attributes.
*
*
* -
*
* 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, which will be applied to the
* messages that Amazon SQS returns in the response. If you do not 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.
*
*
*
* Going forward, new attributes might be added. If you are writing 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
*/
java.util.concurrent.Future receiveMessageAsync(ReceiveMessageRequest receiveMessageRequest);
/**
*
* Retrieves one or more messages, with a maximum limit of 10 messages, from the specified queue. Long poll support
* is enabled by using the WaitTimeSeconds parameter. For more information, see Amazon SQS
* Long Poll 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. This means only the messages on the sampled machines are returned. If the
* number of messages in the queue is small (less than 1000), it is likely you will 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; in which case you should
* repeat the request.
*
*
* For each message returned, the response includes the following:
*
*
* -
*
* Message body
*
*
* -
*
* MD5 digest of the message body. For information about MD5, go to http://www.faqs.org/rfcs/rfc1321.html.
*
*
* -
*
* Message ID you received when you sent the message to the queue.
*
*
* -
*
* Receipt handle.
*
*
* -
*
* Message attributes.
*
*
* -
*
* 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, which will be applied to the
* messages that Amazon SQS returns in the response. If you do not 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.
*
*
*
* Going forward, new attributes might be added. If you are writing 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
*/
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 the queue can remove permissions.
*
*
* @param removePermissionRequest
* @return A Java Future containing the result of the RemovePermission operation returned by the service.
* @sample AmazonSQSAsync.RemovePermission
*/
java.util.concurrent.Future removePermissionAsync(RemovePermissionRequest removePermissionRequest);
/**
*
* Revokes any permissions in the queue policy that matches the specified Label parameter. Only the
* owner of the queue can remove permissions.
*
*
* @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
*/
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. With Amazon SQS, you now have the ability to send large payload
* messages that are up to 256KB (262,144 bytes) in size. To send large payloads, you must use an AWS SDK that
* supports SigV4 signing. To verify whether SigV4 is supported for an AWS SDK, check the SDK release notes.
*
*
*
* The following list shows the characters (in Unicode) allowed in your message, according to the W3C XML
* specification. For more information, go to http://www.w3.org/TR/REC-xml/#charsets If you send any
* characters not included in the list, your request will be rejected.
*
*
* #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
*
*
*
* @param sendMessageRequest
* @return A Java Future containing the result of the SendMessage operation returned by the service.
* @sample AmazonSQSAsync.SendMessage
*/
java.util.concurrent.Future sendMessageAsync(SendMessageRequest sendMessageRequest);
/**
*
* Delivers a message to the specified queue. With Amazon SQS, you now have the ability to send large payload
* messages that are up to 256KB (262,144 bytes) in size. To send large payloads, you must use an AWS SDK that
* supports SigV4 signing. To verify whether SigV4 is supported for an AWS SDK, check the SDK release notes.
*
*
*
* The following list shows the characters (in Unicode) allowed in your message, according to the W3C XML
* specification. For more information, go to http://www.w3.org/TR/REC-xml/#charsets If you send any
* characters not included in the list, your request will be rejected.
*
*
* #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
*
*
*
* @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
*/
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);
/**
*
* Delivers up to ten messages to the specified queue. This is a batch version of SendMessage. The result of
* the send action on each message is reported individually in the response. The maximum allowed individual message
* size is 256 KB (262,144 bytes).
*
*
* The maximum total payload size (i.e., the sum of all a batch's individual message lengths) is also 256 KB
* (262,144 bytes).
*
*
* If the DelaySeconds parameter is not specified for an entry, the default for the queue is used.
*
*
*
* The following list shows the characters (in Unicode) that are allowed in your message, according to the W3C XML
* specification. For more information, go to http://www.faqs.org/rfcs/rfc1321.html. If you send any
* characters that are not included in the list, your request will be rejected.
*
*
* #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
*
*
*
* 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 API 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:
*
*
*
*
*
*
*
* @param sendMessageBatchRequest
* @return A Java Future containing the result of the SendMessageBatch operation returned by the service.
* @sample AmazonSQSAsync.SendMessageBatch
*/
java.util.concurrent.Future sendMessageBatchAsync(SendMessageBatchRequest sendMessageBatchRequest);
/**
*
* Delivers up to ten messages to the specified queue. This is a batch version of SendMessage. The result of
* the send action on each message is reported individually in the response. The maximum allowed individual message
* size is 256 KB (262,144 bytes).
*
*
* The maximum total payload size (i.e., the sum of all a batch's individual message lengths) is also 256 KB
* (262,144 bytes).
*
*
* If the DelaySeconds parameter is not specified for an entry, the default for the queue is used.
*
*
*
* The following list shows the characters (in Unicode) that are allowed in your message, according to the W3C XML
* specification. For more information, go to http://www.faqs.org/rfcs/rfc1321.html. If you send any
* characters that are not included in the list, your request will be rejected.
*
*
* #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
*
*
*
* 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 API 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:
*
*
*
*
*
*
*
* @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
*/
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. When you change a queue's attributes, the change can take up to
* 60 seconds for most of the attributes to propagate throughout the SQS system. Changes made to the
* MessageRetentionPeriod attribute can take up to 15 minutes.
*
*
*
* Going forward, new attributes might be added. If you are writing code that calls this action, we recommend that
* you structure your code so that it can handle new attributes gracefully.
*
*
*
* @param setQueueAttributesRequest
* @return A Java Future containing the result of the SetQueueAttributes operation returned by the service.
* @sample AmazonSQSAsync.SetQueueAttributes
*/
java.util.concurrent.Future setQueueAttributesAsync(SetQueueAttributesRequest setQueueAttributesRequest);
/**
*
* 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 SQS system. Changes made to the
* MessageRetentionPeriod attribute can take up to 15 minutes.
*
*
*
* Going forward, new attributes might be added. If you are writing code that calls this action, we recommend that
* you structure your code so that it can handle new attributes gracefully.
*
*
*
* @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
*/
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);
}