Initial round of assembly resolution and loading

improvements. Isolating extension and function assemblies
into distinct load contexts.

Author: fabiocav

.gitignore

@@ -13,6 +13,7 @@ Publish
 *.Cache
 msbuild.log
 package-lock.json
+**/Properties/launchSettings.json
 
 /packages
 /TestResults

build/common.props

@@ -1,6 +1,7 @@
 <Project>
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>7.2</LangVersion>
     <BuildNumber Condition=" '$(BuildNumber)' == '' ">1</BuildNumber>
     <MajorMinorProductVersion>2.0</MajorMinorProductVersion>
     <Version>$(MajorMinorProductVersion).0-beta2$(VersionSuffix)</Version>

src/WebJobs.Script.WebHost/Properties/launchSettings.json

@@ -2,6 +2,7 @@
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
 using System.Reflection;
+using System.Runtime.Loader;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json.Linq;
 
@@ -64,7 +65,7 @@ public virtual void Initialize()
         /// <param name="assemblyName">The name of the assembly to resolve.</param>
         /// <param name="assembly">The assembly if we were able to resolve.</param>
         /// <returns>True if the assembly could be resolved, false otherwise.</returns>
-        public virtual bool TryResolveAssembly(string assemblyName, out Assembly assembly)
+        public virtual bool TryResolveAssembly(string assemblyName, AssemblyLoadContext targetContext, out Assembly assembly)
         {
             assembly = null;
             return false;

src/WebJobs.Script/Binding/BuiltinExtensionBindingProvider.cs

@@ -72,7 +72,6 @@ public void LoadCustomExtensions()
                 {
                     string extensionName = item.Name ?? item.TypeName;
                     _logger.LogInformation($"Loading custom extension '{extensionName}'");
-
                     Type extensionType = Type.GetType(item.TypeName,
                         assemblyName =>
                         {

src/WebJobs.Script/Binding/Extensibility/ScriptBindingProvider.cs

@@ -5,6 +5,7 @@
 using System.Collections.ObjectModel;
 using System.IO;
 using System.Reflection;
+using System.Runtime.Loader;
 using Microsoft.Azure.WebJobs.Host;
 using Microsoft.Azure.WebJobs.Script.Description;
 using Microsoft.Azure.WebJobs.Script.Extensibility;
@@ -60,7 +61,7 @@ public override bool TryCreate(ScriptBindingContext context, out ScriptBinding b
             return true;
         }
 
-        public override bool TryResolveAssembly(string assemblyName, out Assembly assembly)
+        public override bool TryResolveAssembly(string assemblyName, AssemblyLoadContext targetContext, out Assembly assembly)
         {
             return _metadataProvider.TryResolveAssembly(assemblyName, out assembly);
         }

src/WebJobs.Script/Binding/ExtensionLoader.cs

@@ -38,7 +38,7 @@ public ImmutableArray<Diagnostic> GetDiagnostics()
             return _compilation.WithAnalyzers(GetAnalyzers()).GetAllDiagnosticsAsync().Result;
         }
 
-        public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver)
+        public FunctionSignature GetEntryPointSignature(IFunctionEntryPointResolver entryPointResolver, Assembly functionAssembly)
         {
             if (!_compilation.SyntaxTrees.Any())
             {
@@ -90,7 +90,7 @@ private static bool IsOrUsesAssemblyType(ITypeSymbol typeSymbol, IAssemblySymbol
 
         async Task<object> ICompilation.EmitAsync(CancellationToken cancellationToken) => await EmitAsync(cancellationToken);
 
-        public async Task<Assembly> EmitAsync(CancellationToken cancellationToken)
+        public async Task<DotNetCompilationResult> EmitAsync(CancellationToken cancellationToken)
         {
             try
             {
@@ -113,7 +113,7 @@ public async Task<Assembly> EmitAsync(CancellationToken cancellationToken)
                     // and if so quit here.
                     cancellationToken.ThrowIfCancellationRequested();
 
-                    return Assembly.Load(assemblyStream.GetBuffer(), pdbStream.GetBuffer());
+                    return DotNetCompilationResult.FromBytes(assemblyStream.GetBuffer(), pdbStream.GetBuffer());
                 }
             }
             catch (Exception exc) when (!(exc is CompilationErrorException))

src/WebJobs.Script/Binding/GeneralScriptBindingProvider.cs

@@ -82,7 +82,7 @@ private Compilation GetScriptCompilation(Script<object> script, FunctionMetadata
                 .AddSyntaxTrees(scriptTree);
 
             return compilation.WithOptions(compilation.Options.WithOptimizationLevel(_optimizationLevel))
-                .WithAssemblyName(FunctionAssemblyLoader.GetAssemblyNameFromMetadata(functionMetadata, compilation.AssemblyName));
+                .WithAssemblyName(Utility.GetAssemblyNameFromMetadata(functionMetadata, compilation.AssemblyName));
         }
     }
 }

src/WebJobs.Script/Description/DotNet/Compilation/CSharp/CSharpCompilation.cs

@@ -0,0 +1,89 @@
+// 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.IO;
+using System.Reflection;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Azure.WebJobs.Script.Description
+{
+    public abstract class DotNetCompilationResult
+    {
+        public static DotNetCompilationResult FromBytes(byte[] assemblyBytes, byte[] pdbBytes = null)
+            => new BinaryCompilationResult(assemblyBytes, pdbBytes);
+
+        public static DotNetCompilationResult FromStream(Stream assemblyStream, Stream pdbStream = null)
+            => new BinaryCompilationResult(assemblyStream, pdbStream);
+
+        public static DotNetCompilationResult FromPath(string assemblyPath)
+            => new PathCompilationResult(assemblyPath);
+
+        public abstract Assembly Load(FunctionMetadata metadata, IFunctionMetadataResolver metadataResolver, ILogger logger);
+
+        private sealed class BinaryCompilationResult : DotNetCompilationResult
+        {
+            public BinaryCompilationResult(Stream assemblyBytes)
+                : this(assemblyBytes, null)
+            {
+            }
+
+            public BinaryCompilationResult(Stream assemblyStream, Stream pdbStream)
+            {
+                AssemblyStream = assemblyStream ?? throw new ArgumentNullException(nameof(assemblyStream));
+                PdbStream = pdbStream;
+            }
+
+            public BinaryCompilationResult(byte[] assemblyBytes, byte[] pdbBytes)
+            {
+                if (assemblyBytes == null)
+                {
+                    throw new ArgumentNullException(nameof(assemblyBytes));
+                }
+
+                AssemblyStream = new MemoryStream(assemblyBytes);
+
+                if (pdbBytes != null)
+                {
+                    PdbStream = new MemoryStream(pdbBytes);
+                }
+            }
+
+            public Stream AssemblyStream { get; }
+
+            public Stream PdbStream { get; }
+
+            public override Assembly Load(FunctionMetadata metadata, IFunctionMetadataResolver metadataResolver, ILogger logger)
+            {
+                var context = new DynamicFunctionAssemblyLoadContext(metadata, metadataResolver, logger);
+
+                AssemblyStream.Position = 0;
+
+                if (PdbStream != null)
+                {
+                    PdbStream.Position = 0;
+                }
+
+                return context.LoadFromStream(AssemblyStream, PdbStream);
+            }
+        }
+
+        private sealed class PathCompilationResult : DotNetCompilationResult
+        {
+            public PathCompilationResult(string assemblyPath)
+            {
+                if (string.IsNullOrWhiteSpace(assemblyPath))
+                {
+                    throw new ArgumentException("Invalid path string", nameof(assemblyPath));
+                }
+
+                AssemblyPath = assemblyPath;
+            }
+
+            public string AssemblyPath { get; }
+
+            public override Assembly Load(FunctionMetadata metadata, IFunctionMetadataResolver metadataResolver, ILogger logger)
+                => FunctionAssemblyLoadContext.Shared.LoadFromAssemblyPath(AssemblyPath);
+        }
+    }
+}