Merge branch 'develop' into release/1.1.0

Author: overheadhunter

pom.xml

@@ -38,12 +38,24 @@
     </licenses>
 
 	<dependencies>
+		<dependency>
+			<groupId>org.slf4j</groupId>
+			<artifactId>slf4j-api</artifactId>
+			<version>1.7.36</version>
+		</dependency>
+
 		<dependency>
 			<groupId>org.jetbrains</groupId>
 			<artifactId>annotations</artifactId>
 			<version>23.0.0</version>
 			<scope>provided</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.slf4j</groupId>
+			<artifactId>slf4j-simple</artifactId>
+			<version>1.7.36</version>
+			<scope>test</scope>
+		</dependency>
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
 			<artifactId>junit-jupiter</artifactId>

src/main/java/module-info.java

@@ -7,6 +7,7 @@
 
 module org.cryptomator.integrations.api {
 	requires static org.jetbrains.annotations;
+	requires org.slf4j;
 
 	exports org.cryptomator.integrations.autostart;
 	exports org.cryptomator.integrations.common;

src/main/java/org/cryptomator/integrations/common/ClassLoaderFactory.java

@@ -2,6 +2,8 @@
 
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.VisibleForTesting;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
@@ -10,9 +12,12 @@
 import java.net.URLClassLoader;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.stream.Collectors;
 
 class ClassLoaderFactory {
 
+	private static final Logger LOG = LoggerFactory.getLogger(ClassLoaderFactory.class);
 	private static final String USER_HOME = System.getProperty("user.home");
 	private static final String PLUGIN_DIR_KEY = "cryptomator.pluginDir";
 	private static final String JAR_SUFFIX = ".jar";
@@ -38,7 +43,12 @@ public static URLClassLoader forPluginDir() {
 	@VisibleForTesting
 	@Contract(value = "_ -> new", pure = true)
 	static URLClassLoader forPluginDirWithPath(Path path) throws UncheckedIOException {
-		return URLClassLoader.newInstance(findJars(path));
+		var jars = findJars(path);
+		if (LOG.isDebugEnabled()) {
+			String jarList = Arrays.stream(jars).map(URL::getPath).collect(Collectors.joining(", "));
+			LOG.debug("Found jars in cryptomator.pluginDir: {}", jarList);
+		}
+		return URLClassLoader.newInstance(jars);
 	}
 
 	@VisibleForTesting

src/main/java/org/cryptomator/integrations/common/IntegrationsLoader.java

@@ -2,6 +2,8 @@
 
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.VisibleForTesting;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
@@ -13,6 +15,8 @@
 
 public class IntegrationsLoader {
 
+	private static final Logger LOG = LoggerFactory.getLogger(IntegrationsLoader.class);
+
 	private IntegrationsLoader() {
 	}
 
@@ -39,11 +43,19 @@ public static <T> Optional<T> load(Class<T> clazz) {
 	public static <T> Stream<T> loadAll(Class<T> clazz) {
 		return ServiceLoader.load(clazz, ClassLoaderFactory.forPluginDir())
 				.stream()
+				.peek(service -> logFoundService(clazz, service.type()))
 				.filter(IntegrationsLoader::isSupportedOperatingSystem)
 				.filter(IntegrationsLoader::passesStaticAvailabilityCheck)
 				.sorted(Comparator.comparingInt(IntegrationsLoader::getPriority).reversed())
 				.map(ServiceLoader.Provider::get)
-				.filter(IntegrationsLoader::passesInstanceAvailabilityCheck);
+				.filter(IntegrationsLoader::passesInstanceAvailabilityCheck)
+				.peek(impl -> logServiceIsAvailable(clazz, impl.getClass()));
+	}
+
+	private static void logFoundService(Class<?> apiType, Class<?> implType) {
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("{}: Found implementation: {} in jar {}", apiType.getSimpleName(), implType.getName(), implType.getProtectionDomain().getCodeSource().getLocation().getPath());
+		}
 	}
 
 	private static int getPriority(ServiceLoader.Provider<?> provider) {
@@ -70,10 +82,20 @@ static boolean passesInstanceAvailabilityCheck(Object instance) {
 		return passesAvailabilityCheck(instance.getClass(), instance);
 	}
 
+	private static void logServiceIsAvailable(Class<?> apiType, Class<?> implType) {
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("{}: Implementation is available: {}", apiType.getSimpleName(), implType.getName());
+		}
+	}
+
 	private static <T> boolean passesAvailabilityCheck(Class<? extends T> type, @Nullable T instance) {
 		if (!type.isAnnotationPresent(CheckAvailability.class)) {
 			return true; // if type is not annotated, skip tests
 		}
+		if (!type.getModule().isExported(type.getPackageName(), IntegrationsLoader.class.getModule())) {
+			LOG.error("Can't run @CheckAvailability tests for class {}. Make sure to export {} to {}!", type.getName(), type.getPackageName(), IntegrationsLoader.class.getPackageName());
+			return false;
+		}
 		return Arrays.stream(type.getMethods())
 				.filter(m -> isAvailabilityCheck(m, instance == null))
 				.allMatch(m -> passesAvailabilityCheck(m, instance));
@@ -84,6 +106,7 @@ private static boolean passesAvailabilityCheck(Method m, @Nullable Object instan
 		try {
 			return (boolean) m.invoke(instance);
 		} catch (ReflectiveOperationException e) {
+			LOG.warn("Failed to invoke @CheckAvailability test {}#{}", m.getDeclaringClass(), m.getName(), e);
 			return false;
 		}
 	}