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
 
@@ -31,6 +37,16 @@ internal sealed class HostFactoryResolver
             return ResolveFactory<THostBuilder>(assembly, CreateHostBuilder);
         }
 
+        public static Func<string[], IHostBuilder>? ResolveHostBuilderFactory(Assembly assembly)
+        {
+            if (assembly.EntryPoint is null)
+            {
+                return null;
+            }
+
+            return args => new DeferredHostBuilder(args, assembly.EntryPoint);
+        }
+
         private static Func<string[], T>? ResolveFactory<T>(Assembly assembly, string name)
         {
             var programType = assembly?.EntryPoint?.DeclaringType;
@@ -93,6 +109,17 @@ private static bool IsFactory<TReturn>(MethodInfo? factory)
                 };
             }
 
+            var deferredFactory = ResolveHostBuilderFactory(assembly);
+            if (deferredFactory != null)
+            {
+                return args =>
+                {
+                    var hostBuilder = deferredFactory(args);
+                    var host = hostBuilder.Build();
+                    return host.Services;
+                };
+            }
+
             return null;
         }
 
@@ -112,5 +139,184 @@ private static bool IsFactory<TReturn>(MethodInfo? factory)
             var servicesProperty = hostType.GetProperty("Services", DeclaredOnlyLookup);
             return (IServiceProvider?)servicesProperty?.GetValue(host);
         }
+
+        // This host builder captures calls to the IHostBuilder then replays them on the application's
+        // IHostBuilder when the event fires
+        private class DeferredHostBuilder : IHostBuilder, IObserver<DiagnosticListener>, IObserver<KeyValuePair<string, object?>>
+        {
+            public IDictionary<object, object> Properties { get; } = new Dictionary<object, object>();
+
+            private readonly string[] _args;
+            private readonly MethodInfo _entryPoint;
+
+            private readonly TaskCompletionSource<IHost> _hostTcs = new();
+            private IDisposable? _disposable;
+
+            private Action<IHostBuilder> _configure;
+
+            // The amount of time we wait for the diagnostic source events to fire
+            private static readonly TimeSpan _waitTimeout = TimeSpan.FromSeconds(20);
+
+            public DeferredHostBuilder(string[] args, MethodInfo entryPoint)
+            {
+                _args = args;
+                _entryPoint = entryPoint;
+                _configure = b =>
+                {
+                    // Copy the properties from this builder into the builder
+                    // that we're going to receive
+                    foreach (var pair in Properties)
+                    {
+                        b.Properties[pair.Key] = pair.Value;
+                    }
+                };
+            }
+
+            public IHost Build()
+            {
+                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 entrypoint 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 propogate out of the call to GetAwaiter().GetResult()
+                }
+
+                Debug.Assert(_hostTcs.Task.IsCompleted);
+
+                return _hostTcs.Task.GetAwaiter().GetResult();
+            }
+
+            public IHostBuilder ConfigureAppConfiguration(Action<HostBuilderContext, IConfigurationBuilder> configureDelegate)
+            {
+                _configure += b => b.ConfigureAppConfiguration(configureDelegate);
+                return this;
+            }
+
+            public IHostBuilder ConfigureContainer<TContainerBuilder>(Action<HostBuilderContext, TContainerBuilder> configureDelegate)
+            {
+                _configure += b => b.ConfigureContainer(configureDelegate);
+                return this;
+            }
+
+            public IHostBuilder ConfigureHostConfiguration(Action<IConfigurationBuilder> configureDelegate)
+            {
+                _configure += b => b.ConfigureHostConfiguration(configureDelegate);
+                return this;
+            }
+
+            public IHostBuilder ConfigureServices(Action<HostBuilderContext, IServiceCollection> configureDelegate)
+            {
+                _configure += b => b.ConfigureServices(configureDelegate);
+                return this;
+            }
+
+            public IHostBuilder UseServiceProviderFactory<TContainerBuilder>(IServiceProviderFactory<TContainerBuilder> factory) where TContainerBuilder : notnull
+            {
+                _configure += b => b.UseServiceProviderFactory(factory);
+                return this;
+            }
+
+            public IHostBuilder UseServiceProviderFactory<TContainerBuilder>(Func<HostBuilderContext, IServiceProviderFactory<TContainerBuilder>> factory) where TContainerBuilder : notnull
+            {
+                _configure += b => b.UseServiceProviderFactory(factory);
+                return this;
+            }
+
+            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")
+                {
+                    if (value.Value is IHostBuilder builder)
+                    {
+                        _configure(builder);
+                    }
+                }
+
+                if (value.Key == "HostBuilt")
+                {
+                    if (value.Value is IHost host)
+                    {
+                        _hostTcs.TrySetResult(host);
+
+                        // 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,16 @@
 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;
+
         [Fact]
         [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(BuildWebHostPatternTestSite.Program))]
         public void BuildWebHostPattern_CanFindWebHost()
@@ -46,7 +50,7 @@ public void BuildWebHostPattern__Invalid_CantFindServiceProvider()
         {
             var factory = HostFactoryResolver.ResolveServiceProviderFactory(typeof(BuildWebHostInvalidSignature.Program).Assembly);
 
-            Assert.Null(factory);
+            Assert.NotNull(factory);
         }
 
         [Fact]
@@ -119,13 +123,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);
 
-            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);
+
+                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);
+
+                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);
+
+                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);
+
+                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);
+
+                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);
+
+                Assert.NotNull(factory);
+                Assert.IsAssignableFrom<IServiceProvider>(factory(Array.Empty<string>()));
+            });
         }
     }
 }