Fixed swallower access. Now error handler logs exceptions. (#12703)

Change-Id: If8fe00e10c7ec56cbd8753ff88d4816613a340f2

4 files changed, 106 insertions, 2 deletions

diff --git a/server/src/com/vaadin/server/ErrorHandlingRunnable.java b/server/src/com/vaadin/server/ErrorHandlingRunnable.java
new file mode 100644
index 0000000000..8ae6ce3d5d
--- /dev/null
+++ b/server/src/com/vaadin/server/ErrorHandlingRunnable.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2000-2013 Vaadin Ltd.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.server;
+
+/**
+ * Defines the interface to handle exceptions thrown during the execution of a
+ * FutureAccess.
+ * 
+ * @since 7.1.8
+ * @author Vaadin Ltd
+ */
+public interface ErrorHandlingRunnable extends Runnable {
+
+    /**
+     * Handles exceptions thrown during the execution of a FutureAccess.
+     * 
+     * @since 7.1.8
+     * @param exception
+     *            the thrown exception.
+     */
+    public void handleError(Exception exception);
+
+}
diff --git a/server/src/com/vaadin/server/VaadinService.java b/server/src/com/vaadin/server/VaadinService.java
index c9a5f0974a..44ceaaaf87 100644
--- a/server/src/com/vaadin/server/VaadinService.java
+++ b/server/src/com/vaadin/server/VaadinService.java
@@ -1745,6 +1745,13 @@ public abstract class VaadinService implements Serializable {
                             .getCurrentInstances());
                     CurrentInstance.setCurrent(session);
                     pendingAccess.run();
+
+                    try {
+                        pendingAccess.get();
+
+                    } catch (Exception exception) {
+                        pendingAccess.handleError(exception);
+                    }
                 }
             }
         } finally {
@@ -1752,5 +1759,4 @@ public abstract class VaadinService implements Serializable {
             CurrentInstance.restoreInstances(oldInstances);
         }
     }
-
 }
diff --git a/server/src/com/vaadin/server/VaadinSession.java b/server/src/com/vaadin/server/VaadinSession.java
index c73ac8b686..fd2ed79acd 100644
--- a/server/src/com/vaadin/server/VaadinSession.java
+++ b/server/src/com/vaadin/server/VaadinSession.java
@@ -35,6 +35,7 @@ import java.util.concurrent.Future;
 import java.util.concurrent.FutureTask;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import javax.portlet.PortletSession;
@@ -86,6 +87,7 @@ public class VaadinSession implements HttpSessionBindingListener, Serializable {
         private final Map<Class<?>, CurrentInstance> instances = CurrentInstance
                 .getInstances(true);
         private final VaadinSession session;
+        private Runnable runnable;
 
         /**
          * Creates an instance for the given runnable
@@ -100,6 +102,7 @@ public class VaadinSession implements HttpSessionBindingListener, Serializable {
         public FutureAccess(VaadinSession session, Runnable runnable) {
             super(runnable, null);
             this.session = session;
+            this.runnable = runnable;
         }
 
         @Override
@@ -129,6 +132,36 @@ public class VaadinSession implements HttpSessionBindingListener, Serializable {
         public Map<Class<?>, CurrentInstance> getCurrentInstances() {
             return instances;
         }
+
+        /**
+         * Handles exceptions thrown during the execution of this task.
+         * 
+         * @since 7.1.8
+         * @param exception
+         *            the thrown exception.
+         */
+        public void handleError(Exception exception) {
+            try {
+                if (runnable instanceof ErrorHandlingRunnable) {
+                    ErrorHandlingRunnable errorHandlingRunnable = (ErrorHandlingRunnable) runnable;
+
+                    errorHandlingRunnable.handleError(exception);
+                } else {
+                    ErrorEvent errorEvent = new ErrorEvent(exception);
+
+                    ErrorHandler errorHandler = ErrorEvent
+                            .findErrorHandler(session);
+
+                    if (errorHandler == null) {
+                        errorHandler = new DefaultErrorHandler();
+                    }
+
+                    errorHandler.error(errorEvent);
+                }
+            } catch (Exception e) {
+                getLogger().log(Level.SEVERE, e.getMessage(), e);
+            }
+        }
     }
 
     /**
diff --git a/server/src/com/vaadin/ui/UI.java b/server/src/com/vaadin/ui/UI.java
index 27f04c39e1..746fa194ac 100644
--- a/server/src/com/vaadin/ui/UI.java
+++ b/server/src/com/vaadin/ui/UI.java
@@ -24,6 +24,7 @@ import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Future;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import com.vaadin.event.Action;
@@ -35,6 +36,9 @@ import com.vaadin.navigator.Navigator;
 import com.vaadin.server.ClientConnector;
 import com.vaadin.server.ComponentSizeValidator;
 import com.vaadin.server.ComponentSizeValidator.InvalidLayout;
+import com.vaadin.server.DefaultErrorHandler;
+import com.vaadin.server.ErrorHandler;
+import com.vaadin.server.ErrorHandlingRunnable;
 import com.vaadin.server.LocaleService;
 import com.vaadin.server.Page;
 import com.vaadin.server.PaintException;
@@ -1287,11 +1291,36 @@ public abstract class UI extends AbstractSingleComponentContainer implements
             throw new UIDetachedException();
         }
 
-        return session.access(new Runnable() {
+        return session.access(new ErrorHandlingRunnable() {
             @Override
             public void run() {
                 accessSynchronously(runnable);
             }
+
+            @Override
+            public void handleError(Exception exception) {
+                try {
+                    if (runnable instanceof ErrorHandlingRunnable) {
+                        ErrorHandlingRunnable errorHandlingRunnable = (ErrorHandlingRunnable) runnable;
+
+                        errorHandlingRunnable.handleError(exception);
+                    } else {
+                        ConnectorErrorEvent errorEvent = new ConnectorErrorEvent(
+                                UI.this, exception);
+
+                        ErrorHandler errorHandler = com.vaadin.server.ErrorEvent
+                                .findErrorHandler(UI.this);
+
+                        if (errorHandler == null) {
+                            errorHandler = new DefaultErrorHandler();
+                        }
+
+                        errorHandler.error(errorEvent);
+                    }
+                } catch (Exception e) {
+                    getLogger().log(Level.SEVERE, e.getMessage(), e);
+                }
+            }
         });
     }