Load binding extensions with direct load.

Needed to allow accessing builtin extensions.

Author: MikeStall

src/WebJobs.Script/GlobalSuppressions.cs

@@ -211,4 +211,5 @@
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Scope = "member", Target = "Microsoft.Azure.WebJobs.Script.Eventing.StructuredLogging.StructuredLogEntry.#ToJson()")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Scope = "member", Target = "Microsoft.Azure.WebJobs.Script.Eventing.StructuredLogging.StructuredLogEntry.#ToJson()")]
 [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "_traceWriter", Scope = "member", Target = "Microsoft.Azure.WebJobs.Script.Diagnostics.StructuredLogWriter.#Dispose(System.Boolean)")]
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Scope = "member", Target = "Microsoft.Azure.WebJobs.Script.FileTraceWriter.#.ctor(System.String,System.Diagnostics.TraceLevel,System.Func`2<System.String,System.String>)")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Scope = "member", Target = "Microsoft.Azure.WebJobs.Script.FileTraceWriter.#.ctor(System.String,System.Diagnostics.TraceLevel,System.Func`2<System.String,System.String>)")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.Assembly.LoadFrom", Scope = "member", Target = "Microsoft.Azure.WebJobs.Script.ScriptHost.#GetDirectTypes(System.Collections.Generic.IEnumerable`1<Microsoft.Azure.WebJobs.Script.Description.FunctionMetadata>)")]

src/WebJobs.Script/Host/ScriptHost.cs

@@ -488,6 +488,11 @@ protected virtual void Initialize()
                     }
                 }
                 LoadBuiltinBindings(usedBindingTypes);
+
+                var directTypes = GetDirectTypes(functionMetadata);
+
+                LoadDirectlyReferencesExtensions(directTypes);
+
                 LoadCustomExtensions();
 
                 // Do this after we've loaded the custom extensions. That gives an extension an opportunity to plug in their own implementations.
@@ -517,7 +522,7 @@ protected virtual void Initialize()
                 List<Type> types = new List<Type>();
                 types.Add(type);
 
-                AddDirectTypes(types, functions);
+                types.AddRange(directTypes);
 
                 hostConfig.TypeLocator = new TypeLocator(types);
 
@@ -614,13 +619,14 @@ private void VerifyPrecompileStatus(IEnumerable<FunctionDescriptor> functions)
             }
         }
 
-        private static void AddDirectTypes(List<Type> types, Collection<FunctionDescriptor> functions)
+        // Get the set of types that should be directly loaded. These have the "configurationSource" : "attributes" set.
+        // They will be indexed and invoked directly by the WebJobs SDK and skip the IL generator and invoker paths.
+        private static IEnumerable<Type> GetDirectTypes(IEnumerable<FunctionMetadata> functionMetadatas)
         {
             HashSet<Type> visitedTypes = new HashSet<Type>();
 
-            foreach (var function in functions)
+            foreach (var metadata in functionMetadatas)
             {
-                var metadata = function.Metadata;
                 if (!metadata.IsDirect)
                 {
                     continue;
@@ -632,11 +638,9 @@ private static void AddDirectTypes(List<Type> types, Collection<FunctionDescript
                 Assembly assembly = Assembly.LoadFrom(path);
                 var type = assembly.GetType(typeName);
 
-                if (visitedTypes.Add(type))
-                {
-                    types.Add(type);
-                }
+                visitedTypes.Add(type);
             }
+            return visitedTypes;
         }
 
         private IMetricsLogger CreateMetricsLogger()
@@ -697,6 +701,19 @@ private void LoadCustomExtensions(string extensionsPath)
             }
         }
 
+        // Load extensions that are directly references by the user types.
+        private void LoadDirectlyReferencesExtensions(IEnumerable<Type> userTypes)
+        {
+            var possibleExtensionAssemblies = UserTypeScanner.GetPossibleExtensionAssemblies(userTypes);
+
+            foreach (var kv in possibleExtensionAssemblies)
+            {
+                var assembly = kv.Key;
+                var locationHint = kv.Value;
+                LoadExtensions(assembly, locationHint);
+            }
+        }
+
         private void LoadExtensions(Assembly assembly, string locationHint)
         {
             foreach (var type in assembly.ExportedTypes)
@@ -706,11 +723,31 @@ private void LoadExtensions(Assembly assembly, string locationHint)
                     continue;
                 }
 
+                if (IsExtensionLoaded(type))
+                {
+                    continue;
+                }
+
                 IExtensionConfigProvider instance = (IExtensionConfigProvider)Activator.CreateInstance(type);
                 LoadExtension(instance, locationHint);
             }
         }
 
+        private bool IsExtensionLoaded(Type type)
+        {
+            var registry = this.ScriptConfig.HostConfig.GetService<IExtensionRegistry>();
+            var extensions = registry.GetExtensions<IExtensionConfigProvider>();
+            foreach (var extension in extensions)
+            {
+                var loadedExtentionType = extension.GetType();
+                if (loadedExtentionType == type)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
         // Load a single extension
         private void LoadExtension(IExtensionConfigProvider instance, string locationHint = null)
         {

src/WebJobs.Script/Host/UserTypeScanner.cs

@@ -0,0 +1,63 @@
+// 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.Collections.Generic;
+using System.Reflection;
+using Microsoft.Azure.WebJobs.Description;
+
+namespace Microsoft.Azure.WebJobs.Script
+{
+    // Scan over user types with [Binding] attributes and extract the set of assemblies.
+    internal class UserTypeScanner
+    {
+        // Scan user types for potential binding extensions.
+        // Return mapping of new assemblies along with a hint path for what triggered each.
+        public static Dictionary<Assembly, string> GetPossibleExtensionAssemblies(IEnumerable<Type> userTypes)
+        {
+            // List of possible extension assemblies.
+            var possibleExtensionAssemblies = new Dictionary<Assembly, string>();
+
+            foreach (var type in userTypes)
+            {
+                foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
+                {
+                    ScanMethod(possibleExtensionAssemblies, method);
+                }
+            }
+            return possibleExtensionAssemblies;
+        }
+
+        private static void ScanMethod(Dictionary<Assembly, string> possibleExtensionAssemblies, MethodInfo method)
+        {
+            foreach (var parameter in method.GetParameters())
+            {
+                ScanParameter(possibleExtensionAssemblies, parameter);
+            }
+
+            ScanParameter(possibleExtensionAssemblies, method.ReturnParameter);
+        }
+
+        private static void ScanParameter(Dictionary<Assembly, string> possibleExtensionAssemblies, ParameterInfo parameter)
+        {
+            foreach (var attr in parameter.GetCustomAttributes())
+            {
+                if (IsBindingAttribute(attr))
+                {
+                    Assembly assembly = attr.GetType().Assembly;
+
+                    var method = parameter.Member;
+                    string hintPath = $"referenced by: Method='{method.DeclaringType.FullName}.{method.Name}', Parameter='{parameter.Name}'.";
+
+                    possibleExtensionAssemblies[assembly] = hintPath;
+                }
+            }
+        }
+
+        private static bool IsBindingAttribute(Attribute attribute)
+        {
+            var bindingAttr = attribute.GetType().GetCustomAttribute<BindingAttribute>();
+            return bindingAttr != null;
+        }
+    }
+}

src/WebJobs.Script/WebJobs.Script.csproj

@@ -520,6 +520,7 @@
     <Compile Include="Extensions\IMetricsLoggerExtensions.cs" />
     <Compile Include="Extensions\TraceWriterExtensions.cs" />
     <Compile Include="GlobalSuppressions.cs" />
+    <Compile Include="Host\UserTypeScanner.cs" />
     <Compile Include="Host\PrimaryHostCoordinator.cs" />
     <Compile Include="Host\IScriptHostEnvironment.cs" />
     <Compile Include="Host\NullScriptHostEnvironment.cs" />