Call CompletionCallback just once with DefaultExceptionMapper

core-server/src/main/java/org/glassfish/jersey/server/DefaultExceptionMapper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2022 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
@@ -19,6 +19,7 @@
 import jakarta.ws.rs.WebApplicationException;
 import jakarta.ws.rs.core.Response;
 import jakarta.ws.rs.ext.ExceptionMapper;
+import org.glassfish.jersey.server.internal.LocalizationMessages;
 
 class DefaultExceptionMapper implements ExceptionMapper<Throwable> {
  @Override
@@ -35,6 +36,8 @@ private static Response processWebApplicationException(WebApplicationException e
  }
 
  private static Response processDefaultException(Throwable exception) {
- return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(exception.getMessage()).build();
+ return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+ .entity(LocalizationMessages.ERROR_EXCEPTION_MAPPING_THROWN_TO_CONTAINER())
+ .build();
  }
 }

core-server/src/main/java/org/glassfish/jersey/server/ServerRuntime.java

@@ -365,11 +365,11 @@ public Responder(final RequestProcessingContext processingContext, final ServerR
 
  public void process(ContainerResponse response) {
  processingContext.monitoringEventBuilder().setContainerResponse(response);
- response = processResponse(response);
+ response = processResponse(response, null);
  release(response);
  }
 
- private ContainerResponse processResponse(ContainerResponse response) {
+ private ContainerResponse processResponse(ContainerResponse response, Throwable unmappedThrowable) {
  final Stage<ContainerResponse> respondingRoot = processingContext.createRespondingRoot();
 
  if (respondingRoot != null) {
@@ -379,7 +379,7 @@ private ContainerResponse processResponse(ContainerResponse response) {
 
  // no-exception zone
  // the methods below are guaranteed to not throw any exceptions
- completionCallbackRunner.onComplete(null);
+ completionCallbackRunner.onComplete(unmappedThrowable);
  return response;
  }
 
@@ -427,7 +427,7 @@ public void process(final Throwable throwable) {
  final Response exceptionResponse = mapException(throwable);
  try {
  response = preProcessResponse(exceptionResponse, request);
- processResponse(response);
+ processResponse(response, null);
  } catch (final Throwable respError) {
  LOGGER.log(Level.SEVERE, LocalizationMessages.ERROR_PROCESSING_RESPONSE_FROM_ALREADY_MAPPED_EXCEPTION());
  processingContext.monitoringEventBuilder()
@@ -448,9 +448,10 @@ public void process(final Throwable throwable) {
  try {
  request.getResponseWriter().failure(responseError);
  } finally {
- completionCallbackRunner.onComplete(responseError);
-
  defaultMapperResponse = processResponseWithDefaultExceptionMapper(responseError, request);
+
+ // completionCallbackRunner.onComplete(responseError); is called from
+ // processResponseWithDefaultExceptionMapper
  }
 
  }
@@ -488,7 +489,7 @@ private boolean processResponseError(final Throwable responseError) {
 
  if (processedError != null) {
  processedResponse =
- processResponse(new ContainerResponse(processingContext.request(), processedError));
+ processResponse(new ContainerResponse(processingContext.request(), processedError), null);
  processed = true;
  }
  } catch (final Throwable throwable) {
@@ -545,10 +546,7 @@ private Response mapException(final Throwable originalThrowable) throws Throwabl
 
  final long timestamp = tracingLogger.timestamp(ServerTraceEvent.EXCEPTION_MAPPING);
  final ExceptionMapper mapper = runtime.exceptionMappers.findMapping(throwable);
- if (mapper != null
- && !DefaultExceptionMapper.class.getName()
- .equals(mapper.getClass().getName())
- ) {
+ if (mapper != null && !DefaultExceptionMapper.class.isInstance(mapper)) {
  return processExceptionWithMapper(mapper, throwable, timestamp);
  }
  if (waeResponse != null) {
@@ -625,7 +623,7 @@ private ContainerResponse processResponseWithDefaultExceptionMapper(Throwable ex
  ContainerRequest request) {
  long timestamp = tracingLogger.timestamp(ServerTraceEvent.EXCEPTION_MAPPING);
  final Response response = processExceptionWithMapper(DEFAULT_EXCEPTION_MAPPER, exception, timestamp);
- return processResponse(preProcessResponse(response, request));
+ return processResponse(preProcessResponse(response, request), exception);
  }
 
  private ContainerResponse writeResponse(final ContainerResponse response) {

core-server/src/test/java/org/glassfish/jersey/server/DefaultExceptionMapperTest.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2022 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.server;
+
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.container.AsyncResponse;
+import jakarta.ws.rs.container.CompletionCallback;
+import jakarta.ws.rs.container.Suspended;
+import jakarta.ws.rs.core.Response;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class DefaultExceptionMapperTest {
+ public static final String MESSAGE = "DefaultExceptionMapperTest I/O Exception";
+ @Test
+ public void testIOException() {
+ IOException ioe = new IOException(MESSAGE);
+ DefaultExceptionMapper mapper = new DefaultExceptionMapper();
+ Response response = mapper.toResponse(ioe);
+ Assert.assertFalse(response.getEntity().toString().contains(MESSAGE));
+ }
+
+ @Test
+ public void testCompletionCallback() {
+ AtomicInteger counter = new AtomicInteger();
+ CompletionCallback hitOnceCallback = new CompletionCallback() {
+ @Override
+ public void onComplete(Throwable throwable) {
+ counter.incrementAndGet();
+ }
+ };
+ ResourceConfig resourceConfig = new ResourceConfig().register(new IOExThrowingResource(hitOnceCallback));
+ ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
+ try {
+ applicationHandler.apply(RequestContextBuilder.from("/", "GET").build()).get();
+ } catch (Exception e) {
+ // expected
+ }
+
+ Assert.assertEquals(1, counter.get());
+ }
+
+ @Path("/")
+ public static class IOExThrowingResource {
+ private final CompletionCallback callback;
+
+ public IOExThrowingResource(CompletionCallback callback) {
+ this.callback = callback;
+ }
+
+ @GET
+ public String doGet(@Suspended AsyncResponse asyncResponse) throws IOException {
+ asyncResponse.register(callback);
+ throw new IOException(MESSAGE);
+ }
+ }
+}