Introducing NativeLoader

components/native-loader/build.gradle.kts

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

components/native-loader/src/main/java/datadog/nativeloader/ClassLoaderResourcePathLocator.java

@@ -0,0 +1,34 @@
+package datadog.nativeloader;
+
+import java.net.URL;
+import java.util.Objects;
+
+/** ClassLoaderResourcePathLocator locates library paths inside a {@link ClassLoader} */
+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) {
+    return this.classLoader.getResource(PathUtils.concatPath(component, this.baseResource, path));
+  }
+
+  @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/native-loader/src/main/java/datadog/nativeloader/FlatDirLibraryResolver.java

@@ -0,0 +1,55 @@
+package datadog.nativeloader;
+
+import java.net.URL;
+
+/**
+ * FlatDirLibraryResolver - uses flat directories to provide more specific libraries to load <code>
+ * {os}-{arch}-{libc/musl}</code>
+ */
+public final class FlatDirLibraryResolver implements LibraryResolver {
+  public static final FlatDirLibraryResolver INSTANCE = new FlatDirLibraryResolver();
+
+  private FlatDirLibraryResolver() {}
+
+  @Override
+  public final URL resolve(
+      PathLocator pathLocator, String component, PlatformSpec platformSpec, String libName)
+      throws Exception {
+    PathLocatorHelper pathLocatorHelper = new PathLocatorHelper(libName, pathLocator);
+
+    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 = pathLocatorHelper.locate(component, specializedPath + "/" + libFileName);
+      if (url != null) return url;
+    }
+
+    url = pathLocatorHelper.locate(component, regularPath + "/" + libFileName);
+    if (url != null) return url;
+
+    url = pathLocatorHelper.locate(component, osPath + "/" + 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 = pathLocatorHelper.locate(component, libFileName);
+    if (url != null) return url;
+
+    if (component != null) {
+      url = pathLocatorHelper.locate(null, libFileName);
+      if (url != null) return url;
+    }
+
+    pathLocatorHelper.tryThrow();
+
+    return null;
+  }
+}

components/native-loader/src/main/java/datadog/nativeloader/IntrospectPlatformSpec.java

@@ -0,0 +1,65 @@
+package datadog.nativeloader;
+
+import datadog.environment.OperatingSystem;
+import datadog.environment.OperatingSystem.Architecture;
+
+/*
+ * Default PlatformSpec used in dd-trace-java -- wraps detection code in component:environment
+ */
+final class IntrospectPlatformSpec extends PlatformSpec {
+  static final PlatformSpec INSTANCE = new IntrospectPlatformSpec();
+
+  @Override
+  public boolean isLinux() {
+    return OperatingSystem.isLinux();
+  }
+
+  @Override
+  public boolean isMac() {
+    return OperatingSystem.isMacOs();
+  }
+
+  @Override
+  public boolean isWindows() {
+    return OperatingSystem.isWindows();
+  }
+
+  @Override
+  public boolean isMusl() {
+    return OperatingSystem.isMusl();
+  }
+
+  @Override
+  public boolean isAarch64() {
+    return isArch(Architecture.ARM64);
+  }
+
+  @Override
+  public boolean isArm32() {
+    return isArch(Architecture.ARM);
+  }
+
+  @Override
+  public boolean isX86_32() {
+    return isArch(Architecture.X86);
+  }
+
+  @Override
+  public boolean isX86_64() {
+    return isArch(Architecture.X64);
+  }
+
+  static final boolean isArch(OperatingSystem.Architecture arch) {
+    return (OperatingSystem.architecture() == arch);
+  }
+
+  @Override
+  public int hashCode() {
+    return IntrospectPlatformSpec.class.hashCode();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    return (obj instanceof IntrospectPlatformSpec);
+  }
+}

components/native-loader/src/main/java/datadog/nativeloader/LibDirBasedPathLocator.java

@@ -0,0 +1,49 @@
+package datadog.nativeloader;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Arrays;
+
+/** LibDirBasedPathLocator locates libraries inside a list of library directories */
+final class LibDirBasedPathLocator implements PathLocator {
+  private final File[] libDirs;
+
+  public LibDirBasedPathLocator(File... libDirs) {
+    this.libDirs = libDirs;
+  }
+
+  @Override
+  public URL locate(String component, String path) {
+    String fullPath = PathUtils.concatPath(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 Arrays.hashCode(this.libDirs);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (!(obj instanceof LibDirBasedPathLocator)) return false;
+
+    LibDirBasedPathLocator that = (LibDirBasedPathLocator) obj;
+    return Arrays.equals(this.libDirs, that.libDirs);
+  }
+}

components/native-loader/src/main/java/datadog/nativeloader/LibFile.java

@@ -0,0 +1,81 @@
+package datadog.nativeloader;
+
+import java.io.File;
+import java.nio.file.Path;
+
+/**
+ * Represents a resolved library
+ *
+ * <ul>
+ *   <li>library may be preloaded - with no backing file
+ *   <li>regular file - that doesn't require clean-up
+ *   <li>temporary file - copying from another source - that does require clean-up
+ * </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;
+  }
+
+  /** Indicates if this library was "preloaded" */
+  public boolean isPreloaded() {
+    return (this.file == null);
+  }
+
+  /** Loads the underlying library into the JVM */
+  public void load() throws LibraryLoadException {
+    if (this.isPreloaded()) return;
+
+    try {
+      Runtime.getRuntime().load(this.getAbsolutePath());
+    } catch (Throwable t) {
+      throw new LibraryLoadException(this.libName, t);
+    }
+  }
+
+  /** Provides a File to the library -- returns null for pre-loaded libraries */
+  public final File toFile() {
+    return this.file;
+  }
+
+  /** Provides a Path to the library -- return null for pre-loaded libraries */
+  public final Path toPath() {
+    return this.file == null ? null : this.file.toPath();
+  }
+
+  /** Provides the an absolute path to the library -- returns null for pre-loaded libraries */
+  public final String getAbsolutePath() {
+    return this.file == null ? null : this.file.getAbsolutePath();
+  }
+
+  /** Schedules clean-up of underlying file -- if the file is a temp file */
+  @Override
+  public void close() {
+    if (this.needsCleanup) {
+      NativeLoader.delete(this.file);
+    }
+  }
+}

components/native-loader/src/main/java/datadog/nativeloader/LibraryLoadException.java

@@ -0,0 +1,29 @@
+package datadog.nativeloader;
+
+/** Exception raised when NativeLoader fails to resolve or load a library */
+public class LibraryLoadException extends Exception {
+  static final String UNSUPPORTED_OS = "Unsupported OS";
+  static final String UNSUPPORTED_ARCH = "Unsupported arch";
+
+  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/native-loader/src/main/java/datadog/nativeloader/LibraryResolver.java

@@ -0,0 +1,20 @@
+package datadog.nativeloader;
+
+import java.net.URL;
+
+/**
+ * LibraryResolver encapsulates a library resolution strategy
+ *
+ * <p>The LibraryResolver should use the provided {@link PathLocator} to locate the desired
+ * resources. The LibraryResolver may try multiple locations to find the best possible library to
+ * use.
+ */
+@FunctionalInterface
+public interface LibraryResolver {
+  default boolean isPreloaded(PlatformSpec platform, String libName) {
+    return false;
+  }
+
+  URL resolve(PathLocator pathLocator, String component, PlatformSpec platformSpec, String libName)
+      throws Exception;
+}

components/native-loader/src/main/java/datadog/nativeloader/LibraryResolvers.java

@@ -0,0 +1,44 @@
+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) {
+    return withPreloaded(baseResolver, new HashSet<>(Arrays.asList(preloadedLibNames)));
+  }
+
+  public static final LibraryResolver withPreloaded(
+      LibraryResolver baseResolver, Set<String> preloadedLibNames) {
+    return new LibraryResolver() {
+      @Override
+      public boolean isPreloaded(PlatformSpec platform, String libName) {
+        return preloadedLibNames.contains(libName);
+      }
+
+      @Override
+      public URL resolve(
+          PathLocator pathLocator, String component, PlatformSpec platformSpec, String libName)
+          throws Exception {
+        return baseResolver.resolve(pathLocator, component, platformSpec, libName);
+      }
+    };
+  }
+
+  public static final LibraryResolver flatDirs() {
+    return FlatDirLibraryResolver.INSTANCE;
+  }
+
+  public static final LibraryResolver nestedDirs() {
+    return NestedDirLibraryResolver.INSTANCE;
+  }
+}