diff --git a/server-common/src/main/java/org/a2aproject/sdk/server/events/EventConsumer.java b/server-common/src/main/java/org/a2aproject/sdk/server/events/EventConsumer.java index a4379fb09..1b3054009 100644 --- a/server-common/src/main/java/org/a2aproject/sdk/server/events/EventConsumer.java +++ b/server-common/src/main/java/org/a2aproject/sdk/server/events/EventConsumer.java @@ -6,6 +6,7 @@ import org.a2aproject.sdk.spec.A2AError; import org.a2aproject.sdk.spec.A2AServerException; import org.a2aproject.sdk.spec.Event; +import org.a2aproject.sdk.spec.InternalError; import org.a2aproject.sdk.spec.Message; import org.a2aproject.sdk.spec.Task; import org.a2aproject.sdk.spec.TaskState; @@ -129,6 +130,21 @@ public Flow.Publisher consumeAll() { System.identityHashCode(queue), error, agentCompleted); item = queue.dequeueEventItem(QUEUE_WAIT_MILLISECONDS); if (item == null) { + // dequeueEventItem returns null on a timeout and also on an interrupt, with the + // interrupt flag still set. Only an interrupt ends this consumer: while the flag + // is set, each later poll returns at once, so polling again would spin. + if (Thread.currentThread().isInterrupted()) { + LOGGER.warn("EventConsumer polling thread interrupted, exiting polling loop for queue {}", System.identityHashCode(queue)); + completed = true; + tube.fail(new InternalError("EventConsumer polling thread was interrupted")); + // The close can read the task store, which can throw on an interrupted thread + try { + queue.close(true); + } catch (RuntimeException e) { + LOGGER.warn("Failed to close the queue {} of an interrupted EventConsumer", System.identityHashCode(queue), e); + } + return; + } int queueSize = queue.size(); boolean awaitingFinal = queue.isAwaitingFinalEvent(); LOGGER.debug("EventConsumer poll timeout (null item), agentCompleted={}, queue.size()={}, awaitingFinalEvent={}, timeoutCount={}, awaitingTimeoutCount={}", diff --git a/server-common/src/main/java/org/a2aproject/sdk/server/events/EventQueue.java b/server-common/src/main/java/org/a2aproject/sdk/server/events/EventQueue.java index c6d59d713..d2c485c3d 100644 --- a/server-common/src/main/java/org/a2aproject/sdk/server/events/EventQueue.java +++ b/server-common/src/main/java/org/a2aproject/sdk/server/events/EventQueue.java @@ -354,7 +354,8 @@ public void enqueueEventLocalOnly(Event event) { *

* * @param waitMilliSeconds the maximum time to wait in milliseconds - * @return the EventQueueItem, or null if timeout occurs + * @return the EventQueueItem, or null if timeout occurs or the wait is interrupted + * (in which case the thread's interrupt flag is set) * @throws EventQueueClosedException if the queue is closed and empty * @throws UnsupportedOperationException if called on MainQueue */ @@ -891,6 +892,9 @@ StreamCloseHandle getStreamCloseHandle() { @Override protected void doClose(boolean immediate) { + if (isClosed()) { + return; + } // Invoke all callbacks BEFORE closing, so they can still enqueue events if (!onCloseCallbacks.isEmpty()) { LOGGER.debug("Invoking {} onClose callbacks for task {} BEFORE closing", onCloseCallbacks.size(), taskId); diff --git a/server-common/src/main/java/org/a2aproject/sdk/server/events/InMemoryQueueManager.java b/server-common/src/main/java/org/a2aproject/sdk/server/events/InMemoryQueueManager.java index 27a42b668..f0154563f 100644 --- a/server-common/src/main/java/org/a2aproject/sdk/server/events/InMemoryQueueManager.java +++ b/server-common/src/main/java/org/a2aproject/sdk/server/events/InMemoryQueueManager.java @@ -89,8 +89,11 @@ public void close(String taskId) { if (existing == null) { throw new NoTaskQueueException(); } - // Close the queue to stop EventConsumer polling loop LOGGER.debug("Closing queue {} for task {}", System.identityHashCode(existing), taskId); + // A graceful MainQueue close leaves its children open, and EventConsumers poll the children + if (existing instanceof EventQueue.MainQueue mainQueue) { + mainQueue.closeChildren(); + } existing.close(); } diff --git a/server-common/src/test/java/org/a2aproject/sdk/server/events/EventConsumerTest.java b/server-common/src/test/java/org/a2aproject/sdk/server/events/EventConsumerTest.java index d290a2dcf..696681c2c 100644 --- a/server-common/src/test/java/org/a2aproject/sdk/server/events/EventConsumerTest.java +++ b/server-common/src/test/java/org/a2aproject/sdk/server/events/EventConsumerTest.java @@ -2,6 +2,7 @@ import static org.a2aproject.sdk.jsonrpc.common.json.JsonUtil.fromJson; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; @@ -11,6 +12,8 @@ import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; import java.util.concurrent.Flow; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; @@ -18,10 +21,12 @@ import org.a2aproject.sdk.jsonrpc.common.json.JsonProcessingException; import org.a2aproject.sdk.server.tasks.InMemoryTaskStore; import org.a2aproject.sdk.server.tasks.PushNotificationSender; +import org.a2aproject.sdk.server.tasks.TaskStateProvider; import org.a2aproject.sdk.spec.A2AError; import org.a2aproject.sdk.spec.A2AServerException; import org.a2aproject.sdk.spec.Artifact; import org.a2aproject.sdk.spec.Event; +import org.a2aproject.sdk.spec.InternalError; import org.a2aproject.sdk.spec.Message; import org.a2aproject.sdk.spec.Task; import org.a2aproject.sdk.spec.TaskArtifactUpdateEvent; @@ -32,6 +37,8 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; public class EventConsumerTest { @@ -139,7 +146,8 @@ public void testConsumeOneJsonRpcErrorEvent() throws Exception { @Test public void testConsumeOneQueueEmpty() throws A2AServerException { - assertThrows(A2AServerException.class, () -> eventConsumer.consumeOne()); + A2AServerException exception = assertThrows(A2AServerException.class, () -> eventConsumer.consumeOne()); + assertInstanceOf(InternalError.class, exception.getCause()); } @Test @@ -589,6 +597,89 @@ public void onComplete() { assertEquals(0, receivedEvents.size(), "QueueClosedEvent should be intercepted, not delivered"); } + @ParameterizedTest(name = "agentCompleted={0}") + @ValueSource(booleans = {false, true}) + public void testConsumeAllStopsWhenPollingThreadIsInterrupted(boolean agentCompleted) throws Exception { + assertInterruptedConsumerFailsAndClosesQueue(eventQueue, agentCompleted); + } + + @Test + public void testInterruptedConsumerFailsWithInternalErrorWhenClosingItsQueueThrows() throws Exception { + EventQueue childQueue = EventQueueUtil.getEventQueueBuilder(mainEventBus) + .taskId(TASK_ID) + .mainEventBus(mainEventBus) + .taskStateProvider(new TaskStateProvider() { + @Override + public boolean isTaskActive(String taskId) { + return true; + } + + @Override + public boolean isTaskFinalized(String taskId) { + // As a JDBC pool does when it must wait for a connection on an interrupted thread + if (Thread.currentThread().isInterrupted()) { + throw new IllegalStateException("Interrupted while acquiring"); + } + return false; + } + }) + .build().tap(); + assertInterruptedConsumerFailsAndClosesQueue(childQueue, false); + } + + private void assertInterruptedConsumerFailsAndClosesQueue(EventQueue queue, boolean agentCompleted) throws Exception { + ExecutorService executor = Executors.newSingleThreadExecutor(); + EventConsumer consumer = new EventConsumer(queue, executor); + if (agentCompleted) { + consumer.createAgentRunnableDoneCallback().done(new EnhancedRunnable() { + @Override + public void run() { + } + }); + } + AtomicReference error = new AtomicReference<>(); + CountDownLatch terminated = new CountDownLatch(1); + + consumer.consumeAll().subscribe(new Flow.Subscriber<>() { + @Override + public void onSubscribe(Flow.Subscription subscription) { + subscription.request(Long.MAX_VALUE); + } + + @Override + public void onNext(EventQueueItem item) { + } + + @Override + public void onError(Throwable throwable) { + error.set(throwable); + terminated.countDown(); + } + + @Override + public void onComplete() { + terminated.countDown(); + } + }); + + try { + queue.awaitQueuePollerStart(); + executor.shutdownNow(); + + assertTrue(terminated.await(5, TimeUnit.SECONDS), + "Interrupted consumer should stop instead of polling again"); + assertInstanceOf(InternalError.class, error.get()); + // The consumer closes its queue after it fails the stream + assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); + assertTrue(queue.isClosed(), "Interrupted consumer should close its queue"); + } finally { + // A loop that ignores the interrupt only ends when the queue closes; close it so the executor can terminate. + queue.close(); + executor.shutdownNow(); + assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); + } + } + private void enqueueAndConsumeOneEvent(Event event) throws Exception { // Use callback to wait for event processing waitForEventProcessing(() -> eventQueue.enqueueEvent(event)); diff --git a/server-common/src/test/java/org/a2aproject/sdk/server/events/InMemoryQueueManagerTest.java b/server-common/src/test/java/org/a2aproject/sdk/server/events/InMemoryQueueManagerTest.java index ced36e695..5039c76a2 100644 --- a/server-common/src/test/java/org/a2aproject/sdk/server/events/InMemoryQueueManagerTest.java +++ b/server-common/src/test/java/org/a2aproject/sdk/server/events/InMemoryQueueManagerTest.java @@ -119,6 +119,19 @@ public void testCloseExistingQueue() { assertNull(result); } + @Test + public void testCloseClosesChildQueues() { + String taskId = "close_children_task_id"; + EventQueue first = queueManager.createOrTap(taskId); + EventQueue second = queueManager.tap(taskId); + assertNotNull(second); + + queueManager.close(taskId); + + assertTrue(first.isClosed(), "close(taskId) should close the ChildQueues that consumers poll"); + assertTrue(second.isClosed(), "close(taskId) should close the ChildQueues that consumers poll"); + } + @Test public void testCloseNonexistentQueueThrowsException() { assertThrows(NoTaskQueueException.class, () -> {