Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(sqs): release dedup reservations after failed enqueue (#6535)

Daniel Adler08bd1c7938b2
diff --git a/src/main/java/io/github/hectorvent/floci/services/sqs/SqsService.java b/src/main/java/io/github/hectorvent/floci/services/sqs/SqsService.java
index e41602307f..e0b97d7328 100644
--- a/src/main/java/io/github/hectorvent/floci/services/sqs/SqsService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/sqs/SqsService.java
@@ -1135,24 +1135,36 @@ public class SqsService implements Resettable, ResourceProvider {
return response;
}
- persistDedup(storageKey);
-
- Message message = new Message(body);
- message.setSenderId(effectiveSenderId);
- message.setMessageGroupId(messageGroupId);
- message.setMessageDeduplicationId(dedupId);
- message.setSequenceNumber(sequenceCounter.incrementAndGet());
- message.setAwsTraceHeader(awsTraceHeader);
- if (effectiveDelaySeconds > 0) {
- message.setVisibleAt(Instant.now().plusSeconds(effectiveDelaySeconds));
- }
- if (messageAttributes != null && !messageAttributes.isEmpty()) {
- message.getMessageAttributes().putAll(messageAttributes);
- message.updateMd5OfMessageAttributes();
+ Message message;
+ GuardedMessageQueue messages;
+ try {
+ persistDedup(storageKey);
+ message = new Message(body);
+ message.setSenderId(effectiveSenderId);
+ message.setMessageGroupId(messageGroupId);
+ message.setMessageDeduplicationId(dedupId);
+ message.setSequenceNumber(sequenceCounter.incrementAndGet());
+ message.setAwsTraceHeader(awsTraceHeader);
+ if (effectiveDelaySeconds > 0) {
+ message.setVisibleAt(Instant.now().plusSeconds(effectiveDelaySeconds));
+ }
+ if (messageAttributes != null && !messageAttributes.isEmpty()) {
+ message.getMessageAttributes().putAll(messageAttributes);
+ message.updateMd5OfMessageAttributes();
+ }
+ messages = getOrCreateQueue(storageKey);
+ messages.addMessage(message);
+ } catch (RuntimeException exception) {
+ dedupMap.remove(dedupCacheKey, expiry);
+ try {
+ persistDedup(storageKey);
+ } catch (RuntimeException cleanupFailure) {
+ if (cleanupFailure != exception) {
+ exception.addSuppressed(cleanupFailure);
+ }
+ }
+ throw exception;
}
-
- GuardedMessageQueue messages = getOrCreateQueue(storageKey);
- messages.addMessage(message);
messages.activity().sent(totalSize, false);
deduplicationIdentityCache.computeIfAbsent(storageKey, k -> new ConcurrentHashMap<>())
.putIfAbsent(dedupCacheKey,
diff --git a/src/test/java/io/github/hectorvent/floci/services/sqs/SqsFifoSendFailureTest.java b/src/test/java/io/github/hectorvent/floci/services/sqs/SqsFifoSendFailureTest.java
new file mode 100644
index 0000000000..59a0a584e1
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/sqs/SqsFifoSendFailureTest.java
@@ -0,0 +1,165 @@
+package io.github.hectorvent.floci.services.sqs;
+
+import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.services.sqs.model.Message;
+import io.github.hectorvent.floci.services.sqs.model.Queue;
+import io.github.hectorvent.floci.testing.MutableClock;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SqsFifoSendFailureTest {
+
+ private static final String REGION = "us-east-1";
+ private static final String BASE_URL = "http://localhost:4566";
+
+ @ParameterizedTest
+ @CsvSource({"false,false", "false,true", "true,false", "true,true"})
+ void retryAfterAFailedSendEnqueuesTheMessage(boolean failDedupWrite, boolean restart) {
+ Fixture fixture = new Fixture();
+ SqsService service = fixture.service();
+ Queue queue = service.createQueue("retry.fifo", null, REGION);
+ fixture.messages.failPut = !failDedupWrite;
+ fixture.dedup.failPut = failDedupWrite;
+
+ assertThrows(IllegalStateException.class,
+ () -> service.sendMessage(queue.getQueueUrl(), "original", 0, "group", "id", REGION));
+ assertTrue(service.peekMessages(queue.getQueueUrl(), REGION).isEmpty());
+ SqsService retryService = restart ? fixture.service() : service;
+ Message accepted = retryService.sendMessage(queue.getQueueUrl(), "retry", 0, "group", "id", REGION);
+ Message duplicate = retryService.sendMessage(queue.getQueueUrl(), "again", 0, "group", "id", REGION);
+
+ assertEquals(accepted.getMessageId(), duplicate.getMessageId());
+ assertEquals(List.of("retry"), retryService.peekMessages(queue.getQueueUrl(), REGION)
+ .stream().map(Message::getBody).toList());
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void compensatingAFailedGroupKeepsAnotherGroupsAcceptedIdentity(boolean restart) {
+ Fixture fixture = new Fixture();
+ SqsService service = fixture.service();
+ Queue queue = service.createQueue("groups.fifo", Map.of("DeduplicationScope", "messageGroup"), REGION);
+ Message accepted = service.sendMessage(queue.getQueueUrl(), "accepted", 0, "group-a", "id", REGION);
+ Message received = service.receiveMessage(queue.getQueueUrl(), 1, 30, 0, REGION).getFirst();
+ service.deleteMessage(queue.getQueueUrl(), received.getReceiptHandle(), REGION);
+ fixture.messages.failPut = true;
+
+ assertThrows(IllegalStateException.class,
+ () -> service.sendMessage(queue.getQueueUrl(), "failed", 0, "group-b", "id", REGION));
+ SqsService retryService = restart ? fixture.service() : service;
+ Message duplicate = retryService.sendMessage(queue.getQueueUrl(), "duplicate", 0, "group-a", "id", REGION);
+ retryService.sendMessage(queue.getQueueUrl(), "retry", 0, "group-b", "id", REGION);
+
+ assertEquals(accepted.getMessageId(), duplicate.getMessageId());
+ assertEquals(List.of("retry"), retryService.peekMessages(queue.getQueueUrl(), REGION)
+ .stream().map(Message::getBody).toList());
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void anIdentityWriteFailureAfterEnqueueKeepsTheDeduplicationReservation(boolean restart) {
+ Fixture fixture = new Fixture();
+ SqsService service = fixture.service();
+ Queue queue = service.createQueue("identity.fifo", null, REGION);
+ fixture.identities.failPut = true;
+
+ assertThrows(IllegalStateException.class,
+ () -> service.sendMessage(queue.getQueueUrl(), "accepted", 0, "group", "id", REGION));
+ Message accepted = service.peekMessages(queue.getQueueUrl(), REGION).getFirst();
+ SqsService retryService = restart ? fixture.service() : service;
+ Message duplicate = retryService.sendMessage(queue.getQueueUrl(), "duplicate", 0, "group", "id", REGION);
+
+ assertEquals(accepted.getMessageId(), duplicate.getMessageId());
+ assertEquals(List.of("accepted"), retryService.peekMessages(queue.getQueueUrl(), REGION)
+ .stream().map(Message::getBody).toList());
+ }
+
+ @Test
+ void failedCompensationPreservesTheSendErrorAndReportsItsCleanupFailure() {
+ Fixture fixture = new Fixture();
+ SqsService service = fixture.service();
+ Queue queue = service.createQueue("cleanup.fifo", null, REGION);
+ fixture.messages.failPut = true;
+ fixture.dedup.failDelete = true;
+
+ IllegalStateException failure = assertThrows(IllegalStateException.class,
+ () -> service.sendMessage(queue.getQueueUrl(), "failed", 0, "group", "id", REGION));
+
+ assertEquals("synthetic put failure", failure.getMessage());
+ assertEquals(1, failure.getSuppressed().length);
+ assertEquals("synthetic delete failure", failure.getSuppressed()[0].getMessage());
+ service.sendMessage(queue.getQueueUrl(), "retry", 0, "group", "id", REGION);
+ assertEquals(1, service.peekMessages(queue.getQueueUrl(), REGION).size());
+ }
+
+ @Test
+ void repeatedBackendExceptionDoesNotReplaceTheOriginalFailure() {
+ IllegalStateException backendFailure = new IllegalStateException("synthetic persistent failure");
+ InMemoryStorage<String, Map<String, Long>> dedup = new InMemoryStorage<>() {
+ @Override
+ public void put(String key, Map<String, Long> value) {
+ throw backendFailure;
+ }
+
+ @Override
+ public void delete(String key) {
+ throw backendFailure;
+ }
+ };
+ SqsService service = new SqsService(new InMemoryStorage<>(), new InMemoryStorage<>(), dedup,
+ new InMemoryStorage<>(), 30, 1048576, BASE_URL, new RegionResolver(REGION, "000000000000"),
+ false, null, new MutableClock());
+ Queue queue = service.createQueue("same-error.fifo", null, REGION);
+
+ assertSame(backendFailure, assertThrows(IllegalStateException.class,
+ () -> service.sendMessage(queue.getQueueUrl(), "failed", 0, "group", "id", REGION)));
+ assertTrue(service.peekMessages(queue.getQueueUrl(), REGION).isEmpty());
+ }
+
+ private static class Fixture {
+ private final InMemoryStorage<String, Queue> queues = new InMemoryStorage<>();
+ private final FailingStore<List<Message>> messages = new FailingStore<>();
+ private final FailingStore<Map<String, Long>> dedup = new FailingStore<>();
+ private final FailingStore<Map<String, Map<String, String>>> identities = new FailingStore<>();
+ private final MutableClock clock = new MutableClock();
+
+ SqsService service() {
+ return new SqsService(queues, messages, dedup, identities, 30, 1048576, BASE_URL,
+ new RegionResolver(REGION, "000000000000"), false, null, clock);
+ }
+ }
+
+ private static class FailingStore<V> extends InMemoryStorage<String, V> {
+ private boolean failPut;
+ private boolean failDelete;
+
+ @Override
+ public void put(String key, V value) {
+ if (failPut) {
+ failPut = false;
+ throw new IllegalStateException("synthetic put failure");
+ }
+ super.put(key, value);
+ }
+
+ @Override
+ public void delete(String key) {
+ if (failDelete) {
+ failDelete = false;
+ throw new IllegalStateException("synthetic delete failure");
+ }
+ super.delete(key);
+ }
+ }
+}