defaultUnmarshaller;
/**
* Constructs a new client to invoke service methods on Amazon SQS. 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
* @deprecated use {@link AmazonSQSClientBuilder#defaultClient()}
*/
@Deprecated
public AmazonSQSClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon SQS. 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 Amazon SQS (ex: proxy settings,
* retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AmazonSQSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonSQSClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on Amazon SQS 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.
* @deprecated use {@link AmazonSQSClientBuilder#withCredentials(AWSCredentialsProvider)} for example:
* {@code AmazonSQSClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
public AmazonSQSClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon SQS 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 Amazon SQS (ex: proxy settings,
* retry counts, etc.).
* @deprecated use {@link AmazonSQSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonSQSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonSQSClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
/**
* Constructs a new client to invoke service methods on Amazon SQS 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.
* @deprecated use {@link AmazonSQSClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AmazonSQSClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on Amazon SQS 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 Amazon SQS (ex: proxy settings,
* retry counts, etc.).
* @deprecated use {@link AmazonSQSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonSQSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AmazonSQSClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on Amazon SQS 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 Amazon SQS (ex: proxy settings,
* retry counts, etc.).
* @param requestMetricCollector
* optional request metric collector
* @deprecated use {@link AmazonSQSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AmazonSQSClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AmazonSQSClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AmazonSQSClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
public static AmazonSQSClientBuilder builder() {
return AmazonSQSClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon SQS using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonSQSClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on Amazon SQS using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonSQSClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.PurgeQueueInProgress") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.PurgeQueueInProgress", new PurgeQueueInProgressExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new PurgeQueueInProgressExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidAttributeName") == null) {
exceptionUnmarshallersMap.put("InvalidAttributeName", new InvalidAttributeNameExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidAttributeNameExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.BatchEntryIdsNotDistinct") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.BatchEntryIdsNotDistinct", new BatchEntryIdsNotDistinctExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new BatchEntryIdsNotDistinctExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.TooManyEntriesInBatchRequest") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.TooManyEntriesInBatchRequest", new TooManyEntriesInBatchRequestExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new TooManyEntriesInBatchRequestExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ResourceNotFoundException") == null) {
exceptionUnmarshallersMap.put("ResourceNotFoundException", new ResourceNotFoundExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ResourceNotFoundExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.BatchRequestTooLong") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.BatchRequestTooLong", new BatchRequestTooLongExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new BatchRequestTooLongExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.UnsupportedOperation") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.UnsupportedOperation", new UnsupportedOperationExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new UnsupportedOperationExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidIdFormat") == null) {
exceptionUnmarshallersMap.put("InvalidIdFormat", new InvalidIdFormatExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidIdFormatExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("OverLimit") == null) {
exceptionUnmarshallersMap.put("OverLimit", new OverLimitExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new OverLimitExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.NonExistentQueue") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.NonExistentQueue", new QueueDoesNotExistExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new QueueDoesNotExistExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("QueueAlreadyExists") == null) {
exceptionUnmarshallersMap.put("QueueAlreadyExists", new QueueNameExistsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new QueueNameExistsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.MessageNotInflight") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.MessageNotInflight", new MessageNotInflightExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new MessageNotInflightExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("ReceiptHandleIsInvalid") == null) {
exceptionUnmarshallersMap.put("ReceiptHandleIsInvalid", new ReceiptHandleIsInvalidExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new ReceiptHandleIsInvalidExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("InvalidMessageContents") == null) {
exceptionUnmarshallersMap.put("InvalidMessageContents", new InvalidMessageContentsExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidMessageContentsExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.QueueDeletedRecently") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.QueueDeletedRecently", new QueueDeletedRecentlyExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new QueueDeletedRecentlyExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.EmptyBatchRequest") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.EmptyBatchRequest", new EmptyBatchRequestExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new EmptyBatchRequestExceptionUnmarshaller());
if (exceptionUnmarshallersMap.get("AWS.SimpleQueueService.InvalidBatchEntryId") == null) {
exceptionUnmarshallersMap.put("AWS.SimpleQueueService.InvalidBatchEntryId", new InvalidBatchEntryIdExceptionUnmarshaller());
}
exceptionUnmarshallers.add(new InvalidBatchEntryIdExceptionUnmarshaller());
defaultUnmarshaller = new StandardErrorUnmarshaller(com.amazonaws.services.sqs.model.AmazonSQSException.class);
exceptionUnmarshallers.add(new StandardErrorUnmarshaller(com.amazonaws.services.sqs.model.AmazonSQSException.class));
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
this.setEndpoint("https://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"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Adds a permission to a queue for a specific principal. This allows sharing access
* to the queue.
*
*
* When you create a queue, you have full control access rights for the queue. Only you, the owner of the queue, can
* grant or deny permissions to the queue. For more information about these permissions, see Allow Developers to Write Messages to a Shared Queue in the Amazon SQS Developer Guide.
*
*
*
* -
*
* AddPermission generates a policy for you. You can use SetQueueAttributes to
* upload your policy. For more information, see Using Custom Policies with the Amazon SQS Access Policy Language in the Amazon SQS Developer Guide.
*
*
* -
*
* An Amazon SQS policy can have a maximum of seven actions per statement.
*
*
* -
*
* To remove the ability to change queue permissions, you must deny permission to the AddPermission,
* RemovePermission, and SetQueueAttributes actions in your IAM policy.
*
*
* -
*
* Amazon SQS AddPermission does not support adding a non-account principal.
*
*
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param addPermissionRequest
* @return Result of the AddPermission operation returned by the service.
* @throws OverLimitException
* The specified action violates a limit. For example, ReceiveMessage returns this error if the
* maximum number of in flight messages is reached and AddPermission returns this error if the
* maximum number of permissions for the queue is reached.
* @sample AmazonSQS.AddPermission
* @see AWS API
* Documentation
*/
@Override
public AddPermissionResult addPermission(AddPermissionRequest request) {
request = beforeClientExecution(request);
return executeAddPermission(request);
}
@SdkInternalApi
final AddPermissionResult executeAddPermission(AddPermissionRequest addPermissionRequest) {
ExecutionContext executionContext = createExecutionContext(addPermissionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddPermissionRequestMarshaller().marshall(super.beforeMarshalling(addPermissionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddPermission");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new AddPermissionResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public AddPermissionResult addPermission(String queueUrl, String label, java.util.List aWSAccountIds, java.util.List actions) {
return addPermission(new AddPermissionRequest().withQueueUrl(queueUrl).withLabel(label).withAWSAccountIds(aWSAccountIds).withActions(actions));
}
/**
*
* Cancels a specified message movement task. A message movement can only be cancelled when the current status is
* RUNNING. Cancelling a message movement task does not revert the messages that have already been moved. It can
* only stop the messages that have not been moved yet.
*
*
*
* -
*
* This action is currently limited to supporting message redrive from dead-letter queues (DLQs) only. In this context, the source queue is the dead-letter queue (DLQ), while the
* destination queue can be the original source queue (from which the messages were driven to the
* dead-letter-queue), or a custom destination queue.
*
*
* -
*
* Currently, only standard queues are supported.
*
*
* -
*
* Only one active message movement task is supported per queue at any given time.
*
*
*
*
*
* @param cancelMessageMoveTaskRequest
* @return Result of the CancelMessageMoveTask operation returned by the service.
* @throws ResourceNotFoundException
* One or more specified resources don't exist.
* @throws UnsupportedOperationException
* Error code 400. Unsupported operation.
* @sample AmazonSQS.CancelMessageMoveTask
* @see AWS API
* Documentation
*/
@Override
public CancelMessageMoveTaskResult cancelMessageMoveTask(CancelMessageMoveTaskRequest request) {
request = beforeClientExecution(request);
return executeCancelMessageMoveTask(request);
}
@SdkInternalApi
final CancelMessageMoveTaskResult executeCancelMessageMoveTask(CancelMessageMoveTaskRequest cancelMessageMoveTaskRequest) {
ExecutionContext executionContext = createExecutionContext(cancelMessageMoveTaskRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelMessageMoveTaskRequestMarshaller().marshall(super.beforeMarshalling(cancelMessageMoveTaskRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelMessageMoveTask");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new CancelMessageMoveTaskResultStaxUnmarshaller());
response = invoke(request, responseHandler, 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 default visibility timeout
* for a message is 30 seconds. The minimum is 0 seconds. The maximum is 12 hours. For more information, see
* Visibility Timeout in the Amazon SQS Developer Guide.
*
*
* For example, if the default timeout for a queue is 60 seconds, 15 seconds have elapsed since you received the
* message, and you send a ChangeMessageVisibility call with VisibilityTimeout set to 10 seconds, the
* 10 seconds begin to count from the time that you make the ChangeMessageVisibility call. Thus, any
* attempt to change the visibility timeout or to delete that message 10 seconds after you initially change the
* visibility timeout (a total of 25 seconds) might result in an error.
*
*
* An Amazon SQS message has three basic states:
*
*
* -
*
* Sent to a queue by a producer.
*
*
* -
*
* Received from the queue by a consumer.
*
*
* -
*
* Deleted from the queue.
*
*
*
*
* A message is considered to be stored after it is sent to a queue by a producer, but not yet received from
* the queue by a consumer (that is, between states 1 and 2). There is no limit to the number of stored messages. A
* message is considered to be in flight after it is received from a queue by a consumer, but not yet deleted
* from the queue (that is, between states 2 and 3). There is a limit to the number of in flight messages.
*
*
* Limits that apply to in flight messages are unrelated to the unlimited number of stored messages.
*
*
* For most standard queues (depending on queue traffic and message backlog), there can be a maximum of
* approximately 120,000 in flight messages (received from a queue by a consumer, but not yet deleted from the
* queue). If you reach this limit, Amazon SQS returns the OverLimit error message. To avoid reaching
* the limit, you should delete messages from the queue after they're processed. You can also increase the number of
* queues you use to process your messages. To request a limit increase, file a support request.
*
*
* For FIFO queues, there can be a maximum of 20,000 in flight messages (received from a queue by a consumer, but
* not yet deleted from the queue). If you reach this limit, Amazon SQS returns no error messages.
*
*
*
* If you attempt to set the VisibilityTimeout to a value greater than the maximum time left, Amazon
* SQS returns an error. Amazon SQS doesn't automatically recalculate and increase the timeout to the maximum
* remaining time.
*
*
* Unlike with a queue, when you change the visibility timeout for a specific message the timeout value is applied
* immediately but isn't saved in memory for that message. If you don't delete a message after it is received, the
* visibility timeout for the message reverts to the original timeout value (not to the value you set using the
* ChangeMessageVisibility action) the next time the message is received.
*
*
*
* @param changeMessageVisibilityRequest
* @return Result of the ChangeMessageVisibility operation returned by the service.
* @throws MessageNotInflightException
* The specified message isn't in flight.
* @throws ReceiptHandleIsInvalidException
* The specified receipt handle isn't valid.
* @sample AmazonSQS.ChangeMessageVisibility
* @see AWS
* API Documentation
*/
@Override
public ChangeMessageVisibilityResult changeMessageVisibility(ChangeMessageVisibilityRequest request) {
request = beforeClientExecution(request);
return executeChangeMessageVisibility(request);
}
@SdkInternalApi
final ChangeMessageVisibilityResult executeChangeMessageVisibility(ChangeMessageVisibilityRequest changeMessageVisibilityRequest) {
ExecutionContext executionContext = createExecutionContext(changeMessageVisibilityRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ChangeMessageVisibilityRequestMarshaller().marshall(super.beforeMarshalling(changeMessageVisibilityRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ChangeMessageVisibility");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ChangeMessageVisibilityResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ChangeMessageVisibilityResult changeMessageVisibility(String queueUrl, String receiptHandle, Integer visibilityTimeout) {
return changeMessageVisibility(new ChangeMessageVisibilityRequest().withQueueUrl(queueUrl).withReceiptHandle(receiptHandle)
.withVisibilityTimeout(visibilityTimeout));
}
/**
*
* Changes the visibility timeout of multiple messages. This is a batch version of
* ChangeMessageVisibility. The result of the action on each message is reported individually
* in the response. You can send up to 10 ChangeMessageVisibility requests with each
* ChangeMessageVisibilityBatch action.
*
*
*
* Because the batch request can result in a combination of successful and unsuccessful actions, you should check
* for batch errors even when the call returns an HTTP status code of 200.
*
*
*
* @param changeMessageVisibilityBatchRequest
* @return Result of the ChangeMessageVisibilityBatch operation returned by the service.
* @throws TooManyEntriesInBatchRequestException
* The batch request contains more entries than permissible.
* @throws EmptyBatchRequestException
* The batch request doesn't contain any entries.
* @throws BatchEntryIdsNotDistinctException
* Two or more batch entries in the request have the same Id.
* @throws InvalidBatchEntryIdException
* The Id of a batch entry in a batch request doesn't abide by the specification.
* @sample AmazonSQS.ChangeMessageVisibilityBatch
* @see AWS API Documentation
*/
@Override
public ChangeMessageVisibilityBatchResult changeMessageVisibilityBatch(ChangeMessageVisibilityBatchRequest request) {
request = beforeClientExecution(request);
return executeChangeMessageVisibilityBatch(request);
}
@SdkInternalApi
final ChangeMessageVisibilityBatchResult executeChangeMessageVisibilityBatch(ChangeMessageVisibilityBatchRequest changeMessageVisibilityBatchRequest) {
ExecutionContext executionContext = createExecutionContext(changeMessageVisibilityBatchRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ChangeMessageVisibilityBatchRequestMarshaller().marshall(super.beforeMarshalling(changeMessageVisibilityBatchRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ChangeMessageVisibilityBatch");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ChangeMessageVisibilityBatchResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ChangeMessageVisibilityBatchResult changeMessageVisibilityBatch(String queueUrl, java.util.List entries) {
return changeMessageVisibilityBatch(new ChangeMessageVisibilityBatchRequest().withQueueUrl(queueUrl).withEntries(entries));
}
/**
*
* Creates a new standard or FIFO queue. You can pass one or more attributes in the request. Keep the following in
* mind:
*
*
* -
*
* If you don't specify the FifoQueue attribute, Amazon SQS creates a standard queue.
*
*
*
* You can't change the queue type after you create it and you can't convert an existing standard queue into a FIFO
* queue. You must either create a new FIFO queue for your application or delete your existing standard queue and
* recreate it as a FIFO queue. For more information, see Moving From a Standard Queue to a FIFO Queue in the Amazon SQS Developer Guide.
*
*
* -
*
* If you don't provide a value for an attribute, the queue is created with the default value for the attribute.
*
*
* -
*
* If you delete a queue, you must wait at least 60 seconds before creating a queue with the same name.
*
*
*
*
* To successfully create a new queue, you must provide a queue name that adheres to the limits
* related to queues and is unique within the scope of your queues.
*
*
*
* After you create a queue, you must wait at least one second after the queue is created to be able to use the
* queue.
*
*
*
* To get the queue URL, use the GetQueueUrl action. GetQueueUrl
* requires only the QueueName parameter. be aware of existing queue names:
*
*
* -
*
* If you provide the name of an existing queue along with the exact names and values of all the queue's attributes,
* CreateQueue returns the queue URL for the existing queue.
*
*
* -
*
* If the queue name, attribute names, or attribute values don't match an existing queue, CreateQueue
* returns an error.
*
*
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param createQueueRequest
* @return Result of the CreateQueue operation returned by the service.
* @throws QueueDeletedRecentlyException
* You must wait 60 seconds after deleting a queue before you can create another queue with the same name.
* @throws QueueNameExistsException
* A queue with this name already exists. Amazon SQS returns this error only if the request includes
* attributes whose values differ from those of the existing queue.
* @sample AmazonSQS.CreateQueue
* @see AWS API
* Documentation
*/
@Override
public CreateQueueResult createQueue(CreateQueueRequest request) {
request = beforeClientExecution(request);
return executeCreateQueue(request);
}
@SdkInternalApi
final CreateQueueResult executeCreateQueue(CreateQueueRequest createQueueRequest) {
ExecutionContext executionContext = createExecutionContext(createQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateQueueRequestMarshaller().marshall(super.beforeMarshalling(createQueueRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateQueue");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new CreateQueueResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public CreateQueueResult createQueue(String queueName) {
return createQueue(new CreateQueueRequest().withQueueName(queueName));
}
/**
*
* Deletes the specified message from the specified queue. To select the message to delete, use the
* ReceiptHandle of the message (not the MessageId which you receive when you send
* the message). Amazon SQS can delete a message from a queue even if a visibility timeout setting causes the
* message to be locked by another consumer. Amazon SQS automatically deletes messages left in a queue longer than
* the retention period configured for the queue.
*
*
*
* The ReceiptHandle is associated with a specific instance of receiving a message. If you
* receive a message more than once, the ReceiptHandle is different each time you receive a message.
* When you use the DeleteMessage action, you must provide the most recently received
* ReceiptHandle for the message (otherwise, the request succeeds, but the message will not be
* deleted).
*
*
* For standard queues, it is possible to receive a message even after you delete it. This might happen on rare
* occasions if one of the servers which stores a copy of the message is unavailable when you send the request to
* delete the message. The copy remains on the server and might be returned to you during a subsequent receive
* request. You should ensure that your application is idempotent, so that receiving a message more than once does
* not cause issues.
*
*
*
* @param deleteMessageRequest
* @return Result of the DeleteMessage operation returned by the service.
* @throws InvalidIdFormatException
* The specified receipt handle isn't valid for the current version.
* @throws ReceiptHandleIsInvalidException
* The specified receipt handle isn't valid.
* @sample AmazonSQS.DeleteMessage
* @see AWS API
* Documentation
*/
@Override
public DeleteMessageResult deleteMessage(DeleteMessageRequest request) {
request = beforeClientExecution(request);
return executeDeleteMessage(request);
}
@SdkInternalApi
final DeleteMessageResult executeDeleteMessage(DeleteMessageRequest deleteMessageRequest) {
ExecutionContext executionContext = createExecutionContext(deleteMessageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteMessageRequestMarshaller().marshall(super.beforeMarshalling(deleteMessageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteMessage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new DeleteMessageResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DeleteMessageResult deleteMessage(String queueUrl, String receiptHandle) {
return deleteMessage(new DeleteMessageRequest().withQueueUrl(queueUrl).withReceiptHandle(receiptHandle));
}
/**
*
* Deletes up to ten messages from the specified queue. This is a batch version of
* DeleteMessage. The result of the action on each message is reported individually in the
* response.
*
*
*
* Because the batch request can result in a combination of successful and unsuccessful actions, you should check
* for batch errors even when the call returns an HTTP status code of 200.
*
*
*
* @param deleteMessageBatchRequest
* @return Result of the DeleteMessageBatch operation returned by the service.
* @throws TooManyEntriesInBatchRequestException
* The batch request contains more entries than permissible.
* @throws EmptyBatchRequestException
* The batch request doesn't contain any entries.
* @throws BatchEntryIdsNotDistinctException
* Two or more batch entries in the request have the same Id.
* @throws InvalidBatchEntryIdException
* The Id of a batch entry in a batch request doesn't abide by the specification.
* @sample AmazonSQS.DeleteMessageBatch
* @see AWS API
* Documentation
*/
@Override
public DeleteMessageBatchResult deleteMessageBatch(DeleteMessageBatchRequest request) {
request = beforeClientExecution(request);
return executeDeleteMessageBatch(request);
}
@SdkInternalApi
final DeleteMessageBatchResult executeDeleteMessageBatch(DeleteMessageBatchRequest deleteMessageBatchRequest) {
ExecutionContext executionContext = createExecutionContext(deleteMessageBatchRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteMessageBatchRequestMarshaller().marshall(super.beforeMarshalling(deleteMessageBatchRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteMessageBatch");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new DeleteMessageBatchResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DeleteMessageBatchResult deleteMessageBatch(String queueUrl, java.util.List entries) {
return deleteMessageBatch(new DeleteMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries));
}
/**
*
* Deletes the queue specified by the QueueUrl, regardless of the queue's contents.
*
*
*
* Be careful with the DeleteQueue action: When you delete a queue, any messages in the queue are no
* longer available.
*
*
*
* When you delete a queue, the deletion process takes up to 60 seconds. Requests you send involving that queue
* during the 60 seconds might succeed. For example, a SendMessage request might succeed, but
* after 60 seconds the queue and the message you sent no longer exist.
*
*
* When you delete a queue, you must wait at least 60 seconds before creating a queue with the same name.
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
* The delete operation uses the HTTP GET verb.
*
*
*
* @param deleteQueueRequest
* @return Result of the DeleteQueue operation returned by the service.
* @sample AmazonSQS.DeleteQueue
* @see AWS API
* Documentation
*/
@Override
public DeleteQueueResult deleteQueue(DeleteQueueRequest request) {
request = beforeClientExecution(request);
return executeDeleteQueue(request);
}
@SdkInternalApi
final DeleteQueueResult executeDeleteQueue(DeleteQueueRequest deleteQueueRequest) {
ExecutionContext executionContext = createExecutionContext(deleteQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteQueueRequestMarshaller().marshall(super.beforeMarshalling(deleteQueueRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteQueue");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new DeleteQueueResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DeleteQueueResult deleteQueue(String queueUrl) {
return deleteQueue(new DeleteQueueRequest().withQueueUrl(queueUrl));
}
/**
*
* Gets attributes for the specified queue.
*
*
*
* To determine whether a queue is FIFO, you
* can check whether QueueName ends with the .fifo suffix.
*
*
*
* @param getQueueAttributesRequest
* @return Result of the GetQueueAttributes operation returned by the service.
* @throws InvalidAttributeNameException
* The specified attribute doesn't exist.
* @sample AmazonSQS.GetQueueAttributes
* @see AWS API
* Documentation
*/
@Override
public GetQueueAttributesResult getQueueAttributes(GetQueueAttributesRequest request) {
request = beforeClientExecution(request);
return executeGetQueueAttributes(request);
}
@SdkInternalApi
final GetQueueAttributesResult executeGetQueueAttributes(GetQueueAttributesRequest getQueueAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(getQueueAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetQueueAttributesRequestMarshaller().marshall(super.beforeMarshalling(getQueueAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetQueueAttributes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new GetQueueAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public GetQueueAttributesResult getQueueAttributes(String queueUrl, java.util.List attributeNames) {
return getQueueAttributes(new GetQueueAttributesRequest().withQueueUrl(queueUrl).withAttributeNames(attributeNames));
}
/**
*
* Returns the URL of an existing Amazon SQS queue.
*
*
* To access a queue that belongs to another AWS account, use the QueueOwnerAWSAccountId parameter to
* specify the account ID of the queue's owner. The queue's owner must grant you permission to access the queue. For
* more information about shared queue access, see AddPermission or see Allow Developers to Write Messages to a Shared Queue in the Amazon SQS Developer Guide.
*
*
* @param getQueueUrlRequest
* @return Result of the GetQueueUrl operation returned by the service.
* @throws QueueDoesNotExistException
* The specified queue doesn't exist.
* @sample AmazonSQS.GetQueueUrl
* @see AWS API
* Documentation
*/
@Override
public GetQueueUrlResult getQueueUrl(GetQueueUrlRequest request) {
request = beforeClientExecution(request);
return executeGetQueueUrl(request);
}
@SdkInternalApi
final GetQueueUrlResult executeGetQueueUrl(GetQueueUrlRequest getQueueUrlRequest) {
ExecutionContext executionContext = createExecutionContext(getQueueUrlRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetQueueUrlRequestMarshaller().marshall(super.beforeMarshalling(getQueueUrlRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetQueueUrl");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new GetQueueUrlResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public GetQueueUrlResult getQueueUrl(String queueName) {
return getQueueUrl(new GetQueueUrlRequest().withQueueName(queueName));
}
/**
*
* Returns a list of your queues that have the RedrivePolicy queue attribute configured with a
* dead-letter queue.
*
*
* The ListDeadLetterSourceQueues methods supports pagination. Set parameter MaxResults in
* the request to specify the maximum number of results to be returned in the response. If you do not set
* MaxResults, the response includes a maximum of 1,000 results. If you set MaxResults and
* there are additional results to display, the response includes a value for NextToken. Use
* NextToken as a parameter in your next request to ListDeadLetterSourceQueues to receive
* the next page of results.
*
*
* For more information about using dead-letter queues, see Using Amazon SQS Dead-Letter Queues in the Amazon SQS Developer Guide.
*
*
* @param listDeadLetterSourceQueuesRequest
* @return Result of the ListDeadLetterSourceQueues operation returned by the service.
* @throws QueueDoesNotExistException
* The specified queue doesn't exist.
* @sample AmazonSQS.ListDeadLetterSourceQueues
* @see AWS
* API Documentation
*/
@Override
public ListDeadLetterSourceQueuesResult listDeadLetterSourceQueues(ListDeadLetterSourceQueuesRequest request) {
request = beforeClientExecution(request);
return executeListDeadLetterSourceQueues(request);
}
@SdkInternalApi
final ListDeadLetterSourceQueuesResult executeListDeadLetterSourceQueues(ListDeadLetterSourceQueuesRequest listDeadLetterSourceQueuesRequest) {
ExecutionContext executionContext = createExecutionContext(listDeadLetterSourceQueuesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDeadLetterSourceQueuesRequestMarshaller().marshall(super.beforeMarshalling(listDeadLetterSourceQueuesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListDeadLetterSourceQueues");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListDeadLetterSourceQueuesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets the most recent message movement tasks (up to 10) under a specific source queue.
*
*
*
* -
*
* This action is currently limited to supporting message redrive from dead-letter queues (DLQs) only. In this context, the source queue is the dead-letter queue (DLQ), while the
* destination queue can be the original source queue (from which the messages were driven to the
* dead-letter-queue), or a custom destination queue.
*
*
* -
*
* Currently, only standard queues are supported.
*
*
* -
*
* Only one active message movement task is supported per queue at any given time.
*
*
*
*
*
* @param listMessageMoveTasksRequest
* @return Result of the ListMessageMoveTasks operation returned by the service.
* @throws ResourceNotFoundException
* One or more specified resources don't exist.
* @throws UnsupportedOperationException
* Error code 400. Unsupported operation.
* @sample AmazonSQS.ListMessageMoveTasks
* @see AWS API
* Documentation
*/
@Override
public ListMessageMoveTasksResult listMessageMoveTasks(ListMessageMoveTasksRequest request) {
request = beforeClientExecution(request);
return executeListMessageMoveTasks(request);
}
@SdkInternalApi
final ListMessageMoveTasksResult executeListMessageMoveTasks(ListMessageMoveTasksRequest listMessageMoveTasksRequest) {
ExecutionContext executionContext = createExecutionContext(listMessageMoveTasksRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListMessageMoveTasksRequestMarshaller().marshall(super.beforeMarshalling(listMessageMoveTasksRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListMessageMoveTasks");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ListMessageMoveTasksResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* List all cost allocation tags added to the specified Amazon SQS queue. For an overview, see Tagging
* Your Amazon SQS Queues in the Amazon SQS Developer Guide.
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param listQueueTagsRequest
* @return Result of the ListQueueTags operation returned by the service.
* @sample AmazonSQS.ListQueueTags
* @see AWS API
* Documentation
*/
@Override
public ListQueueTagsResult listQueueTags(ListQueueTagsRequest request) {
request = beforeClientExecution(request);
return executeListQueueTags(request);
}
@SdkInternalApi
final ListQueueTagsResult executeListQueueTags(ListQueueTagsRequest listQueueTagsRequest) {
ExecutionContext executionContext = createExecutionContext(listQueueTagsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListQueueTagsRequestMarshaller().marshall(super.beforeMarshalling(listQueueTagsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListQueueTags");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ListQueueTagsResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListQueueTagsResult listQueueTags(String queueUrl) {
return listQueueTags(new ListQueueTagsRequest().withQueueUrl(queueUrl));
}
/**
*
* Returns a list of your queues in the current region. The response includes a maximum of 1,000 results. If you
* specify a value for the optional QueueNamePrefix parameter, only queues with a name that begins with
* the specified value are returned.
*
*
* The listQueues methods supports pagination. Set parameter MaxResults in the request to
* specify the maximum number of results to be returned in the response. If you do not set MaxResults,
* the response includes a maximum of 1,000 results. If you set MaxResults and there are additional
* results to display, the response includes a value for NextToken. Use NextToken as a
* parameter in your next request to listQueues to receive the next page of results.
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param listQueuesRequest
* @return Result of the ListQueues operation returned by the service.
* @sample AmazonSQS.ListQueues
* @see AWS API
* Documentation
*/
@Override
public ListQueuesResult listQueues(ListQueuesRequest request) {
request = beforeClientExecution(request);
return executeListQueues(request);
}
@SdkInternalApi
final ListQueuesResult executeListQueues(ListQueuesRequest listQueuesRequest) {
ExecutionContext executionContext = createExecutionContext(listQueuesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListQueuesRequestMarshaller().marshall(super.beforeMarshalling(listQueuesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListQueues");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new ListQueuesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListQueuesResult listQueues() {
return listQueues(new ListQueuesRequest());
}
@Override
public ListQueuesResult listQueues(String queueNamePrefix) {
return listQueues(new ListQueuesRequest().withQueueNamePrefix(queueNamePrefix));
}
/**
*
* Deletes available messages in a queue (including in-flight messages) specified by the QueueURL
* parameter.
*
*
*
* When you use the PurgeQueue action, you can't retrieve any messages deleted from a queue.
*
*
* The message deletion process takes up to 60 seconds. We recommend waiting for 60 seconds regardless of your
* queue's size.
*
*
*
* Messages sent to the queue before you call PurgeQueue might be received but are deleted
* within the next minute.
*
*
* Messages sent to the queue after you call PurgeQueue might be deleted while the queue is
* being purged.
*
*
* @param purgeQueueRequest
* @return Result of the PurgeQueue operation returned by the service.
* @throws QueueDoesNotExistException
* The specified queue doesn't exist.
* @throws PurgeQueueInProgressException
* Indicates that the specified queue previously received a PurgeQueue request within the last
* 60 seconds (the time it can take to delete the messages in the queue).
* @sample AmazonSQS.PurgeQueue
* @see AWS API
* Documentation
*/
@Override
public PurgeQueueResult purgeQueue(PurgeQueueRequest request) {
request = beforeClientExecution(request);
return executePurgeQueue(request);
}
@SdkInternalApi
final PurgeQueueResult executePurgeQueue(PurgeQueueRequest purgeQueueRequest) {
ExecutionContext executionContext = createExecutionContext(purgeQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PurgeQueueRequestMarshaller().marshall(super.beforeMarshalling(purgeQueueRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PurgeQueue");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new PurgeQueueResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves one or more messages (up to 10), from the specified queue. Using the WaitTimeSeconds
* parameter enables long-poll support. For more information, see Amazon
* SQS Long Polling in the Amazon SQS Developer Guide.
*
*
* Short poll is the default behavior where a weighted random set of machines is sampled on a
* ReceiveMessage call. Thus, only the messages on the sampled machines are returned. If the number of
* messages in the queue is small (fewer than 1,000), you most likely get fewer messages than you requested per
* ReceiveMessage call. If the number of messages in the queue is extremely small, you might not
* receive any messages in a particular ReceiveMessage response. If this happens, repeat the request.
*
*
* For each message returned, the response includes the following:
*
*
* -
*
* The message body.
*
*
* -
*
* An MD5 digest of the message body. For information about MD5, see RFC1321.
*
*
* -
*
* The MessageId you received when you sent the message to the queue.
*
*
* -
*
* The receipt handle.
*
*
* -
*
* The message attributes.
*
*
* -
*
* An MD5 digest of the message attributes.
*
*
*
*
* The receipt handle is the identifier you must provide when deleting the message. For more information, see Queue and Message Identifiers in the Amazon SQS Developer Guide.
*
*
* You can provide the VisibilityTimeout parameter in your request. The parameter is applied to the
* messages that Amazon SQS returns in the response. If you don't include the parameter, the overall visibility
* timeout for the queue is used for the returned messages. For more information, see Visibility Timeout in the Amazon SQS Developer Guide.
*
*
* A message that isn't deleted or a message whose visibility isn't extended before the visibility timeout expires
* counts as a failed receive. Depending on the configuration of the queue, the message might be sent to the
* dead-letter queue.
*
*
*
* In the future, new attributes might be added. If you write code that calls this action, we recommend that you
* structure your code so that it can handle new attributes gracefully.
*
*
*
* @param receiveMessageRequest
* @return Result of the ReceiveMessage operation returned by the service.
* @throws OverLimitException
* The specified action violates a limit. For example, ReceiveMessage returns this error if the
* maximum number of in flight messages is reached and AddPermission returns this error if the
* maximum number of permissions for the queue is reached.
* @sample AmazonSQS.ReceiveMessage
* @see AWS API
* Documentation
*/
@Override
public ReceiveMessageResult receiveMessage(ReceiveMessageRequest request) {
request = beforeClientExecution(request);
return executeReceiveMessage(request);
}
@SdkInternalApi
final ReceiveMessageResult executeReceiveMessage(ReceiveMessageRequest receiveMessageRequest) {
ExecutionContext executionContext = createExecutionContext(receiveMessageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ReceiveMessageRequestMarshaller().marshall(super.beforeMarshalling(receiveMessageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ReceiveMessage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new ReceiveMessageResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ReceiveMessageResult receiveMessage(String queueUrl) {
return receiveMessage(new ReceiveMessageRequest().withQueueUrl(queueUrl));
}
/**
*
* Revokes any permissions in the queue policy that matches the specified Label parameter.
*
*
*
* -
*
* Only the owner of a queue can remove permissions from it.
*
*
* -
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
* -
*
* To remove the ability to change queue permissions, you must deny permission to the AddPermission,
* RemovePermission, and SetQueueAttributes actions in your IAM policy.
*
*
*
*
*
* @param removePermissionRequest
* @return Result of the RemovePermission operation returned by the service.
* @sample AmazonSQS.RemovePermission
* @see AWS API
* Documentation
*/
@Override
public RemovePermissionResult removePermission(RemovePermissionRequest request) {
request = beforeClientExecution(request);
return executeRemovePermission(request);
}
@SdkInternalApi
final RemovePermissionResult executeRemovePermission(RemovePermissionRequest removePermissionRequest) {
ExecutionContext executionContext = createExecutionContext(removePermissionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RemovePermissionRequestMarshaller().marshall(super.beforeMarshalling(removePermissionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RemovePermission");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new RemovePermissionResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public RemovePermissionResult removePermission(String queueUrl, String label) {
return removePermission(new RemovePermissionRequest().withQueueUrl(queueUrl).withLabel(label));
}
/**
*
* Delivers a message to the specified queue.
*
*
*
* A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed:
*
*
* #x9 | #xA | #xD | #x20 to #xD7FF |
* #xE000 to #xFFFD | #x10000 to #x10FFFF
*
*
* Any characters not included in this list will be rejected. For more information, see the W3C specification for characters.
*
*
*
* @param sendMessageRequest
* @return Result of the SendMessage operation returned by the service.
* @throws InvalidMessageContentsException
* The message contains characters outside the allowed set.
* @throws UnsupportedOperationException
* Error code 400. Unsupported operation.
* @sample AmazonSQS.SendMessage
* @see AWS API
* Documentation
*/
@Override
public SendMessageResult sendMessage(SendMessageRequest request) {
request = beforeClientExecution(request);
return executeSendMessage(request);
}
@SdkInternalApi
final SendMessageResult executeSendMessage(SendMessageRequest sendMessageRequest) {
ExecutionContext executionContext = createExecutionContext(sendMessageRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SendMessageRequestMarshaller().marshall(super.beforeMarshalling(sendMessageRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SendMessage");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new SendMessageResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public SendMessageResult sendMessage(String queueUrl, String messageBody) {
return sendMessage(new SendMessageRequest().withQueueUrl(queueUrl).withMessageBody(messageBody));
}
/**
*
* You can use SendMessageBatch to send up to 10 messages to the specified queue by assigning either
* identical or different values to each message (or by not assigning values at all). This is a batch version of
* SendMessage. For a FIFO queue, multiple messages within a single batch are enqueued in the
* order they are sent.
*
*
* The result of sending each message is reported individually in the response. Because the batch request can result
* in a combination of successful and unsuccessful actions, you should check for batch errors even when the call
* returns an HTTP status code of 200.
*
*
* The maximum allowed individual message size and the maximum total payload size (the sum of the individual lengths
* of all of the batched messages) are both 256 KiB (262,144 bytes).
*
*
*
* A message can include only XML, JSON, and unformatted text. The following Unicode characters are allowed:
*
*
* #x9 | #xA | #xD | #x20 to #xD7FF |
* #xE000 to #xFFFD | #x10000 to #x10FFFF
*
*
* Any characters not included in this list will be rejected. For more information, see the W3C specification for characters.
*
*
*
* If you don't specify the DelaySeconds parameter for an entry, Amazon SQS uses the default value for
* the queue.
*
*
* @param sendMessageBatchRequest
* @return Result of the SendMessageBatch operation returned by the service.
* @throws TooManyEntriesInBatchRequestException
* The batch request contains more entries than permissible.
* @throws EmptyBatchRequestException
* The batch request doesn't contain any entries.
* @throws BatchEntryIdsNotDistinctException
* Two or more batch entries in the request have the same Id.
* @throws BatchRequestTooLongException
* The length of all the messages put together is more than the limit.
* @throws InvalidBatchEntryIdException
* The Id of a batch entry in a batch request doesn't abide by the specification.
* @throws UnsupportedOperationException
* Error code 400. Unsupported operation.
* @sample AmazonSQS.SendMessageBatch
* @see AWS API
* Documentation
*/
@Override
public SendMessageBatchResult sendMessageBatch(SendMessageBatchRequest request) {
request = beforeClientExecution(request);
return executeSendMessageBatch(request);
}
@SdkInternalApi
final SendMessageBatchResult executeSendMessageBatch(SendMessageBatchRequest sendMessageBatchRequest) {
ExecutionContext executionContext = createExecutionContext(sendMessageBatchRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SendMessageBatchRequestMarshaller().marshall(super.beforeMarshalling(sendMessageBatchRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SendMessageBatch");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SendMessageBatchResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public SendMessageBatchResult sendMessageBatch(String queueUrl, java.util.List entries) {
return sendMessageBatch(new SendMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries));
}
/**
*
* Sets the value of one or more queue attributes. When you change a queue's attributes, the change can take up to
* 60 seconds for most of the attributes to propagate throughout the Amazon SQS system. Changes made to the
* MessageRetentionPeriod attribute can take up to 15 minutes and will impact existing messages in the
* queue potentially causing them to be expired and deleted if the MessageRetentionPeriod is reduced
* below the age of existing messages.
*
*
*
* -
*
* In the future, new attributes might be added. If you write code that calls this action, we recommend that you
* structure your code so that it can handle new attributes gracefully.
*
*
* -
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
* -
*
* To remove the ability to change queue permissions, you must deny permission to the AddPermission,
* RemovePermission, and SetQueueAttributes actions in your IAM policy.
*
*
*
*
*
* @param setQueueAttributesRequest
* @return Result of the SetQueueAttributes operation returned by the service.
* @throws InvalidAttributeNameException
* The specified attribute doesn't exist.
* @sample AmazonSQS.SetQueueAttributes
* @see AWS API
* Documentation
*/
@Override
public SetQueueAttributesResult setQueueAttributes(SetQueueAttributesRequest request) {
request = beforeClientExecution(request);
return executeSetQueueAttributes(request);
}
@SdkInternalApi
final SetQueueAttributesResult executeSetQueueAttributes(SetQueueAttributesRequest setQueueAttributesRequest) {
ExecutionContext executionContext = createExecutionContext(setQueueAttributesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SetQueueAttributesRequestMarshaller().marshall(super.beforeMarshalling(setQueueAttributesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SetQueueAttributes");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new SetQueueAttributesResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public SetQueueAttributesResult setQueueAttributes(String queueUrl, java.util.Map attributes) {
return setQueueAttributes(new SetQueueAttributesRequest().withQueueUrl(queueUrl).withAttributes(attributes));
}
/**
*
* Starts an asynchronous task to move messages from a specified source queue to a specified destination queue.
*
*
*
* -
*
* This action is currently limited to supporting message redrive from queues that are configured as dead-letter queues (DLQs) of other Amazon SQS queues only. Non-SQS queue sources of dead-letter queues, such
* as Lambda or Amazon SNS topics, are currently not supported.
*
*
* -
*
* In dead-letter queues redrive context, the StartMessageMoveTask the source queue is the DLQ, while
* the destination queue can be the original source queue (from which the messages were driven to the
* dead-letter-queue), or a custom destination queue.
*
*
* -
*
* Currently, only standard queues support redrive. FIFO queues don't support redrive.
*
*
* -
*
* Only one active message movement task is supported per queue at any given time.
*
*
*
*
*
* @param startMessageMoveTaskRequest
* @return Result of the StartMessageMoveTask operation returned by the service.
* @throws ResourceNotFoundException
* One or more specified resources don't exist.
* @throws UnsupportedOperationException
* Error code 400. Unsupported operation.
* @sample AmazonSQS.StartMessageMoveTask
* @see AWS API
* Documentation
*/
@Override
public StartMessageMoveTaskResult startMessageMoveTask(StartMessageMoveTaskRequest request) {
request = beforeClientExecution(request);
return executeStartMessageMoveTask(request);
}
@SdkInternalApi
final StartMessageMoveTaskResult executeStartMessageMoveTask(StartMessageMoveTaskRequest startMessageMoveTaskRequest) {
ExecutionContext executionContext = createExecutionContext(startMessageMoveTaskRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartMessageMoveTaskRequestMarshaller().marshall(super.beforeMarshalling(startMessageMoveTaskRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartMessageMoveTask");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(
new StartMessageMoveTaskResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Add cost allocation tags to the specified Amazon SQS queue. For an overview, see Tagging
* Your Amazon SQS Queues in the Amazon SQS Developer Guide.
*
*
* When you use queue tags, keep the following guidelines in mind:
*
*
* -
*
* Adding more than 50 tags to a queue isn't recommended.
*
*
* -
*
* Tags don't have any semantic meaning. Amazon SQS interprets tags as character strings.
*
*
* -
*
* Tags are case-sensitive.
*
*
* -
*
* A new tag with a key identical to that of an existing tag overwrites the existing tag.
*
*
*
*
* For a full list of tag restrictions, see Quotas related to queues in the Amazon SQS Developer Guide.
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param tagQueueRequest
* @return Result of the TagQueue operation returned by the service.
* @sample AmazonSQS.TagQueue
* @see AWS API
* Documentation
*/
@Override
public TagQueueResult tagQueue(TagQueueRequest request) {
request = beforeClientExecution(request);
return executeTagQueue(request);
}
@SdkInternalApi
final TagQueueResult executeTagQueue(TagQueueRequest tagQueueRequest) {
ExecutionContext executionContext = createExecutionContext(tagQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TagQueueRequestMarshaller().marshall(super.beforeMarshalling(tagQueueRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TagQueue");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new TagQueueResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public TagQueueResult tagQueue(String queueUrl, java.util.Map tags) {
return tagQueue(new TagQueueRequest().withQueueUrl(queueUrl).withTags(tags));
}
/**
*
* Remove cost allocation tags from the specified Amazon SQS queue. For an overview, see Tagging
* Your Amazon SQS Queues in the Amazon SQS Developer Guide.
*
*
*
* Cross-account permissions don't apply to this action. For more information, see Grant cross-account permissions to a role and a username in the Amazon SQS Developer Guide.
*
*
*
* @param untagQueueRequest
* @return Result of the UntagQueue operation returned by the service.
* @sample AmazonSQS.UntagQueue
* @see AWS API
* Documentation
*/
@Override
public UntagQueueResult untagQueue(UntagQueueRequest request) {
request = beforeClientExecution(request);
return executeUntagQueue(request);
}
@SdkInternalApi
final UntagQueueResult executeUntagQueue(UntagQueueRequest untagQueueRequest) {
ExecutionContext executionContext = createExecutionContext(untagQueueRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UntagQueueRequestMarshaller().marshall(super.beforeMarshalling(untagQueueRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "SQS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UntagQueue");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
StaxResponseHandler responseHandler = new StaxResponseHandler(new UntagQueueResultStaxUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public UntagQueueResult untagQueue(String queueUrl, java.util.List tagKeys) {
return untagQueue(new UntagQueueRequest().withQueueUrl(queueUrl).withTagKeys(tagKeys));
}
/**
* 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);
}
@Override
protected final SignerProvider createSignerProvider(Signer signer) {
return new com.amazonaws.services.sqs.internal.auth.SQSSignerProvider(this, signer);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallersMap, defaultUnmarshaller);
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@Override
public void shutdown() {
super.shutdown();
}
}