Java tutorial
/* * Copyright 2014-2019 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. * <p> * <b>Note:</b> Do not directly implement this interface, new methods are added to it regularly. Extend from * {@link com.amazonaws.services.sqs.AbstractAmazonSQSAsync} instead. * </p> * <p> * <p> * Welcome to the <i>Amazon Simple Queue Service API Reference</i>. * </p> * <p> * Amazon Simple Queue Service (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. * </p> * <p> * You can use <a href="http://aws.amazon.com/tools/#sdk">AWS SDKs</a> to access Amazon SQS using your favorite * programming language. The SDKs perform tasks such as the following automatically: * </p> * <ul> * <li> * <p> * Cryptographically sign your service requests * </p> * </li> * <li> * <p> * Retry requests * </p> * </li> * <li> * <p> * Handle error responses * </p> * </li> * </ul> * <p> * <b>Additional Information</b> * </p> * <ul> * <li> * <p> * <a href="http://aws.amazon.com/sqs/">Amazon SQS Product Page</a> * </p> * </li> * <li> * <p> * <i>Amazon Simple Queue Service Developer Guide</i> * </p> * <ul> * <li> * <p> * <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-making-api-requests.html"> * Making API Requests</a> * </p> * </li> * <li> * <p> * <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-attributes.html"> * Amazon SQS Message Attributes</a> * </p> * </li> * <li> * <p> * <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html"> * Amazon SQS Dead-Letter Queues</a> * </p> * </li> * </ul> * </li> * <li> * <p> * <a href="http://docs.aws.amazon.com/cli/latest/reference/sqs/index.html">Amazon SQS in the <i>AWS CLI Command * Reference</i> </a> * </p> * </li> * <li> * <p> * <i>Amazon Web Services General Reference</i> * </p> * <ul> * <li> * <p> * <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#sqs_region">Regions and Endpoints</a> * </p> * </li> * </ul> * </li> * </ul> */ @Generated("com.amazonaws:aws-java-sdk-code-generator") public interface AmazonSQSAsync extends AmazonSQS { /** * <p> * Adds a permission to a queue for a specific <a * href="https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#P">principal</a>. This allows sharing access * to the queue. * </p> * <p> * 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 <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-writing-an-sqs-policy.html#write-messages-to-shared-queue" * >Allow Developers to Write Messages to a Shared Queue</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * <note> * <ul> * <li> * <p> * <code>AddPermission</code> generates a policy for you. You can use <code> <a>SetQueueAttributes</a> </code> to * upload your policy. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-creating-custom-policies.html" * >Using Custom Policies with the Amazon SQS Access Policy Language</a> in the <i>Amazon Simple Queue Service * Developer Guide</i>. * </p> * </li> * <li> * <p> * An Amazon SQS policy can have a maximum of 7 actions. * </p> * </li> * <li> * <p> * To remove the ability to change queue permissions, you must deny permission to the <code>AddPermission</code>, * <code>RemovePermission</code>, and <code>SetQueueAttributes</code> actions in your IAM policy. * </p> * </li> * </ul> * </note> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @param addPermissionRequest * @return A Java Future containing the result of the AddPermission operation returned by the service. * @sample AmazonSQSAsync.AddPermission * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/AddPermission" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<AddPermissionResult> addPermissionAsync(AddPermissionRequest addPermissionRequest); /** * <p> * Adds a permission to a queue for a specific <a * href="https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#P">principal</a>. This allows sharing access * to the queue. * </p> * <p> * 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 <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-writing-an-sqs-policy.html#write-messages-to-shared-queue" * >Allow Developers to Write Messages to a Shared Queue</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * <note> * <ul> * <li> * <p> * <code>AddPermission</code> generates a policy for you. You can use <code> <a>SetQueueAttributes</a> </code> to * upload your policy. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-creating-custom-policies.html" * >Using Custom Policies with the Amazon SQS Access Policy Language</a> in the <i>Amazon Simple Queue Service * Developer Guide</i>. * </p> * </li> * <li> * <p> * An Amazon SQS policy can have a maximum of 7 actions. * </p> * </li> * <li> * <p> * To remove the ability to change queue permissions, you must deny permission to the <code>AddPermission</code>, * <code>RemovePermission</code>, and <code>SetQueueAttributes</code> actions in your IAM policy. * </p> * </li> * </ul> * </note> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/AddPermission" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<AddPermissionResult> addPermissionAsync(AddPermissionRequest addPermissionRequest, com.amazonaws.handlers.AsyncHandler<AddPermissionRequest, AddPermissionResult> asyncHandler); /** * Simplified method form for invoking the AddPermission operation. * * @see #addPermissionAsync(AddPermissionRequest) */ java.util.concurrent.Future<AddPermissionResult> addPermissionAsync(String queueUrl, String label, java.util.List<String> aWSAccountIds, java.util.List<String> actions); /** * Simplified method form for invoking the AddPermission operation with an AsyncHandler. * * @see #addPermissionAsync(AddPermissionRequest, com.amazonaws.handlers.AsyncHandler) */ java.util.concurrent.Future<AddPermissionResult> addPermissionAsync(String queueUrl, String label, java.util.List<String> aWSAccountIds, java.util.List<String> actions, com.amazonaws.handlers.AsyncHandler<AddPermissionRequest, AddPermissionResult> asyncHandler); /** * <p> * 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 <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html"> * Visibility Timeout</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * For example, you have a message with a visibility timeout of 5 minutes. After 3 minutes, you call * <code>ChangeMessageVisibility</code> with a timeout of 10 minutes. You can continue to call * <code>ChangeMessageVisibility</code> to extend the visibility timeout to the maximum allowed time. If you try to * extend the visibility timeout beyond the maximum, your request is rejected. * </p> * <p> * An Amazon SQS message has three basic states: * </p> * <ol> * <li> * <p> * Sent to a queue by a producer. * </p> * </li> * <li> * <p> * Received from the queue by a consumer. * </p> * </li> * <li> * <p> * Deleted from the queue. * </p> * </li> * </ol> * <p> * A message is considered to be <i>stored</i> 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 <i>in flight</i> after it is received from a queue by a consumer, but not yet deleted * from the queue (that is, between states 2 and 3). There is a limit to the number of inflight messages. * </p> * <p> * Limits that apply to inflight messages are unrelated to the <i>unlimited</i> number of stored messages. * </p> * <p> * For most standard queues (depending on queue traffic and message backlog), there can be a maximum of * approximately 120,000 inflight messages (received from a queue by a consumer, but not yet deleted from the * queue). If you reach this limit, Amazon SQS returns the <code>OverLimit</code> 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, <a href= * "https://console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase&limitType=service-code-sqs" * >file a support request</a>. * </p> * <p> * For FIFO queues, there can be a maximum of 20,000 inflight messages (received from a queue by a consumer, but not * yet deleted from the queue). If you reach this limit, Amazon SQS returns no error messages. * </p> * <important> * <p> * If you attempt to set the <code>VisibilityTimeout</code> 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. * </p> * <p> * 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 * <code>ChangeMessageVisibility</code> action) the next time the message is received. * </p> * </important> * * @param changeMessageVisibilityRequest * @return A Java Future containing the result of the ChangeMessageVisibility operation returned by the service. * @sample AmazonSQSAsync.ChangeMessageVisibility * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ChangeMessageVisibility" target="_top">AWS * API Documentation</a> */ java.util.concurrent.Future<ChangeMessageVisibilityResult> changeMessageVisibilityAsync( ChangeMessageVisibilityRequest changeMessageVisibilityRequest); /** * <p> * 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 <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html"> * Visibility Timeout</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * For example, you have a message with a visibility timeout of 5 minutes. After 3 minutes, you call * <code>ChangeMessageVisibility</code> with a timeout of 10 minutes. You can continue to call * <code>ChangeMessageVisibility</code> to extend the visibility timeout to the maximum allowed time. If you try to * extend the visibility timeout beyond the maximum, your request is rejected. * </p> * <p> * An Amazon SQS message has three basic states: * </p> * <ol> * <li> * <p> * Sent to a queue by a producer. * </p> * </li> * <li> * <p> * Received from the queue by a consumer. * </p> * </li> * <li> * <p> * Deleted from the queue. * </p> * </li> * </ol> * <p> * A message is considered to be <i>stored</i> 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 <i>in flight</i> after it is received from a queue by a consumer, but not yet deleted * from the queue (that is, between states 2 and 3). There is a limit to the number of inflight messages. * </p> * <p> * Limits that apply to inflight messages are unrelated to the <i>unlimited</i> number of stored messages. * </p> * <p> * For most standard queues (depending on queue traffic and message backlog), there can be a maximum of * approximately 120,000 inflight messages (received from a queue by a consumer, but not yet deleted from the * queue). If you reach this limit, Amazon SQS returns the <code>OverLimit</code> 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, <a href= * "https://console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase&limitType=service-code-sqs" * >file a support request</a>. * </p> * <p> * For FIFO queues, there can be a maximum of 20,000 inflight messages (received from a queue by a consumer, but not * yet deleted from the queue). If you reach this limit, Amazon SQS returns no error messages. * </p> * <important> * <p> * If you attempt to set the <code>VisibilityTimeout</code> 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. * </p> * <p> * 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 * <code>ChangeMessageVisibility</code> action) the next time the message is received. * </p> * </important> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ChangeMessageVisibility" target="_top">AWS * API Documentation</a> */ java.util.concurrent.Future<ChangeMessageVisibilityResult> changeMessageVisibilityAsync( ChangeMessageVisibilityRequest changeMessageVisibilityRequest, com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityRequest, ChangeMessageVisibilityResult> asyncHandler); /** * Simplified method form for invoking the ChangeMessageVisibility operation. * * @see #changeMessageVisibilityAsync(ChangeMessageVisibilityRequest) */ java.util.concurrent.Future<ChangeMessageVisibilityResult> 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<ChangeMessageVisibilityResult> changeMessageVisibilityAsync(String queueUrl, String receiptHandle, Integer visibilityTimeout, com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityRequest, ChangeMessageVisibilityResult> asyncHandler); /** * <p> * Changes the visibility timeout of multiple messages. This is a batch version of * <code> <a>ChangeMessageVisibility</a>.</code> The result of the action on each message is reported individually * in the response. You can send up to 10 <code> <a>ChangeMessageVisibility</a> </code> requests with each * <code>ChangeMessageVisibilityBatch</code> action. * </p> * <important> * <p> * 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 <code>200</code>. * </p> * </important> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * * @param changeMessageVisibilityBatchRequest * @return A Java Future containing the result of the ChangeMessageVisibilityBatch operation returned by the * service. * @sample AmazonSQSAsync.ChangeMessageVisibilityBatch * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ChangeMessageVisibilityBatch" * target="_top">AWS API Documentation</a> */ java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync( ChangeMessageVisibilityBatchRequest changeMessageVisibilityBatchRequest); /** * <p> * Changes the visibility timeout of multiple messages. This is a batch version of * <code> <a>ChangeMessageVisibility</a>.</code> The result of the action on each message is reported individually * in the response. You can send up to 10 <code> <a>ChangeMessageVisibility</a> </code> requests with each * <code>ChangeMessageVisibilityBatch</code> action. * </p> * <important> * <p> * 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 <code>200</code>. * </p> * </important> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ChangeMessageVisibilityBatch" * target="_top">AWS API Documentation</a> */ java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync( ChangeMessageVisibilityBatchRequest changeMessageVisibilityBatchRequest, com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityBatchRequest, ChangeMessageVisibilityBatchResult> asyncHandler); /** * Simplified method form for invoking the ChangeMessageVisibilityBatch operation. * * @see #changeMessageVisibilityBatchAsync(ChangeMessageVisibilityBatchRequest) */ java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync( String queueUrl, java.util.List<ChangeMessageVisibilityBatchRequestEntry> entries); /** * Simplified method form for invoking the ChangeMessageVisibilityBatch operation with an AsyncHandler. * * @see #changeMessageVisibilityBatchAsync(ChangeMessageVisibilityBatchRequest, com.amazonaws.handlers.AsyncHandler) */ java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync( String queueUrl, java.util.List<ChangeMessageVisibilityBatchRequestEntry> entries, com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityBatchRequest, ChangeMessageVisibilityBatchResult> asyncHandler); /** * <p> * Creates a new standard or FIFO queue. You can pass one or more attributes in the request. Keep the following * caveats in mind: * </p> * <ul> * <li> * <p> * If you don't specify the <code>FifoQueue</code> attribute, Amazon SQS creates a standard queue. * </p> * <note> * <p> * 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 <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-moving" * >Moving From a Standard Queue to a FIFO Queue</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * </note></li> * <li> * <p> * If you don't provide a value for an attribute, the queue is created with the default value for the attribute. * </p> * </li> * <li> * <p> * If you delete a queue, you must wait at least 60 seconds before creating a queue with the same name. * </p> * </li> * </ul> * <p> * To successfully create a new queue, you must provide a queue name that adheres to the <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/limits-queues.html">limits * related to queues</a> and is unique within the scope of your queues. * </p> * <p> * To get the queue URL, use the <code> <a>GetQueueUrl</a> </code> action. <code> <a>GetQueueUrl</a> </code> * requires only the <code>QueueName</code> parameter. be aware of existing queue names: * </p> * <ul> * <li> * <p> * If you provide the name of an existing queue along with the exact names and values of all the queue's attributes, * <code>CreateQueue</code> returns the queue URL for the existing queue. * </p> * </li> * <li> * <p> * If the queue name, attribute names, or attribute values don't match an existing queue, <code>CreateQueue</code> * returns an error. * </p> * </li> * </ul> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @param createQueueRequest * @return A Java Future containing the result of the CreateQueue operation returned by the service. * @sample AmazonSQSAsync.CreateQueue * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/CreateQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<CreateQueueResult> createQueueAsync(CreateQueueRequest createQueueRequest); /** * <p> * Creates a new standard or FIFO queue. You can pass one or more attributes in the request. Keep the following * caveats in mind: * </p> * <ul> * <li> * <p> * If you don't specify the <code>FifoQueue</code> attribute, Amazon SQS creates a standard queue. * </p> * <note> * <p> * 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 <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-moving" * >Moving From a Standard Queue to a FIFO Queue</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * </note></li> * <li> * <p> * If you don't provide a value for an attribute, the queue is created with the default value for the attribute. * </p> * </li> * <li> * <p> * If you delete a queue, you must wait at least 60 seconds before creating a queue with the same name. * </p> * </li> * </ul> * <p> * To successfully create a new queue, you must provide a queue name that adheres to the <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/limits-queues.html">limits * related to queues</a> and is unique within the scope of your queues. * </p> * <p> * To get the queue URL, use the <code> <a>GetQueueUrl</a> </code> action. <code> <a>GetQueueUrl</a> </code> * requires only the <code>QueueName</code> parameter. be aware of existing queue names: * </p> * <ul> * <li> * <p> * If you provide the name of an existing queue along with the exact names and values of all the queue's attributes, * <code>CreateQueue</code> returns the queue URL for the existing queue. * </p> * </li> * <li> * <p> * If the queue name, attribute names, or attribute values don't match an existing queue, <code>CreateQueue</code> * returns an error. * </p> * </li> * </ul> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/CreateQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<CreateQueueResult> createQueueAsync(CreateQueueRequest createQueueRequest, com.amazonaws.handlers.AsyncHandler<CreateQueueRequest, CreateQueueResult> asyncHandler); /** * Simplified method form for invoking the CreateQueue operation. * * @see #createQueueAsync(CreateQueueRequest) */ java.util.concurrent.Future<CreateQueueResult> 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<CreateQueueResult> createQueueAsync(String queueName, com.amazonaws.handlers.AsyncHandler<CreateQueueRequest, CreateQueueResult> asyncHandler); /** * <p> * Deletes the specified message from the specified queue. To select the message to delete, use the * <code>ReceiptHandle</code> of the message (<i>not</i> the <code>MessageId</code> 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. * </p> * <note> * <p> * The <code>ReceiptHandle</code> is associated with a <i>specific instance</i> of receiving a message. If you * receive a message more than once, the <code>ReceiptHandle</code> is different each time you receive a message. * When you use the <code>DeleteMessage</code> action, you must provide the most recently received * <code>ReceiptHandle</code> for the message (otherwise, the request succeeds, but the message might not be * deleted). * </p> * <p> * 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. * </p> * </note> * * @param deleteMessageRequest * @return A Java Future containing the result of the DeleteMessage operation returned by the service. * @sample AmazonSQSAsync.DeleteMessage * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/DeleteMessage" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<DeleteMessageResult> deleteMessageAsync(DeleteMessageRequest deleteMessageRequest); /** * <p> * Deletes the specified message from the specified queue. To select the message to delete, use the * <code>ReceiptHandle</code> of the message (<i>not</i> the <code>MessageId</code> 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. * </p> * <note> * <p> * The <code>ReceiptHandle</code> is associated with a <i>specific instance</i> of receiving a message. If you * receive a message more than once, the <code>ReceiptHandle</code> is different each time you receive a message. * When you use the <code>DeleteMessage</code> action, you must provide the most recently received * <code>ReceiptHandle</code> for the message (otherwise, the request succeeds, but the message might not be * deleted). * </p> * <p> * 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. * </p> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/DeleteMessage" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<DeleteMessageResult> deleteMessageAsync(DeleteMessageRequest deleteMessageRequest, com.amazonaws.handlers.AsyncHandler<DeleteMessageRequest, DeleteMessageResult> asyncHandler); /** * Simplified method form for invoking the DeleteMessage operation. * * @see #deleteMessageAsync(DeleteMessageRequest) */ java.util.concurrent.Future<DeleteMessageResult> 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<DeleteMessageResult> deleteMessageAsync(String queueUrl, String receiptHandle, com.amazonaws.handlers.AsyncHandler<DeleteMessageRequest, DeleteMessageResult> asyncHandler); /** * <p> * Deletes up to ten messages from the specified queue. This is a batch version of * <code> <a>DeleteMessage</a>.</code> The result of the action on each message is reported individually in the * response. * </p> * <important> * <p> * 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 <code>200</code>. * </p> * </important> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * * @param deleteMessageBatchRequest * @return A Java Future containing the result of the DeleteMessageBatch operation returned by the service. * @sample AmazonSQSAsync.DeleteMessageBatch * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/DeleteMessageBatch" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync( DeleteMessageBatchRequest deleteMessageBatchRequest); /** * <p> * Deletes up to ten messages from the specified queue. This is a batch version of * <code> <a>DeleteMessage</a>.</code> The result of the action on each message is reported individually in the * response. * </p> * <important> * <p> * 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 <code>200</code>. * </p> * </important> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/DeleteMessageBatch" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync( DeleteMessageBatchRequest deleteMessageBatchRequest, com.amazonaws.handlers.AsyncHandler<DeleteMessageBatchRequest, DeleteMessageBatchResult> asyncHandler); /** * Simplified method form for invoking the DeleteMessageBatch operation. * * @see #deleteMessageBatchAsync(DeleteMessageBatchRequest) */ java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(String queueUrl, java.util.List<DeleteMessageBatchRequestEntry> entries); /** * Simplified method form for invoking the DeleteMessageBatch operation with an AsyncHandler. * * @see #deleteMessageBatchAsync(DeleteMessageBatchRequest, com.amazonaws.handlers.AsyncHandler) */ java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(String queueUrl, java.util.List<DeleteMessageBatchRequestEntry> entries, com.amazonaws.handlers.AsyncHandler<DeleteMessageBatchRequest, DeleteMessageBatchResult> asyncHandler); /** * <p> * Deletes the queue specified by the <code>QueueUrl</code>, regardless of the queue's contents. If the specified * queue doesn't exist, Amazon SQS returns a successful response. * </p> * <important> * <p> * Be careful with the <code>DeleteQueue</code> action: When you delete a queue, any messages in the queue are no * longer available. * </p> * </important> * <p> * 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 <code> <a>SendMessage</a> </code> request might succeed, but * after 60 seconds the queue and the message you sent no longer exist. * </p> * <p> * When you delete a queue, you must wait at least 60 seconds before creating a queue with the same name. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @param deleteQueueRequest * @return A Java Future containing the result of the DeleteQueue operation returned by the service. * @sample AmazonSQSAsync.DeleteQueue * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/DeleteQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<DeleteQueueResult> deleteQueueAsync(DeleteQueueRequest deleteQueueRequest); /** * <p> * Deletes the queue specified by the <code>QueueUrl</code>, regardless of the queue's contents. If the specified * queue doesn't exist, Amazon SQS returns a successful response. * </p> * <important> * <p> * Be careful with the <code>DeleteQueue</code> action: When you delete a queue, any messages in the queue are no * longer available. * </p> * </important> * <p> * 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 <code> <a>SendMessage</a> </code> request might succeed, but * after 60 seconds the queue and the message you sent no longer exist. * </p> * <p> * When you delete a queue, you must wait at least 60 seconds before creating a queue with the same name. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/DeleteQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<DeleteQueueResult> deleteQueueAsync(DeleteQueueRequest deleteQueueRequest, com.amazonaws.handlers.AsyncHandler<DeleteQueueRequest, DeleteQueueResult> asyncHandler); /** * Simplified method form for invoking the DeleteQueue operation. * * @see #deleteQueueAsync(DeleteQueueRequest) */ java.util.concurrent.Future<DeleteQueueResult> 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<DeleteQueueResult> deleteQueueAsync(String queueUrl, com.amazonaws.handlers.AsyncHandler<DeleteQueueRequest, DeleteQueueResult> asyncHandler); /** * <p> * Gets attributes for the specified queue. * </p> * <note> * <p> * To determine whether a queue is <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO</a>, you * can check whether <code>QueueName</code> ends with the <code>.fifo</code> suffix. * </p> * </note> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * * @param getQueueAttributesRequest * @return A Java Future containing the result of the GetQueueAttributes operation returned by the service. * @sample AmazonSQSAsync.GetQueueAttributes * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/GetQueueAttributes" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync( GetQueueAttributesRequest getQueueAttributesRequest); /** * <p> * Gets attributes for the specified queue. * </p> * <note> * <p> * To determine whether a queue is <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO</a>, you * can check whether <code>QueueName</code> ends with the <code>.fifo</code> suffix. * </p> * </note> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/GetQueueAttributes" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync( GetQueueAttributesRequest getQueueAttributesRequest, com.amazonaws.handlers.AsyncHandler<GetQueueAttributesRequest, GetQueueAttributesResult> asyncHandler); /** * Simplified method form for invoking the GetQueueAttributes operation. * * @see #getQueueAttributesAsync(GetQueueAttributesRequest) */ java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(String queueUrl, java.util.List<String> attributeNames); /** * Simplified method form for invoking the GetQueueAttributes operation with an AsyncHandler. * * @see #getQueueAttributesAsync(GetQueueAttributesRequest, com.amazonaws.handlers.AsyncHandler) */ java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(String queueUrl, java.util.List<String> attributeNames, com.amazonaws.handlers.AsyncHandler<GetQueueAttributesRequest, GetQueueAttributesResult> asyncHandler); /** * <p> * Returns the URL of an existing Amazon SQS queue. * </p> * <p> * To access a queue that belongs to another AWS account, use the <code>QueueOwnerAWSAccountId</code> 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 <code> <a>AddPermission</a> </code> or see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-writing-an-sqs-policy.html#write-messages-to-shared-queue" * >Allow Developers to Write Messages to a Shared Queue</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * * @param getQueueUrlRequest * @return A Java Future containing the result of the GetQueueUrl operation returned by the service. * @sample AmazonSQSAsync.GetQueueUrl * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/GetQueueUrl" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(GetQueueUrlRequest getQueueUrlRequest); /** * <p> * Returns the URL of an existing Amazon SQS queue. * </p> * <p> * To access a queue that belongs to another AWS account, use the <code>QueueOwnerAWSAccountId</code> 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 <code> <a>AddPermission</a> </code> or see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-writing-an-sqs-policy.html#write-messages-to-shared-queue" * >Allow Developers to Write Messages to a Shared Queue</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/GetQueueUrl" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(GetQueueUrlRequest getQueueUrlRequest, com.amazonaws.handlers.AsyncHandler<GetQueueUrlRequest, GetQueueUrlResult> asyncHandler); /** * Simplified method form for invoking the GetQueueUrl operation. * * @see #getQueueUrlAsync(GetQueueUrlRequest) */ java.util.concurrent.Future<GetQueueUrlResult> 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<GetQueueUrlResult> getQueueUrlAsync(String queueName, com.amazonaws.handlers.AsyncHandler<GetQueueUrlRequest, GetQueueUrlResult> asyncHandler); /** * <p> * Returns a list of your queues that have the <code>RedrivePolicy</code> queue attribute configured with a * dead-letter queue. * </p> * <p> * For more information about using dead-letter queues, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html" * >Using Amazon SQS Dead-Letter Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * * @param listDeadLetterSourceQueuesRequest * @return A Java Future containing the result of the ListDeadLetterSourceQueues operation returned by the service. * @sample AmazonSQSAsync.ListDeadLetterSourceQueues * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ListDeadLetterSourceQueues" target="_top">AWS * API Documentation</a> */ java.util.concurrent.Future<ListDeadLetterSourceQueuesResult> listDeadLetterSourceQueuesAsync( ListDeadLetterSourceQueuesRequest listDeadLetterSourceQueuesRequest); /** * <p> * Returns a list of your queues that have the <code>RedrivePolicy</code> queue attribute configured with a * dead-letter queue. * </p> * <p> * For more information about using dead-letter queues, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html" * >Using Amazon SQS Dead-Letter Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ListDeadLetterSourceQueues" target="_top">AWS * API Documentation</a> */ java.util.concurrent.Future<ListDeadLetterSourceQueuesResult> listDeadLetterSourceQueuesAsync( ListDeadLetterSourceQueuesRequest listDeadLetterSourceQueuesRequest, com.amazonaws.handlers.AsyncHandler<ListDeadLetterSourceQueuesRequest, ListDeadLetterSourceQueuesResult> asyncHandler); /** * <p> * List all cost allocation tags added to the specified Amazon SQS queue. For an overview, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html">Tagging * Your Amazon SQS Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @param listQueueTagsRequest * @return A Java Future containing the result of the ListQueueTags operation returned by the service. * @sample AmazonSQSAsync.ListQueueTags * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ListQueueTags" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<ListQueueTagsResult> listQueueTagsAsync(ListQueueTagsRequest listQueueTagsRequest); /** * <p> * List all cost allocation tags added to the specified Amazon SQS queue. For an overview, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html">Tagging * Your Amazon SQS Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ListQueueTags" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<ListQueueTagsResult> listQueueTagsAsync(ListQueueTagsRequest listQueueTagsRequest, com.amazonaws.handlers.AsyncHandler<ListQueueTagsRequest, ListQueueTagsResult> asyncHandler); /** * Simplified method form for invoking the ListQueueTags operation. * * @see #listQueueTagsAsync(ListQueueTagsRequest) */ java.util.concurrent.Future<ListQueueTagsResult> 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<ListQueueTagsResult> listQueueTagsAsync(String queueUrl, com.amazonaws.handlers.AsyncHandler<ListQueueTagsRequest, ListQueueTagsResult> asyncHandler); /** * <p> * Returns a list of your queues. The maximum number of queues that can be returned is 1,000. If you specify a value * for the optional <code>QueueNamePrefix</code> parameter, only queues with a name that begins with the specified * value are returned. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @param listQueuesRequest * @return A Java Future containing the result of the ListQueues operation returned by the service. * @sample AmazonSQSAsync.ListQueues * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ListQueues" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(ListQueuesRequest listQueuesRequest); /** * <p> * Returns a list of your queues. The maximum number of queues that can be returned is 1,000. If you specify a value * for the optional <code>QueueNamePrefix</code> parameter, only queues with a name that begins with the specified * value are returned. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ListQueues" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(ListQueuesRequest listQueuesRequest, com.amazonaws.handlers.AsyncHandler<ListQueuesRequest, ListQueuesResult> asyncHandler); /** * Simplified method form for invoking the ListQueues operation. * * @see #listQueuesAsync(ListQueuesRequest) */ java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(); /** * Simplified method form for invoking the ListQueues operation with an AsyncHandler. * * @see #listQueuesAsync(ListQueuesRequest, com.amazonaws.handlers.AsyncHandler) */ java.util.concurrent.Future<ListQueuesResult> listQueuesAsync( com.amazonaws.handlers.AsyncHandler<ListQueuesRequest, ListQueuesResult> asyncHandler); /** * Simplified method form for invoking the ListQueues operation. * * @see #listQueuesAsync(ListQueuesRequest) */ java.util.concurrent.Future<ListQueuesResult> 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<ListQueuesResult> listQueuesAsync(String queueNamePrefix, com.amazonaws.handlers.AsyncHandler<ListQueuesRequest, ListQueuesResult> asyncHandler); /** * <p> * Deletes the messages in a queue specified by the <code>QueueURL</code> parameter. * </p> * <important> * <p> * When you use the <code>PurgeQueue</code> action, you can't retrieve any messages deleted from a queue. * </p> * <p> * The message deletion process takes up to 60 seconds. We recommend waiting for 60 seconds regardless of your * queue's size. * </p> * </important> * <p> * Messages sent to the queue <i>before</i> you call <code>PurgeQueue</code> might be received but are deleted * within the next minute. * </p> * <p> * Messages sent to the queue <i>after</i> you call <code>PurgeQueue</code> might be deleted while the queue is * being purged. * </p> * * @param purgeQueueRequest * @return A Java Future containing the result of the PurgeQueue operation returned by the service. * @sample AmazonSQSAsync.PurgeQueue * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/PurgeQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<PurgeQueueResult> purgeQueueAsync(PurgeQueueRequest purgeQueueRequest); /** * <p> * Deletes the messages in a queue specified by the <code>QueueURL</code> parameter. * </p> * <important> * <p> * When you use the <code>PurgeQueue</code> action, you can't retrieve any messages deleted from a queue. * </p> * <p> * The message deletion process takes up to 60 seconds. We recommend waiting for 60 seconds regardless of your * queue's size. * </p> * </important> * <p> * Messages sent to the queue <i>before</i> you call <code>PurgeQueue</code> might be received but are deleted * within the next minute. * </p> * <p> * Messages sent to the queue <i>after</i> you call <code>PurgeQueue</code> might be deleted while the queue is * being purged. * </p> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/PurgeQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<PurgeQueueResult> purgeQueueAsync(PurgeQueueRequest purgeQueueRequest, com.amazonaws.handlers.AsyncHandler<PurgeQueueRequest, PurgeQueueResult> asyncHandler); /** * <p> * Retrieves one or more messages (up to 10), from the specified queue. Using the <code>WaitTimeSeconds</code> * parameter enables long-poll support. For more information, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html">Amazon * SQS Long Polling</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * Short poll is the default behavior where a weighted random set of machines is sampled on a * <code>ReceiveMessage</code> 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 * <code>ReceiveMessage</code> call. If the number of messages in the queue is extremely small, you might not * receive any messages in a particular <code>ReceiveMessage</code> response. If this happens, repeat the request. * </p> * <p> * For each message returned, the response includes the following: * </p> * <ul> * <li> * <p> * The message body. * </p> * </li> * <li> * <p> * An MD5 digest of the message body. For information about MD5, see <a * href="https://www.ietf.org/rfc/rfc1321.txt">RFC1321</a>. * </p> * </li> * <li> * <p> * The <code>MessageId</code> you received when you sent the message to the queue. * </p> * </li> * <li> * <p> * The receipt handle. * </p> * </li> * <li> * <p> * The message attributes. * </p> * </li> * <li> * <p> * An MD5 digest of the message attributes. * </p> * </li> * </ul> * <p> * The receipt handle is the identifier you must provide when deleting the message. For more information, see <a * href * ="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-message-identifiers.html" * >Queue and Message Identifiers</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * You can provide the <code>VisibilityTimeout</code> 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 <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html" * >Visibility Timeout</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * 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. * </p> * <note> * <p> * 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. * </p> * </note> * * @param receiveMessageRequest * @return A Java Future containing the result of the ReceiveMessage operation returned by the service. * @sample AmazonSQSAsync.ReceiveMessage * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ReceiveMessage" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync( ReceiveMessageRequest receiveMessageRequest); /** * <p> * Retrieves one or more messages (up to 10), from the specified queue. Using the <code>WaitTimeSeconds</code> * parameter enables long-poll support. For more information, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html">Amazon * SQS Long Polling</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * Short poll is the default behavior where a weighted random set of machines is sampled on a * <code>ReceiveMessage</code> 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 * <code>ReceiveMessage</code> call. If the number of messages in the queue is extremely small, you might not * receive any messages in a particular <code>ReceiveMessage</code> response. If this happens, repeat the request. * </p> * <p> * For each message returned, the response includes the following: * </p> * <ul> * <li> * <p> * The message body. * </p> * </li> * <li> * <p> * An MD5 digest of the message body. For information about MD5, see <a * href="https://www.ietf.org/rfc/rfc1321.txt">RFC1321</a>. * </p> * </li> * <li> * <p> * The <code>MessageId</code> you received when you sent the message to the queue. * </p> * </li> * <li> * <p> * The receipt handle. * </p> * </li> * <li> * <p> * The message attributes. * </p> * </li> * <li> * <p> * An MD5 digest of the message attributes. * </p> * </li> * </ul> * <p> * The receipt handle is the identifier you must provide when deleting the message. For more information, see <a * href * ="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-message-identifiers.html" * >Queue and Message Identifiers</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * You can provide the <code>VisibilityTimeout</code> 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 <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html" * >Visibility Timeout</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * 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. * </p> * <note> * <p> * 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. * </p> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/ReceiveMessage" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync( ReceiveMessageRequest receiveMessageRequest, com.amazonaws.handlers.AsyncHandler<ReceiveMessageRequest, ReceiveMessageResult> asyncHandler); /** * Simplified method form for invoking the ReceiveMessage operation. * * @see #receiveMessageAsync(ReceiveMessageRequest) */ java.util.concurrent.Future<ReceiveMessageResult> 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<ReceiveMessageResult> receiveMessageAsync(String queueUrl, com.amazonaws.handlers.AsyncHandler<ReceiveMessageRequest, ReceiveMessageResult> asyncHandler); /** * <p> * Revokes any permissions in the queue policy that matches the specified <code>Label</code> parameter. * </p> * <note> * <ul> * <li> * <p> * Only the owner of a queue can remove permissions from it. * </p> * </li> * <li> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </li> * <li> * <p> * To remove the ability to change queue permissions, you must deny permission to the <code>AddPermission</code>, * <code>RemovePermission</code>, and <code>SetQueueAttributes</code> actions in your IAM policy. * </p> * </li> * </ul> * </note> * * @param removePermissionRequest * @return A Java Future containing the result of the RemovePermission operation returned by the service. * @sample AmazonSQSAsync.RemovePermission * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/RemovePermission" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<RemovePermissionResult> removePermissionAsync( RemovePermissionRequest removePermissionRequest); /** * <p> * Revokes any permissions in the queue policy that matches the specified <code>Label</code> parameter. * </p> * <note> * <ul> * <li> * <p> * Only the owner of a queue can remove permissions from it. * </p> * </li> * <li> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </li> * <li> * <p> * To remove the ability to change queue permissions, you must deny permission to the <code>AddPermission</code>, * <code>RemovePermission</code>, and <code>SetQueueAttributes</code> actions in your IAM policy. * </p> * </li> * </ul> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/RemovePermission" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<RemovePermissionResult> removePermissionAsync( RemovePermissionRequest removePermissionRequest, com.amazonaws.handlers.AsyncHandler<RemovePermissionRequest, RemovePermissionResult> asyncHandler); /** * Simplified method form for invoking the RemovePermission operation. * * @see #removePermissionAsync(RemovePermissionRequest) */ java.util.concurrent.Future<RemovePermissionResult> 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<RemovePermissionResult> removePermissionAsync(String queueUrl, String label, com.amazonaws.handlers.AsyncHandler<RemovePermissionRequest, RemovePermissionResult> asyncHandler); /** * <p> * Delivers a message to the specified queue. * </p> * <important> * <p> * A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed: * </p> * <p> * <code>#x9</code> | <code>#xA</code> | <code>#xD</code> | <code>#x20</code> to <code>#xD7FF</code> | * <code>#xE000</code> to <code>#xFFFD</code> | <code>#x10000</code> to <code>#x10FFFF</code> * </p> * <p> * Any characters not included in this list will be rejected. For more information, see the <a * href="http://www.w3.org/TR/REC-xml/#charsets">W3C specification for characters</a>. * </p> * </important> * * @param sendMessageRequest * @return A Java Future containing the result of the SendMessage operation returned by the service. * @sample AmazonSQSAsync.SendMessage * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/SendMessage" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<SendMessageResult> sendMessageAsync(SendMessageRequest sendMessageRequest); /** * <p> * Delivers a message to the specified queue. * </p> * <important> * <p> * A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed: * </p> * <p> * <code>#x9</code> | <code>#xA</code> | <code>#xD</code> | <code>#x20</code> to <code>#xD7FF</code> | * <code>#xE000</code> to <code>#xFFFD</code> | <code>#x10000</code> to <code>#x10FFFF</code> * </p> * <p> * Any characters not included in this list will be rejected. For more information, see the <a * href="http://www.w3.org/TR/REC-xml/#charsets">W3C specification for characters</a>. * </p> * </important> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/SendMessage" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<SendMessageResult> sendMessageAsync(SendMessageRequest sendMessageRequest, com.amazonaws.handlers.AsyncHandler<SendMessageRequest, SendMessageResult> asyncHandler); /** * Simplified method form for invoking the SendMessage operation. * * @see #sendMessageAsync(SendMessageRequest) */ java.util.concurrent.Future<SendMessageResult> 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<SendMessageResult> sendMessageAsync(String queueUrl, String messageBody, com.amazonaws.handlers.AsyncHandler<SendMessageRequest, SendMessageResult> asyncHandler); /** * <p> * Delivers up to ten messages to the specified queue. This is a batch version of <code> <a>SendMessage</a>.</code> * For a FIFO queue, multiple messages within a single batch are enqueued in the order they are sent. * </p> * <p> * 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 <code>200</code>. * </p> * <p> * The maximum allowed individual message size and the maximum total payload size (the sum of the individual lengths * of all of the batched messages) are both 256 KB (262,144 bytes). * </p> * <important> * <p> * A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed: * </p> * <p> * <code>#x9</code> | <code>#xA</code> | <code>#xD</code> | <code>#x20</code> to <code>#xD7FF</code> | * <code>#xE000</code> to <code>#xFFFD</code> | <code>#x10000</code> to <code>#x10FFFF</code> * </p> * <p> * Any characters not included in this list will be rejected. For more information, see the <a * href="http://www.w3.org/TR/REC-xml/#charsets">W3C specification for characters</a>. * </p> * </important> * <p> * If you don't specify the <code>DelaySeconds</code> parameter for an entry, Amazon SQS uses the default value for * the queue. * </p> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * * @param sendMessageBatchRequest * @return A Java Future containing the result of the SendMessageBatch operation returned by the service. * @sample AmazonSQSAsync.SendMessageBatch * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/SendMessageBatch" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync( SendMessageBatchRequest sendMessageBatchRequest); /** * <p> * Delivers up to ten messages to the specified queue. This is a batch version of <code> <a>SendMessage</a>.</code> * For a FIFO queue, multiple messages within a single batch are enqueued in the order they are sent. * </p> * <p> * 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 <code>200</code>. * </p> * <p> * The maximum allowed individual message size and the maximum total payload size (the sum of the individual lengths * of all of the batched messages) are both 256 KB (262,144 bytes). * </p> * <important> * <p> * A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed: * </p> * <p> * <code>#x9</code> | <code>#xA</code> | <code>#xD</code> | <code>#x20</code> to <code>#xD7FF</code> | * <code>#xE000</code> to <code>#xFFFD</code> | <code>#x10000</code> to <code>#x10FFFF</code> * </p> * <p> * Any characters not included in this list will be rejected. For more information, see the <a * href="http://www.w3.org/TR/REC-xml/#charsets">W3C specification for characters</a>. * </p> * </important> * <p> * If you don't specify the <code>DelaySeconds</code> parameter for an entry, Amazon SQS uses the default value for * the queue. * </p> * <p> * Some actions take lists of parameters. These lists are specified using the <code>param.n</code> notation. Values * of <code>n</code> are integers starting from 1. For example, a parameter list with two elements looks like this: * </p> * <p> * <code>&Attribute.1=first</code> * </p> * <p> * <code>&Attribute.2=second</code> * </p> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/SendMessageBatch" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync( SendMessageBatchRequest sendMessageBatchRequest, com.amazonaws.handlers.AsyncHandler<SendMessageBatchRequest, SendMessageBatchResult> asyncHandler); /** * Simplified method form for invoking the SendMessageBatch operation. * * @see #sendMessageBatchAsync(SendMessageBatchRequest) */ java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(String queueUrl, java.util.List<SendMessageBatchRequestEntry> entries); /** * Simplified method form for invoking the SendMessageBatch operation with an AsyncHandler. * * @see #sendMessageBatchAsync(SendMessageBatchRequest, com.amazonaws.handlers.AsyncHandler) */ java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(String queueUrl, java.util.List<SendMessageBatchRequestEntry> entries, com.amazonaws.handlers.AsyncHandler<SendMessageBatchRequest, SendMessageBatchResult> asyncHandler); /** * <p> * Sets the value of one or more queue attributes. When you change a queue's attributes, the change can take up to * 60 seconds for most of the attributes to propagate throughout the Amazon SQS system. Changes made to the * <code>MessageRetentionPeriod</code> attribute can take up to 15 minutes. * </p> * <note> * <ul> * <li> * <p> * 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. * </p> * </li> * <li> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </li> * <li> * <p> * To remove the ability to change queue permissions, you must deny permission to the <code>AddPermission</code>, * <code>RemovePermission</code>, and <code>SetQueueAttributes</code> actions in your IAM policy. * </p> * </li> * </ul> * </note> * * @param setQueueAttributesRequest * @return A Java Future containing the result of the SetQueueAttributes operation returned by the service. * @sample AmazonSQSAsync.SetQueueAttributes * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/SetQueueAttributes" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<SetQueueAttributesResult> setQueueAttributesAsync( SetQueueAttributesRequest setQueueAttributesRequest); /** * <p> * Sets the value of one or more queue attributes. When you change a queue's attributes, the change can take up to * 60 seconds for most of the attributes to propagate throughout the Amazon SQS system. Changes made to the * <code>MessageRetentionPeriod</code> attribute can take up to 15 minutes. * </p> * <note> * <ul> * <li> * <p> * 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. * </p> * </li> * <li> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </li> * <li> * <p> * To remove the ability to change queue permissions, you must deny permission to the <code>AddPermission</code>, * <code>RemovePermission</code>, and <code>SetQueueAttributes</code> actions in your IAM policy. * </p> * </li> * </ul> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/SetQueueAttributes" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<SetQueueAttributesResult> setQueueAttributesAsync( SetQueueAttributesRequest setQueueAttributesRequest, com.amazonaws.handlers.AsyncHandler<SetQueueAttributesRequest, SetQueueAttributesResult> asyncHandler); /** * Simplified method form for invoking the SetQueueAttributes operation. * * @see #setQueueAttributesAsync(SetQueueAttributesRequest) */ java.util.concurrent.Future<SetQueueAttributesResult> setQueueAttributesAsync(String queueUrl, java.util.Map<String, String> attributes); /** * Simplified method form for invoking the SetQueueAttributes operation with an AsyncHandler. * * @see #setQueueAttributesAsync(SetQueueAttributesRequest, com.amazonaws.handlers.AsyncHandler) */ java.util.concurrent.Future<SetQueueAttributesResult> setQueueAttributesAsync(String queueUrl, java.util.Map<String, String> attributes, com.amazonaws.handlers.AsyncHandler<SetQueueAttributesRequest, SetQueueAttributesResult> asyncHandler); /** * <p> * Add cost allocation tags to the specified Amazon SQS queue. For an overview, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html">Tagging * Your Amazon SQS Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * When you use queue tags, keep the following guidelines in mind: * </p> * <ul> * <li> * <p> * Adding more than 50 tags to a queue isn't recommended. * </p> * </li> * <li> * <p> * Tags don't have any semantic meaning. Amazon SQS interprets tags as character strings. * </p> * </li> * <li> * <p> * Tags are case-sensitive. * </p> * </li> * <li> * <p> * A new tag with a key identical to that of an existing tag overwrites the existing tag. * </p> * </li> * </ul> * <p> * For a full list of tag restrictions, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-limits.html#limits-queues" * >Limits Related to Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @param tagQueueRequest * @return A Java Future containing the result of the TagQueue operation returned by the service. * @sample AmazonSQSAsync.TagQueue * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/TagQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<TagQueueResult> tagQueueAsync(TagQueueRequest tagQueueRequest); /** * <p> * Add cost allocation tags to the specified Amazon SQS queue. For an overview, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html">Tagging * Your Amazon SQS Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <p> * When you use queue tags, keep the following guidelines in mind: * </p> * <ul> * <li> * <p> * Adding more than 50 tags to a queue isn't recommended. * </p> * </li> * <li> * <p> * Tags don't have any semantic meaning. Amazon SQS interprets tags as character strings. * </p> * </li> * <li> * <p> * Tags are case-sensitive. * </p> * </li> * <li> * <p> * A new tag with a key identical to that of an existing tag overwrites the existing tag. * </p> * </li> * </ul> * <p> * For a full list of tag restrictions, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-limits.html#limits-queues" * >Limits Related to Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/TagQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<TagQueueResult> tagQueueAsync(TagQueueRequest tagQueueRequest, com.amazonaws.handlers.AsyncHandler<TagQueueRequest, TagQueueResult> asyncHandler); /** * Simplified method form for invoking the TagQueue operation. * * @see #tagQueueAsync(TagQueueRequest) */ java.util.concurrent.Future<TagQueueResult> tagQueueAsync(String queueUrl, java.util.Map<String, String> tags); /** * Simplified method form for invoking the TagQueue operation with an AsyncHandler. * * @see #tagQueueAsync(TagQueueRequest, com.amazonaws.handlers.AsyncHandler) */ java.util.concurrent.Future<TagQueueResult> tagQueueAsync(String queueUrl, java.util.Map<String, String> tags, com.amazonaws.handlers.AsyncHandler<TagQueueRequest, TagQueueResult> asyncHandler); /** * <p> * Remove cost allocation tags from the specified Amazon SQS queue. For an overview, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html">Tagging * Your Amazon SQS Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @param untagQueueRequest * @return A Java Future containing the result of the UntagQueue operation returned by the service. * @sample AmazonSQSAsync.UntagQueue * @see <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/UntagQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<UntagQueueResult> untagQueueAsync(UntagQueueRequest untagQueueRequest); /** * <p> * Remove cost allocation tags from the specified Amazon SQS queue. For an overview, see <a * href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html">Tagging * Your Amazon SQS Queues</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. * </p> * <note> * <p> * Cross-account permissions don't apply to this action. For more information, see <a href= * "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name" * >Grant Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple Queue Service Developer * Guide</i>. * </p> * </note> * * @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 <a href="http://docs.aws.amazon.com/goto/WebAPI/sqs-2012-11-05/UntagQueue" target="_top">AWS API * Documentation</a> */ java.util.concurrent.Future<UntagQueueResult> untagQueueAsync(UntagQueueRequest untagQueueRequest, com.amazonaws.handlers.AsyncHandler<UntagQueueRequest, UntagQueueResult> asyncHandler); /** * Simplified method form for invoking the UntagQueue operation. * * @see #untagQueueAsync(UntagQueueRequest) */ java.util.concurrent.Future<UntagQueueResult> untagQueueAsync(String queueUrl, java.util.List<String> tagKeys); /** * Simplified method form for invoking the UntagQueue operation with an AsyncHandler. * * @see #untagQueueAsync(UntagQueueRequest, com.amazonaws.handlers.AsyncHandler) */ java.util.concurrent.Future<UntagQueueResult> untagQueueAsync(String queueUrl, java.util.List<String> tagKeys, com.amazonaws.handlers.AsyncHandler<UntagQueueRequest, UntagQueueResult> asyncHandler); }