SQS AWS - message.acknowledge - exception with acknowledge mode: UNORDERED_ACKNOWLEDGE - amazon-web-services

Question

I was running the SyncMessageReceiverUnorderedAcknowledge.java program, exactly as written on: http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/jmsclient.html#jmsclient-ackmode
public class SyncMessageReceiverUnorderedAcknowledge {
// Visibility time-out for the queue. It must match to the one set for the queue for this example to work.
private static final long TIME_OUT_SECONDS = 1;
public static void main(String args[]) throws JMSException, InterruptedException {
// Create the configuration for the example
ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiverUnorderedAcknowledge", args);
// Setup logging for the example
ExampleCommon.setupLogging();
// Create the connection factory based on the config
SQSConnectionFactory connectionFactory =
SQSConnectionFactory.builder()
.withRegion(config.getRegion())
.withAWSCredentialsProvider(config.getCredentialsProvider())
.build();
// Create the connection
SQSConnection connection = connectionFactory.createConnection();
// Create the queue if needed
ExampleCommon.ensureQueueExists(connection, config.getQueueName());
// Create the session with unordered acknowledge mode
Session session = connection.createSession(false, **SQSSession.UNORDERED_ACKNOWLEDGE**);
// Create the producer and consume
MessageProducer producer = session.createProducer(session.createQueue(config.getQueueName()));
MessageConsumer consumer = session.createConsumer(session.createQueue(config.getQueueName()));
// Open the connection
connection.start();
// Send two text messages
sendMessage(producer, session, "Message 1");
sendMessage(producer, session, "Message 2");
// Receive a message and don't acknowledge it
receiveMessage(consumer, false);
// Receive another message and acknowledge it
receiveMessage(consumer, true);
// Wait for the visibility time out, so that unacknowledged messages reappear in the queue
System.out.println("Waiting for visibility timeout...");
Thread.sleep(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS));
// Attempt to receive another message and acknowledge it. This will result in receiving the first message since
// we have acknowledged only the second message. In the UNORDERED_ACKNOWLEDGE mode, all the messages must
// be explicitly acknowledged.
receiveMessage(consumer, true);
// Close the connection. This will close the session automatically
connection.close();
System.out.println("Connection closed.");
}
/**
* Sends a message through the producer.
*
* #param producer Message producer
* #param session Session
* #param messageText Text for the message to be sent
* #throws JMSException
*/
private static void sendMessage(MessageProducer producer, Session session, String messageText) throws JMSException {
// Create a text message and send it
producer.send(session.createTextMessage(messageText));
}
/**
* Receives a message through the consumer synchronously with the default timeout (TIME_OUT_SECONDS).
* If a message is received, the message is printed. If no message is received, "Queue is empty!" is
* printed.
*
* #param consumer Message consumer
* #param acknowledge If true and a message is received, the received message is acknowledged.
* #throws JMSException
*/
private static void receiveMessage(MessageConsumer consumer, boolean acknowledge) throws JMSException {
// Receive a message
Message message = consumer.receive(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS));
if (message == null) {
System.out.println("Queue is empty!");
} else {
// Since this queue has only text messages, cast the message object and print the text
System.out.println("Received: " + ((TextMessage) message).getText());
// Acknowledge the message if asked
if (acknowledge) **message.acknowledge();**
}
}
}
When the below code is reached:
// Create the session with unordered acknowledge mode
Session session = connection.createSession(false,SQSSession.UNORDERED_ACKNOWLEDGE);
// Acknowledge the message if asked
if (acknowledge) message.acknowledge();
I get the following exception:
Exception in thread "main" java.lang.NoSuchMethodError: com.amazonaws.services.sqs.AmazonSQS.deleteMessage(Lcom/amazonaws/services/sqs/model/DeleteMessageRequest;)V
at com.amazon.sqs.javamessaging.AmazonSQSMessagingClientWrapper.deleteMessage(AmazonSQSMessagingClientWrapper.java:127)
at com.amazon.sqs.javamessaging.acknowledge.UnorderedAcknowledger.acknowledge(UnorderedAcknowledger.java:42)
at com.amazon.sqs.javamessaging.message.SQSMessage.acknowledge(SQSMessage.java:883)
at sample.sqs.SyncMessageReceiverUnorderedAcknowledge.receiveMessage(SyncMessageReceiverUnorderedAcknowledge.java:116)
at sample.sqs.SyncMessageReceiverUnorderedAcknowledge.main(SyncMessageReceiverUnorderedAcknowledge.java:67)
I am running with the following gradle dependencies:
compile("com.amazonaws:aws-java-sdk-sqs:1.11.13")
compile("com.amazonaws:amazon-sqs-java-messaging-lib:1.0.0")
I debugged the code, and all the aws amazon java classes looks perfect.
In addition, I created a new program that will run isolated deleteMessage.
With deleteMessage(DeleteMessageRequest deleteMessageRequest) - I get the same exception.
But With DeleteMessageBatchResult deleteMessageBatch(DeleteMessageBatchRequest deleteMessageBatchRequest) - Which is in the same classes - It works!
I cleaned the gradle cache folder, downloaded again all the jars, vlean, build, but I get the same results :-(
Help will be highly appreciated.

Answer 1

https://github.com/awslabs/amazon-sqs-java-messaging-lib/issues/22
I changed gradle dependencies:
compile("com.amazonaws:aws-java-sdk-sqs:1.9.6")
And now it works perfect.
Opening pom.xml of amazon-sqs-java-messaging-lib project, I can see:
<properties> <aws-java-sdk.version>1.9.6</aws-java-sdk.version> </properties>
I wonder when do AWS team plan to change it to the latest one (e.g. 1.11.13)? or one of the latest.