[v3.x] Enhancing native dependency resolution for Linux/OSX (#8375)

* Enhancing native dependency resolution for Linux/OSX

* Fix systemruntime info and spelling

* Remove StringComparison argument from Contains

Co-authored-by: Fabio Cavalcante <[email protected]>
Co-authored-by: Lilian Kasem <[email protected]>

Author: 3 people

src/WebJobs.Script/Description/DotNet/DynamicFunctionAssemblyLoadContext.cs

@@ -37,7 +37,7 @@ protected override Assembly OnResolvingAssembly(AssemblyLoadContext context, Ass
 
             if (assembly == null)
             {
-                _logger.AssemblyDynamiclyResolutionFailure(assemblyName.FullName, _functionMetadata.Name);
+                _logger.AssemblyDynamicallyResolutionFailure(assemblyName.FullName, _functionMetadata.Name);
             }
 
             return assembly;
@@ -61,7 +61,7 @@ protected override Assembly Load(AssemblyName assemblyName)
             assembly = _metadataResolver?.ResolveAssembly(assemblyName, this);
             if (assembly == null)
             {
-                _logger.AssemblyDynamiclyResolved(assemblyName.FullName, _functionMetadata.Name);
+                _logger.AssemblyDynamicallyResolved(assemblyName.FullName, _functionMetadata.Name);
             }
 
             return assembly;

src/WebJobs.Script/Description/DotNet/FunctionAssemblyLoadContext.cs

@@ -440,12 +440,14 @@ protected virtual Assembly OnResolvingAssembly(AssemblyLoadContext arg1, Assembl
 
         protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
         {
-            string fileName = GetUnmanagedLibraryFileName(unmanagedDllName);
-            string filePath = GetRuntimeNativeAssetPath(fileName);
-
-            if (filePath != null)
+            foreach (var fileName in GetUnmanagedLibraryFileNames(unmanagedDllName, SystemRuntimeInformation.Instance.GetOSPlatform()))
             {
-                return LoadUnmanagedDllFromPath(filePath);
+                string filePath = GetRuntimeNativeAssetPath(fileName);
+
+                if (filePath != null)
+                {
+                    return LoadUnmanagedDllFromPath(filePath);
+                }
             }
 
             return base.LoadUnmanagedDll(unmanagedDllName);
@@ -481,45 +483,102 @@ internal static string ProbeForNativeAsset(IList<string> probingPaths, string as
 
             List<string> rids = DependencyHelper.GetRuntimeFallbacks();
 
-            string result = rids.Select(r => Path.Combine(runtimesPath, r, ridSubFolder, assetFileName))
-                .Union(probingPaths.Select(p => Path.Combine(p, assetFileName)))
-                .FirstOrDefault(p => fileBase.Exists(p));
+            foreach (string rid in rids)
+            {
+                string path = Path.Combine(runtimesPath, rid, ridSubFolder, assetFileName);
+                if (fileBase.Exists(path))
+                {
+                    return path;
+                }
+            }
 
-            return result;
+            foreach (var probingPath in probingPaths)
+            {
+                string path = Path.Combine(probingPath, assetFileName);
+
+                if (fileBase.Exists(path))
+                {
+                    return path;
+                }
+            }
+
+            return null;
         }
 
-        internal string GetUnmanagedLibraryFileName(string unmanagedLibraryName)
+        internal static IEnumerable<string> GetUnmanagedLibraryFileNames(string unmanagedLibraryName, OSPlatform platform)
         {
             // We need to properly resolve the native library in different platforms:
-            // - Windows will append the '.DLL' extension to the name
-            // - Linux uses the 'lib' prefix and '.so' suffix. The version may also be appended to the suffix
-            // - macOS uses the 'lib' prefix '.dylib'
-            // To handle the different scenarios described above, we'll just have a pattern that gives us the ability
-            // to match the variations across different platforms. If needed, we can expand this in the future to have
-            // logic specific to the platform we're running under.
-
-            string fileName = null;
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            // Windows:
+            //  - Will append the '.dll' extension to the name, if it does not already have the extension.
+            // Linux and macOS:
+            // - Returns the following, in order (where prefix is 'lib' and suffix is '.so' for Linux and '.dylib' for macOS):
+            //    - libname + suffix
+            //    - prefix + libname + suffix **
+            //    - libname
+            //    - prefix + libname *
+            // On Linux only, if the library name ends with the suffix or contains the suffix + '.' (i.e. .so or .so.)
+            // - Returns the following, in order (where prefix is 'lib' and suffix is '.so'):
+            //    - libname
+            //    - prefix + libname *
+            //    - libname + suffix
+            //    - prefix + libname + suffix **
+            // * Will only be returned if the path delimiter is not present in the library name
+            // ** Would typically have the same path delimiter check, but we maintain this here for backwards compatibility
+
+            if (platform == OSPlatform.Windows)
             {
                 if (unmanagedLibraryName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
                 {
-                    fileName = unmanagedLibraryName;
+                    yield return unmanagedLibraryName;
                 }
                 else
                 {
-                    fileName = unmanagedLibraryName + ".dll";
+                    yield return unmanagedLibraryName + ".dll";
                 }
             }
-            else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+            else
             {
-                fileName = "lib" + unmanagedLibraryName + ".dylib";
+                const string prefix = "lib";
+                string suffix = platform == OSPlatform.Linux
+                    ? ".so"
+                    : ".dylib";
+
+                foreach (var name in GetUnixUnmanagedLibraryFileNames(unmanagedLibraryName, prefix, suffix, platform))
+                {
+                    yield return name;
+                }
             }
-            else
+        }
+
+        private static IEnumerable<string> GetUnixUnmanagedLibraryFileNames(string unmanagedLibraryName, string prefix, string suffix, OSPlatform platform)
+        {
+            bool containsPathDelimiter = unmanagedLibraryName.Contains(Path.DirectorySeparatorChar);
+            bool containsExtension = platform == OSPlatform.Linux
+                && (unmanagedLibraryName.EndsWith(suffix, StringComparison.OrdinalIgnoreCase)
+                || unmanagedLibraryName.ToLower().Contains(suffix));
+
+            if (containsExtension)
             {
-                fileName = "lib" + unmanagedLibraryName + ".so";
+                yield return unmanagedLibraryName;
+
+                if (!containsPathDelimiter)
+                {
+                    yield return prefix + unmanagedLibraryName;
+                }
             }
 
-            return fileName;
+            yield return unmanagedLibraryName + suffix;
+            yield return prefix + unmanagedLibraryName + suffix;
+
+            if (!containsExtension)
+            {
+                yield return unmanagedLibraryName;
+
+                if (!containsPathDelimiter)
+                {
+                    yield return prefix + unmanagedLibraryName;
+                }
+            }
         }
 
         protected static string ResolveFunctionBaseProbingPath()

src/WebJobs.Script/Diagnostics/Extensions/DescriptionLoggerExtension.cs

@@ -10,11 +10,11 @@ public static class DescriptionLoggerExtension
     {
         // EventId range is 1-99
 
-        private static readonly Action<ILogger, string, string, Exception> _assemblyDynamiclyResolved =
+        private static readonly Action<ILogger, string, string, Exception> _assemblyDynamicallyResolved =
         LoggerMessage.Define<string, string>(LogLevel.Trace, new EventId(1, nameof(AssemblyResolved)),
             "Resolved assembly '{assemblyName}' in the function load context using the dynamic resolver for function '{functionName}'");
 
-        private static readonly Action<ILogger, string, string, Exception> _assemblyDynamiclyResolutionFailure =
+        private static readonly Action<ILogger, string, string, Exception> _assemblyDynamicallyResolutionFailure =
             LoggerMessage.Define<string, string>(LogLevel.Trace, new EventId(2, nameof(AssemblyResolutionFailure)),
                 "Attempt to resolve assembly '{assemblyName}' failed in the function load context using the dynamic resolver for function '{functionName}'");
 
@@ -26,14 +26,14 @@ public static class DescriptionLoggerExtension
             LoggerMessage.Define<string, string>(LogLevel.Trace, new EventId(4, nameof(AssemblyResolutionFailure)),
                 "Attempt to resolve assembly '{assemblyName}' failed in the function load context using the resolver '{assemblyResolverName}'");
 
-        public static void AssemblyDynamiclyResolved(this ILogger logger, string assemblyName, string functionName)
+        public static void AssemblyDynamicallyResolved(this ILogger logger, string assemblyName, string functionName)
         {
-            _assemblyDynamiclyResolved(logger, assemblyName, functionName, null);
+            _assemblyDynamicallyResolved(logger, assemblyName, functionName, null);
         }
 
-        public static void AssemblyDynamiclyResolutionFailure(this ILogger logger, string assemblyName, string functionName)
+        public static void AssemblyDynamicallyResolutionFailure(this ILogger logger, string assemblyName, string functionName)
         {
-            _assemblyDynamiclyResolutionFailure(logger, assemblyName, functionName, null);
+            _assemblyDynamicallyResolutionFailure(logger, assemblyName, functionName, null);
         }
 
         public static void AssemblyResolved(this ILogger logger, string assemblyName, string assemblyResolverName)

src/WebJobs.Script/Workers/RuntimeInformation/ISystemRuntimeInformation.cs renamed to src/WebJobs.Script/RuntimeInformation/ISystemRuntimeInformation.cs

@@ -3,7 +3,7 @@
 
 using System.Runtime.InteropServices;
 
-namespace Microsoft.Azure.WebJobs.Script.Workers
+namespace Microsoft.Azure.WebJobs.Script
 {
     public interface ISystemRuntimeInformation
     {

src/WebJobs.Script/RuntimeInformation/SystemRuntimeInformation.cs

@@ -0,0 +1,42 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Azure.WebJobs.Script
+{
+    public class SystemRuntimeInformation : ISystemRuntimeInformation
+    {
+        private static OSPlatform? _platform;
+        private static Lazy<SystemRuntimeInformation> _runtimeInformationInstance = new Lazy<SystemRuntimeInformation>(() => new SystemRuntimeInformation());
+
+        public static ISystemRuntimeInformation Instance => _runtimeInformationInstance.Value;
+
+        public Architecture GetOSArchitecture()
+        {
+            return RuntimeInformation.OSArchitecture;
+        }
+
+        public OSPlatform GetOSPlatform()
+        {
+            if (_platform == null)
+            {
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    _platform = OSPlatform.Windows;
+                }
+                else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                {
+                    _platform = OSPlatform.OSX;
+                }
+                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                {
+                    _platform = OSPlatform.Linux;
+                }
+            }
+
+            return _platform.Value;
+        }
+    }
+}

src/WebJobs.Script/Workers/RuntimeInformation/SystemRuntimeInformation.cs

@@ -139,5 +139,57 @@ public void ProbeForNativeAssets_FindsAsset(string assetPath)
             string result = FunctionAssemblyLoadContext.ProbeForNativeAsset(probingPaths, "assembly.dll", mockFile.Object);
             Assert.Equal(assetPath, result);
         }
+
+        [Theory]
+        [MemberData(nameof(UnmanagedLibraryNames))]
+        public void GetUnmanagedLibraryFileNames_ReturnsExpectedResults(string libName, string[] expectedResults, OSPlatform platform)
+        {
+            var result = FunctionAssemblyLoadContext.GetUnmanagedLibraryFileNames(libName, platform);
+
+            Assert.Equal(expectedResults, result);
+        }
+
+        public static IEnumerable<object[]> UnmanagedLibraryNames()
+        {
+            return new[]
+            {
+                new object[]
+                {
+                    "testdep",
+                    new string[] { "testdep.dll" },
+                    OSPlatform.Windows
+                },
+                new object[]
+                {
+                    "testdep.dll",
+                    new string[] { "testdep.dll" },
+                    OSPlatform.Windows
+                },
+                new object[]
+                {
+                    "testdep",
+                    new string[] { "testdep.so", "libtestdep.so", "testdep", "libtestdep" },
+                    OSPlatform.Linux
+                },
+                new object[]
+                {
+                    "testdep",
+                    new string[] { "testdep.dylib", "libtestdep.dylib", "testdep", "libtestdep" },
+                    OSPlatform.OSX
+                },
+                new object[]
+                {
+                    "testdep.so",
+                    new string[] { "testdep.so", "libtestdep.so", "testdep.so.so", "libtestdep.so.so" },
+                    OSPlatform.Linux
+                },
+                new object[]
+                {
+                    "testdep.so.6",
+                    new string[] { "testdep.so.6", "libtestdep.so.6", "testdep.so.6.so", "libtestdep.so.6.so" },
+                    OSPlatform.Linux
+                },
+            };
+        }
     }
 }