Fire diagnostic source events from IHostBuilder.Build

src/libraries/Microsoft.Extensions.HostFactoryResolver/src/HostFactoryResolver.cs

@@ -2,7 +2,13 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 
 #nullable enable
 
@@ -16,6 +22,9 @@ internal sealed class HostFactoryResolver
         public const string CreateWebHostBuilder = nameof(CreateWebHostBuilder);
         public const string CreateHostBuilder = nameof(CreateHostBuilder);
 
+        // The amount of time we wait for the diagnostic source events to fire
+        private static readonly TimeSpan s_defaultWaitTimeout = TimeSpan.FromSeconds(5);
+
         public static Func<string[], TWebHost>? ResolveWebHostFactory<TWebHost>(Assembly assembly)
         {
             return ResolveFactory<TWebHost>(assembly, BuildWebHost);
@@ -31,6 +40,35 @@ internal sealed class HostFactoryResolver
             return ResolveFactory<THostBuilder>(assembly, CreateHostBuilder);
         }
 
+        public static Func<string[], object>? ResolveHostFactory(Assembly assembly, TimeSpan? waitTimeout = null, bool stopApplication = true, Action<object>? configureHostBuilder = null)
+        {
+            if (assembly.EntryPoint is null)
+            {
+                return null;
+            }
+
+            try
+            {
+                // Attempt to load hosting and check the version to make sure the events
+                // even have a change of firing (they were adding in .NET >= 6)
+                var hostingAssembly = Assembly.Load("Microsoft.Extensions.Hosting");
+                if (hostingAssembly.GetName().Version is Version version && version.Major < 6)
+                {
+                    return null;
+                }
+
+                // We're using a version >= 6 so the events can fire. If they don't fire
+                // then it's because the application isn't using the hosting APIs
+            }
+            catch
+            {
+                // There was an error loading the extensions assembly, return null.
+                return null;
+            }
+
+            return args => new HostingListener(args, assembly.EntryPoint, waitTimeout ?? s_defaultWaitTimeout, stopApplication, configureHostBuilder).CreateHost();
+        }
+
         private static Func<string[], T>? ResolveFactory<T>(Assembly assembly, string name)
         {
             var programType = assembly?.EntryPoint?.DeclaringType;
@@ -58,7 +96,7 @@ private static bool IsFactory<TReturn>(MethodInfo? factory)
         }
 
         // Used by EF tooling without any Hosting references. Looses some return type safety checks.
-        public static Func<string[], IServiceProvider?>? ResolveServiceProviderFactory(Assembly assembly)
+        public static Func<string[], IServiceProvider?>? ResolveServiceProviderFactory(Assembly assembly, TimeSpan? waitTimeout = null)
         {
             // Prefer the older patterns by default for back compat.
             var webHostFactory = ResolveWebHostFactory<object>(assembly);
@@ -93,6 +131,16 @@ private static bool IsFactory<TReturn>(MethodInfo? factory)
                 };
             }
 
+            var hostFactory = ResolveHostFactory(assembly, waitTimeout: waitTimeout);
+            if (hostFactory != null)
+            {
+                return args =>
+                {
+                    var host = hostFactory(args);
+                    return GetServiceProvider(host);
+                };
+            }
+
             return null;
         }
 
@@ -112,5 +160,133 @@ private static bool IsFactory<TReturn>(MethodInfo? factory)
             var servicesProperty = hostType.GetProperty("Services", DeclaredOnlyLookup);
             return (IServiceProvider?)servicesProperty?.GetValue(host);
         }
+
+        private class HostingListener : IObserver<DiagnosticListener>, IObserver<KeyValuePair<string, object?>>
+        {
+            private readonly string[] _args;
+            private readonly MethodInfo _entryPoint;
+            private readonly TimeSpan _waitTimeout;
+            private readonly bool _stopApplication;
+
+            private readonly TaskCompletionSource<object> _hostTcs = new();
+            private IDisposable? _disposable;
+            private Action<object>? _configure;
+
+            public HostingListener(string[] args, MethodInfo entryPoint, TimeSpan waitTimeout, bool stopApplication, Action<object>? configure)
+            {
+                _args = args;
+                _entryPoint = entryPoint;
+                _waitTimeout = waitTimeout;
+                _stopApplication = stopApplication;
+                _configure = configure;
+            }
+
+            public object CreateHost()
+            {
+                using var subscription = DiagnosticListener.AllListeners.Subscribe(this);
+
+                // Kick off the entry point on a new thread so we don't block the current one
+                // in case we need to timeout the execution
+                var thread = new Thread(() =>
+                {
+                    try
+                    {
+                        var parameters = _entryPoint.GetParameters();
+                        if (parameters.Length == 0)
+                        {
+                            _entryPoint.Invoke(null, Array.Empty<object>());
+                        }
+                        else
+                        {
+                            _entryPoint.Invoke(null, new object[] { _args });
+                        }
+
+                        // Try to set an exception if the entry point returns gracefully, this will force
+                        // build to throw
+                        _hostTcs.TrySetException(new InvalidOperationException("Unable to build IHost"));
+                    }
+                    catch (TargetInvocationException tie) when (tie.InnerException is StopTheHostException)
+                    {
+                        // The host was stopped by our own logic
+                    }
+                    catch (TargetInvocationException tie)
+                    {
+                        // Another exception happened, propagate that to the caller
+                        _hostTcs.TrySetException(tie.InnerException ?? tie);
+                    }
+                    catch (Exception ex)
+                    {
+                        // Another exception happened, propagate that to the caller
+                        _hostTcs.TrySetException(ex);
+                    }
+                })
+                {
+                    // Make sure this doesn't hang the process
+                    IsBackground = true
+                };
+
+                // Start the thread
+                thread.Start();
+
+                try
+                {
+                    // Wait before throwing an exception
+                    if (!_hostTcs.Task.Wait(_waitTimeout))
+                    {
+                        throw new InvalidOperationException("Unable to build IHost");
+                    }
+                }
+                catch (AggregateException) when (_hostTcs.Task.IsCompleted)
+                {
+                    // Lets this propagate out of the call to GetAwaiter().GetResult()
+                }
+
+                Debug.Assert(_hostTcs.Task.IsCompleted);
+
+                return _hostTcs.Task.GetAwaiter().GetResult();
+            }
+
+            public void OnCompleted()
+            {
+                _disposable?.Dispose();
+            }
+
+            public void OnError(Exception error)
+            {
+
+            }
+
+            public void OnNext(DiagnosticListener value)
+            {
+                if (value.Name == "Microsoft.Extensions.Hosting")
+                {
+                    _disposable = value.Subscribe(this);
+                }
+            }
+
+            public void OnNext(KeyValuePair<string, object?> value)
+            {
+                if (value.Key == "HostBuilding")
+                {
+                    _configure?.Invoke(value.Value!);
+                }
+
+                if (value.Key == "HostBuilt")
+                {
+                    _hostTcs.TrySetResult(value.Value!);
+
+                    if (_stopApplication)
+                    {
+                        // Stop the host from running further
+                        throw new StopTheHostException();
+                    }
+                }
+            }
+
+            private class StopTheHostException : Exception
+            {
+
+            }
+        }
     }
 }

src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderInvalidSignature/Program.cs

@@ -2,14 +2,15 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using MockHostTypes;
+using Microsoft.Extensions.Hosting;
 
 namespace CreateHostBuilderInvalidSignature
 {
     public class Program
     {
         public static void Main(string[] args)
         {
-            var webHost = CreateHostBuilder(null, args).Build();
+            var webHost = CreateHostBuilder(null, args)?.Build();
         }
 
         // Extra parameter

src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/CreateHostBuilderPatternTestSite/Program.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using MockHostTypes;
+using Microsoft.Extensions.Hosting;
 
 namespace CreateHostBuilderPatternTestSite
 {

src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/HostFactoryResolverTests.cs

@@ -4,12 +4,18 @@
 using MockHostTypes;
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using Microsoft.DotNet.RemoteExecutor;
 using Xunit;
 
 namespace Microsoft.Extensions.Hosting.Tests
 {
     public class HostFactoryResolverTests
     {
+        public static bool RequirementsMet => RemoteExecutor.IsSupported && PlatformDetection.IsThreadingSupported;
+
+        private static readonly TimeSpan s_WaitTimeout = TimeSpan.FromSeconds(20);
+
         [Fact]
         [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(BuildWebHostPatternTestSite.Program))]
         public void BuildWebHostPattern_CanFindWebHost()
@@ -46,7 +52,7 @@ public void BuildWebHostPattern__Invalid_CantFindServiceProvider()
         {
             var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(BuildWebHostInvalidSignature.Program).Assembly);
 
-            Assert.Null(factory);
+            Assert.NotNull(factory);
         }
 
         [Fact]
@@ -119,13 +125,95 @@ public void CreateHostBuilderPattern__Invalid_CantFindHostBuilder()
             Assert.Null(factory);
         }
 
-        [Fact]
+        [ConditionalFact(nameof(RequirementsMet))]
         [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(CreateHostBuilderInvalidSignature.Program))]
         public void CreateHostBuilderPattern__Invalid_CantFindServiceProvider()
         {
-            var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(CreateHostBuilderInvalidSignature.Program).Assembly);
+            using var _ = RemoteExecutor.Invoke(() => 
+            {
+                var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(CreateHostBuilderInvalidSignature.Program).Assembly, s_WaitTimeout);
 
-            Assert.Null(factory);
+                Assert.NotNull(factory);
+                Assert.Throws<InvalidOperationException>(() => factory(Array.Empty<string>()));
+            });
+        }
+
+        [ConditionalFact(nameof(RequirementsMet))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPattern.Program))]
+        public void NoSpecialEntryPointPattern()
+        {
+            using var _ = RemoteExecutor.Invoke(() => 
+            {
+                var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPattern.Program).Assembly, s_WaitTimeout);
+
+                Assert.NotNull(factory);
+                Assert.IsAssignableFrom<IServiceProvider>(factory(Array.Empty<string>()));
+            });
+        }
+
+        [ConditionalFact(nameof(RequirementsMet))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPatternThrows.Program))]
+        public void NoSpecialEntryPointPatternThrows()
+        {
+            using var _ = RemoteExecutor.Invoke(() => 
+            {
+                var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPatternThrows.Program).Assembly, s_WaitTimeout);
+
+                Assert.NotNull(factory);
+                Assert.Throws<Exception>(() => factory(Array.Empty<string>()));
+            });
+        }
+
+        [ConditionalFact(nameof(RequirementsMet))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPatternExits.Program))]
+        public void NoSpecialEntryPointPatternExits()
+        {
+            using var _ = RemoteExecutor.Invoke(() => 
+            {
+                var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPatternExits.Program).Assembly, s_WaitTimeout);
+
+                Assert.NotNull(factory);
+                Assert.Throws<InvalidOperationException>(() => factory(Array.Empty<string>()));
+            });
+        }
+
+        [ConditionalFact(nameof(RequirementsMet))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPatternHangs.Program))]
+        public void NoSpecialEntryPointPatternHangs()
+        {
+            using var _ = RemoteExecutor.Invoke(() => 
+            {
+                var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPatternHangs.Program).Assembly, s_WaitTimeout);
+
+                Assert.NotNull(factory);
+                Assert.Throws<InvalidOperationException>(() => factory(Array.Empty<string>()));
+            });
+        }
+
+        [ConditionalFact(nameof(RequirementsMet))]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(NoSpecialEntryPointPatternMainNoArgs.Program))]
+        public void NoSpecialEntryPointPatternMainNoArgs()
+        {
+            using var _ = RemoteExecutor.Invoke(() => 
+            {
+                var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(NoSpecialEntryPointPatternMainNoArgs.Program).Assembly, s_WaitTimeout);
+
+                Assert.NotNull(factory);
+                Assert.IsAssignableFrom<IServiceProvider>(factory(Array.Empty<string>()));
+            });
+        }
+
+        [ConditionalFact(nameof(RequirementsMet))]
+        public void TopLevelStatements()
+        {
+            using var _ = RemoteExecutor.Invoke(() => 
+            {
+                var assembly = Assembly.Load("TopLevelStatements");
+                var factory = HostFactoryResolver.ResolveServiceProviderFactory(assembly, s_WaitTimeout);
+
+                Assert.NotNull(factory);
+                Assert.IsAssignableFrom<IServiceProvider>(factory(Array.Empty<string>()));
+            });
         }
     }
 }

src/libraries/Microsoft.Extensions.HostFactoryResolver/tests/Microsoft.Extensions.HostFactoryResolver.Tests.csproj

@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);net461</TargetFrameworks>
+    <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
   </PropertyGroup>
 
   <ItemGroup>
@@ -20,5 +21,15 @@
     <ProjectReference Include="CreateHostBuilderPatternTestSite\CreateHostBuilderPatternTestSite.csproj" />
     <ProjectReference Include="CreateWebHostBuilderInvalidSignature\CreateWebHostBuilderInvalidSignature.csproj" />
     <ProjectReference Include="CreateWebHostBuilderPatternTestSite\CreateWebHostBuilderPatternTestSite.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPattern\NoSpecialEntryPointPattern.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPatternThrows\NoSpecialEntryPointPatternThrows.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPatternExits\NoSpecialEntryPointPatternExits.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPatternHangs\NoSpecialEntryPointPatternHangs.csproj" />
+    <ProjectReference Include="NoSpecialEntryPointPatternMainNoArgs\NoSpecialEntryPointPatternMainNoArgs.csproj" />
+    <ProjectReference Include="TopLevelStatements\TopLevelStatements.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Hosting.Abstractions\src\Microsoft.Extensions.Hosting.Abstractions.csproj" />
   </ItemGroup>
 </Project>