com.amazonaws.services.sqs.buffered.QueueBufferConfig Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk Show documentation
Show all versions of aws-java-sdk Show documentation
The Amazon Web Services SDK for Java provides Java APIs for building software on AWS' cost-effective, scalable, and reliable infrastructure products. The AWS Java SDK allows developers to code against APIs for all of Amazon's infrastructure web services (Amazon S3, Amazon EC2, Amazon SQS, Amazon Relational Database Service, Amazon AutoScaling, etc).
The newest version!
/*
* Copyright 2012-2014 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.buffered;
import com.amazonaws.AmazonClientException;
public class QueueBufferConfig {
public static final int MAX_BATCH_SIZE_DEFAULT = 10;
/** the maximum number of entries in a batch command */
private int maxBatchSize;
/** Updated as the service now supports messages of size max 256 KiB.*/
public static final long SERVICE_MAX_BATCH_SIZE_BYTES = 256 * 1024 - 1;
/**
* The maximum time (milliseconds) a send batch is held open for additional
* outbound requests. The longer this timeout, the longer messages wait for
* other messages to be added to the batch. Increasing this timeout reduces
* the number of calls made and increases throughput, but also increases
* average message latency.
*/
private long maxBatchOpenMs;
/** 200 milliseconds */
public static final long MAX_BATCH_OPEN_MS_DEFAULT = 200;
/**
* Should we use long polling or not?
* */
private boolean longPoll;
/** true */
private static final boolean LONG_POLL_DEFAULT = true;
/**
* The maximum number of concurrent batches for each type of outbound
* request. The greater the number, the greater the throughput that can be
* achieved (at the expense of consuming more threads).
*/
private int maxInflightOutboundBatches;
/** 5 batches */
public static final int MAX_INFLIGHT_OUTBOUND_BATCHES_DEFAULT = 5;
/**
* The maximum number of concurrent receive message batches. The greater
* this number, the faster the queue will be pulling messages from the SQS
* servers (at the expense of consuming more threads).
*/
private int maxInflightReceiveBatches;
/** 10 batches */
public static final int MAX_INFLIGHT_RECEIVE_BATCHES_DEFAULT = 10;
/**
* If more than that number of completed receive batches are waiting in the
* buffer, the querying for new messages will stop.
*
* The larger this number, the more messages the buffer queue will pre-fetch
* and keep in the buffer on the client side, and the faster receive
* requests will be satisfied.
*
* The visibility timeout of a pre-fetched message starts at the point of
* pre-fetch, which means that while the message is in the local buffer it
* is unavailable for other clients to process, and when this client retrieves it,
* part of the visibility timeout may have already expired.
*
* The number of messages prefetched will not exceed 10 * maxDoneReceiveBatches,
* as there can be a maximum of 10 messages per batch.
*
* */
private int maxDoneReceiveBatches;
/** 10 batches */
public static final int MAX_DONE_RECEIVE_BATCHES_DEFAULT = 10;
/**
* Maximum permitted size of a SendMessage or SendMessageBatch message, in
* bytes
*/
private long maxBatchSizeBytes;
/** 256 kilobytes*/
public static final long MAX_BATCH_SIZE_BYTES_DEFAULT = SERVICE_MAX_BATCH_SIZE_BYTES;
/**
* Custom visibility timeout to use when retrieving messages from SQS. If
* set to a value greater than zero, this timeout will override the default
* visibility timeout set on the SQS queue. Set it to -1 to use the
* default visiblity timeout of the queue. Visibility timeout of 0 seconds
* is not supported.
* */
private int visibilityTimeoutSeconds;
/** -1, which means use the visibility timeout of the queue */
public static final int VISIBILITY_TIMEOUT_SECONDS_DEFAULT = -1;
/**
* Specifies the amount of time, in seconds, the receive call will block
* on the server waiting for messages to arrive if the queue is empty when
* the receive call is first made.
*
* This setting has no effect if long polling is disabled.
* */
private int longPollWaitTimeoutSeconds;
public static final int LONGPOLL_WAIT_TIMEOUT_SECONDS_DEFAULT = 20;
public QueueBufferConfig( long maxBatchOpenMs,
int maxInflightOutboundBatches,
int maxInflightReceiveBatches,
int maxDoneReceiveBatches,
boolean paramLongPoll,
long maxBatchSizeBytes,
int visibilityTimeout,
int longPollTimeout,
int maxBatch
) {
super();
this.maxBatchOpenMs = maxBatchOpenMs;
this.maxInflightOutboundBatches = maxInflightOutboundBatches;
this.maxInflightReceiveBatches = maxInflightReceiveBatches;
this.maxDoneReceiveBatches = maxDoneReceiveBatches;
this.longPoll = paramLongPoll;
this.maxBatchSizeBytes = maxBatchSizeBytes;
this.visibilityTimeoutSeconds = visibilityTimeout;
this.longPollWaitTimeoutSeconds = longPollTimeout;
this.maxBatchSize = maxBatch;
}
public QueueBufferConfig() {
this( MAX_BATCH_OPEN_MS_DEFAULT,
MAX_INFLIGHT_OUTBOUND_BATCHES_DEFAULT,
MAX_INFLIGHT_RECEIVE_BATCHES_DEFAULT,
MAX_DONE_RECEIVE_BATCHES_DEFAULT,
LONG_POLL_DEFAULT,
MAX_BATCH_SIZE_BYTES_DEFAULT,
VISIBILITY_TIMEOUT_SECONDS_DEFAULT,
LONGPOLL_WAIT_TIMEOUT_SECONDS_DEFAULT,
MAX_BATCH_SIZE_DEFAULT
);
}
/** copy constructor */
public QueueBufferConfig( QueueBufferConfig other ) {
longPoll = other.longPoll;
longPollWaitTimeoutSeconds = other.longPollWaitTimeoutSeconds;
maxBatchOpenMs = other.maxBatchOpenMs;
maxBatchSize = other.maxBatchSize;
maxBatchSizeBytes = other.maxBatchSizeBytes;
maxDoneReceiveBatches = other.maxDoneReceiveBatches;
maxInflightOutboundBatches = other.maxInflightOutboundBatches;
maxInflightReceiveBatches = other.maxInflightReceiveBatches;
visibilityTimeoutSeconds = other.visibilityTimeoutSeconds;
}
@Override
public String toString() {
return "QueueBufferConfig [maxBatchSize=" + maxBatchSize
+ ", maxBatchOpenMs=" + maxBatchOpenMs + ", longPoll="
+ longPoll + ", maxInflightOutboundBatches="
+ maxInflightOutboundBatches + ", maxInflightReceiveBatches="
+ maxInflightReceiveBatches + ", maxDoneReceiveBatches="
+ maxDoneReceiveBatches + ", maxBatchSizeBytes="
+ maxBatchSizeBytes + ", visibilityTimeoutSeconds="
+ visibilityTimeoutSeconds + ", longPollWaitTimeoutSeconds="
+ longPollWaitTimeoutSeconds + "]";
}
/**
* The maximum time (milliseconds) a send batch is held open for additional
* outbound requests. The longer this timeout, the longer messages wait for
* other messages to be added to the batch. Increasing this timeout reduces
* the number of calls made and increases throughput, but also increases
* average message latency.
*/
public long getMaxBatchOpenMs() {
return maxBatchOpenMs;
}
/**
* The maximum time (milliseconds) a send batch is held open for additional
* outbound requests. The longer this timeout, the longer messages wait for
* other messages to be added to the batch. Increasing this timeout reduces
* the number of calls made and increases throughput, but also increases
* average message latency.
*/
public void setMaxBatchOpenMs(long maxBatchOpenMs) {
this.maxBatchOpenMs = maxBatchOpenMs;
}
public QueueBufferConfig withMaxBatchOpenMs(long maxBatchOpenMs) {
this.maxBatchOpenMs = maxBatchOpenMs;
return this;
}
/**
* @return true if the queue buffer will use long polling while retrieveing
* messages from the SQS server, false otherwise.
* */
public boolean isLongPoll() {
return longPoll;
}
/**
* Specify "true" for receive requests to use long polling.
* */
public void setLongPoll(boolean longPoll) {
this.longPoll = longPoll;
}
public QueueBufferConfig withLongPoll(boolean longPoll) {
this.longPoll = longPoll;
return this;
}
/**
* The maximum number of concurrent batches for each type of outbound
* request. The greater the number, the greater the throughput that can be
* achieved (at the expense of consuming more threads).
*/
public int getMaxInflightOutboundBatches() {
return maxInflightOutboundBatches;
}
/**
* The maximum number of concurrent batches for each type of outbound
* request. The greater the number, the greater the throughput that can be
* achieved (at the expense of consuming more threads).
*/
public void setMaxInflightOutboundBatches(int maxInflightOutboundBatches) {
this.maxInflightOutboundBatches = maxInflightOutboundBatches;
}
public QueueBufferConfig withMaxInflightOutboundBatches(int maxInflightOutboundBatches) {
this.maxInflightOutboundBatches = maxInflightOutboundBatches;
return this;
}
/**
* The maximum number of concurrent receive message batches. The greater
* this number, the faster the queue will be pulling messages from the SQS
* servers (at the expense of consuming more threads).
*/
public int getMaxInflightReceiveBatches() {
return maxInflightReceiveBatches;
}
/**
* The maximum number of concurrent receive message batches. The greater
* this number, the faster the queue will be pulling messages from the SQS
* servers (at the expense of consuming more threads).
*/
public void setMaxInflightReceiveBatches(int maxInflightReceiveBatches) {
this.maxInflightReceiveBatches = maxInflightReceiveBatches;
}
public QueueBufferConfig withMaxInflightReceiveBatches(int maxInflightReceiveBatches) {
this.maxInflightReceiveBatches = maxInflightReceiveBatches;
return this;
}
/**
* If more than that number of completed receive batches are waiting in the
* buffer, the querying for new messages will stop.
*
* The larger this number, the more messages the queue buffer will pre-fetch
* and keep in the buffer on the client side, and the faster receive
* requests will be satisfied.
*
* The visibility timeout of a pre-fetched message starts at the point of
* pre-fetch, which means that while the message is in the local buffer it
* is unavailable for other clients to process, and when this client retrieves it,
* part of the visibility timeout may have already expired.
*
* The number of messages prefetched will not exceed 10 * maxDoneReceiveBatches,
* as there can be a maximum of 10 messages per batch.
*
* */
public int getMaxDoneReceiveBatches() {
return maxDoneReceiveBatches;
}
/**
* If more than that number of completed receive batches are waiting in the
* buffer, the querying for new messages will stop.
*
* The larger this number, the more messages the queue buffer will pre-fetch
* and keep in the buffer on the client side, and the faster receive
* requests will be satisfied.
*
* The visibility timeout of a pre-fetched message starts at the point of
* pre-fetch, which means that while the message is in the local buffer it
* is unavailable for other clients to process, and when this client retrieves it,
* part of the visibility timeout may have already expired.
*
* The number of messages prefetched will not exceed 10 * maxDoneReceiveBatches,
* as there can be a maximum of 10 messages per batch.
*
* */
public void setMaxDoneReceiveBatches(int maxDoneReceiveBatches) {
this.maxDoneReceiveBatches = maxDoneReceiveBatches;
}
public QueueBufferConfig withMaxDoneReceiveBatches(int maxDoneReceiveBatches) {
this.maxDoneReceiveBatches = maxDoneReceiveBatches;
return this;
}
/**
* Maximum permitted size of a SendMessage or SendMessageBatch message, in
* bytes. This setting is also enforced on the server, and if this client
* submits a request of a size larger than the server can support, the server
* will reject the request.
*/
public long getMaxBatchSizeBytes() {
return maxBatchSizeBytes;
}
/**
* Maximum permitted size of a SendMessage or SendMessageBatch message, in
* bytes. This setting is also enforced on the server, and if this client
* submits a request of a size larger than the server can support, the
* server will reject the request.
*
* @throws IllegalArgumentException
* if the size being set is greater than the service allowed
* size for message body.
*/
public void setMaxBatchSizeBytes(long maxBatchSizeBytes) {
if (maxBatchSizeBytes > SERVICE_MAX_BATCH_SIZE_BYTES) {
throw new IllegalArgumentException(
"Maximum Size of the message cannot be greater than the allowed limit of "
+ SERVICE_MAX_BATCH_SIZE_BYTES + " bytes");
}
this.maxBatchSizeBytes = maxBatchSizeBytes;
}
public QueueBufferConfig withMaxBatchSizeBytes(long maxBatchSizeBytes) {
this.maxBatchSizeBytes = maxBatchSizeBytes;
return this;
}
/**
* Custom visibility timeout to use when retrieving messages from SQS. If
* set to a value greater than zero, this timeout will override the default
* visibility timeout set on the SQS queue. Set it to -1 to use the
* default visiblity timeout of the queue. Visibility timeout of 0 seconds
* is not supported.
* */
public int getVisibilityTimeoutSeconds() {
return visibilityTimeoutSeconds;
}
/**
* Custom visibility timeout to use when retrieving messages from SQS. If
* set to a value greater than zero, this timeout will override the default
* visibility timeout set on the SQS queue. Set it to -1 to use the
* default visiblity timeout of the queue. Visibility timeout of 0 seconds
* is not supported.
* */
public void setVisibilityTimeoutSeconds(int visibilityTimeoutSeconds) {
this.visibilityTimeoutSeconds = visibilityTimeoutSeconds;
}
public QueueBufferConfig withVisibilityTimeoutSeconds(int visibilityTimeoutSeconds) {
this.visibilityTimeoutSeconds = visibilityTimeoutSeconds;
return this;
}
/**
* Specifies the amount of time, in seconds, the receive call will block
* on the server waiting for messages to arrive if the queue is empty when
* the receive call is first made.
*
* This setting has no effect if long polling is disabled.
* */
public void setLongPollWaitTimeoutSeconds(int longPollWaitTimeoutSeconds) {
this.longPollWaitTimeoutSeconds = longPollWaitTimeoutSeconds;
}
/**
* Specifies the amount of time, in seconds, the receive call will block
* on the server waiting for messages to arrive if the queue is empty when
* the receive call is first made.
*
* This setting has no effect if long polling is disabled.
* */
public int getLongPollWaitTimeoutSeconds() {
return longPollWaitTimeoutSeconds;
}
public QueueBufferConfig withLongPollWaitTimeoutSeconds(int longPollWaitTimeoutSeconds) {
this.longPollWaitTimeoutSeconds = longPollWaitTimeoutSeconds;
return this;
}
/**
* Specifies the maximum number of entries the bufferinc client will
* put in a single batch request.
* */
public int getMaxBatchSize() {
return maxBatchSize;
}
/**
* Specifies the maximum number of entries the bufferinc client will
* put in a single batch request.
* */
public void setMaxBatchSize(int maxBatchSize) {
this.maxBatchSize = maxBatchSize;
}
/**
* Specifies the maximum number of entries the bufferinc client will
* put in a single batch request.
* */
public QueueBufferConfig withMaxBatchSize(int maxBatchSize) {
this.maxBatchSize = maxBatchSize;
return this;
}
/**
* this method checks the config for validity. If the config is deemed to be
* invalid, an informative exception is thrown.
*
* @throws AmazonClientException
* with a message explaining why the config was invalid
*/
void validate() {
if (visibilityTimeoutSeconds == 0 ) {
throw new AmazonClientException("Visibility timeout value may not be equal to zero ");
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy