Search for native library in runtimes dir and allow setting NativeLibraryPath on .NET Core.

Author: tmat

LibGit2Sharp/Core/NativeMethods.cs

@@ -27,19 +27,31 @@ internal static class NativeMethods
 
         static NativeMethods()
         {
-            if (Platform.IsRunningOnNetFramework())
+            if (Platform.IsRunningOnNetFramework() || Platform.IsRunningOnNetCore())
             {
-                string dllPath = Path.Combine(GlobalSettings.GetAndLockNativeLibraryPath(), libgit2 + ".dll");
+                string dllPath = Path.Combine(GlobalSettings.GetAndLockNativeLibraryPath(), libgit2 + Platform.GetNativeLibraryExtension());
 
                 // Try to load the .dll from the path explicitly.
                 // If this call succeeds further DllImports will find the library loaded and not attempt to load it again.
                 // If it fails the next DllImport will load the library from safe directories.
-                LoadWindowsLibrary(dllPath);
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    LoadWindowsLibrary(dllPath);
+                }
+                else
+                {
+                    LoadUnixLibrary(dllPath, RTLD_NOW);
+                }
             }
 
             InitializeNativeLibrary();
         }
 
+        public const int RTLD_NOW = 0x002;
+
+        [DllImport("libdl", EntryPoint = "dlopen")]
+        private static extern IntPtr LoadUnixLibrary(string path, int flags);
+
         [DllImport("kernel32", EntryPoint = "LoadLibrary")]
         private static extern IntPtr LoadWindowsLibrary(string path);
 

LibGit2Sharp/Core/Platform.cs

@@ -33,10 +33,48 @@ public static OperatingSystemType OperatingSystem
                     return OperatingSystemType.MacOSX;
                 }
 
-                throw new InvalidOperationException();
+                throw new PlatformNotSupportedException();
             }
         }
 
+        /// <summary>
+        /// Determines the RID to use when loading libgit2 native library.
+        /// This method only supports RIDs that are currently used by LibGit2Sharp.NativeBinaries.
+        /// </summary>
+        public static string GetNativeLibraryRuntimeId()
+        {
+            switch (OperatingSystem)
+            {
+                case OperatingSystemType.MacOSX:
+                    return "osx";
+
+                case OperatingSystemType.Unix:
+                    return "linux-" + ProcessorArchitecture;
+
+                case OperatingSystemType.Windows:
+                    return "win7-" + ProcessorArchitecture;
+            }
+
+            throw new PlatformNotSupportedException();
+        }
+
+        public static string GetNativeLibraryExtension()
+        {
+            switch (OperatingSystem)
+            {
+                case OperatingSystemType.MacOSX:
+                    return ".dylib";
+
+                case OperatingSystemType.Unix:
+                    return ".so";
+
+                case OperatingSystemType.Windows:
+                    return ".dll";
+            }
+
+            throw new PlatformNotSupportedException();
+        }
+
         /// <summary>
         /// Returns true if the runtime is Mono.
         /// </summary>
@@ -48,5 +86,11 @@ public static bool IsRunningOnMono()
         /// </summary>
         public static bool IsRunningOnNetFramework()
             => typeof(object).Assembly.GetName().Name == "mscorlib" && !IsRunningOnMono();
+
+        /// <summary>
+        /// Returns true if the runtime is .NET Core.
+        /// </summary>
+        public static bool IsRunningOnNetCore()
+            => typeof(object).Assembly.GetName().Name != "mscorlib";
     }
 }

LibGit2Sharp/GlobalSettings.cs

@@ -23,36 +23,57 @@ public static class GlobalSettings
 
         static GlobalSettings()
         {
-            nativeLibraryPathAllowed = Platform.IsRunningOnNetFramework();
+            bool netFX = Platform.IsRunningOnNetFramework();
+            bool netCore = Platform.IsRunningOnNetCore();
+
+            nativeLibraryPathAllowed = netFX || netCore;
 
             if (nativeLibraryPathAllowed)
             {
-                /* Assembly.CodeBase is not actually a correctly formatted
-                 * URI.  It's merely prefixed with `file:///` and has its
-                 * backslashes flipped.  This is superior to EscapedCodeBase,
-                 * which does not correctly escape things, and ambiguates a
-                 * space (%20) with a literal `%20` in the path.  Sigh.
-                 */
-                var managedPath = Assembly.GetExecutingAssembly().CodeBase;
-                if (managedPath == null)
-                {
-                    managedPath = Assembly.GetExecutingAssembly().Location;
-                }
-                else if (managedPath.StartsWith("file:///"))
+                string assemblyDirectory = GetExecutingAssemblyDirectory();
+
+                if (netFX)
                 {
-                    managedPath = managedPath.Substring(8).Replace('/', '\\');
+                    // For .NET Framework apps the dependencies are deployed to lib/win32/{architecture} directory
+                    nativeLibraryPath = Path.Combine(assemblyDirectory, "lib", "win32");
                 }
-                else if (managedPath.StartsWith("file://"))
+                else
                 {
-                    managedPath = @"\\" + managedPath.Substring(7).Replace('/', '\\');
+                    // .NET Core apps that depend on native libraries load them directly from paths specified
+                    // in .deps.json file of that app and the native library loader just works.
+                    // However, .NET Core doesn't support .deps.json for plugins yet (such as msbuild tasks).
+                    // To address that shortcoming we assume that the plugin deploys the native binaries to runtimes\{rid}\native
+                    // directories and search there.
+                    nativeLibraryPath = Path.Combine(assemblyDirectory, "runtimes", Platform.GetNativeLibraryRuntimeId(), "native");
                 }
+            }
 
-                managedPath = Path.GetDirectoryName(managedPath);
+            registeredFilters = new Dictionary<Filter, FilterRegistration>();
+        }
 
-                nativeLibraryPath = Path.Combine(managedPath, "lib", "win32");
+        private static string GetExecutingAssemblyDirectory()
+        {
+            // Assembly.CodeBase is not actually a correctly formatted
+            // URI.  It's merely prefixed with `file:///` and has its
+            // backslashes flipped.  This is superior to EscapedCodeBase,
+            // which does not correctly escape things, and ambiguates a
+            // space (%20) with a literal `%20` in the path.  Sigh.
+            var managedPath = Assembly.GetExecutingAssembly().CodeBase;
+            if (managedPath == null)
+            {
+                managedPath = Assembly.GetExecutingAssembly().Location;
+            }
+            else if (managedPath.StartsWith("file:///"))
+            {
+                managedPath = managedPath.Substring(8).Replace('/', '\\');
+            }
+            else if (managedPath.StartsWith("file://"))
+            {
+                managedPath = @"\\" + managedPath.Substring(7).Replace('/', '\\');
             }
 
-            registeredFilters = new Dictionary<Filter, FilterRegistration>();
+            managedPath = Path.GetDirectoryName(managedPath);
+            return managedPath;
         }
 
         /// <summary>
@@ -152,17 +173,18 @@ public static LogConfiguration LogConfiguration
         }
 
         /// <summary>
-        /// Sets a path for loading native binaries on .NET Framework.
-        /// When specified, native .dll will first be searched in a
-        /// subdirectory of the given path corresponding to the
-        /// architecture ("x86" or "x64") before falling
-        /// back to searching the default load directories
-        /// (<see cref="DllImportSearchPath.AssemblyDirectory"/>,
+        /// Sets a path for loading native binaries on .NET Framework or .NET Core.
+        /// When specified, native library will first be searched under the given path.
+        /// On .NET Framework a subdirectory corresponding to the architecture  ("x86" or "x64") is appended,
+        /// otherwise the native library is expected to be found in the directory as specified.
+        ///
+        /// If the library is not found it will be searched in standard search paths:
+        /// <see cref="DllImportSearchPath.AssemblyDirectory"/>,
         /// <see cref="DllImportSearchPath.ApplicationDirectory"/> and
-        /// <see cref="DllImportSearchPath.SafeDirectories"/>).
+        /// <see cref="DllImportSearchPath.SafeDirectories"/>.
         /// <para>
         /// This must be set before any other calls to the library,
-        /// and is not available on other platforms than .NET Framework.
+        /// and is not available on other platforms than .NET Framework and .NET Core.
         /// </para>
         /// </summary>
         public static string NativeLibraryPath
@@ -171,7 +193,7 @@ public static string NativeLibraryPath
             {
                 if (!nativeLibraryPathAllowed)
                 {
-                    throw new LibGit2SharpException("Querying the native hint path is only supported on Windows platforms");
+                    throw new LibGit2SharpException("Querying the native hint path is only supported on .NET Framework and .NET Core platforms");
                 }
 
                 return nativeLibraryPath;
@@ -181,7 +203,7 @@ public static string NativeLibraryPath
             {
                 if (!nativeLibraryPathAllowed)
                 {
-                    throw new LibGit2SharpException("Setting the native hint path is only supported on Windows platforms");
+                    throw new LibGit2SharpException("Setting the native hint path is only supported on .NET Framework and .NET Core platforms");
                 }
 
                 if (nativeLibraryPathLocked)
@@ -203,7 +225,10 @@ public static string NativeLibraryPath
         internal static string GetAndLockNativeLibraryPath()
         {
             nativeLibraryPathLocked = true;
-            return Path.Combine(nativeLibraryPath, Platform.ProcessorArchitecture);
+
+            return Platform.IsRunningOnNetFramework() ?
+                Path.Combine(nativeLibraryPath, Platform.ProcessorArchitecture) :
+                nativeLibraryPath;
         }
 
         /// <summary>