Improved error handling

* Created AsyncTaskService to build async UI operations which always log
uncaught exceptions
* Changed all executor service invocations in the UI to invocations of
AsyncTaskService
* Improved error handling in some other places, especially
try-with-resources
* Unlocking read/write locks in NioFile when opening of a channel fails

main/ui/src/main/java/org/cryptomator/ui/CryptomatorComponent.java

@@ -14,6 +14,7 @@ import javax.inject.Singleton;
 
 import org.cryptomator.ui.controllers.MainController;
 import org.cryptomator.ui.settings.Localization;
+import org.cryptomator.ui.util.AsyncTaskService;
 import org.cryptomator.ui.util.DeferredCloser;
 
 import dagger.Component;
@@ -21,6 +22,9 @@ import dagger.Component;
 @Singleton
 @Component(modules = CryptomatorModule.class)
 interface CryptomatorComponent {
+
+	AsyncTaskService asyncTaskService();
+
 	ExecutorService executorService();
 
 	DeferredCloser deferredCloser();

main/ui/src/main/java/org/cryptomator/ui/controllers/UnlockController.java

@@ -11,7 +11,6 @@ package org.cryptomator.ui.controllers;
 import java.net.URL;
 import java.util.Comparator;
 import java.util.Optional;
-import java.util.concurrent.ExecutorService;
 
 import javax.inject.Inject;
 
@@ -27,6 +26,7 @@ import org.cryptomator.ui.controls.SecPasswordField;
 import org.cryptomator.ui.model.Vault;
 import org.cryptomator.ui.settings.Localization;
 import org.cryptomator.ui.settings.Settings;
+import org.cryptomator.ui.util.AsyncTaskService;
 import org.fxmisc.easybind.EasyBind;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -56,7 +56,7 @@ public class UnlockController extends LocalizedFXMLViewController {
 	private static final Logger LOG = LoggerFactory.getLogger(UnlockController.class);
 
 	private final Application app;
-	private final ExecutorService exec;
+	private final AsyncTaskService asyncTaskService;
 	private final Lazy<FrontendFactory> frontendFactory;
 	private final Settings settings;
 	private final WindowsDriveLetters driveLetters;
@@ -65,10 +65,10 @@ public class UnlockController extends LocalizedFXMLViewController {
 	private Optional<UnlockListener> listener = Optional.empty();
 
 	@Inject
-	public UnlockController(Application app, Localization localization, ExecutorService exec, Lazy<FrontendFactory> frontendFactory, Settings settings, WindowsDriveLetters driveLetters) {
+	public UnlockController(Application app, Localization localization, AsyncTaskService asyncTaskService, Lazy<FrontendFactory> frontendFactory, Settings settings, WindowsDriveLetters driveLetters) {
 		super(localization);
 		this.app = app;
-		this.exec = exec;
+		this.asyncTaskService = asyncTaskService;
 		this.frontendFactory = frontendFactory;
 		this.settings = settings;
 		this.driveLetters = driveLetters;
@@ -275,8 +275,7 @@ public class UnlockController extends LocalizedFXMLViewController {
 		progressIndicator.setVisible(true);
 		downloadsPageLink.setVisible(false);
 		CharSequence password = passwordField.getCharacters();
-		exec.submit(() -> this.unlock(vault.get(), password));
-
+		asyncTaskService.asyncTaskOf(() -> this.unlock(vault.get(), password)).run();
 	}
 
 	private void unlock(Vault vault, CharSequence password) {

main/ui/src/main/java/org/cryptomator/ui/controllers/UnlockedController.java

@@ -10,7 +10,6 @@ package org.cryptomator.ui.controllers;
 
 import java.net.URL;
 import java.util.Optional;
-import java.util.concurrent.ExecutorService;
 
 import javax.inject.Inject;
 import javax.inject.Provider;
@@ -19,6 +18,7 @@ import org.cryptomator.frontend.CommandFailedException;
 import org.cryptomator.ui.model.Vault;
 import org.cryptomator.ui.settings.Localization;
 import org.cryptomator.ui.util.ActiveWindowStyleSupport;
+import org.cryptomator.ui.util.AsyncTaskService;
 import org.fxmisc.easybind.EasyBind;
 
 import javafx.animation.Animation;
@@ -52,16 +52,16 @@ public class UnlockedController extends LocalizedFXMLViewController {
 
 	private final Stage macWarningsWindow = new Stage();
 	private final MacWarningsController macWarningsController;
-	private final ExecutorService exec;
+	private final AsyncTaskService asyncTaskService;
 	private final ObjectProperty<Vault> vault = new SimpleObjectProperty<>();
 	private Optional<LockListener> listener = Optional.empty();
 	private Timeline ioAnimation;
 
 	@Inject
-	public UnlockedController(Localization localization, Provider<MacWarningsController> macWarningsControllerProvider, ExecutorService exec) {
+	public UnlockedController(Localization localization, Provider<MacWarningsController> macWarningsControllerProvider, AsyncTaskService asyncTaskService) {
 		super(localization);
 		this.macWarningsController = macWarningsControllerProvider.get();
-		this.exec = exec;
+		this.asyncTaskService = asyncTaskService;
 
 		macWarningsController.vault.bind(this.vault);
 	}
@@ -116,18 +116,14 @@ public class UnlockedController extends LocalizedFXMLViewController {
 
 	@FXML
 	private void didClickLockVault(ActionEvent event) {
-		exec.submit(() -> {
-			try {
-				vault.get().unmount();
-			} catch (CommandFailedException e) {
-				Platform.runLater(() -> {
-					messageLabel.setText(localization.getString("unlocked.label.unmountFailed"));
-				});
-				return;
-			}
+		asyncTaskService.asyncTaskOf(() -> {
+			vault.get().unmount();
 			vault.get().deactivateFrontend();
-			listener.ifPresent(this::invokeListenerLater);
-		});
+		}).onError(CommandFailedException.class, () -> {
+			messageLabel.setText(localization.getString("unlocked.label.unmountFailed"));
+		}).andFinally(() -> {
+			listener.ifPresent(listener -> listener.didLock(this));
+		}).run();
 	}
 
 	@FXML
@@ -142,15 +138,11 @@ public class UnlockedController extends LocalizedFXMLViewController {
 
 	@FXML
 	private void didClickRevealVault(ActionEvent event) {
-		exec.submit(() -> {
-			try {
-				vault.get().reveal();
-			} catch (CommandFailedException e) {
-				Platform.runLater(() -> {
-					messageLabel.setText(localization.getString("unlocked.label.revealFailed"));
-				});
-			}
-		});
+		asyncTaskService.asyncTaskOf(() -> {
+			vault.get().reveal();
+		}).onError(CommandFailedException.class, () -> {
+			messageLabel.setText(localization.getString("unlocked.label.revealFailed"));
+		}).run();
 	}
 
 	@FXML
@@ -258,12 +250,6 @@ public class UnlockedController extends LocalizedFXMLViewController {
 		this.listener = Optional.ofNullable(listener);
 	}
 
-	private void invokeListenerLater(LockListener listener) {
-		Platform.runLater(() -> {
-			listener.didLock(this);
-		});
-	}
-
 	@FunctionalInterface
 	interface LockListener {
 		void didLock(UnlockedController ctrl);

main/ui/src/main/java/org/cryptomator/ui/controllers/UpgradeController.java

@@ -3,7 +3,6 @@ package org.cryptomator.ui.controllers;
 import java.net.URL;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.concurrent.ExecutorService;
 
 import javax.inject.Inject;
 
@@ -13,11 +12,9 @@ import org.cryptomator.ui.model.UpgradeStrategy;
 import org.cryptomator.ui.model.UpgradeStrategy.UpgradeFailedException;
 import org.cryptomator.ui.model.Vault;
 import org.cryptomator.ui.settings.Localization;
+import org.cryptomator.ui.util.AsyncTaskService;
 import org.fxmisc.easybind.EasyBind;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
-import javafx.application.Platform;
 import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleObjectProperty;
 import javafx.event.ActionEvent;
@@ -28,19 +25,17 @@ import javafx.scene.control.ProgressIndicator;
 
 public class UpgradeController extends LocalizedFXMLViewController {
 
-	private static final Logger LOG = LoggerFactory.getLogger(UpgradeController.class);
-
 	final ObjectProperty<Vault> vault = new SimpleObjectProperty<>();
 	final ObjectProperty<Optional<UpgradeStrategy>> strategy = new SimpleObjectProperty<>();
 	private final UpgradeStrategies strategies;
-	private final ExecutorService exec;
+	private final AsyncTaskService asyncTaskService;
 	private Optional<UpgradeListener> listener = Optional.empty();
 
 	@Inject
-	public UpgradeController(Localization localization, UpgradeStrategies strategies, ExecutorService exec) {
+	public UpgradeController(Localization localization, UpgradeStrategies strategies, AsyncTaskService asyncTaskService) {
 		super(localization);
 		this.strategies = strategies;
-		this.exec = exec;
+		this.asyncTaskService = asyncTaskService;
 	}
 
 	@FXML
@@ -103,26 +98,22 @@ public class UpgradeController extends LocalizedFXMLViewController {
 		Vault v = Objects.requireNonNull(vault.getValue());
 		passwordField.setDisable(true);
 		progressIndicator.setVisible(true);
-		exec.submit(() -> {
-			if (!instruction.isApplicable(v)) {
-				LOG.error("No upgrade needed for " + v.path().getValue());
-				throw new IllegalStateException("No ugprade needed for " + v.path().getValue());
-			}
-			try {
-				instruction.upgrade(v, passwordField.getCharacters());
-				Platform.runLater(this::showNextUpgrade);
-			} catch (UpgradeFailedException e) {
-				Platform.runLater(() -> {
+		asyncTaskService //
+				.asyncTaskOf(() -> {
+					if (!instruction.isApplicable(v)) {
+						throw new IllegalStateException("No ugprade needed for " + v.path().getValue());
+					}
+					instruction.upgrade(v, passwordField.getCharacters());
+				}) //
+				.onSuccess(this::showNextUpgrade) //
+				.onError(UpgradeFailedException.class, e -> {
 					errorLabel.setText(e.getLocalizedMessage());
-				});
-			} finally {
-				Platform.runLater(() -> {
+				}) //
+				.andFinally(() -> {
 					progressIndicator.setVisible(false);
 					passwordField.setDisable(false);
 					passwordField.swipe();
-				});
-			}
-		});
+				}).run();
 	}
 
 	private void showNextUpgrade() {

main/ui/src/main/java/org/cryptomator/ui/controllers/WelcomeController.java

@@ -8,14 +8,12 @@
  ******************************************************************************/
 package org.cryptomator.ui.controllers;
 
-import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
-import java.util.concurrent.ExecutorService;
 
 import javax.inject.Inject;
 import javax.inject.Named;
@@ -31,6 +29,7 @@ import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.SystemUtils;
 import org.cryptomator.ui.settings.Localization;
 import org.cryptomator.ui.settings.Settings;
+import org.cryptomator.ui.util.AsyncTaskService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -54,15 +53,15 @@ public class WelcomeController extends LocalizedFXMLViewController {
 	private final Application app;
 	private final Settings settings;
 	private final Comparator<String> semVerComparator;
-	private final ExecutorService executor;
+	private final AsyncTaskService asyncTaskService;
 
 	@Inject
-	public WelcomeController(Application app, Localization localization, Settings settings, @Named("SemVer") Comparator<String> semVerComparator, ExecutorService executor) {
+	public WelcomeController(Application app, Localization localization, Settings settings, @Named("SemVer") Comparator<String> semVerComparator, AsyncTaskService asyncTaskService) {
 		super(localization);
 		this.app = app;
 		this.settings = settings;
 		this.semVerComparator = semVerComparator;
-		this.executor = executor;
+		this.asyncTaskService = asyncTaskService;
 	}
 
 	@FXML
@@ -82,7 +81,7 @@ public class WelcomeController extends LocalizedFXMLViewController {
 		if (areUpdatesManagedExternally()) {
 			checkForUpdatesContainer.setVisible(false);
 		} else if (settings.isCheckForUpdatesEnabled()) {
-			executor.execute(this::checkForUpdates);
+			this.checkForUpdates();
 		}
 	}
 
@@ -100,16 +99,14 @@ public class WelcomeController extends LocalizedFXMLViewController {
 	}
 
 	private void checkForUpdates() {
-		Platform.runLater(() -> {
-			checkForUpdatesStatus.setText(localization.getString("welcome.checkForUpdates.label.currentlyChecking"));
-			checkForUpdatesIndicator.setVisible(true);
-		});
-		final HttpClient client = new HttpClient();
-		final HttpMethod method = new GetMethod("https://cryptomator.org/downloads/latestVersion.json");
-		client.getParams().setParameter(HttpClientParams.USER_AGENT, "Cryptomator VersionChecker/" + applicationVersion().orElse("SNAPSHOT"));
-		client.getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
-		client.getParams().setConnectionManagerTimeout(5000);
-		try {
+		checkForUpdatesStatus.setText(localization.getString("welcome.checkForUpdates.label.currentlyChecking"));
+		checkForUpdatesIndicator.setVisible(true);
+		asyncTaskService.asyncTaskOf(() -> {
+			final HttpClient client = new HttpClient();
+			final HttpMethod method = new GetMethod("https://cryptomator.org/downloads/latestVersion.json");
+			client.getParams().setParameter(HttpClientParams.USER_AGENT, "Cryptomator VersionChecker/" + applicationVersion().orElse("SNAPSHOT"));
+			client.getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
+			client.getParams().setConnectionManagerTimeout(5000);
 			client.executeMethod(method);
 			final InputStream responseBodyStream = method.getResponseBodyAsStream();
 			if (method.getStatusCode() == HttpStatus.SC_OK && responseBodyStream != null) {
@@ -121,14 +118,10 @@ public class WelcomeController extends LocalizedFXMLViewController {
 					this.compareVersions(map);
 				}
 			}
-		} catch (IOException e) {
-			// no error handling required. Maybe next time the version check is successful.
-		} finally {
-			Platform.runLater(() -> {
-				checkForUpdatesStatus.setText("");
-				checkForUpdatesIndicator.setVisible(false);
-			});
-		}
+		}).andFinally(() -> {
+			checkForUpdatesStatus.setText("");
+			checkForUpdatesIndicator.setVisible(false);
+		}).run();
 	}
 
 	private Optional<String> applicationVersion() {

main/ui/src/main/java/org/cryptomator/ui/util/AsyncTaskService.java

@@ -0,0 +1,174 @@
+package org.cryptomator.ui.util;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.cryptomator.common.ConsumerThrowingException;
+import org.cryptomator.common.RunnableThrowingException;
+import org.cryptomator.common.SupplierThrowingException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javafx.application.Platform;
+
+@Singleton
+public class AsyncTaskService {
+
+	private static final Logger LOG = LoggerFactory.getLogger(AsyncTaskService.class);
+
+	private final ExecutorService executor;
+
+	@Inject
+	public AsyncTaskService(ExecutorService executor) {
+		this.executor = executor;
+	}
+
+	public AsyncTaskWithoutSuccessHandler<Void> asyncTaskOf(RunnableThrowingException<?> task) {
+		return new AsyncTaskImpl<>(() -> {
+			task.run();
+			return null;
+		});
+	}
+
+	public <ResultType> AsyncTaskWithoutSuccessHandler<ResultType> asyncTaskOf(SupplierThrowingException<ResultType, ?> task) {
+		return new AsyncTaskImpl<>(task);
+	}
+
+	private class AsyncTaskImpl<ResultType> implements AsyncTaskWithoutSuccessHandler<ResultType> {
+
+		private final SupplierThrowingException<ResultType, ?> task;
+
+		private ConsumerThrowingException<ResultType, ?> successHandler = value -> {
+		};
+		private List<ErrorHandler<Throwable>> errorHandlers = new ArrayList<>();
+		private RunnableThrowingException<?> finallyHandler = () -> {
+		};
+
+		public AsyncTaskImpl(SupplierThrowingException<ResultType, ?> task) {
+			this.task = task;
+		}
+
+		@Override
+		public AsyncTaskWithoutErrorHandler onSuccess(ConsumerThrowingException<ResultType, ?> handler) {
+			successHandler = handler;
+			return this;
+		}
+
+		@Override
+		public AsyncTaskWithoutErrorHandler onSuccess(RunnableThrowingException<?> handler) {
+			return onSuccess(result -> handler.run());
+		}
+
+		@SuppressWarnings({"unchecked", "rawtypes"})
+		@Override
+		public <ErrorType extends Throwable> AsyncTaskWithoutErrorHandler onError(Class<ErrorType> type, ConsumerThrowingException<ErrorType, ?> handler) {
+			errorHandlers.add((ErrorHandler) new ErrorHandler<>(type, handler));
+			return this;
+		}
+
+		@Override
+		public <ErrorType extends Throwable> AsyncTaskWithoutErrorHandler onError(Class<ErrorType> type, RunnableThrowingException<?> handler) {
+			return onError(type, error -> handler.run());
+		}
+
+		@Override
+		public AsyncTask andFinally(RunnableThrowingException<?> handler) {
+			finallyHandler = handler;
+			return this;
+		}
+
+		@Override
+		public void run() {
+			errorHandlers.add(ErrorHandler.LOGGING_HANDLER);
+			executor.execute(() -> logExceptions(() -> {
+				try {
+					ResultType result = task.get();
+					Platform.runLater(() -> {
+						try {
+							successHandler.accept(result);
+						} catch (Throwable e) {
+							LOG.error("Uncaught exception", e);
+						}
+					});
+				} catch (Throwable e) {
+					ErrorHandler<Throwable> errorHandler = errorHandlerFor(e);
+					Platform.runLater(toRunnableLoggingException(() -> errorHandler.accept(e)));
+				} finally {
+					Platform.runLater(toRunnableLoggingException(finallyHandler));
+				}
+			}));
+		}
+
+		private ErrorHandler<Throwable> errorHandlerFor(Throwable e) {
+			return errorHandlers.stream().filter(handler -> handler.handles(e)).findFirst().get();
+		}
+
+	}
+
+	private static Runnable toRunnableLoggingException(RunnableThrowingException<?> delegate) {
+		return () -> logExceptions(delegate);
+	}
+
+	private static void logExceptions(RunnableThrowingException<?> delegate) {
+		try {
+			delegate.run();
+		} catch (Throwable e) {
+			LOG.error("Uncaught exception", e);
+		}
+	}
+
+	private static class ErrorHandler<ErrorType> implements ConsumerThrowingException<ErrorType, Throwable> {
+
+		public static final ErrorHandler<Throwable> LOGGING_HANDLER = new ErrorHandler<Throwable>(Throwable.class, error -> {
+			LOG.error("Uncaught exception", error);
+		});
+
+		private final Class<ErrorType> type;
+		private final ConsumerThrowingException<ErrorType, ?> delegate;
+
+		public ErrorHandler(Class<ErrorType> type, ConsumerThrowingException<ErrorType, ?> delegate) {
+			this.type = type;
+			this.delegate = delegate;
+		}
+
+		public boolean handles(Throwable error) {
+			return type.isInstance(error);
+		}
+
+		@Override
+		public void accept(ErrorType error) throws Throwable {
+			delegate.accept(error);
+		}
+
+	}
+
+	public interface AsyncTaskWithoutSuccessHandler<ResultType> extends AsyncTaskWithoutErrorHandler {
+
+		AsyncTaskWithoutErrorHandler onSuccess(ConsumerThrowingException<ResultType, ?> handler);
+
+		AsyncTaskWithoutErrorHandler onSuccess(RunnableThrowingException<?> handler);
+
+	}
+
+	public interface AsyncTaskWithoutErrorHandler extends AsyncTaskWithoutFinallyHandler {
+
+		<ErrorType extends Throwable> AsyncTaskWithoutErrorHandler onError(Class<ErrorType> type, ConsumerThrowingException<ErrorType, ?> handler);
+
+		<ErrorType extends Throwable> AsyncTaskWithoutErrorHandler onError(Class<ErrorType> type, RunnableThrowingException<?> handler);
+
+	}
+
+	public interface AsyncTaskWithoutFinallyHandler extends AsyncTask {
+
+		AsyncTask andFinally(RunnableThrowingException<?> handler);
+
+	}
+
+	public interface AsyncTask extends Runnable {
+	}
+
+}