com.amazonaws.services.sqs.AmazonSQSClient Maven / Gradle / Ivy
Show all versions of aws-sdk-android Show documentation
/*
* Copyright 2010-2015 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 org.w3c.dom.*;
import java.net.*;
import java.util.*;
import java.util.Map.Entry;
import com.amazonaws.*;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.services.sqs.model.*;
import com.amazonaws.services.sqs.model.transform.*;
/**
* Client for accessing AmazonSQS. All service calls made
* using this client are blocking, and will not return until the service call
* completes.
*
* Amazon Simple Queue Service
* Welcome to the Amazon Simple Queue Service API Reference . This
* section describes who should read this guide, how the guide is
* organized, and other resources related to the Amazon Simple Queue
* Service (Amazon SQS).
*
*
* Amazon SQS offers reliable and scalable hosted queues for storing
* messages as they travel between computers. By using Amazon SQS, you
* can move data between distributed components of your applications that
* perform different tasks without losing messages or requiring each
* component to be always available.
*
*
* Helpful Links:
*
* -
* Current WSDL (2012-11-05)
*
* -
* Making API Requests
*
* -
* Amazon SQS product page
*
* -
* Using Amazon SQS Dead Letter Queues
*
* -
* Regions and Endpoints
*
*
*
*
*
*
* We also provide SDKs that enable you to access Amazon SQS from your
* preferred programming language. The SDKs contain functionality that
* automatically takes care of tasks such as:
*
*
*
*
* - Cryptographically signing your service requests
* - Retrying requests
* - Handling error responses
*
*
*
*
*
* For a list of available SDKs, go to
* Tools for Amazon Web Services
* .
*
*/
public class AmazonSQSClient extends AmazonWebServiceClient implements AmazonSQS {
/** Provider for AWS credentials. */
private AWSCredentialsProvider awsCredentialsProvider;
/**
* List of exception unmarshallers for all AmazonSQS exceptions.
*/
protected final List> exceptionUnmarshallers
= new ArrayList>();
/**
* Constructs a new client to invoke service methods on
* AmazonSQS. A credentials provider chain will be used
* that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @see DefaultAWSCredentialsProviderChain
*/
public AmazonSQSClient() {
this(new DefaultAWSCredentialsProviderChain(), new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on
* AmazonSQS. A credentials provider chain will be used
* that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param clientConfiguration The client configuration options controlling how this
* client connects to AmazonSQS
* (ex: proxy settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
*/
public AmazonSQSClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on
* AmazonSQS using the specified AWS account credentials.
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param awsCredentials The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
*/
public AmazonSQSClient(AWSCredentials awsCredentials) {
this(awsCredentials, new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on
* AmazonSQS using the specified AWS account credentials
* and client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param awsCredentials The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
* @param clientConfiguration The client configuration options controlling how this
* client connects to AmazonSQS
* (ex: proxy settings, retry counts, etc.).
*/
public AmazonSQSClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
init();
}
/**
* Constructs a new client to invoke service methods on
* AmazonSQS using the specified AWS account credentials provider.
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
*/
public AmazonSQSClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, new ClientConfiguration());
}
/**
* Constructs a new client to invoke service methods on
* AmazonSQS using the specified AWS account credentials
* provider and client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
* @param clientConfiguration The client configuration options controlling how this
* client connects to AmazonSQS
* (ex: proxy settings, retry counts, etc.).
*/
public AmazonSQSClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on
* AmazonSQS using the specified AWS account credentials
* provider, client configuration options, and request metric collector.
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
* @param clientConfiguration The client configuration options controlling how this
* client connects to AmazonSQS
* (ex: proxy settings, retry counts, etc.).
* @param requestMetricCollector optional request metric collector
*/
public AmazonSQSClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
private void init() {
exceptionUnmarshallers.add(new QueueDeletedRecentlyExceptionUnmarshaller());
exceptionUnmarshallers.add(new QueueNameExistsExceptionUnmarshaller());
exceptionUnmarshallers.add(new EmptyBatchRequestExceptionUnmarshaller());
exceptionUnmarshallers.add(new UnsupportedOperationExceptionUnmarshaller());
exceptionUnmarshallers.add(new InvalidMessageContentsExceptionUnmarshaller());
exceptionUnmarshallers.add(new InvalidBatchEntryIdExceptionUnmarshaller());
exceptionUnmarshallers.add(new OverLimitExceptionUnmarshaller());
exceptionUnmarshallers.add(new TooManyEntriesInBatchRequestExceptionUnmarshaller());
exceptionUnmarshallers.add(new InvalidIdFormatExceptionUnmarshaller());
exceptionUnmarshallers.add(new QueueDoesNotExistExceptionUnmarshaller());
exceptionUnmarshallers.add(new InvalidAttributeNameExceptionUnmarshaller());
exceptionUnmarshallers.add(new BatchRequestTooLongExceptionUnmarshaller());
exceptionUnmarshallers.add(new ReceiptHandleIsInvalidExceptionUnmarshaller());
exceptionUnmarshallers.add(new MessageNotInflightExceptionUnmarshaller());
exceptionUnmarshallers.add(new BatchEntryIdsNotDistinctExceptionUnmarshaller());
exceptionUnmarshallers.add(new StandardErrorUnmarshaller());
// calling this.setEndPoint(...) will also modify the signer accordingly
this.setEndpoint("sqs.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain(
"/com/amazonaws/services/sqs/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain(
"/com/amazonaws/services/sqs/request.handler2s"));
}
/**
*
* Sets the value of one or more queue attributes. When you change a
* queue's attributes, the change can take up to 60 seconds for most of
* the attributes to propagate throughout the SQS system. Changes made to
* the MessageRetentionPeriod attribute can take up to 15
* minutes.
*
*
* NOTE:Going forward, new attributes might be added. If you are
* writing code that calls this action, we recommend that you structure
* your code so that it can handle new attributes gracefully.
*
*
* @param setQueueAttributesRequest Container for the necessary
* parameters to execute the SetQueueAttributes service method on
* AmazonSQS.
*
*
* @throws InvalidAttributeNameException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void setQueueAttributes(SetQueueAttributesRequest setQueueAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(setQueueAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new SetQueueAttributesRequestMarshaller().marshall(setQueueAttributesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
invoke(request, null, executionContext);
} finally {
endClientExecution(awsRequestMetrics, request, null);
}
}
/**
*
* Changes the visibility timeout of multiple messages. This is a batch
* version of ChangeMessageVisibility. The result of the action on each
* message is reported individually in the response. You can send up to
* 10 ChangeMessageVisibility requests with each
* ChangeMessageVisibilityBatch action.
*
*
* IMPORTANT:Because the batch request can result in a
* combination of successful and unsuccessful actions, you should check
* for batch errors even when the call returns an HTTP status code of
* 200.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param changeMessageVisibilityBatchRequest Container for the necessary
* parameters to execute the ChangeMessageVisibilityBatch service method
* on AmazonSQS.
*
* @return The response from the ChangeMessageVisibilityBatch service
* method, as returned by AmazonSQS.
*
* @throws BatchEntryIdsNotDistinctException
* @throws TooManyEntriesInBatchRequestException
* @throws InvalidBatchEntryIdException
* @throws EmptyBatchRequestException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public ChangeMessageVisibilityBatchResult changeMessageVisibilityBatch(ChangeMessageVisibilityBatchRequest changeMessageVisibilityBatchRequest) {
ExecutionContext executionContext = createExecutionContext(changeMessageVisibilityBatchRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new ChangeMessageVisibilityBatchRequestMarshaller().marshall(changeMessageVisibilityBatchRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new ChangeMessageVisibilityBatchResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Changes the visibility timeout of a specified message in a queue to a
* new value. The maximum allowed timeout value you can set the value to
* is 12 hours. This means you can't extend the timeout of a message in
* an existing queue to more than a total visibility timeout of 12 hours.
* (For more information visibility timeout, see
* Visibility Timeout
* in the Amazon SQS Developer Guide .)
*
*
* For example, let's say you have a message and its default message
* visibility timeout is 30 minutes. You could call
* ChangeMessageVisiblity with a value of two hours and the
* effective timeout would be two hours and 30 minutes. When that time
* comes near you could again extend the time out by calling
* ChangeMessageVisiblity, but this time the maximum allowed timeout
* would be 9 hours and 30 minutes.
*
*
* NOTE: There is a 120,000 limit for the number of inflight
* messages per queue. Messages are inflight after they have been
* received from the queue by a consuming component, but have not yet
* been deleted from the queue. If you reach the 120,000 limit, you will
* receive an OverLimit error message from Amazon SQS. To help avoid
* reaching the limit, you should delete the messages from the queue
* after they have been processed. You can also increase the number of
* queues you use to process the messages.
*
*
* IMPORTANT:If you attempt to set the VisibilityTimeout to an
* amount more than the maximum time left, Amazon SQS returns an error.
* It will not automatically recalculate and increase the timeout to the
* maximum time remaining.
*
*
* IMPORTANT:Unlike with a queue, when you change the visibility
* timeout for a specific message, that timeout value is applied
* immediately but is not saved in memory for that message. If you don't
* delete a message after it is received, the visibility timeout for the
* message the next time it is received reverts to the original timeout
* value, not the value you set with the ChangeMessageVisibility action.
*
*
* @param changeMessageVisibilityRequest Container for the necessary
* parameters to execute the ChangeMessageVisibility service method on
* AmazonSQS.
*
*
* @throws ReceiptHandleIsInvalidException
* @throws MessageNotInflightException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void changeMessageVisibility(ChangeMessageVisibilityRequest changeMessageVisibilityRequest) {
ExecutionContext executionContext = createExecutionContext(changeMessageVisibilityRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new ChangeMessageVisibilityRequestMarshaller().marshall(changeMessageVisibilityRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
invoke(request, null, executionContext);
} finally {
endClientExecution(awsRequestMetrics, request, null);
}
}
/**
*
* Returns the URL of an existing queue. This action provides a simple
* way to retrieve the URL of an Amazon SQS queue.
*
*
* To access a queue that belongs to another AWS account, use the
* QueueOwnerAWSAccountId parameter to specify the account
* ID of the queue's owner. The queue's owner must grant you permission
* to access the queue. For more information about shared queue access,
* see AddPermission or go to
* Shared Queues
* in the Amazon SQS Developer Guide .
*
*
* @param getQueueUrlRequest Container for the necessary parameters to
* execute the GetQueueUrl service method on AmazonSQS.
*
* @return The response from the GetQueueUrl service method, as returned
* by AmazonSQS.
*
* @throws QueueDoesNotExistException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public GetQueueUrlResult getQueueUrl(GetQueueUrlRequest getQueueUrlRequest) {
ExecutionContext executionContext = createExecutionContext(getQueueUrlRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new GetQueueUrlRequestMarshaller().marshall(getQueueUrlRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new GetQueueUrlResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Revokes any permissions in the queue policy that matches the
* specified Label parameter. Only the owner of the queue
* can remove permissions.
*
*
* @param removePermissionRequest Container for the necessary parameters
* to execute the RemovePermission service method on AmazonSQS.
*
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void removePermission(RemovePermissionRequest removePermissionRequest) {
ExecutionContext executionContext = createExecutionContext(removePermissionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new RemovePermissionRequestMarshaller().marshall(removePermissionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
invoke(request, null, executionContext);
} finally {
endClientExecution(awsRequestMetrics, request, null);
}
}
/**
*
* Gets attributes for the specified queue. The following attributes are
* supported:
*
* -
All - returns all values.
* -
ApproximateNumberOfMessages - returns the
* approximate number of visible messages in a queue. For more
* information, see
* Resources Required to Process Messages
* in the Amazon SQS Developer Guide .
* -
ApproximateNumberOfMessagesNotVisible - returns the
* approximate number of messages that are not timed-out and not deleted.
* For more information, see
* Resources Required to Process Messages
* in the Amazon SQS Developer Guide .
* -
VisibilityTimeout - returns the visibility timeout
* for the queue. For more information about visibility timeout, see
* Visibility Timeout
* in the Amazon SQS Developer Guide .
* -
CreatedTimestamp - returns the time when the queue
* was created (epoch time in seconds).
* -
LastModifiedTimestamp - returns the time when the
* queue was last changed (epoch time in seconds).
* -
Policy - returns the queue's policy.
* -
MaximumMessageSize - returns the limit of how many
* bytes a message can contain before Amazon SQS rejects it.
* -
MessageRetentionPeriod - returns the number of
* seconds Amazon SQS retains a message.
* -
QueueArn - returns the queue's Amazon resource name
* (ARN).
* -
ApproximateNumberOfMessagesDelayed - returns the
* approximate number of messages that are pending to be added to the
* queue.
* -
DelaySeconds - returns the default delay on the
* queue in seconds.
* -
ReceiveMessageWaitTimeSeconds - returns the time
* for which a ReceiveMessage call will wait for a message to
* arrive.
* -
RedrivePolicy - returns the parameters for dead
* letter queue functionality of the source queue. For more information
* about RedrivePolicy and dead letter queues, see
* Using Amazon SQS Dead Letter Queues
* in the Amazon SQS Developer Guide .
*
*
*
*
*
* NOTE:Going forward, new attributes might be added. If you are
* writing code that calls this action, we recommend that you structure
* your code so that it can handle new attributes gracefully.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param getQueueAttributesRequest Container for the necessary
* parameters to execute the GetQueueAttributes service method on
* AmazonSQS.
*
* @return The response from the GetQueueAttributes service method, as
* returned by AmazonSQS.
*
* @throws InvalidAttributeNameException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public GetQueueAttributesResult getQueueAttributes(GetQueueAttributesRequest getQueueAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(getQueueAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new GetQueueAttributesRequestMarshaller().marshall(getQueueAttributesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new GetQueueAttributesResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Delivers up to ten messages to the specified queue. This is a batch
* version of SendMessage. The result of the send action on each message
* is reported individually in the response. The maximum allowed
* individual message size is 256 KB (262,144 bytes).
*
*
* The maximum total payload size (i.e., the sum of all a batch's
* individual message lengths) is also 256 KB (262,144 bytes).
*
*
* If the DelaySeconds parameter is not specified for an
* entry, the default for the queue is used.
*
*
* IMPORTANT:The following list shows the characters (in Unicode)
* that are allowed in your message, according to the W3C XML
* specification. For more information, go to
* http://www.faqs.org/rfcs/rfc1321.html. If you send any characters that
* are not included in the list, your request will be rejected. #x9 | #xA
* | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
*
*
* IMPORTANT: Because the batch request can result in a
* combination of successful and unsuccessful actions, you should check
* for batch errors even when the call returns an HTTP status code of
* 200.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param sendMessageBatchRequest Container for the necessary parameters
* to execute the SendMessageBatch service method on AmazonSQS.
*
* @return The response from the SendMessageBatch service method, as
* returned by AmazonSQS.
*
* @throws BatchEntryIdsNotDistinctException
* @throws TooManyEntriesInBatchRequestException
* @throws BatchRequestTooLongException
* @throws UnsupportedOperationException
* @throws InvalidBatchEntryIdException
* @throws EmptyBatchRequestException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public SendMessageBatchResult sendMessageBatch(SendMessageBatchRequest sendMessageBatchRequest) {
ExecutionContext executionContext = createExecutionContext(sendMessageBatchRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new SendMessageBatchRequestMarshaller().marshall(sendMessageBatchRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new SendMessageBatchResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of your queues that have the RedrivePolicy queue
* attribute configured with a dead letter queue.
*
*
* For more information about using dead letter queues, see
* Using Amazon SQS Dead Letter Queues
* .
*
*
* @param listDeadLetterSourceQueuesRequest Container for the necessary
* parameters to execute the ListDeadLetterSourceQueues service method on
* AmazonSQS.
*
* @return The response from the ListDeadLetterSourceQueues service
* method, as returned by AmazonSQS.
*
* @throws QueueDoesNotExistException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public ListDeadLetterSourceQueuesResult listDeadLetterSourceQueues(ListDeadLetterSourceQueuesRequest listDeadLetterSourceQueuesRequest) {
ExecutionContext executionContext = createExecutionContext(listDeadLetterSourceQueuesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new ListDeadLetterSourceQueuesRequestMarshaller().marshall(listDeadLetterSourceQueuesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new ListDeadLetterSourceQueuesResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the queue specified by the queue URL , regardless of
* whether the queue is empty. If the specified queue does not exist,
* Amazon SQS returns a successful response.
*
*
* IMPORTANT: Use DeleteQueue with care; once you delete your
* queue, any messages in the queue are no longer available.
*
*
* When you delete a queue, the deletion process takes up to 60 seconds.
* Requests you send involving that queue during the 60 seconds might
* succeed. For example, a SendMessage request might succeed, but after
* the 60 seconds, the queue and that message you sent no longer exist.
* Also, when you delete a queue, you must wait at least 60 seconds
* before creating a queue with the same name.
*
*
* We reserve the right to delete queues that have had no activity for
* more than 30 days. For more information, see
* How Amazon SQS Queues Work
* in the Amazon SQS Developer Guide .
*
*
* @param deleteQueueRequest Container for the necessary parameters to
* execute the DeleteQueue service method on AmazonSQS.
*
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void deleteQueue(DeleteQueueRequest deleteQueueRequest) {
ExecutionContext executionContext = createExecutionContext(deleteQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new DeleteQueueRequestMarshaller().marshall(deleteQueueRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
invoke(request, null, executionContext);
} finally {
endClientExecution(awsRequestMetrics, request, null);
}
}
/**
*
* Delivers a message to the specified queue. With Amazon SQS, you now
* have the ability to send large payload messages that are up to 256KB
* (262,144 bytes) in size. To send large payloads, you must use an AWS
* SDK that supports SigV4 signing. To verify whether SigV4 is supported
* for an AWS SDK, check the SDK release notes.
*
*
* IMPORTANT: The following list shows the characters (in
* Unicode) allowed in your message, according to the W3C XML
* specification. For more information, go to
* http://www.w3.org/TR/REC-xml/#charsets If you send any characters not
* included in the list, your request will be rejected. #x9 | #xA | #xD |
* [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
*
*
* @param sendMessageRequest Container for the necessary parameters to
* execute the SendMessage service method on AmazonSQS.
*
* @return The response from the SendMessage service method, as returned
* by AmazonSQS.
*
* @throws InvalidMessageContentsException
* @throws UnsupportedOperationException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public SendMessageResult sendMessage(SendMessageRequest sendMessageRequest) {
ExecutionContext executionContext = createExecutionContext(sendMessageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new SendMessageRequestMarshaller().marshall(sendMessageRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new SendMessageResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves one or more messages, with a maximum limit of 10 messages,
* from the specified queue. Long poll support is enabled by using the
* WaitTimeSeconds parameter. For more information, see
* Amazon SQS Long Poll
* in the Amazon SQS Developer Guide .
*
*
* Short poll is the default behavior where a weighted random set of
* machines is sampled on a ReceiveMessage call. This means
* only the messages on the sampled machines are returned. If the number
* of messages in the queue is small (less than 1000), it is likely you
* will get fewer messages than you requested per
* ReceiveMessage call. If the number of messages in the
* queue is extremely small, you might not receive any messages in a
* particular ReceiveMessage response; in which case you
* should repeat the request.
*
*
* For each message returned, the response includes the following:
*
*
*
* -
* Message body
*
*
* -
* MD5 digest of the message body. For information about MD5, go to
* http://www.faqs.org/rfcs/rfc1321.html
* .
*
*
* -
* Message ID you received when you sent the message to the queue.
*
*
* -
* Receipt handle.
*
*
* -
* Message attributes.
*
*
* -
* MD5 digest of the message attributes.
*
*
*
*
*
* The receipt handle is the identifier you must provide when deleting
* the message. For more information, see
* Queue and Message Identifiers
* in the Amazon SQS Developer Guide .
*
*
* You can provide the VisibilityTimeout parameter in your
* request, which will be applied to the messages that Amazon SQS returns
* in the response. If you do not include the parameter, the overall
* visibility timeout for the queue is used for the returned messages.
* For more information, see
* Visibility Timeout
* in the Amazon SQS Developer Guide .
*
*
* NOTE: Going forward, new attributes might be added. If you are
* writing code that calls this action, we recommend that you structure
* your code so that it can handle new attributes gracefully.
*
*
* @param receiveMessageRequest Container for the necessary parameters to
* execute the ReceiveMessage service method on AmazonSQS.
*
* @return The response from the ReceiveMessage service method, as
* returned by AmazonSQS.
*
* @throws OverLimitException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public ReceiveMessageResult receiveMessage(ReceiveMessageRequest receiveMessageRequest) {
ExecutionContext executionContext = createExecutionContext(receiveMessageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new ReceiveMessageRequestMarshaller().marshall(receiveMessageRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new ReceiveMessageResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of your queues. The maximum number of queues that can
* be returned is 1000. If you specify a value for the optional
* QueueNamePrefix parameter, only queues with a name
* beginning with the specified value are returned.
*
*
* @param listQueuesRequest Container for the necessary parameters to
* execute the ListQueues service method on AmazonSQS.
*
* @return The response from the ListQueues service method, as returned
* by AmazonSQS.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public ListQueuesResult listQueues(ListQueuesRequest listQueuesRequest) {
ExecutionContext executionContext = createExecutionContext(listQueuesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new ListQueuesRequestMarshaller().marshall(listQueuesRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new ListQueuesResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes multiple messages. This is a batch version of DeleteMessage.
* The result of the delete action on each message is reported
* individually in the response.
*
*
* IMPORTANT: Because the batch request can result in a
* combination of successful and unsuccessful actions, you should check
* for batch errors even when the call returns an HTTP status code of
* 200.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param deleteMessageBatchRequest Container for the necessary
* parameters to execute the DeleteMessageBatch service method on
* AmazonSQS.
*
* @return The response from the DeleteMessageBatch service method, as
* returned by AmazonSQS.
*
* @throws BatchEntryIdsNotDistinctException
* @throws TooManyEntriesInBatchRequestException
* @throws InvalidBatchEntryIdException
* @throws EmptyBatchRequestException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public DeleteMessageBatchResult deleteMessageBatch(DeleteMessageBatchRequest deleteMessageBatchRequest) {
ExecutionContext executionContext = createExecutionContext(deleteMessageBatchRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new DeleteMessageBatchRequestMarshaller().marshall(deleteMessageBatchRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new DeleteMessageBatchResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a new queue, or returns the URL of an existing one. When you
* request CreateQueue , you provide a name for the queue.
* To successfully create a new queue, you must provide a name that is
* unique within the scope of your own queues.
*
*
* NOTE: If you delete a queue, you must wait at least 60 seconds
* before creating a queue with the same name.
*
*
* You may pass one or more attributes in the request. If you do not
* provide a value for any attribute, the queue will have the default
* value for that attribute. Permitted attributes are the same that can
* be set using SetQueueAttributes.
*
*
* NOTE: Use GetQueueUrl to get a queue's URL. GetQueueUrl
* requires only the QueueName parameter.
*
*
* If you provide the name of an existing queue, along with the exact
* names and values of all the queue's attributes,
* CreateQueue returns the queue URL for the existing queue.
* If the queue name, attribute names, or attribute values do not match
* an existing queue, CreateQueue returns an error.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param createQueueRequest Container for the necessary parameters to
* execute the CreateQueue service method on AmazonSQS.
*
* @return The response from the CreateQueue service method, as returned
* by AmazonSQS.
*
* @throws QueueNameExistsException
* @throws QueueDeletedRecentlyException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public CreateQueueResult createQueue(CreateQueueRequest createQueueRequest) {
ExecutionContext executionContext = createExecutionContext(createQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
Response response = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new CreateQueueRequestMarshaller().marshall(createQueueRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
response = invoke(request, new CreateQueueResultStaxUnmarshaller(), executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds a permission to a queue for a specific
* principal
* . This allows for sharing access to the queue.
*
*
* When you create a queue, you have full control access rights for the
* queue. Only you (as owner of the queue) can grant or deny permissions
* to the queue. For more information about these permissions, see
* Shared Queues
* in the Amazon SQS Developer Guide .
*
*
* NOTE: AddPermission writes an Amazon SQS-generated policy. If
* you want to write your own policy, use SetQueueAttributes to upload
* your policy. For more information about writing your own policy, see
* Using The Access Policy Language in the Amazon SQS Developer Guide.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param addPermissionRequest Container for the necessary parameters to
* execute the AddPermission service method on AmazonSQS.
*
*
* @throws OverLimitException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void addPermission(AddPermissionRequest addPermissionRequest) {
ExecutionContext executionContext = createExecutionContext(addPermissionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new AddPermissionRequestMarshaller().marshall(addPermissionRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
invoke(request, null, executionContext);
} finally {
endClientExecution(awsRequestMetrics, request, null);
}
}
/**
*
* Deletes the specified message from the specified queue. You specify
* the message by using the message's receipt handle and not
* the message ID you received when you sent the message.
* Even if the message is locked by another reader due to the visibility
* timeout setting, it is still deleted from the queue. If you leave a
* message in the queue for longer than the queue's configured retention
* period, Amazon SQS automatically deletes it.
*
*
* NOTE: The receipt handle is associated with a specific
* instance of receiving the message. If you receive a message more than
* once, the receipt handle you get each time you receive the message is
* different. When you request DeleteMessage, if you don't provide the
* most recently received receipt handle for the message, the request
* will still succeed, but the message might not be deleted.
*
*
* IMPORTANT: It is possible you will receive a message even
* after you have deleted it. This might happen on rare occasions if one
* of the servers storing a copy of the message is unavailable when you
* request to delete the message. The copy remains on the server and
* might be returned to you again on a subsequent receive request. You
* should create your system to be idempotent so that receiving a
* particular message more than once is not a problem.
*
*
* @param deleteMessageRequest Container for the necessary parameters to
* execute the DeleteMessage service method on AmazonSQS.
*
*
* @throws ReceiptHandleIsInvalidException
* @throws InvalidIdFormatException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void deleteMessage(DeleteMessageRequest deleteMessageRequest) {
ExecutionContext executionContext = createExecutionContext(deleteMessageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
Request request = null;
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
try {
request = new DeleteMessageRequestMarshaller().marshall(deleteMessageRequest);
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
invoke(request, null, executionContext);
} finally {
endClientExecution(awsRequestMetrics, request, null);
}
}
/**
*
* Returns a list of your queues. The maximum number of queues that can
* be returned is 1000. If you specify a value for the optional
* QueueNamePrefix parameter, only queues with a name
* beginning with the specified value are returned.
*
*
* @return The response from the ListQueues service method, as returned
* by AmazonSQS.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public ListQueuesResult listQueues() throws AmazonServiceException, AmazonClientException {
return listQueues(new ListQueuesRequest());
}
/**
*
* Sets the value of one or more queue attributes. When you change a
* queue's attributes, the change can take up to 60 seconds for most of
* the attributes to propagate throughout the SQS system. Changes made to
* the MessageRetentionPeriod attribute can take up to 15
* minutes.
*
*
* NOTE:Going forward, new attributes might be added. If you are
* writing code that calls this action, we recommend that you structure
* your code so that it can handle new attributes gracefully.
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param attributes A map of attributes to set. The following lists
* the names, descriptions, and values of the special request parameters
* the SetQueueAttributes action uses:
* DelaySeconds - The time in seconds that the delivery
* of all messages in the queue will be delayed. An integer from 0 to 900
* (15 minutes). The default for this attribute is 0 (zero).MaximumMessageSize - The limit of how many bytes a
* message can contain before Amazon SQS rejects it. An integer from 1024
* bytes (1 KiB) up to 262144 bytes (256 KiB). The default for this
* attribute is 262144 (256 KiB).MessageRetentionPeriod - The number of seconds Amazon
* SQS retains a message. Integer representing seconds, from 60 (1
* minute) to 1209600 (14 days). The default for this attribute is 345600
* (4 days).Policy - The queue's policy. A valid
* form-url-encoded policy. For more information about policy structure,
* see Basic
* Policy Structure in the Amazon SQS Developer Guide. For
* more information about form-url-encoding, see http://www.w3.org/MarkUp/html-spec/html-spec_8.html#SEC8.2.1.ReceiveMessageWaitTimeSeconds - The time for which a
* ReceiveMessage call will wait for a message to arrive. An integer from
* 0 to 20 (seconds). The default for this attribute is 0. VisibilityTimeout - The visibility timeout for the
* queue. An integer from 0 to 43200 (12 hours). The default for this
* attribute is 30. For more information about visibility timeout, see
* Visibility Timeout in the Amazon SQS Developer Guide.RedrivePolicy - The parameters for dead letter queue
* functionality of the source queue. For more information about
* RedrivePolicy and dead letter queues, see Using Amazon SQS Dead Letter
* Queues in the Amazon SQS Developer Guide.
*
* @return The response from the SetQueueAttributes service method, as
* returned by AmazonSQS.
*
* @throws InvalidAttributeNameException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void setQueueAttributes(String queueUrl, java.util.Map attributes) {
SetQueueAttributesRequest setQueueAttributesRequest = new SetQueueAttributesRequest();
setQueueAttributesRequest.setQueueUrl(queueUrl);
setQueueAttributesRequest.setAttributes(attributes);
setQueueAttributes(setQueueAttributesRequest);
}
/**
*
* Changes the visibility timeout of multiple messages. This is a batch
* version of ChangeMessageVisibility. The result of the action on each
* message is reported individually in the response. You can send up to
* 10 ChangeMessageVisibility requests with each
* ChangeMessageVisibilityBatch action.
*
*
* IMPORTANT:Because the batch request can result in a
* combination of successful and unsuccessful actions, you should check
* for batch errors even when the call returns an HTTP status code of
* 200.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param entries A list of receipt handles of the messages for which the
* visibility timeout must be changed.
*
* @return The response from the ChangeMessageVisibilityBatch service
* method, as returned by AmazonSQS.
*
* @throws BatchEntryIdsNotDistinctException
* @throws TooManyEntriesInBatchRequestException
* @throws InvalidBatchEntryIdException
* @throws EmptyBatchRequestException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public ChangeMessageVisibilityBatchResult changeMessageVisibilityBatch(String queueUrl, java.util.List entries) {
ChangeMessageVisibilityBatchRequest changeMessageVisibilityBatchRequest = new ChangeMessageVisibilityBatchRequest();
changeMessageVisibilityBatchRequest.setQueueUrl(queueUrl);
changeMessageVisibilityBatchRequest.setEntries(entries);
return changeMessageVisibilityBatch(changeMessageVisibilityBatchRequest);
}
/**
*
* Changes the visibility timeout of a specified message in a queue to a
* new value. The maximum allowed timeout value you can set the value to
* is 12 hours. This means you can't extend the timeout of a message in
* an existing queue to more than a total visibility timeout of 12 hours.
* (For more information visibility timeout, see
* Visibility Timeout
* in the Amazon SQS Developer Guide .)
*
*
* For example, let's say you have a message and its default message
* visibility timeout is 30 minutes. You could call
* ChangeMessageVisiblity with a value of two hours and the
* effective timeout would be two hours and 30 minutes. When that time
* comes near you could again extend the time out by calling
* ChangeMessageVisiblity, but this time the maximum allowed timeout
* would be 9 hours and 30 minutes.
*
*
* NOTE: There is a 120,000 limit for the number of inflight
* messages per queue. Messages are inflight after they have been
* received from the queue by a consuming component, but have not yet
* been deleted from the queue. If you reach the 120,000 limit, you will
* receive an OverLimit error message from Amazon SQS. To help avoid
* reaching the limit, you should delete the messages from the queue
* after they have been processed. You can also increase the number of
* queues you use to process the messages.
*
*
* IMPORTANT:If you attempt to set the VisibilityTimeout to an
* amount more than the maximum time left, Amazon SQS returns an error.
* It will not automatically recalculate and increase the timeout to the
* maximum time remaining.
*
*
* IMPORTANT:Unlike with a queue, when you change the visibility
* timeout for a specific message, that timeout value is applied
* immediately but is not saved in memory for that message. If you don't
* delete a message after it is received, the visibility timeout for the
* message the next time it is received reverts to the original timeout
* value, not the value you set with the ChangeMessageVisibility action.
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param receiptHandle The receipt handle associated with the message
* whose visibility timeout should be changed. This parameter is returned
* by the ReceiveMessage action.
* @param visibilityTimeout The new value (in seconds - from 0 to 43200 -
* maximum 12 hours) for the message's visibility timeout.
*
* @return The response from the ChangeMessageVisibility service method,
* as returned by AmazonSQS.
*
* @throws ReceiptHandleIsInvalidException
* @throws MessageNotInflightException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void changeMessageVisibility(String queueUrl, String receiptHandle, Integer visibilityTimeout) {
ChangeMessageVisibilityRequest changeMessageVisibilityRequest = new ChangeMessageVisibilityRequest();
changeMessageVisibilityRequest.setQueueUrl(queueUrl);
changeMessageVisibilityRequest.setReceiptHandle(receiptHandle);
changeMessageVisibilityRequest.setVisibilityTimeout(visibilityTimeout);
changeMessageVisibility(changeMessageVisibilityRequest);
}
/**
*
* Returns the URL of an existing queue. This action provides a simple
* way to retrieve the URL of an Amazon SQS queue.
*
*
* To access a queue that belongs to another AWS account, use the
* QueueOwnerAWSAccountId parameter to specify the account
* ID of the queue's owner. The queue's owner must grant you permission
* to access the queue. For more information about shared queue access,
* see AddPermission or go to
* Shared Queues
* in the Amazon SQS Developer Guide .
*
*
* @param queueName The name of the queue whose URL must be fetched.
* Maximum 80 characters; alphanumeric characters, hyphens (-), and
* underscores (_) are allowed.
*
* @return The response from the GetQueueUrl service method, as returned
* by AmazonSQS.
*
* @throws QueueDoesNotExistException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public GetQueueUrlResult getQueueUrl(String queueName) {
GetQueueUrlRequest getQueueUrlRequest = new GetQueueUrlRequest();
getQueueUrlRequest.setQueueName(queueName);
return getQueueUrl(getQueueUrlRequest);
}
/**
*
* Revokes any permissions in the queue policy that matches the
* specified Label parameter. Only the owner of the queue
* can remove permissions.
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param label The identification of the permission to remove. This is
* the label added with the AddPermission action.
*
* @return The response from the RemovePermission service method, as
* returned by AmazonSQS.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void removePermission(String queueUrl, String label) {
RemovePermissionRequest removePermissionRequest = new RemovePermissionRequest();
removePermissionRequest.setQueueUrl(queueUrl);
removePermissionRequest.setLabel(label);
removePermission(removePermissionRequest);
}
/**
*
* Gets attributes for the specified queue. The following attributes are
* supported:
*
* -
All - returns all values.
* -
ApproximateNumberOfMessages - returns the
* approximate number of visible messages in a queue. For more
* information, see
* Resources Required to Process Messages
* in the Amazon SQS Developer Guide .
* -
ApproximateNumberOfMessagesNotVisible - returns the
* approximate number of messages that are not timed-out and not deleted.
* For more information, see
* Resources Required to Process Messages
* in the Amazon SQS Developer Guide .
* -
VisibilityTimeout - returns the visibility timeout
* for the queue. For more information about visibility timeout, see
* Visibility Timeout
* in the Amazon SQS Developer Guide .
* -
CreatedTimestamp - returns the time when the queue
* was created (epoch time in seconds).
* -
LastModifiedTimestamp - returns the time when the
* queue was last changed (epoch time in seconds).
* -
Policy - returns the queue's policy.
* -
MaximumMessageSize - returns the limit of how many
* bytes a message can contain before Amazon SQS rejects it.
* -
MessageRetentionPeriod - returns the number of
* seconds Amazon SQS retains a message.
* -
QueueArn - returns the queue's Amazon resource name
* (ARN).
* -
ApproximateNumberOfMessagesDelayed - returns the
* approximate number of messages that are pending to be added to the
* queue.
* -
DelaySeconds - returns the default delay on the
* queue in seconds.
* -
ReceiveMessageWaitTimeSeconds - returns the time
* for which a ReceiveMessage call will wait for a message to
* arrive.
* -
RedrivePolicy - returns the parameters for dead
* letter queue functionality of the source queue. For more information
* about RedrivePolicy and dead letter queues, see
* Using Amazon SQS Dead Letter Queues
* in the Amazon SQS Developer Guide .
*
*
*
*
*
* NOTE:Going forward, new attributes might be added. If you are
* writing code that calls this action, we recommend that you structure
* your code so that it can handle new attributes gracefully.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param attributeNames A list of attributes to retrieve information
* for.
*
* @return The response from the GetQueueAttributes service method, as
* returned by AmazonSQS.
*
* @throws InvalidAttributeNameException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public GetQueueAttributesResult getQueueAttributes(String queueUrl, java.util.List attributeNames) {
GetQueueAttributesRequest getQueueAttributesRequest = new GetQueueAttributesRequest();
getQueueAttributesRequest.setQueueUrl(queueUrl);
getQueueAttributesRequest.setAttributeNames(attributeNames);
return getQueueAttributes(getQueueAttributesRequest);
}
/**
*
* Delivers up to ten messages to the specified queue. This is a batch
* version of SendMessage. The result of the send action on each message
* is reported individually in the response. The maximum allowed
* individual message size is 256 KB (262,144 bytes).
*
*
* The maximum total payload size (i.e., the sum of all a batch's
* individual message lengths) is also 256 KB (262,144 bytes).
*
*
* If the DelaySeconds parameter is not specified for an
* entry, the default for the queue is used.
*
*
* IMPORTANT:The following list shows the characters (in Unicode)
* that are allowed in your message, according to the W3C XML
* specification. For more information, go to
* http://www.faqs.org/rfcs/rfc1321.html. If you send any characters that
* are not included in the list, your request will be rejected. #x9 | #xA
* | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
*
*
* IMPORTANT: Because the batch request can result in a
* combination of successful and unsuccessful actions, you should check
* for batch errors even when the call returns an HTTP status code of
* 200.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param entries A list of SendMessageBatchRequestEntry items.
*
* @return The response from the SendMessageBatch service method, as
* returned by AmazonSQS.
*
* @throws BatchEntryIdsNotDistinctException
* @throws TooManyEntriesInBatchRequestException
* @throws BatchRequestTooLongException
* @throws UnsupportedOperationException
* @throws InvalidBatchEntryIdException
* @throws EmptyBatchRequestException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public SendMessageBatchResult sendMessageBatch(String queueUrl, java.util.List entries) {
SendMessageBatchRequest sendMessageBatchRequest = new SendMessageBatchRequest();
sendMessageBatchRequest.setQueueUrl(queueUrl);
sendMessageBatchRequest.setEntries(entries);
return sendMessageBatch(sendMessageBatchRequest);
}
/**
*
* Deletes the queue specified by the queue URL , regardless of
* whether the queue is empty. If the specified queue does not exist,
* Amazon SQS returns a successful response.
*
*
* IMPORTANT: Use DeleteQueue with care; once you delete your
* queue, any messages in the queue are no longer available.
*
*
* When you delete a queue, the deletion process takes up to 60 seconds.
* Requests you send involving that queue during the 60 seconds might
* succeed. For example, a SendMessage request might succeed, but after
* the 60 seconds, the queue and that message you sent no longer exist.
* Also, when you delete a queue, you must wait at least 60 seconds
* before creating a queue with the same name.
*
*
* We reserve the right to delete queues that have had no activity for
* more than 30 days. For more information, see
* How Amazon SQS Queues Work
* in the Amazon SQS Developer Guide .
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
*
* @return The response from the DeleteQueue service method, as returned
* by AmazonSQS.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void deleteQueue(String queueUrl) {
DeleteQueueRequest deleteQueueRequest = new DeleteQueueRequest();
deleteQueueRequest.setQueueUrl(queueUrl);
deleteQueue(deleteQueueRequest);
}
/**
*
* Delivers a message to the specified queue. With Amazon SQS, you now
* have the ability to send large payload messages that are up to 256KB
* (262,144 bytes) in size. To send large payloads, you must use an AWS
* SDK that supports SigV4 signing. To verify whether SigV4 is supported
* for an AWS SDK, check the SDK release notes.
*
*
* IMPORTANT: The following list shows the characters (in
* Unicode) allowed in your message, according to the W3C XML
* specification. For more information, go to
* http://www.w3.org/TR/REC-xml/#charsets If you send any characters not
* included in the list, your request will be rejected. #x9 | #xA | #xD |
* [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to #x10FFFF]
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param messageBody The message to send. String maximum 256 KB in size.
* For a list of allowed characters, see the preceding important note.
*
* @return The response from the SendMessage service method, as returned
* by AmazonSQS.
*
* @throws InvalidMessageContentsException
* @throws UnsupportedOperationException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public SendMessageResult sendMessage(String queueUrl, String messageBody) {
SendMessageRequest sendMessageRequest = new SendMessageRequest();
sendMessageRequest.setQueueUrl(queueUrl);
sendMessageRequest.setMessageBody(messageBody);
return sendMessage(sendMessageRequest);
}
/**
*
* Retrieves one or more messages, with a maximum limit of 10 messages,
* from the specified queue. Long poll support is enabled by using the
* WaitTimeSeconds parameter. For more information, see
* Amazon SQS Long Poll
* in the Amazon SQS Developer Guide .
*
*
* Short poll is the default behavior where a weighted random set of
* machines is sampled on a ReceiveMessage call. This means
* only the messages on the sampled machines are returned. If the number
* of messages in the queue is small (less than 1000), it is likely you
* will get fewer messages than you requested per
* ReceiveMessage call. If the number of messages in the
* queue is extremely small, you might not receive any messages in a
* particular ReceiveMessage response; in which case you
* should repeat the request.
*
*
* For each message returned, the response includes the following:
*
*
*
* -
* Message body
*
*
* -
* MD5 digest of the message body. For information about MD5, go to
* http://www.faqs.org/rfcs/rfc1321.html
* .
*
*
* -
* Message ID you received when you sent the message to the queue.
*
*
* -
* Receipt handle.
*
*
* -
* Message attributes.
*
*
* -
* MD5 digest of the message attributes.
*
*
*
*
*
* The receipt handle is the identifier you must provide when deleting
* the message. For more information, see
* Queue and Message Identifiers
* in the Amazon SQS Developer Guide .
*
*
* You can provide the VisibilityTimeout parameter in your
* request, which will be applied to the messages that Amazon SQS returns
* in the response. If you do not include the parameter, the overall
* visibility timeout for the queue is used for the returned messages.
* For more information, see
* Visibility Timeout
* in the Amazon SQS Developer Guide .
*
*
* NOTE: Going forward, new attributes might be added. If you are
* writing code that calls this action, we recommend that you structure
* your code so that it can handle new attributes gracefully.
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
*
* @return The response from the ReceiveMessage service method, as
* returned by AmazonSQS.
*
* @throws OverLimitException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public ReceiveMessageResult receiveMessage(String queueUrl) {
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.setQueueUrl(queueUrl);
return receiveMessage(receiveMessageRequest);
}
/**
*
* Returns a list of your queues. The maximum number of queues that can
* be returned is 1000. If you specify a value for the optional
* QueueNamePrefix parameter, only queues with a name
* beginning with the specified value are returned.
*
*
* @param queueNamePrefix A string to use for filtering the list results.
* Only those queues whose name begins with the specified string are
* returned.
*
* @return The response from the ListQueues service method, as returned
* by AmazonSQS.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public ListQueuesResult listQueues(String queueNamePrefix) {
ListQueuesRequest listQueuesRequest = new ListQueuesRequest();
listQueuesRequest.setQueueNamePrefix(queueNamePrefix);
return listQueues(listQueuesRequest);
}
/**
*
* Deletes multiple messages. This is a batch version of DeleteMessage.
* The result of the delete action on each message is reported
* individually in the response.
*
*
* IMPORTANT: Because the batch request can result in a
* combination of successful and unsuccessful actions, you should check
* for batch errors even when the call returns an HTTP status code of
* 200.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param entries A list of receipt handles for the messages to be
* deleted.
*
* @return The response from the DeleteMessageBatch service method, as
* returned by AmazonSQS.
*
* @throws BatchEntryIdsNotDistinctException
* @throws TooManyEntriesInBatchRequestException
* @throws InvalidBatchEntryIdException
* @throws EmptyBatchRequestException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public DeleteMessageBatchResult deleteMessageBatch(String queueUrl, java.util.List entries) {
DeleteMessageBatchRequest deleteMessageBatchRequest = new DeleteMessageBatchRequest();
deleteMessageBatchRequest.setQueueUrl(queueUrl);
deleteMessageBatchRequest.setEntries(entries);
return deleteMessageBatch(deleteMessageBatchRequest);
}
/**
*
* Creates a new queue, or returns the URL of an existing one. When you
* request CreateQueue , you provide a name for the queue.
* To successfully create a new queue, you must provide a name that is
* unique within the scope of your own queues.
*
*
* NOTE: If you delete a queue, you must wait at least 60 seconds
* before creating a queue with the same name.
*
*
* You may pass one or more attributes in the request. If you do not
* provide a value for any attribute, the queue will have the default
* value for that attribute. Permitted attributes are the same that can
* be set using SetQueueAttributes.
*
*
* NOTE: Use GetQueueUrl to get a queue's URL. GetQueueUrl
* requires only the QueueName parameter.
*
*
* If you provide the name of an existing queue, along with the exact
* names and values of all the queue's attributes,
* CreateQueue returns the queue URL for the existing queue.
* If the queue name, attribute names, or attribute values do not match
* an existing queue, CreateQueue returns an error.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param queueName The name for the queue to be created.
*
* @return The response from the CreateQueue service method, as returned
* by AmazonSQS.
*
* @throws QueueNameExistsException
* @throws QueueDeletedRecentlyException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public CreateQueueResult createQueue(String queueName) {
CreateQueueRequest createQueueRequest = new CreateQueueRequest();
createQueueRequest.setQueueName(queueName);
return createQueue(createQueueRequest);
}
/**
*
* Adds a permission to a queue for a specific
* principal
* . This allows for sharing access to the queue.
*
*
* When you create a queue, you have full control access rights for the
* queue. Only you (as owner of the queue) can grant or deny permissions
* to the queue. For more information about these permissions, see
* Shared Queues
* in the Amazon SQS Developer Guide .
*
*
* NOTE: AddPermission writes an Amazon SQS-generated policy. If
* you want to write your own policy, use SetQueueAttributes to upload
* your policy. For more information about writing your own policy, see
* Using The Access Policy Language in the Amazon SQS Developer Guide.
*
*
* NOTE:Some API actions take lists of parameters. These lists
* are specified using the param.n notation. Values of n are integers
* starting from 1. For example, a parameter list with two elements looks
* like this:
*
*
* &Attribute.1=this
*
*
* &Attribute.2=that
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param label The unique identification of the permission you're
* setting (e.g., AliceSendMessage). Constraints: Maximum 80
* characters; alphanumeric characters, hyphens (-), and underscores (_)
* are allowed.
* @param aWSAccountIds The AWS account number of the principal
* who will be given permission. The principal must have an AWS account,
* but does not need to be signed up for Amazon SQS. For information
* about locating the AWS account identification, see Your
* AWS Identifiers in the Amazon SQS Developer Guide.
* @param actions The action the client wants to allow for the specified
* principal. The following are valid values: * | SendMessage |
* ReceiveMessage | DeleteMessage | ChangeMessageVisibility |
* GetQueueAttributes | GetQueueUrl. For more information about
* these actions, see Understanding
* Permissions in the Amazon SQS Developer Guide.
* Specifying SendMessage, DeleteMessage, or
* ChangeMessageVisibility for the ActionName.n
* also grants permissions for the corresponding batch versions of those
* actions: SendMessageBatch,
* DeleteMessageBatch, and
* ChangeMessageVisibilityBatch.
*
* @return The response from the AddPermission service method, as
* returned by AmazonSQS.
*
* @throws OverLimitException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void addPermission(String queueUrl, String label, java.util.List aWSAccountIds, java.util.List actions) {
AddPermissionRequest addPermissionRequest = new AddPermissionRequest();
addPermissionRequest.setQueueUrl(queueUrl);
addPermissionRequest.setLabel(label);
addPermissionRequest.setAWSAccountIds(aWSAccountIds);
addPermissionRequest.setActions(actions);
addPermission(addPermissionRequest);
}
/**
*
* Deletes the specified message from the specified queue. You specify
* the message by using the message's receipt handle and not
* the message ID you received when you sent the message.
* Even if the message is locked by another reader due to the visibility
* timeout setting, it is still deleted from the queue. If you leave a
* message in the queue for longer than the queue's configured retention
* period, Amazon SQS automatically deletes it.
*
*
* NOTE: The receipt handle is associated with a specific
* instance of receiving the message. If you receive a message more than
* once, the receipt handle you get each time you receive the message is
* different. When you request DeleteMessage, if you don't provide the
* most recently received receipt handle for the message, the request
* will still succeed, but the message might not be deleted.
*
*
* IMPORTANT: It is possible you will receive a message even
* after you have deleted it. This might happen on rare occasions if one
* of the servers storing a copy of the message is unavailable when you
* request to delete the message. The copy remains on the server and
* might be returned to you again on a subsequent receive request. You
* should create your system to be idempotent so that receiving a
* particular message more than once is not a problem.
*
*
* @param queueUrl The URL of the Amazon SQS queue to take action on.
* @param receiptHandle The receipt handle associated with the message to
* delete.
*
* @return The response from the DeleteMessage service method, as
* returned by AmazonSQS.
*
* @throws ReceiptHandleIsInvalidException
* @throws InvalidIdFormatException
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonSQS indicating
* either a problem with the data in the request, or a server side issue.
*/
public void deleteMessage(String queueUrl, String receiptHandle) {
DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest();
deleteMessageRequest.setQueueUrl(queueUrl);
deleteMessageRequest.setReceiptHandle(receiptHandle);
deleteMessage(deleteMessageRequest);
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for
* debugging issues where a service isn't acting as expected. This data isn't considered part
* of the result data returned by an operation, so it's available through this separate,
* diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access
* this extra diagnostic information for an executed request, you should use this method
* to retrieve it as soon as possible after executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none
* is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
private Response invoke(Request request,
Unmarshaller unmarshaller,
ExecutionContext executionContext)
{
request.setEndpoint(endpoint);
request.setTimeOffset(timeOffset);
AmazonWebServiceRequest originalRequest = request.getOriginalRequest();
for (Entry entry : originalRequest.copyPrivateRequestParameters().entrySet()) {
request.addParameter(entry.getKey(), entry.getValue());
}
AWSCredentials credentials = awsCredentialsProvider.getCredentials();
if (originalRequest.getRequestCredentials() != null) {
credentials = originalRequest.getRequestCredentials();
}
executionContext.setCredentials(credentials);
StaxResponseHandler responseHandler = new StaxResponseHandler(unmarshaller);
DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
}