fix: don't use ErrorHandler for IOExceptions in StreamReceiverHandler (#10553)

Fixes #10351

Co-authored-by: Pekka Hyvönen <pekka@vaadin.com>

Author: 2 people

flow-server/src/main/java/com/vaadin/flow/server/communication/StreamReceiverHandler.java

@@ -187,9 +187,16 @@ protected void doHandleMultipartFileUpload(VaadinSession session,
                 success = handleMultipartFileUploadFromInputStream(session,
                         request, streamReceiver, owner);
             }
+        } catch (IOException exception) {
+            // do not report IO exceptions via ErrorHandler
+            getLogger().warn(
+                    "IO Exception during file upload, fired as StreamingErrorEvent",
+                    exception);
         } catch (Exception exception) {
             session.lock();
             try {
+                // Report other than IO exceptions, which are mistakes, via
+                // ErrorHandler
                 session.getErrorHandler().error(new ErrorEvent(exception));
             } finally {
                 session.unlock();
@@ -500,37 +507,39 @@ private final Pair<Boolean, UploadStatus> streamToReceiver(
                 session.unlock();
             }
             success = true;
-        } catch (UploadInterruptedException e) {
-            // Download interrupted by application code
-            tryToCloseStream(out);
-            StreamVariable.StreamingErrorEvent event = new StreamingErrorEventImpl(
-                    filename, type, contentLength, totalBytes, e);
-            session.lock();
-            try {
-                streamVariable.streamingFailed(event);
-            } finally {
-                session.unlock();
-            }
-            // Note, we are not throwing interrupted exception forward as it is
-            // not a terminal level error like all other exception.
+        } catch (UploadInterruptedException | IOException e) {
+            // Download is either interrupted by application code or some
+            // IOException happens
+            onStreamingFailed(session, filename, type, contentLength,
+                    streamVariable, out, totalBytes, e);
+            // Interrupted exception and IOEXception are not thrown forward:
+            // it's enough to fire them via streamVariable
         } catch (final Exception e) {
-            tryToCloseStream(out);
-            session.lock();
-            try {
-                StreamVariable.StreamingErrorEvent event = new StreamingErrorEventImpl(
-                        filename, type, contentLength, totalBytes, e);
-                streamVariable.streamingFailed(event);
-                // throw exception for terminal to be handled (to be passed to
-                // terminalErrorHandler)
-                throw new UploadException(e);
-            } finally {
-                session.unlock();
-            }
+            onStreamingFailed(session, filename, type, contentLength,
+                    streamVariable, out, totalBytes, e);
+            // Throw not IOException and interrupted exception for terminal to
+            // be handled (to be passed to terminalErrorHandler): such
+            // exceptions mean mistakes in the implementation logic (not upload
+            // I/O operations).
+            throw new UploadException(e);
         }
         return new Pair<>(startedEvent.isDisposed(),
                 success ? UploadStatus.OK : UploadStatus.ERROR);
     }
 
+    private void onStreamingFailed(VaadinSession session, String filename,
+            String type, long contentLength, StreamVariable streamVariable,
+            OutputStream out, long totalBytes, final Exception exception) {
+        tryToCloseStream(out);
+        session.lock();
+        try {
+            streamVariable.streamingFailed(new StreamingErrorEventImpl(filename,
+                    type, contentLength, totalBytes, exception));
+        } finally {
+            session.unlock();
+        }
+    }
+
     private long updateProgress(VaadinSession session,
             StreamVariable streamVariable,
             StreamingProgressEventImpl progressEvent, long lastStreamingEvent,

flow-server/src/test/java/com/vaadin/flow/server/communication/StreamReceiverHandlerTest.java

@@ -34,6 +34,7 @@
 import com.vaadin.flow.server.StreamReceiver;
 import com.vaadin.flow.server.StreamResourceRegistry;
 import com.vaadin.flow.server.StreamVariable;
+import com.vaadin.flow.server.UploadException;
 import com.vaadin.flow.server.VaadinRequest;
 import com.vaadin.flow.server.VaadinResponse;
 import com.vaadin.flow.server.VaadinServlet;
@@ -72,6 +73,8 @@ public class StreamReceiverHandlerTest {
     private StreamReceiver streamReceiver;
     @Mock
     private StreamResourceRegistry registry;
+    @Mock
+    private ErrorHandler errorHandler;
 
     private VaadinServletService mockService;
 
@@ -403,4 +406,32 @@ public void partsAreUsedDirectlyIfPresentWithoutParsingInput()
                 ApplicationConstants.CONTENT_TYPE_TEXT_HTML_UTF_8);
         Mockito.verify(response, Mockito.times(0)).setStatus(Mockito.anyInt());
     }
+
+    @Test
+    public void handleFileUploadValidationAndData_inputStreamThrowsIOException_exceptionIsNotRethrown_exceptionIsNotHandlerByErrorHandler()
+            throws UploadException {
+        InputStream inputStream = new InputStream() {
+
+            @Override
+            public int read() throws IOException {
+                throw new IOException();
+            }
+        };
+        handler.handleFileUploadValidationAndData(session, inputStream,
+                streamReceiver, null, null, 0, stateNode);
+
+        verifyZeroInteractions(errorHandler);
+        verify(streamVariable).streamingFailed(Mockito.any());
+    }
+
+    @Test
+    public void doHandleMultipartFileUpload_IOExceptionIsThrown_exceptionIsNotRethrown_exceptionIsNotHandlerByErrorHandler()
+            throws IOException, ServletException {
+        VaadinServletRequest request = Mockito.mock(VaadinServletRequest.class);
+        Mockito.doThrow(IOException.class).when(request).getParts();
+        handler.doHandleMultipartFileUpload(session, request, response,
+                streamReceiver, stateNode);
+        verifyZeroInteractions(errorHandler);
+    }
+
 }