Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(sqs): implement StartMessageMoveTask / List / Cancel with async drain + rate limiting (#910)

Stuart Lang5dedeff9e4fe
diff --git a/src/main/java/io/github/hectorvent/floci/services/sqs/GuardedMessageQueue.java b/src/main/java/io/github/hectorvent/floci/services/sqs/GuardedMessageQueue.java
index 91d18638d4..b61ca67e7f 100644
--- a/src/main/java/io/github/hectorvent/floci/services/sqs/GuardedMessageQueue.java
+++ b/src/main/java/io/github/hectorvent/floci/services/sqs/GuardedMessageQueue.java
@@ -189,6 +189,20 @@ class GuardedMessageQueue {
}
}
+ /** Remove and return the first message in insertion order, or null if empty.
+ * Used by the message-move-task worker so the source queue stays observably
+ * populated for the duration of a rate-limited move. */
+ Message drainOne() {
+ try (var _ = hold()) {
+ if (messages.isEmpty()) {
+ return null;
+ }
+ Message head = messages.remove(0);
+ persist();
+ return head;
+ }
+ }
+
record MessageCounts(long visible, long inFlight) {
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/sqs/SqsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/sqs/SqsJsonHandler.java
index 4c9c2469b5..e0c65ad9be 100644
--- a/src/main/java/io/github/hectorvent/floci/services/sqs/SqsJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/sqs/SqsJsonHandler.java
@@ -57,6 +57,7 @@ public class SqsJsonHandler {
case "ListDeadLetterSourceQueues" -> handleListDeadLetterSourceQueues(request, region);
case "StartMessageMoveTask" -> handleStartMessageMoveTask(request, region);
case "ListMessageMoveTasks" -> handleListMessageMoveTasks(request, region);
+ case "CancelMessageMoveTask" -> handleCancelMessageMoveTask(request, region);
case "AddPermission" -> handleAddPermission(request, region);
case "RemovePermission" -> handleRemovePermission(request, region);
default -> Response.status(400)
@@ -412,7 +413,8 @@ public class SqsJsonHandler {
private Response handleStartMessageMoveTask(JsonNode request, String region) {
String sourceArn = request.path("SourceArn").asText(null);
String destinationArn = request.path("DestinationArn").asText(null);
- String taskHandle = sqsService.startMessageMoveTask(sourceArn, destinationArn, region);
+ int maxRate = request.path("MaxNumberOfMessagesPerSecond").asInt(0);
+ String taskHandle = sqsService.startMessageMoveTask(sourceArn, destinationArn, maxRate, region);
ObjectNode response = objectMapper.createObjectNode();
response.put("TaskHandle", taskHandle);
return Response.ok(response).build();
@@ -420,9 +422,36 @@ public class SqsJsonHandler {
private Response handleListMessageMoveTasks(JsonNode request, String region) {
String sourceArn = request.path("SourceArn").asText(null);
- sqsService.listMessageMoveTasks(sourceArn, region);
+ int maxResults = request.path("MaxResults").asInt(10);
+ List<SqsService.MoveTask> tasks = sqsService.listMessageMoveTasks(sourceArn, region);
ObjectNode response = objectMapper.createObjectNode();
- response.putArray("Results");
+ ArrayNode results = response.putArray("Results");
+ int count = 0;
+ for (SqsService.MoveTask t : tasks) {
+ if (count++ >= maxResults) break;
+ ObjectNode node = results.addObject();
+ node.put("TaskHandle", t.taskHandle());
+ node.put("SourceArn", t.sourceArn());
+ if (t.destinationArn() != null) {
+ node.put("DestinationArn", t.destinationArn());
+ }
+ node.put("MaxNumberOfMessagesPerSecond", t.maxNumberOfMessagesPerSecond());
+ node.put("Status", t.status());
+ node.put("ApproximateNumberOfMessagesMoved", t.approximateNumberOfMessagesMoved());
+ node.put("ApproximateNumberOfMessagesToMove", t.approximateNumberOfMessagesToMove());
+ node.put("StartedTimestamp", t.startedTimestampMillis());
+ if (t.failureReason() != null) {
+ node.put("FailureReason", t.failureReason());
+ }
+ }
+ return Response.ok(response).build();
+ }
+
+ private Response handleCancelMessageMoveTask(JsonNode request, String region) {
+ String taskHandle = request.path("TaskHandle").asText(null);
+ long moved = sqsService.cancelMessageMoveTask(taskHandle, region);
+ ObjectNode response = objectMapper.createObjectNode();
+ response.put("ApproximateNumberOfMessagesMoved", moved);
return Response.ok(response).build();
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/sqs/SqsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/sqs/SqsQueryHandler.java
index 782925f9ae..26e2708119 100644
--- a/src/main/java/io/github/hectorvent/floci/services/sqs/SqsQueryHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/sqs/SqsQueryHandler.java
@@ -56,6 +56,7 @@ public class SqsQueryHandler {
case "ListDeadLetterSourceQueues" -> handleListDeadLetterSourceQueues(params, region);
case "StartMessageMoveTask" -> handleStartMessageMoveTask(params, region);
case "ListMessageMoveTasks" -> handleListMessageMoveTasks(params, region);
+ case "CancelMessageMoveTask" -> handleCancelMessageMoveTask(params, region);
case "AddPermission" -> handleAddPermission(params, region);
case "RemovePermission" -> handleRemovePermission(params, region);
default -> AwsQueryResponse.error("UnsupportedOperation",
@@ -377,18 +378,46 @@ public class SqsQueryHandler {
private Response handleStartMessageMoveTask(MultivaluedMap<String, String> params, String region) {
String sourceArn = getParam(params, "SourceArn");
String destinationArn = getParam(params, "DestinationArn");
- String taskHandle = sqsService.startMessageMoveTask(sourceArn, destinationArn, region);
+ int maxRate = getIntParam(params, "MaxNumberOfMessagesPerSecond", 0);
+ String taskHandle = sqsService.startMessageMoveTask(sourceArn, destinationArn, maxRate, region);
var xml = new XmlBuilder().elem("TaskHandle", taskHandle);
return Response.ok(AwsQueryResponse.envelope("StartMessageMoveTask", null, xml.build())).build();
}
private Response handleListMessageMoveTasks(MultivaluedMap<String, String> params, String region) {
String sourceArn = getParam(params, "SourceArn");
- sqsService.listMessageMoveTasks(sourceArn, region);
- var xml = new XmlBuilder(); // Empty list for mock
+ int maxResults = getIntParam(params, "MaxResults", 10);
+ List<SqsService.MoveTask> tasks = sqsService.listMessageMoveTasks(sourceArn, region);
+ var xml = new XmlBuilder();
+ int count = 0;
+ for (SqsService.MoveTask t : tasks) {
+ if (count++ >= maxResults) break;
+ xml.start("member")
+ .elem("TaskHandle", t.taskHandle())
+ .elem("SourceArn", t.sourceArn());
+ if (t.destinationArn() != null) {
+ xml.elem("DestinationArn", t.destinationArn());
+ }
+ xml.elem("MaxNumberOfMessagesPerSecond", t.maxNumberOfMessagesPerSecond())
+ .elem("Status", t.status())
+ .elem("ApproximateNumberOfMessagesMoved", t.approximateNumberOfMessagesMoved())
+ .elem("ApproximateNumberOfMessagesToMove", t.approximateNumberOfMessagesToMove())
+ .elem("StartedTimestamp", t.startedTimestampMillis());
+ if (t.failureReason() != null) {
+ xml.elem("FailureReason", t.failureReason());
+ }
+ xml.end("member");
+ }
return Response.ok(AwsQueryResponse.envelope("ListMessageMoveTasks", null, xml.build())).build();
}
+ private Response handleCancelMessageMoveTask(MultivaluedMap<String, String> params, String region) {
+ String taskHandle = getParam(params, "TaskHandle");
+ long moved = sqsService.cancelMessageMoveTask(taskHandle, region);
+ var xml = new XmlBuilder().elem("ApproximateNumberOfMessagesMoved", moved);
+ return Response.ok(AwsQueryResponse.envelope("CancelMessageMoveTask", null, xml.build())).build();
+ }
+
private Response handlePurgeQueue(MultivaluedMap<String, String> params, String region) {
String queueUrl = getParam(params, "QueueUrl");
sqsService.purgeQueue(queueUrl, region);
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 ce615126cf..45caef03ba 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
@@ -38,12 +38,32 @@ public class SqsService {
private final ConcurrentHashMap<String, Object> queueLocks = new ConcurrentHashMap<>();
private final ConcurrentHashMap<String, RedrivePolicy> redrivePolicyCache = new ConcurrentHashMap<>();
private final ConcurrentHashMap<String, ConcurrentHashMap<String, Instant>> deduplicationCache = new ConcurrentHashMap<>();
+ /** Move tasks keyed by opaque task handle. */
+ private final ConcurrentHashMap<String, MoveTask> moveTasksByHandle = new ConcurrentHashMap<>();
+ /** Per-task cancellation flag the move worker polls between iterations. */
+ private final ConcurrentHashMap<String, java.util.concurrent.atomic.AtomicBoolean> moveTaskCancellation =
+ new ConcurrentHashMap<>();
+ /** Move tasks execute on a background thread so MaxNumberOfMessagesPerSecond can throttle
+ * and CancelMessageMoveTask has something to interrupt. One thread per task is sufficient. */
+ private final java.util.concurrent.ExecutorService moveTaskExecutor =
+ java.util.concurrent.Executors.newCachedThreadPool(r -> {
+ Thread t = new Thread(r, "sqs-move-task");
+ t.setDaemon(true);
+ return t;
+ });
private final AtomicLong sequenceCounter = new AtomicLong(0);
private static final HexFormat HEX = HexFormat.of();
private record RedrivePolicy(int maxReceiveCount, String deadLetterTargetArn) {
}
+ public record MoveTask(String taskHandle, String sourceArn, String destinationArn,
+ int maxNumberOfMessagesPerSecond, String status,
+ long approximateNumberOfMessagesMoved,
+ long approximateNumberOfMessagesToMove,
+ long startedTimestampMillis, String failureReason) {
+ }
+
private final int defaultVisibilityTimeout;
private final int maxMessageSize;
private final String baseUrl;
@@ -651,6 +671,9 @@ public class SqsService {
for (Message msg : dlqCandidates) {
msg.setVisibleAt(null);
msg.setReceiptHandle(null);
+ // Remember where the message came from so StartMessageMoveTask
+ // with no DestinationArn can put it back.
+ msg.setOriginalSourceQueueUrl(queue.getQueueUrl());
}
String dlqStorageKey = regionKey(region, dlqUrl);
getOrCreateQueue(dlqStorageKey).addAll(dlqCandidates);
@@ -769,8 +792,7 @@ public class SqsService {
List<String> sourceQueues = new ArrayList<>();
String prefix = region + "::";
for (Queue q : queueStore.scan(k -> k.startsWith(prefix))) {
- String redrive = q.getAttributes().get("RedrivePolicy");
- if (redrive != null && redrive.contains(targetArn)) {
+ if (targetArn.equals(redriveDlqArn(q))) {
sourceQueues.add(q.getQueueUrl());
}
}
@@ -778,29 +800,238 @@ public class SqsService {
}
public String startMessageMoveTask(String sourceArn, String destinationArn, String region) {
+ return startMessageMoveTask(sourceArn, destinationArn, 0, region);
+ }
+
+ public String startMessageMoveTask(String sourceArn, String destinationArn,
+ int maxNumberOfMessagesPerSecond, String region) {
+ if (sourceArn == null) {
+ throw new AwsException("InvalidParameterValue", "SourceArn is required.", 400);
+ }
String sourceUrl = queueUrlFromArn(sourceArn, region);
- String destUrl = destinationArn != null ? queueUrlFromArn(destinationArn, region) : null;
if (sourceUrl == null) {
- throw new AwsException("InvalidParameterValue", "Invalid source ARN", 400);
+ throw new AwsException("InvalidParameterValue",
+ "Invalid source ARN: " + sourceArn, 400);
}
-
String srcKey = regionKey(region, sourceUrl);
- ensureQueueExists(srcKey);
+ if (queueStore.get(srcKey).isEmpty()) {
+ throw new AwsException("ResourceNotFoundException",
+ "The resource that you specified for the SourceArn parameter does not exist.", 404);
+ }
+ // Source must be referenced as a DLQ by some other queue's RedrivePolicy.
+ if (!isDeadLetterQueue(sourceArn, region)) {
+ throw new AwsException("InvalidParameterValue",
+ "Source queue is not configured as a dead-letter queue.", 400);
+ }
+ // Reject a second task that races against a still-active one for the same source.
+ // The move runs on a background worker, so RUNNING is the canonical "active" check;
+ // the additional 1-second window covers the small gap between StartMessageMoveTask
+ // returning and the worker flipping the task to RUNNING (so back-to-back start
+ // calls that AWS would reject can't slip through).
+ long now = System.currentTimeMillis();
+ for (MoveTask existing : moveTasksByHandle.values()) {
+ if (!sourceArn.equals(existing.sourceArn())) {
+ continue;
+ }
+ if ("RUNNING".equals(existing.status())
+ || (now - existing.startedTimestampMillis()) < 1_000) {
+ throw new AwsException("InvalidParameterValue",
+ "There is already a task running. Only one active task is allowed for a source queue arn at a given time.",
+ 400);
+ }
+ }
- var srcQueue = getOrCreateQueue(srcKey);
- List<Message> drained = srcQueue.drainAll();
+ String destUrl = null;
+ if (destinationArn != null) {
+ destUrl = queueUrlFromArn(destinationArn, region);
+ if (destUrl == null) {
+ throw new AwsException("ResourceNotFoundException",
+ "The resource that you specified for the DestinationArn parameter does not exist.", 404);
+ }
+ String destKey = regionKey(region, destUrl);
+ if (queueStore.get(destKey).isEmpty()) {
+ throw new AwsException("ResourceNotFoundException",
+ "The resource that you specified for the DestinationArn parameter does not exist.", 404);
+ }
+ }
+
+ var srcQueueInitial = getOrCreateQueue(srcKey);
+ long toMove = srcQueueInitial.messageCounts().visible()
+ + srcQueueInitial.messageCounts().inFlight();
+
+ String taskHandle = "task-" + UUID.randomUUID();
+ moveTasksByHandle.put(taskHandle, new MoveTask(
+ taskHandle, sourceArn, destinationArn,
+ maxNumberOfMessagesPerSecond, "RUNNING",
+ 0L, toMove, System.currentTimeMillis(), null));
+ var cancelled = new java.util.concurrent.atomic.AtomicBoolean(false);
+ moveTaskCancellation.put(taskHandle, cancelled);
+
+ // Move the first message synchronously inside the request scope so callers
+ // that poll the destination immediately after StartMessageMoveTask returns
+ // see motion without racing against the executor's thread startup. The
+ // remainder runs on the background worker at the requested rate, draining
+ // one message at a time so the source queue stays observably populated.
+ long initialMoved = 0;
+ Message firstMsg = srcQueueInitial.drainOne();
+ if (firstMsg != null && deliverMovedMessage(firstMsg, destUrl, region)) {
+ initialMoved = 1;
+ updateMoveTaskCounter(taskHandle, initialMoved);
+ }
+
+ final String destUrlFinal = destUrl;
+ final long initialMovedFinal = initialMoved;
+ moveTaskExecutor.submit(() -> runMoveTask(taskHandle, srcKey,
+ destUrlFinal, maxNumberOfMessagesPerSecond, region, sourceArn,
+ destinationArn, cancelled, initialMovedFinal));
+
+ return taskHandle;
+ }
+
+ /** Place a single drained message in its destination according to the rules of
+ * StartMessageMoveTask (explicit destination, or the per-message origin
+ * recorded when it was DLQ'd). Resets per-receive state so the message
+ * starts a fresh life. Returns true when the message was placed. */
+ private boolean deliverMovedMessage(Message msg, String destUrl, String region) {
+ msg.setReceiveCount(0);
+ msg.setFirstReceiveTimestamp(null);
+ msg.setReceiptHandle(null);
+ msg.setVisibleAt(null);
if (destUrl != null) {
String destKey = regionKey(region, destUrl);
- ensureQueueExists(destKey);
- getOrCreateQueue(destKey).addAll(drained);
+ getOrCreateQueue(destKey).addAll(List.of(msg));
+ return true;
+ }
+ if (msg.getOriginalSourceQueueUrl() != null) {
+ // No request scope on the background worker, so queueStore.get() resolves
+ // to the default account prefix and can't verify the destination. The
+ // in-memory messagesByQueue map is keyed by the full URL (which carries
+ // the account), so addAll on the right storage key lands the message in
+ // the queue any future receive will see.
+ String originKey = regionKey(region, msg.getOriginalSourceQueueUrl());
+ getOrCreateQueue(originKey).addAll(List.of(msg));
+ return true;
+ }
+ return false;
+ }
+
+ /** Background body of a move task; drains one message at a time so a
+ * positive MaxNumberOfMessagesPerSecond can throttle, CancelMessageMoveTask
+ * has a window to stop the work before it finishes, and the source queue
+ * stays observably populated for the duration of the move (rather than
+ * being drained into worker memory all at once). */
+ private void runMoveTask(String taskHandle, String srcKey, String destUrl,
+ int maxRate, String region, String sourceArn,
+ String destinationArn,
+ java.util.concurrent.atomic.AtomicBoolean cancelled,
+ long initialMoved) {
+ long intervalMillis = maxRate > 0 ? Math.max(1L, 1000L / maxRate) : 0L;
+ long moved = initialMoved;
+ try {
+ var srcQueue = getOrCreateQueue(srcKey);
+ while (!cancelled.get()) {
+ if (intervalMillis > 0) {
+ try {
+ Thread.sleep(intervalMillis);
+ } catch (InterruptedException ie) {
+ Thread.currentThread().interrupt();
+ return;
+ }
+ if (cancelled.get()) {
+ break;
+ }
+ }
+ Message msg = srcQueue.drainOne();
+ if (msg == null) {
+ break;
+ }
+ if (deliverMovedMessage(msg, destUrl, region)) {
+ moved++;
+ updateMoveTaskCounter(taskHandle, moved);
+ }
+ }
+ } finally {
+ MoveTask cur = moveTasksByHandle.get(taskHandle);
+ if (cur != null) {
+ String status = cancelled.get() ? "CANCELLED" : "COMPLETED";
+ moveTasksByHandle.put(taskHandle, new MoveTask(
+ cur.taskHandle(), cur.sourceArn(), cur.destinationArn(),
+ cur.maxNumberOfMessagesPerSecond(), status,
+ moved, cur.approximateNumberOfMessagesToMove(),
+ cur.startedTimestampMillis(), cur.failureReason()));
+ }
+ LOG.infov("Move task {0} {1}: moved {2} messages from {3} to {4}", taskHandle,
+ cancelled.get() ? "cancelled" : "completed", moved, sourceArn,
+ destinationArn != null ? destinationArn : "original source");
}
+ }
- LOG.infov("Moved messages from {0} to {1}", sourceArn, destinationArn != null ? destinationArn : "original source");
- return "task-" + UUID.randomUUID().toString();
+ private void updateMoveTaskCounter(String taskHandle, long moved) {
+ MoveTask cur = moveTasksByHandle.get(taskHandle);
+ if (cur == null) {
+ return;
+ }
+ moveTasksByHandle.put(taskHandle, new MoveTask(
+ cur.taskHandle(), cur.sourceArn(), cur.destinationArn(),
+ cur.maxNumberOfMessagesPerSecond(), cur.status(),
+ moved, cur.approximateNumberOfMessagesToMove(),
+ cur.startedTimestampMillis(), cur.failureReason()));
+ }
+
+ public List<MoveTask> listMessageMoveTasks(String sourceArn, String region) {
+ if (sourceArn == null) {
+ return List.of();
+ }
+ List<MoveTask> matching = new ArrayList<>();
+ for (MoveTask t : moveTasksByHandle.values()) {
+ if (sourceArn.equals(t.sourceArn())) {
+ matching.add(t);
+ }
+ }
+ matching.sort(Comparator.comparingLong(MoveTask::startedTimestampMillis).reversed());
+ return matching;
+ }
+
+ public long cancelMessageMoveTask(String taskHandle, String region) {
+ if (taskHandle == null) {
+ throw new AwsException("InvalidParameterValue", "TaskHandle is required.", 400);
+ }
+ MoveTask task = moveTasksByHandle.get(taskHandle);
+ if (task == null) {
+ throw new AwsException("ResourceNotFoundException",
+ "The task you specified does not exist.", 404);
+ }
+ // Signal the background worker to stop. The worker flips status to CANCELLED in
+ // its finally block and updates the moved counter; read both back here.
+ var flag = moveTaskCancellation.get(taskHandle);
+ if (flag != null) {
+ flag.set(true);
+ }
+ return moveTasksByHandle.getOrDefault(taskHandle, task).approximateNumberOfMessagesMoved();
}
- public List<Map<String, Object>> listMessageMoveTasks(String sourceArn, String region) {
- return Collections.emptyList();
+ private boolean isDeadLetterQueue(String queueArn, String region) {
+ String prefix = region + "::";
+ for (Queue q : queueStore.scan(k -> k.startsWith(prefix))) {
+ if (queueArn.equals(redriveDlqArn(q))) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static String redriveDlqArn(Queue queue) {
+ String raw = queue.getAttributes().get("RedrivePolicy");
+ if (raw == null) {
+ return null;
+ }
+ try {
+ JsonNode policy = new com.fasterxml.jackson.databind.ObjectMapper().readTree(raw);
+ JsonNode dlqArn = policy.get("deadLetterTargetArn");
+ return dlqArn != null && !dlqArn.isNull() ? dlqArn.asText() : null;
+ } catch (Exception e) {
+ return null;
+ }
}
public record ChangeVisibilityBatchEntry(String id, String receiptHandle, int visibilityTimeout) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/sqs/model/Message.java b/src/main/java/io/github/hectorvent/floci/services/sqs/model/Message.java
index 0dab645b4e..f1e2dde91f 100644
--- a/src/main/java/io/github/hectorvent/floci/services/sqs/model/Message.java
+++ b/src/main/java/io/github/hectorvent/floci/services/sqs/model/Message.java
@@ -27,6 +27,12 @@ public class Message {
private String messageDeduplicationId;
private long sequenceNumber;
+ // When this message was relocated to a DLQ via the redrive policy, the URL of the
+ // queue it came from. Consumed by StartMessageMoveTask with no DestinationArn so
+ // we can return each message to where it originated. Not part of any AWS-visible
+ // surface.
+ private String originalSourceQueueUrl;
+
// Transient fields for visibility timeout tracking
@JsonIgnore
private String receiptHandle;
@@ -85,6 +91,9 @@ public class Message {
public long getSequenceNumber() { return sequenceNumber; }
public void setSequenceNumber(long sequenceNumber) { this.sequenceNumber = sequenceNumber; }
+ public String getOriginalSourceQueueUrl() { return originalSourceQueueUrl; }
+ public void setOriginalSourceQueueUrl(String originalSourceQueueUrl) { this.originalSourceQueueUrl = originalSourceQueueUrl; }
+
@JsonIgnore
public boolean isVisible() {
return visibleAt == null || !Instant.now().isBefore(visibleAt);
diff --git a/src/test/java/io/github/hectorvent/floci/services/sqs/SqsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/sqs/SqsServiceTest.java
index a8b72b3300..3058e1533e 100644
--- a/src/test/java/io/github/hectorvent/floci/services/sqs/SqsServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/sqs/SqsServiceTest.java
@@ -596,6 +596,139 @@ class SqsServiceTest {
assertEquals("msg3", third.get(0).getBody());
}
+ private static String queueArn(String name) {
+ return "arn:aws:sqs:us-east-1:000000000000:" + name;
+ }
+
+ @Test
+ void startMessageMoveTask_storesTaskRetrievableByListMessageMoveTasks() {
+ sqsService.createQueue("orders-dlq", null);
+ String dlqArn = queueArn("orders-dlq");
+ sqsService.createQueue("orders",
+ Map.of("RedrivePolicy",
+ "{\"deadLetterTargetArn\":\"" + dlqArn + "\",\"maxReceiveCount\":\"1\"}"));
+ sqsService.createQueue("orders-replay", null);
+ String destArn = queueArn("orders-replay");
+
+ String taskHandle = sqsService.startMessageMoveTask(dlqArn, destArn, 25, "us-east-1");
+
+ assertNotNull(taskHandle);
+ List<SqsService.MoveTask> tasks = sqsService.listMessageMoveTasks(dlqArn, "us-east-1");
+ SqsService.MoveTask task = tasks.get(0);
+ assertEquals(taskHandle, task.taskHandle());
+ assertEquals(dlqArn, task.sourceArn());
+ assertEquals(destArn, task.destinationArn());
+ assertEquals(25, task.maxNumberOfMessagesPerSecond());
+ }
+
+ @Test
+ void startMessageMoveTask_destinationDoesNotExist_throwsResourceNotFound() {
+ sqsService.createQueue("a-dlq", null);
+ String dlqArn = queueArn("a-dlq");
+ sqsService.createQueue("a",
+ Map.of("RedrivePolicy",
+ "{\"deadLetterTargetArn\":\"" + dlqArn + "\",\"maxReceiveCount\":\"1\"}"));
+
+ AwsException ex = assertThrows(AwsException.class, () ->
+ sqsService.startMessageMoveTask(dlqArn, queueArn("nope"), 0, "us-east-1"));
+ assertEquals("ResourceNotFoundException", ex.getErrorCode());
+ }
+
+ @Test
+ void startMessageMoveTask_sourceIsNotDeadLetterQueue_throwsInvalidParameterValue() {
+ sqsService.createQueue("just-a-queue", null);
+ sqsService.createQueue("dest", null);
+
+ AwsException ex = assertThrows(AwsException.class, () ->
+ sqsService.startMessageMoveTask(queueArn("just-a-queue"),
+ queueArn("dest"), 0, "us-east-1"));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ }
+
+ @Test
+ void startMessageMoveTask_doesNotMatchSubstringOfAnotherQueueArn() {
+ // Regression: isDeadLetterQueue / listDeadLetterSourceQueues used to
+ // substring-match the raw RedrivePolicy JSON, so a queue named "foo"
+ // would be falsely treated as a DLQ when another queue's redrive policy
+ // referenced ":foo-bar". Now both look at the parsed deadLetterTargetArn.
+ sqsService.createQueue("dlq-real", null);
+ String realDlqArn = queueArn("dlq-real");
+ sqsService.createQueue("main-real",
+ Map.of("RedrivePolicy",
+ "{\"deadLetterTargetArn\":\"" + realDlqArn + "\",\"maxReceiveCount\":\"1\"}"));
+
+ // Create a queue whose ARN is a strict prefix of realDlqArn.
+ sqsService.createQueue("dlq", null);
+ String prefixArn = queueArn("dlq");
+ sqsService.createQueue("dest", null);
+
+ AwsException ex = assertThrows(AwsException.class, () ->
+ sqsService.startMessageMoveTask(prefixArn, queueArn("dest"), 0, "us-east-1"));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+
+ // listDeadLetterSourceQueues should also only return source queues whose
+ // redrive policy references the exact ARN, not a substring match.
+ assertEquals(0, sqsService.listDeadLetterSourceQueues(
+ sqsService.getQueueUrl("dlq", "us-east-1"), "us-east-1").size());
+ assertEquals(1, sqsService.listDeadLetterSourceQueues(
+ sqsService.getQueueUrl("dlq-real", "us-east-1"), "us-east-1").size());
+ }
+
+ @Test
+ void startMessageMoveTask_concurrentSecondTaskOnSameSource_throwsInvalidParameterValue() {
+ sqsService.createQueue("d-concurrent", null);
+ String dlqArn = queueArn("d-concurrent");
+ sqsService.createQueue("p-concurrent",
+ Map.of("RedrivePolicy",
+ "{\"deadLetterTargetArn\":\"" + dlqArn + "\",\"maxReceiveCount\":\"1\"}"));
+ sqsService.createQueue("dest-concurrent", null);
+ String destArn = queueArn("dest-concurrent");
+
+ sqsService.startMessageMoveTask(dlqArn, destArn, 0, "us-east-1");
+
+ AwsException ex = assertThrows(AwsException.class, () ->
+ sqsService.startMessageMoveTask(dlqArn, destArn, 0, "us-east-1"));
+ assertEquals("InvalidParameterValue", ex.getErrorCode());
+ assertTrue(ex.getMessage().toLowerCase().contains("already a task running"));
+ }
+
+ @Test
+ void cancelMessageMoveTask_unknownHandle_throwsResourceNotFound() {
+ AwsException ex = assertThrows(AwsException.class, () ->
+ sqsService.cancelMessageMoveTask("task-does-not-exist", "us-east-1"));
+ assertEquals("ResourceNotFoundException", ex.getErrorCode());
+ }
+
+ @Test
+ void cancelMessageMoveTask_knownHandle_stopsBackgroundWorker() throws Exception {
+ Queue dlq = sqsService.createQueue("d", null);
+ String dlqArn = queueArn("d");
+ sqsService.createQueue("p",
+ Map.of("RedrivePolicy",
+ "{\"deadLetterTargetArn\":\"" + dlqArn + "\",\"maxReceiveCount\":\"1\"}"));
+ sqsService.createQueue("dest", null);
+ String destArn = queueArn("dest");
+
+ // Load enough messages that, at the throttled rate, the worker can't possibly
+ // drain the queue before cancel is observed.
+ for (int i = 0; i < 50; i++) {
+ sqsService.sendMessage(dlq.getQueueUrl(), "msg-" + i, 0, null, null);
+ }
+
+ String taskHandle = sqsService.startMessageMoveTask(dlqArn, destArn, 1, "us-east-1");
+ sqsService.cancelMessageMoveTask(taskHandle, "us-east-1");
+
+ // Give the worker a moment to observe the cancel and write the terminal status.
+ for (int i = 0; i < 50; i++) {
+ var status = sqsService.listMessageMoveTasks(dlqArn, "us-east-1").get(0).status();
+ if ("CANCELLED".equals(status)) {
+ return;
+ }
+ Thread.sleep(50);
+ }
+ fail("Move task did not transition to CANCELLED within timeout");
+ }
+
@Test
void fifoDedup_scopedToMessageGroup_acceptsSameDedupIdAcrossGroups() {
Queue fifo = sqsService.createQueue("fair.fifo",