Introducing NativeLoader

Introducing NativeLoader API intended to standardize how native libraries are loaded in dd-trace-java

NativeLoader allows for using different file layout and file resolution strategies

Author: dougqh

components/nativeloader/build.gradle.kts

@@ -0,0 +1,9 @@
+plugins {
+  `java-library`
+}
+
+apply(from = "$rootDir/gradle/java.gradle")
+
+dependencies {
+  implementation(project(":components:environment"))
+}

components/nativeloader/src/main/java/datadog/nativeloader/ClassLoaderResourcePathLocator.java

@@ -0,0 +1,39 @@
+package datadog.nativeloader;
+
+import java.net.URL;
+import java.util.Objects;
+
+public final class ClassLoaderResourcePathLocator implements PathLocator {
+  private final ClassLoader classLoader;
+  private final String baseResource;
+  
+  public ClassLoaderResourcePathLocator(
+    final ClassLoader classLoader,
+    final String baseResource)
+  {
+    this.classLoader = classLoader;
+    this.baseResource = baseResource;
+  }
+  
+  @Override
+  public URL locate(String component, String path) {
+    String fullPath = component == null ? "" : component;
+    fullPath = this.baseResource == null ? fullPath : fullPath + "/" + this.baseResource;
+    fullPath = fullPath.isEmpty() ? path : fullPath + "/" + path;
+
+    return this.classLoader.getResource(fullPath);
+  }
+  
+  @Override
+  public int hashCode() {
+	return Objects.hash(this.classLoader, this.baseResource);
+  }
+  
+  @Override
+  public boolean equals(Object obj) {
+	if (!(obj instanceof ClassLoaderResourcePathLocator)) return false;
+	
+	ClassLoaderResourcePathLocator that = (ClassLoaderResourcePathLocator)obj;
+	return this.classLoader.equals(that.classLoader) && Objects.equals(this.baseResource, that.baseResource);
+  }
+}

components/nativeloader/src/main/java/datadog/nativeloader/FileBasedPathLocator.java

@@ -0,0 +1,49 @@
+package datadog.nativeloader;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Arrays;
+import java.util.Objects;
+
+public final class FileBasedPathLocator implements PathLocator {
+  private final File[] libDirs;
+  
+  public FileBasedPathLocator(File... libDirs) {
+    this.libDirs = libDirs;
+  }
+  
+  @Override
+  public URL locate(String component, String path) {
+    String fullPath = component == null ? path : component + "/" + path;
+    
+    for ( File libDir: this.libDirs ) {
+      File libFile = new File(libDir, fullPath);
+      if ( libFile.exists() ) return toUrl(libFile);
+    }
+    
+    return null;
+  }
+  
+  @SuppressWarnings("deprecation")
+  private static final URL toUrl(File file) {
+    try {
+      return file.toURL();
+    } catch ( MalformedURLException e ) {
+      return null;
+    }
+  }
+  
+  @Override
+  public int hashCode() {
+	return Objects.hash(this.libDirs);
+  }
+  
+  @Override
+  public boolean equals(Object obj) {
+	if (!(obj instanceof FileBasedPathLocator)) return false;
+	
+	FileBasedPathLocator that = (FileBasedPathLocator)obj;
+	return Arrays.equals(this.libDirs, that.libDirs);
+  }
+}

components/nativeloader/src/main/java/datadog/nativeloader/FlatDirLibraryResolver.java

@@ -0,0 +1,42 @@
+package datadog.nativeloader;
+
+import java.net.URL;
+
+public final class FlatDirLibraryResolver implements LibraryResolver {
+  public static final LibraryResolver INSTANCE = new FlatDirLibraryResolver();
+  
+  private FlatDirLibraryResolver() {}
+  
+  @Override
+  public final URL resolve(PathLocator pathLocator, String component, PlatformSpec platformSpec, String libName) {
+    String libFileName = PathUtils.libFileName(platformSpec, libName);
+    
+    String osPath = PathUtils.osPartOf(platformSpec);
+    String archPath = PathUtils.archPartOf(platformSpec);
+    String libcPath = PathUtils.libcPartOf(platformSpec);
+    
+    URL url;
+    String regularPath = osPath + "-" + archPath;
+    
+    if ( libcPath != null ) {
+      String specializedPath = regularPath + "-" + libcPath;
+      url = pathLocator.locate(component, specializedPath + "/" + libFileName);
+      if ( url != null ) return url;
+    }
+    
+    url = pathLocator.locate(component, regularPath + "/" + libFileName);
+    if ( url != null ) return url;
+    
+    // fallback to searching at top-level, mostly concession to good out-of-box behavior
+    // with java.library.path
+    url = pathLocator.locate(component, libFileName);
+    if ( url != null ) return url;
+    
+    if ( component != null ) {
+      url = pathLocator.locate(null, libFileName);
+      if ( url != null ) return url;
+    }
+    
+    return null;
+  }
+}

components/nativeloader/src/main/java/datadog/nativeloader/LibFile.java

@@ -0,0 +1,65 @@
+package datadog.nativeloader;
+
+import java.io.File;
+
+/**
+ * Represents a resolved library
+ * <ul>
+ * <li>library may be preloaded - with no backing file</li>
+ * <li>regular file - that doesn't require clean-up</li>
+ * <li>temporary file - copying from another source - that does require clean-up</li>
+ * </ul>
+ */
+public final class LibFile implements AutoCloseable {
+  static final boolean NO_CLEAN_UP = false;
+  static final boolean CLEAN_UP = true;
+  
+  static final LibFile preloaded(String libName) {
+	return new LibFile(libName, null, NO_CLEAN_UP);
+  }
+  
+  static final LibFile fromFile(String libName, File file) {
+    return new LibFile(libName, file, NO_CLEAN_UP);
+  }
+
+  static final LibFile fromTempFile(String libName, File file) {
+    return new LibFile(libName, file, CLEAN_UP);
+  }
+  
+  final String libName;
+  
+  final File file;
+  final boolean needsCleanup;
+  
+  LibFile(String libName, File file, boolean needsCleanup) {
+    this.libName = libName;
+    
+    this.file = file;
+    this.needsCleanup = needsCleanup;
+  }
+  
+  public boolean isPreloaded() {
+    return (this.file == null);
+  }
+  
+  public void load() throws LibraryLoadException {
+    if ( this.isPreloaded() ) return;
+    
+    try {
+      Runtime.getRuntime().load(this.getAbsolutePath());
+    } catch ( Throwable t ) {
+      throw new LibraryLoadException(this.libName, t);
+    }
+  }
+  
+  public final String getAbsolutePath() {
+    return this.file.getAbsolutePath();
+  }
+
+  @Override
+  public void close() {
+    if ( this.needsCleanup ) {
+      NativeLoader.delete(this.file);
+    }
+  }
+}

components/nativeloader/src/main/java/datadog/nativeloader/LibraryLoadException.java

@@ -0,0 +1,28 @@
+package datadog.nativeloader;
+
+/**
+ * Exception raised when NativeLoader fails to resolve or load a library
+ */
+public class LibraryLoadException extends Exception {
+  private static final long serialVersionUID = 1L;
+
+  public LibraryLoadException(String libName) {
+    super(message(libName));
+  }
+  
+  public LibraryLoadException(String libName, Throwable cause) {
+    this(message(libName), cause.getMessage(), cause);
+  }
+  
+  public LibraryLoadException(String libName, String message) {
+    super(message(libName) + " - " + message);
+  }
+  
+  public LibraryLoadException(String libName, String message, Throwable cause) {
+    super(message(libName) + " - " + message, cause);
+  }
+  
+  static final String message(String libName) {
+    return "Unable to resolve library " + libName; 
+  }
+}

components/nativeloader/src/main/java/datadog/nativeloader/LibraryResolver.java

@@ -0,0 +1,18 @@
+package datadog.nativeloader;
+
+import java.net.URL;
+
+public interface LibraryResolver {
+  default boolean isPreloaded(
+   PlatformSpec platform,
+   String libName)
+  {
+    return false;
+  }
+  
+  URL resolve(
+   PathLocator pathLocator,
+   String component,
+   PlatformSpec platformSpec,
+   String libName);
+}

components/nativeloader/src/main/java/datadog/nativeloader/LibraryResolvers.java

@@ -0,0 +1,37 @@
+package datadog.nativeloader;
+
+import java.net.URL;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public final class LibraryResolvers {
+  private LibraryResolvers() {}
+  
+  public static final LibraryResolver defaultLibraryResolver() {
+    return flatDirs();
+  }
+  
+  public static final LibraryResolver withPreloaded(LibraryResolver baseResolver, String... preloadedLibNames) {
+	Set<String> preloadedSet = new HashSet<>(Arrays.asList(preloadedLibNames));
+	return new LibraryResolver() {
+	  @Override
+	  public boolean isPreloaded(PlatformSpec platform, String libName) {
+		return preloadedSet.contains(libName);
+	  }
+	  
+	  @Override
+	  public URL resolve(PathLocator pathLocator, String component, PlatformSpec platformSpec, String libName) {
+		return baseResolver.resolve(pathLocator, component, platformSpec, libName);
+      }
+	};
+  }
+  
+  public static final LibraryResolver flatDirs() {
+    return FlatDirLibraryResolver.INSTANCE;
+  }
+  
+  public static final LibraryResolver nestedDirs() {
+    return NestedDirLibraryResolver.INSTANCE;
+  }
+}