Prevent NPE in the servlet container by writing the entity when the servlet container is shutdown

Signed-off-by: jansupol <jan.supol@oracle.com>

Author: jansupol

containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/internal/ResponseWriter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2024 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2025 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -116,6 +116,10 @@ public void setSuspendTimeout(final long timeOut, final TimeUnit timeUnit) throw
     @Override
     public OutputStream writeResponseStatusAndHeaders(final long contentLength, final ContainerResponse responseContext)
             throws ContainerException {
+        if (asyncExt.isCompleted()) {
+            return null;
+        }
+
         this.responseContext.complete(responseContext);
 
         // first set the content length, so that if headers have an explicit value, it takes precedence over this one

containers/jersey-servlet-core/src/main/java/org/glassfish/jersey/servlet/spi/AsyncContextDelegate.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2025 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -42,4 +42,17 @@ public interface AsyncContextDelegate {
      * Invoked upon a response writing completion when the response write is either committed or canceled.
      */
     public void complete();
+
+    /**
+     * <p>
+     *     Return {@code true} when the AsyncContext is completed, such as when {@link #complete()} has been called.
+     * </p>
+     * <p>
+     *     For compatibility, the default is {@code false}.
+     * </p>
+     * @return {@code true} when the AsyncContext is completed.
+     */
+    public default boolean isCompleted() {
+        return false;
+    }
 }

containers/jersey-servlet/src/main/java/org/glassfish/jersey/servlet/async/AsyncContextDelegateProviderImpl.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2025 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -16,12 +16,15 @@
 
 package org.glassfish.jersey.servlet.async;
 
+import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import javax.servlet.AsyncContext;
+import javax.servlet.AsyncEvent;
+import javax.servlet.AsyncListener;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
@@ -70,10 +73,35 @@ private ExtensionImpl(final HttpServletRequest request, final HttpServletRespons
         public void suspend() throws IllegalStateException {
             // Suspend only if not completed and not suspended before.
             if (!completed.get() && asyncContextRef.get() == null) {
+                AsyncContext asyncContext = getAsyncContext();
+                asyncContext.addListener(new CompletedAsyncContextListener());
                 asyncContextRef.set(getAsyncContext());
             }
         }
 
+        private class CompletedAsyncContextListener implements AsyncListener {
+
+            @Override
+            public void onComplete(AsyncEvent event) throws IOException {
+                complete();
+            }
+
+            @Override
+            public void onTimeout(AsyncEvent event) throws IOException {
+
+            }
+
+            @Override
+            public void onError(AsyncEvent event) throws IOException {
+                complete();
+            }
+
+            @Override
+            public void onStartAsync(AsyncEvent event) throws IOException {
+
+            }
+        }
+
         private AsyncContext getAsyncContext() {
             final AsyncContext asyncContext;
             if (request.isAsyncStarted()) {
@@ -102,5 +130,10 @@ public void complete() {
                 asyncContext.complete();
             }
         }
+
+        @Override
+        public boolean isCompleted() {
+            return completed.get();
+        }
     }
 }

containers/jersey-servlet/src/test/java/org/glassfish/jersey/servlet/async/AsyncContextClosedTest.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.servlet.async;
+
+import org.glassfish.jersey.server.spi.ContainerResponseWriter;
+import org.glassfish.jersey.servlet.internal.ResponseWriter;
+import org.junit.jupiter.api.Test;
+
+import javax.servlet.AsyncContext;
+import javax.servlet.AsyncListener;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+public class AsyncContextClosedTest {
+    @Test
+    public void testClosedAsyncContext() {
+        List<AsyncListener> asyncListeners = new ArrayList<>(1);
+        AsyncContext async = (AsyncContext) Proxy.newProxyInstance(getClass().getClassLoader(),
+                new Class[]{AsyncContext.class}, new InvocationHandler() {
+                    @Override
+                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                        switch (method.getName()) {
+                            case "addListener":
+                                asyncListeners.add((AsyncListener) args[0]);
+                            case "complete":
+                                asyncListeners.forEach((asyncListener -> {
+                                    try {
+                                        asyncListener.onComplete(null);
+                                    } catch (IOException e) {
+                                        throw new RuntimeException(e);
+                                    }
+                                }));
+                        }
+                        return null;
+                    }
+                });
+
+        HttpServletRequest request = (HttpServletRequest) Proxy.newProxyInstance(getClass().getClassLoader(),
+                new Class[]{HttpServletRequest.class}, new InvocationHandler() {
+                    boolean asyncStarted = false;
+
+                    @Override
+                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                        switch (method.getName()) {
+                            case "isAsyncStarted":
+                                return asyncStarted;
+                            case "startAsync":
+                                asyncStarted = true;
+                                return async;
+                            case "getAsyncContext":
+                                return async;
+
+                        }
+                        return null;
+                    }
+                });
+
+        HttpServletResponse response = (HttpServletResponse) Proxy.newProxyInstance(getClass().getClassLoader(),
+                new Class[]{HttpServletResponse.class}, new InvocationHandler() {
+                    @Override
+                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                        return null;
+                    }
+                });
+
+        // Create writer
+        ResponseWriter writer = new ResponseWriter(false, false, response,
+                new AsyncContextDelegateProviderImpl().createDelegate(request, response),
+                Executors.newSingleThreadScheduledExecutor());
+        writer.suspend(10, TimeUnit.SECONDS, new ContainerResponseWriter.TimeoutHandler() {
+            @Override
+            public void onTimeout(ContainerResponseWriter responseWriter) {
+                throw new IllegalStateException();
+            }
+        });
+        // Simulate completion by the Servlet Container;
+        request.getAsyncContext().complete();
+        // Check write is ignored
+        writer.writeResponseStatusAndHeaders(10, null);
+    }
+}