Skip to content

Commit 90a4869

Browse files
committed
Close servlet streamable HTTP transports on async lifecycle events
1 parent 4186ca1 commit 90a4869

2 files changed

Lines changed: 260 additions & 3 deletions

File tree

‎mcp-core/src/main/java/io/modelcontextprotocol/server/transport/HttpServletStreamableServerTransportProvider.java‎

Lines changed: 31 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,8 @@
2727
import io.modelcontextprotocol.util.Assert;
2828
import io.modelcontextprotocol.util.KeepAliveScheduler;
2929
import jakarta.servlet.AsyncContext;
30+
import jakarta.servlet.AsyncEvent;
31+
import jakarta.servlet.AsyncListener;
3032
import jakarta.servlet.ServletException;
3133
import jakarta.servlet.annotation.WebServlet;
3234
import jakarta.servlet.http.HttpServlet;
@@ -538,6 +540,7 @@ else if (message instanceof McpSchema.JSONRPCRequest jsonrpcRequest) {
538540

539541
HttpServletStreamableMcpSessionTransport sessionTransport = new HttpServletStreamableMcpSessionTransport(
540542
sessionId, asyncContext, response.getWriter());
543+
registerAsyncLifecycle(asyncContext, sessionId, sessionTransport::close);
541544

542545
try {
543546
session.responseStream(jsonrpcRequest, sessionTransport)
@@ -546,7 +549,7 @@ else if (message instanceof McpSchema.JSONRPCRequest jsonrpcRequest) {
546549
}
547550
catch (Exception e) {
548551
logger.error("Failed to handle request stream: {}", e.getMessage());
549-
asyncContext.complete();
552+
sessionTransport.close();
550553
}
551554
}
552555
else {
@@ -579,6 +582,32 @@ else if (message instanceof McpSchema.JSONRPCRequest jsonrpcRequest) {
579582
}
580583
}
581584

585+
private void registerAsyncLifecycle(AsyncContext asyncContext, String sessionId, Runnable onClose) {
586+
asyncContext.addListener(new AsyncListener() {
587+
@Override
588+
public void onComplete(AsyncEvent event) throws IOException {
589+
logger.debug("SSE async context completed for session: {}", sessionId);
590+
onClose.run();
591+
}
592+
593+
@Override
594+
public void onTimeout(AsyncEvent event) throws IOException {
595+
logger.debug("SSE async context timed out for session: {}", sessionId);
596+
onClose.run();
597+
}
598+
599+
@Override
600+
public void onError(AsyncEvent event) throws IOException {
601+
logger.debug("SSE async context errored for session: {}", sessionId);
602+
onClose.run();
603+
}
604+
605+
@Override
606+
public void onStartAsync(AsyncEvent event) throws IOException {
607+
}
608+
});
609+
}
610+
582611
/**
583612
* Handles DELETE requests for session deletion.
584613
* @param request The HTTP servlet request
@@ -768,8 +797,7 @@ public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message, String messageId
768797
}
769798
catch (Exception e) {
770799
logger.error("Failed to send message to session {}: {}", this.sessionId, e.getMessage());
771-
HttpServletStreamableServerTransportProvider.this.sessions.remove(this.sessionId);
772-
this.asyncContext.complete();
800+
this.close();
773801
}
774802
finally {
775803
lock.unlock();
Lines changed: 229 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,229 @@
1+
/*
2+
* Copyright 2024-2026 the original author or authors.
3+
*/
4+
5+
package io.modelcontextprotocol.server.transport;
6+
7+
import java.io.ByteArrayInputStream;
8+
import java.io.IOException;
9+
import java.io.PrintWriter;
10+
import java.io.StringWriter;
11+
import java.nio.charset.StandardCharsets;
12+
import java.time.Duration;
13+
import java.util.Map;
14+
import java.util.concurrent.atomic.AtomicReference;
15+
16+
import jakarta.servlet.AsyncContext;
17+
import jakarta.servlet.AsyncEvent;
18+
import jakarta.servlet.AsyncListener;
19+
import jakarta.servlet.ReadListener;
20+
import jakarta.servlet.ServletInputStream;
21+
import jakarta.servlet.ServletOutputStream;
22+
import jakarta.servlet.WriteListener;
23+
import jakarta.servlet.http.HttpServletRequest;
24+
import jakarta.servlet.http.HttpServletResponse;
25+
import org.junit.jupiter.api.Test;
26+
import org.mockito.ArgumentCaptor;
27+
import reactor.core.publisher.Mono;
28+
29+
import io.modelcontextprotocol.json.McpJsonMapper;
30+
import io.modelcontextprotocol.server.McpNotificationHandler;
31+
import io.modelcontextprotocol.server.McpRequestHandler;
32+
import io.modelcontextprotocol.spec.HttpHeaders;
33+
import io.modelcontextprotocol.spec.McpSchema;
34+
import io.modelcontextprotocol.spec.McpStreamableServerSession;
35+
import io.modelcontextprotocol.spec.json.gson.GsonMcpJsonMapper;
36+
37+
import static org.assertj.core.api.Assertions.assertThat;
38+
import static org.mockito.ArgumentMatchers.any;
39+
import static org.mockito.ArgumentMatchers.eq;
40+
import static org.mockito.Mockito.doAnswer;
41+
import static org.mockito.Mockito.mock;
42+
import static org.mockito.Mockito.verify;
43+
import static org.mockito.Mockito.when;
44+
45+
class HttpServletStreamableServerTransportProviderTests {
46+
47+
private final McpJsonMapper jsonMapper = new GsonMcpJsonMapper();
48+
49+
@Test
50+
void postStreamingRequestRegistersAsyncListenerAndClosesTransportOnDisconnect() throws Exception {
51+
HttpServletStreamableServerTransportProvider provider = HttpServletStreamableServerTransportProvider.builder()
52+
.jsonMapper(this.jsonMapper)
53+
.mcpEndpoint("/mcp")
54+
.build();
55+
56+
String sessionId = "session-post";
57+
McpRequestHandler<Object> echoHandler = (exchange, params) -> Mono.just(params);
58+
McpStreamableServerSession session = createSession(sessionId, Map.of("echo", echoHandler), Map.of());
59+
provider.setSessionFactory(request -> new McpStreamableServerSession.McpStreamableServerSessionInit(session,
60+
Mono.just(testInitializeResult())));
61+
62+
initializeSession(provider, sessionId);
63+
64+
HttpServletRequest request = mock(HttpServletRequest.class);
65+
HttpServletResponse response = mock(HttpServletResponse.class);
66+
AsyncContext asyncContext = mock(AsyncContext.class);
67+
StringWriter output = new StringWriter();
68+
PrintWriter writer = new PrintWriter(output, true);
69+
70+
when(request.getRequestURI()).thenReturn("/mcp");
71+
when(request.getHeader("Accept")).thenReturn("text/event-stream, application/json");
72+
when(request.getHeader(HttpHeaders.MCP_SESSION_ID)).thenReturn(sessionId);
73+
when(request.getHeaderNames()).thenReturn(java.util.Collections.emptyEnumeration());
74+
when(request.getInputStream()).thenReturn(servletInputStream(this.jsonMapper
75+
.writeValueAsString(new McpSchema.JSONRPCRequest("echo", "request-1", Map.of("value", "ok")))
76+
.getBytes(StandardCharsets.UTF_8)));
77+
when(request.startAsync()).thenReturn(asyncContext);
78+
when(response.getWriter()).thenReturn(writer);
79+
80+
provider.doPost(request, response);
81+
82+
assertThat(output.toString()).contains("\"result\":{\"value\":\"ok\"}");
83+
84+
ArgumentCaptor<AsyncListener> listenerCaptor = ArgumentCaptor.forClass(AsyncListener.class);
85+
verify(asyncContext).addListener(listenerCaptor.capture());
86+
87+
listenerCaptor.getValue().onError(new AsyncEvent(asyncContext));
88+
89+
verify(asyncContext).complete();
90+
}
91+
92+
@Test
93+
void sendFailureClosesOnlyCurrentTransportWithoutRemovingSession() throws Exception {
94+
HttpServletStreamableServerTransportProvider provider = HttpServletStreamableServerTransportProvider.builder()
95+
.jsonMapper(this.jsonMapper)
96+
.mcpEndpoint("/mcp")
97+
.build();
98+
String sessionId = "session-send-failure";
99+
McpStreamableServerSession session = createSession(sessionId, Map.of(), Map.of());
100+
provider.setSessionFactory(request -> new McpStreamableServerSession.McpStreamableServerSessionInit(session,
101+
Mono.just(testInitializeResult())));
102+
initializeSession(provider, sessionId);
103+
104+
HttpServletRequest getRequest = mock(HttpServletRequest.class);
105+
HttpServletResponse getResponse = mock(HttpServletResponse.class);
106+
AsyncContext getAsyncContext = mock(AsyncContext.class);
107+
PrintWriter failingWriter = new PrintWriter(new FailingServletOutputStream(), true);
108+
109+
when(getRequest.getRequestURI()).thenReturn("/mcp");
110+
when(getRequest.getHeader("Accept")).thenReturn("text/event-stream");
111+
when(getRequest.getHeader(HttpHeaders.MCP_SESSION_ID)).thenReturn(sessionId);
112+
when(getRequest.getHeader(HttpHeaders.LAST_EVENT_ID)).thenReturn(null);
113+
when(getRequest.getHeaderNames()).thenReturn(java.util.Collections.emptyEnumeration());
114+
when(getRequest.startAsync()).thenReturn(getAsyncContext);
115+
when(getResponse.getWriter()).thenReturn(failingWriter);
116+
117+
provider.doGet(getRequest, getResponse);
118+
provider.notifyClient(sessionId, "server/notification", Map.of("boom", true)).block();
119+
120+
verify(getAsyncContext).complete();
121+
122+
HttpServletRequest deleteRequest = mock(HttpServletRequest.class);
123+
HttpServletResponse deleteResponse = mock(HttpServletResponse.class);
124+
when(deleteRequest.getRequestURI()).thenReturn("/mcp");
125+
when(deleteRequest.getHeader(HttpHeaders.MCP_SESSION_ID)).thenReturn(sessionId);
126+
when(deleteRequest.getHeaderNames()).thenReturn(java.util.Collections.emptyEnumeration());
127+
128+
provider.doDelete(deleteRequest, deleteResponse);
129+
130+
verify(deleteResponse).setStatus(HttpServletResponse.SC_OK);
131+
}
132+
133+
private void initializeSession(HttpServletStreamableServerTransportProvider provider, String expectedSessionId)
134+
throws Exception {
135+
HttpServletRequest request = mock(HttpServletRequest.class);
136+
HttpServletResponse response = mock(HttpServletResponse.class);
137+
StringWriter output = new StringWriter();
138+
PrintWriter writer = new PrintWriter(output, true);
139+
when(request.getRequestURI()).thenReturn("/mcp");
140+
when(request.getHeader("Accept")).thenReturn("text/event-stream, application/json");
141+
when(request.getHeaderNames()).thenReturn(java.util.Collections.emptyEnumeration());
142+
when(request.getInputStream()).thenReturn(servletInputStream(this.jsonMapper
143+
.writeValueAsString(
144+
new McpSchema.JSONRPCRequest(McpSchema.METHOD_INITIALIZE, "init-1", testInitializeRequest()))
145+
.getBytes(StandardCharsets.UTF_8)));
146+
when(response.getWriter()).thenReturn(writer);
147+
148+
doAnswer(invocation -> {
149+
assertThat(invocation.getArgument(1, String.class)).isEqualTo(expectedSessionId);
150+
return null;
151+
}).when(response).setHeader(eq(HttpHeaders.MCP_SESSION_ID), any(String.class));
152+
153+
provider.doPost(request, response);
154+
verify(response).setStatus(HttpServletResponse.SC_OK);
155+
}
156+
157+
private McpStreamableServerSession createSession(String sessionId,
158+
Map<String, McpRequestHandler<?>> requestHandlers,
159+
Map<String, McpNotificationHandler> notificationHandlers) {
160+
return new McpStreamableServerSession(sessionId, testInitializeRequest().capabilities(),
161+
testInitializeRequest().clientInfo(), Duration.ofSeconds(2), requestHandlers, notificationHandlers);
162+
}
163+
164+
private McpSchema.InitializeRequest testInitializeRequest() {
165+
return McpSchema.InitializeRequest
166+
.builder("2025-11-25", new McpSchema.ClientCapabilities(null, null, null, null),
167+
new McpSchema.Implementation("test-client", "1.0.0"))
168+
.build();
169+
}
170+
171+
private McpSchema.InitializeResult testInitializeResult() {
172+
return McpSchema.InitializeResult
173+
.builder("2025-11-25", new McpSchema.ServerCapabilities(null, null, null, null, null, null),
174+
new McpSchema.Implementation("test-server", "1.0.0"))
175+
.build();
176+
}
177+
178+
private static ServletInputStream servletInputStream(byte[] data) {
179+
ByteArrayInputStream delegate = new ByteArrayInputStream(data);
180+
return new ServletInputStream() {
181+
182+
@Override
183+
public boolean isFinished() {
184+
return delegate.available() == 0;
185+
}
186+
187+
@Override
188+
public boolean isReady() {
189+
return true;
190+
}
191+
192+
@Override
193+
public void setReadListener(ReadListener readListener) {
194+
}
195+
196+
@Override
197+
public int read() {
198+
return delegate.read();
199+
}
200+
201+
@Override
202+
public int read(byte[] buf, int off, int len) {
203+
return delegate.read(buf, off, len);
204+
}
205+
};
206+
}
207+
208+
private static final class FailingServletOutputStream extends ServletOutputStream {
209+
210+
private final AtomicReference<IOException> failure = new AtomicReference<>(
211+
new IOException("Client disconnected"));
212+
213+
@Override
214+
public void write(int b) throws IOException {
215+
throw this.failure.get();
216+
}
217+
218+
@Override
219+
public boolean isReady() {
220+
return false;
221+
}
222+
223+
@Override
224+
public void setWriteListener(WriteListener writeListener) {
225+
}
226+
227+
}
228+
229+
}

0 commit comments

Comments
 (0)