public FabricContainer(ServiceCollection services = null)
{
services = services ?? new ServiceCollection();
this.RegisterInstance <IServiceScopeInitializer>(this);
//#if NETCORE20
this.AsFabricContainer().BuildServiceProvider(services);
//#else
// this.AsFabricContainer().WithAspNetCoreServiceProvider();
//#endif
var _hostingEnvironment = new HostingEnvironment();
var _config = new ConfigurationBuilder()
.AddEnvironmentVariables(prefix: "ASPNETCORE_")
.Build();
var _options = new WebHostOptions(_config, Assembly.GetEntryAssembly()?.GetName().Name)
{
};
// Microsoft.AspNetCore.Hosting.Internal.HostingEnvironmentExtensions.Initialize
var contentRootPath = ResolveContentRootPath(_options.ContentRootPath, AppContext.BaseDirectory);
_hostingEnvironment.Initialize(contentRootPath, _options);
this.RegisterInstance <IHostingEnvironment>(_hostingEnvironment);
}
public override IWebHost Build()
{
var host = base.Build();
_options2 = _options;
return(host);
}
internal static void Initialize(
this IWebHostEnvironment hostingEnvironment,
string contentRootPath,
WebHostOptions options,
IHostEnvironment?baseEnvironment = null)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (string.IsNullOrEmpty(contentRootPath))
{
throw new ArgumentException("A valid non-empty content root must be provided.", nameof(contentRootPath));
}
if (!Directory.Exists(contentRootPath))
{
throw new ArgumentException($"The content root '{contentRootPath}' does not exist.", nameof(contentRootPath));
}
hostingEnvironment.ApplicationName = baseEnvironment?.ApplicationName ?? options.ApplicationName;
hostingEnvironment.ContentRootPath = contentRootPath;
hostingEnvironment.ContentRootFileProvider = baseEnvironment?.ContentRootFileProvider ?? new PhysicalFileProvider(hostingEnvironment.ContentRootPath);
var webRoot = options.WebRoot;
if (webRoot == null)
{
// Default to /wwwroot if it exists.
var wwwroot = Path.Combine(hostingEnvironment.ContentRootPath, "wwwroot");
if (Directory.Exists(wwwroot))
{
hostingEnvironment.WebRootPath = wwwroot;
}
}
else
{
hostingEnvironment.WebRootPath = Path.Combine(hostingEnvironment.ContentRootPath, webRoot);
}
if (!string.IsNullOrEmpty(hostingEnvironment.WebRootPath))
{
hostingEnvironment.WebRootPath = Path.GetFullPath(hostingEnvironment.WebRootPath);
if (!Directory.Exists(hostingEnvironment.WebRootPath))
{
Directory.CreateDirectory(hostingEnvironment.WebRootPath);
}
hostingEnvironment.WebRootFileProvider = new PhysicalFileProvider(hostingEnvironment.WebRootPath);
}
else
{
hostingEnvironment.WebRootFileProvider = new NullFileProvider();
}
hostingEnvironment.EnvironmentName =
baseEnvironment?.EnvironmentName ??
options.Environment ??
hostingEnvironment.EnvironmentName;
}
private static IHostingEnvironment InitializeEnvironment()
{
IConfigurationRoot config = new ConfigurationBuilder().AddEnvironmentVariables("ASPNETCORE_").Build();
var options = new WebHostOptions(config, GetApplicationName());
var env = new HostingEnvironment();
env.Initialize(AppContext.BaseDirectory, options);
return(env);
}
public override IWebHost Build()
{
var host = base.Build();
_options2 = _options;
//_options.CaptureStartupErrors = true;
//_options.SuppressStatusMessages = false;
return(host);
}
public void ReadsOldEnvKey()
{
var parameters = new Dictionary <string, string>()
{
{ "ENVIRONMENT", "Development" }
};
var config = new WebHostOptions(new ConfigurationBuilder().AddInMemoryCollection(parameters).Build());
Assert.Equal("Development", config.Environment);
}
public void ReadsOldEnvKey()
{
var parameters = new Dictionary <string, string>()
{
{ "ENVIRONMENT", Environments.Development }
};
var config = new WebHostOptions(new ConfigurationBuilder().AddInMemoryCollection(parameters).Build(), applicationNameFallback: null);
Assert.Equal(Environments.Development, config.Environment);
}
public void AllowsNumberForDetailedErrors(string value, bool expected)
{
var parameters = new Dictionary <string, string>()
{
{ "detailedErrors", value }
};
var config = new WebHostOptions(new ConfigurationBuilder().AddInMemoryCollection(parameters).Build(), applicationNameFallback: null);
Assert.Equal(expected, config.DetailedErrors);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc(options =>
{
options.Filters.AddService(typeof(ApiExplorerDataFilter));
});
services.AddSingleton <ApiExplorerDataFilter>();
var hostingEnvironment = services.BuildServiceProvider().GetService <IHostingEnvironment>();
var webHostOptions = new WebHostOptions(Configuration);
}
private static IHostingEnvironment GetHostingEnvironment(Func <string> contentRootPath)
{
var hostingEnvironment = new HostingEnvironment();
var webHostOptions = new WebHostOptions();
hostingEnvironment.Initialize("Template", contentRootPath(), webHostOptions);
hostingEnvironment.EnvironmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
return(hostingEnvironment);
}
public ConsoleApp(
IServiceCollection appServices,
IServiceProvider hostingServiceProvider,
IConfiguration config,
WebHostOptions options,
AggregateException hostingStartupErrors)
{
_config = config;
_hostingStartupErrors = hostingStartupErrors;
_options = options;
_applicationServiceCollection = appServices;
_hostingServiceProvider = hostingServiceProvider;
_startup = _hostingServiceProvider.GetService <IConsoleStartup>();
}
public SmallWebHost(IServiceProvider provider,
IConfiguration config,
Microsoft.Extensions.Hosting.IApplicationLifetime applicationLifetime,
ILogger <SmallWebHost> logger,
WebHostOptions options,
Action <IApplicationBuilder> appFuncBuilder)
{
Services = provider;
_config = config;
_options = options;
_logger = logger;
_applicationLifetime = applicationLifetime as Microsoft.Extensions.Hosting.Internal.ApplicationLifetime;
_appFuncBuilder = appFuncBuilder;
}
private IServiceCollection BuildCommonServices(out AggregateException hostingStartupErrors)
{
hostingStartupErrors = null;
_options = new WebHostOptions(_config);
var services = new ServiceCollection();
var contentRootPath = ResolveContentRootPath(_options.ContentRootPath, AppContext.BaseDirectory);
Environment.Initialize(Assembly.GetEntryAssembly()?.GetName().Name, contentRootPath, _options);
_context.HostingEnvironment = Environment;
services.AddSingleton <IHostingEnvironment>(Environment);
var builder = new ConfigurationBuilder()
.SetBasePath(Environment.ContentRootPath)
.AddConfiguration(_config);
foreach (var configureAppConfiguration in _configureAppConfigurationBuilderDelegates)
{
configureAppConfiguration(_context, builder);
}
var configuration = builder.Build();
services.AddSingleton <IConfiguration>(configuration);
_context.Configuration = configuration;
services.AddTransient <IServiceProviderFactory <IServiceCollection>, DefaultServiceProviderFactory>();
services.AddOptions();
services.AddLogging();
foreach (var configureServices in _configureServicesDelegates)
{
configureServices(_config, services);
}
return(services);
}
private void ExecuteHostingStartups()
{
var webHostOptions = new WebHostOptions(_config);
if (webHostOptions.PreventHostingStartup)
{
return;
}
var exceptions = new List <Exception>();
var processed = new HashSet <Assembly>();
_hostingStartupWebHostBuilder = new HostingStartupWebHostBuilder(this);
// Execute the hosting startup assemblies
foreach (var assemblyName in webHostOptions.GetFinalHostingStartupAssemblies())
{
try
{
var assembly = Assembly.Load(new AssemblyName(assemblyName));
if (!processed.Add(assembly))
{
// Already processed, skip it
continue;
}
foreach (var attribute in assembly.GetCustomAttributes <HostingStartupAttribute>())
{
var hostingStartup = (IHostingStartup)Activator.CreateInstance(attribute.HostingStartupType) !;
hostingStartup.Configure(_hostingStartupWebHostBuilder);
}
}
catch (Exception ex)
{
// Capture any errors that happen during startup
exceptions.Add(new InvalidOperationException($"Startup assembly {assemblyName} failed to execute. See the inner exception for more details.", ex));
}
}
if (exceptions.Count > 0)
{
_hostingStartupErrors = new AggregateException(exceptions);
}
}
public WebHost(
IServiceCollection appServices,
IServiceProvider hostingServiceProvider,
WebHostOptions options,
IConfiguration config,
AggregateException?hostingStartupErrors)
{
if (appServices == null)
{
throw new ArgumentNullException(nameof(appServices));
}
if (hostingServiceProvider == null)
{
throw new ArgumentNullException(nameof(hostingServiceProvider));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_config = config;
_hostingStartupErrors = hostingStartupErrors;
_options = options;
_applicationServiceCollection = appServices;
_hostingServiceProvider = hostingServiceProvider;
_applicationServiceCollection.AddSingleton <ApplicationLifetime>();
// There's no way to to register multiple service types per definition. See https://github.com/aspnet/DependencyInjection/issues/360
#pragma warning disable CS8634 // The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'class' constraint.
_applicationServiceCollection.AddSingleton(services
=> services.GetService <ApplicationLifetime>() as IHostApplicationLifetime);
#pragma warning disable CS0618 // Type or member is obsolete
_applicationServiceCollection.AddSingleton(services
=> services.GetService <ApplicationLifetime>() as AspNetCore.Hosting.IApplicationLifetime);
_applicationServiceCollection.AddSingleton(services
=> services.GetService <ApplicationLifetime>() as Extensions.Hosting.IApplicationLifetime);
#pragma warning restore CS0618 // Type or member is obsolete
#pragma warning restore CS8634 // The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'class' constraint.
_applicationServiceCollection.AddSingleton <HostedServiceExecutor>();
}
public static IHostBuilder AddKestrelApp(this IHostBuilder builder, Action <IApplicationBuilder> appBuilder)
{
builder.ConfigureServices(services =>
{
var sp = services.BuildServiceProvider();
var appLifetime = ActivatorUtilities.CreateInstance <ApplicationLifetime>(sp);
services.AddSingleton <Microsoft.AspNetCore.Hosting.IApplicationLifetime>(appLifetime);
services.AddSingleton <Microsoft.Extensions.Hosting.IApplicationLifetime>(appLifetime);
var hostOptions = new WebHostOptions(sp.GetRequiredService <IConfiguration>(), Assembly.GetEntryAssembly()?.GetName().Name);
var commonHosting = new HostingEnvironment();
commonHosting.Initialize(sp.GetRequiredService <Microsoft.Extensions.Hosting.IHostingEnvironment>(), hostOptions);
services.AddSingleton <Microsoft.AspNetCore.Hosting.IHostingEnvironment>(commonHosting);
services.AddSingleton <Microsoft.Extensions.Hosting.IHostingEnvironment>(commonHosting);
var listener = new DiagnosticListener("Microsoft.AspNetCore");
services.AddSingleton <DiagnosticListener>(listener);
services.AddSingleton <DiagnosticSource>(listener);
services.AddTransient <IServiceProviderFactory <IServiceCollection>, DefaultServiceProviderFactory>();
services.AddSingleton <ObjectPoolProvider, DefaultObjectPoolProvider>();
services.AddTransient <IApplicationBuilderFactory, ApplicationBuilderFactory>();
services.AddTransient <IHttpContextFactory, HttpContextFactory>();
services.AddScoped <IMiddlewareFactory, MiddlewareFactory>();
services.AddTransient <IStartupFilter, AutoRequestServicesStartupFilter>();
services.TryAddSingleton <ITransportFactory, LibuvTransportFactory>();
services.AddTransient <IConfigureOptions <KestrelServerOptions>, KestrelServerOptionsSetup>();
services.AddSingleton <IServer, KestrelServer>();
services.AddSingleton(provider => ConstructWebHost(provider, hostOptions, appBuilder));
services.AddSingleton <IHostedService, HttpHostedService>();
});
return(builder);
}
public void ReadsParametersCorrectly()
{
var parameters = new Dictionary <string, string>()
{
{ "webroot", "wwwroot" },
{ "server", "Microsoft.AspNetCore.Server.Kestrel" },
{ "application", "MyProjectReference" },
{ "environment", "Development" },
{ "detailederrors", "true" },
{ "captureStartupErrors", "true" }
};
var config = new WebHostOptions(new ConfigurationBuilder().AddInMemoryCollection(parameters).Build());
Assert.Equal("wwwroot", config.WebRoot);
Assert.Equal("Microsoft.AspNetCore.Server.Kestrel", config.ServerAssembly);
Assert.Equal("MyProjectReference", config.Application);
Assert.Equal("Development", config.Environment);
Assert.True(config.CaptureStartupErrors);
Assert.True(config.DetailedErrors);
}
private static WebHostBuilderContext GetWebHostBuilderContext(HostBuilderContext context)
{
if (!context.Properties.TryGetValue(typeof(WebHostBuilderContext), out var contextVal))
{
var options = new WebHostOptions(context.Configuration, Assembly.GetEntryAssembly()?.GetName().Name ?? string.Empty);
var webHostBuilderContext = new WebHostBuilderContext
{
Configuration = context.Configuration,
HostingEnvironment = new HostingEnvironment(),
};
webHostBuilderContext.HostingEnvironment.Initialize(context.HostingEnvironment.ContentRootPath, options);
context.Properties[typeof(WebHostBuilderContext)] = webHostBuilderContext;
context.Properties[typeof(WebHostOptions)] = options;
return(webHostBuilderContext);
}
// Refresh config, it's periodically updated/replaced
var webHostContext = (WebHostBuilderContext)contextVal;
webHostContext.Configuration = context.Configuration;
return(webHostContext);
}
public WebHost(
IServiceCollection appServices,
IServiceProvider hostingServiceProvider,
WebHostOptions options,
IConfiguration config,
AggregateException?hostingStartupErrors)
{
if (appServices == null)
{
throw new ArgumentNullException(nameof(appServices));
}
if (hostingServiceProvider == null)
{
throw new ArgumentNullException(nameof(hostingServiceProvider));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_config = config;
_hostingStartupErrors = hostingStartupErrors;
_options = options;
_applicationServiceCollection = appServices;
_hostingServiceProvider = hostingServiceProvider;
_applicationServiceCollection.AddSingleton <ApplicationLifetime>();
// There's no way to to register multiple service types per definition. See https://github.com/aspnet/DependencyInjection/issues/360
_applicationServiceCollection.AddSingleton <IHostApplicationLifetime>(services
=> services.GetService <ApplicationLifetime>() !);
#pragma warning disable CS0618 // Type or member is obsolete
_applicationServiceCollection.AddSingleton <AspNetCore.Hosting.IApplicationLifetime>(services
=> services.GetService <ApplicationLifetime>() !);
_applicationServiceCollection.AddSingleton <Extensions.Hosting.IApplicationLifetime>(services
=> services.GetService <ApplicationLifetime>() !);
#pragma warning restore CS0618 // Type or member is obsolete
_applicationServiceCollection.AddSingleton <HostedServiceExecutor>();
}
public void ReadsParametersCorrectly()
{
var parameters = new Dictionary <string, string>()
{
{ WebHostDefaults.WebRootKey, "wwwroot" },
{ WebHostDefaults.ApplicationKey, "MyProjectReference" },
{ WebHostDefaults.StartupAssemblyKey, "MyProjectReference" },
{ WebHostDefaults.EnvironmentKey, Environments.Development },
{ WebHostDefaults.DetailedErrorsKey, "true" },
{ WebHostDefaults.CaptureStartupErrorsKey, "true" },
{ WebHostDefaults.SuppressStatusMessagesKey, "true" }
};
var config = new WebHostOptions(new ConfigurationBuilder().AddInMemoryCollection(parameters).Build(), applicationNameFallback: null);
Assert.Equal("wwwroot", config.WebRoot);
Assert.Equal("MyProjectReference", config.ApplicationName);
Assert.Equal("MyProjectReference", config.StartupAssembly);
Assert.Equal(Environments.Development, config.Environment);
Assert.True(config.CaptureStartupErrors);
Assert.True(config.DetailedErrors);
Assert.True(config.SuppressStatusMessages);
}
private WebHostBuilderContext GetWebHostBuilderContext(HostBuilderContext context)
{
if (!context.Properties.TryGetValue(typeof(WebHostBuilderContext), out var contextVal))
{
// Use _config as a fallback for WebHostOptions in case the chained source was removed from the hosting IConfigurationBuilder.
var options = new WebHostOptions(context.Configuration, fallbackConfiguration: _config);
var webHostBuilderContext = new WebHostBuilderContext
{
Configuration = context.Configuration,
HostingEnvironment = new HostingEnvironment(),
};
webHostBuilderContext.HostingEnvironment.Initialize(context.HostingEnvironment.ContentRootPath, options);
context.Properties[typeof(WebHostBuilderContext)] = webHostBuilderContext;
context.Properties[typeof(WebHostOptions)] = options;
return(webHostBuilderContext);
}
// Refresh config, it's periodically updated/replaced
var webHostContext = (WebHostBuilderContext)contextVal;
webHostContext.Configuration = context.Configuration;
return(webHostContext);
}
private static IWebHost ConstructWebHost(IServiceProvider sp, WebHostOptions hostOptions, Action <IApplicationBuilder> appBuilder)
{
return(ActivatorUtilities.CreateInstance(sp, typeof(SmallWebHost), hostOptions, appBuilder) as IWebHost);
}
public static Microsoft.AspNetCore.Hosting.IHostingEnvironment Initialize(this Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment, Microsoft.Extensions.Hosting.IHostingEnvironment baseEnv, WebHostOptions options)
{
hostingEnvironment.ApplicationName = options.ApplicationName;
hostingEnvironment.ContentRootPath = baseEnv.ContentRootPath;
hostingEnvironment.ContentRootFileProvider = new PhysicalFileProvider(hostingEnvironment.ContentRootPath);
var webRoot = options.WebRoot;
if (webRoot == null)
{
// Default to /wwwroot if it exists.
var wwwroot = Path.Combine(hostingEnvironment.ContentRootPath, "wwwroot");
if (Directory.Exists(wwwroot))
{
hostingEnvironment.WebRootPath = wwwroot;
}
}
else
{
hostingEnvironment.WebRootPath = Path.Combine(hostingEnvironment.ContentRootPath, webRoot);
}
if (!string.IsNullOrEmpty(hostingEnvironment.WebRootPath))
{
hostingEnvironment.WebRootPath = Path.GetFullPath(hostingEnvironment.WebRootPath);
if (!Directory.Exists(hostingEnvironment.WebRootPath))
{
Directory.CreateDirectory(hostingEnvironment.WebRootPath);
}
hostingEnvironment.WebRootFileProvider = new PhysicalFileProvider(hostingEnvironment.WebRootPath);
}
else
{
hostingEnvironment.WebRootFileProvider = new NullFileProvider();
}
hostingEnvironment.EnvironmentName =
options.Environment ??
hostingEnvironment.EnvironmentName;
return(hostingEnvironment);
}
private static async Task RunAsync(string[] args, CancellationToken token)
{
args[2] = args[2].Replace("^>", ">").Replace("^<", "<");;
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddEnvironmentVariables();
var config = builder.Build();
var _options = new WebHostOptions(config);
var appEnvironment = PlatformServices.Default.Application;
var applicationName = _options.ApplicationName ?? appEnvironment.ApplicationName;
var environment = new HostingEnvironment();
environment.Initialize(applicationName, Directory.GetCurrentDirectory(), _options);
var url = "http://localhost:5000";
var basePath = environment.IsProduction() ?
environment.ContentRootPath
: Path.Combine(environment.ContentRootPath, "artifacts", "app");
using (var host = new WebHostBuilder()
.UseKestrel()
.UseConfiguration(config)
.UseUrls(url)
.UseWebRoot(basePath)
.UseContentRoot(Directory.GetCurrentDirectory())
.ConfigureLogging(l => l.AddConsole(config.GetSection("Logging")))
.ConfigureServices(ConfigureServices)
.Configure(app =>
{
// to do - wire in our HTTP endpoints
app.UseStaticFiles();
app.UseWebPages();
})
.Build())
{
host.Start();// (token); //.Run(token);
var result = await RequireJS.RunAsync <object, string>(host.Services.GetService <INodeServices>(), basePath.Replace("\\", "/"), "AppInsightsQueryReporter", url, new
{
appId = args[0],
appKey = args[1],
query = args[2]
});
Console.WriteLine(result.ToString());
// await Task.Delay(Timeout.Infinite, token);
}
}
internal ServiceRegistry CompileConfigurationAndServicesForIdiomaticBootstrapping()
{
_baseServices.Insert(0, ServiceDescriptor.Singleton <IHostedService, MessagingActivator>());
// Add services
var options = new WebHostOptions(EnvironmentConfiguration);
var contentRootPath = ResolveContentRootPath(options.ContentRootPath, AppContext.BaseDirectory);
// Initialize the hosting environment
// TODO -- Watch this, if there are bugs in bootstrapping!!!!!!
_hostingEnvironment.Initialize(contentRootPath, options);
_hostingEnvironment.ApplicationName = ApplicationAssembly.FullName;
var context = new WebHostBuilderContext
{
Configuration = EnvironmentConfiguration,
HostingEnvironment = _hostingEnvironment
};
Services.AddSingleton(_hostingEnvironment);
Services.AddSingleton(context);
var builder = Configuration
.SetBasePath(_hostingEnvironment.ContentRootPath)
.AddInMemoryCollection(EnvironmentConfiguration.AsEnumerable());
foreach (var configureAppConfiguration in _configureAppConfigurationBuilderDelegates)
{
configureAppConfiguration(context, builder);
}
var configuration = builder.Build();
Services.AddSingleton <IConfiguration>(configuration);
Services.AddSingleton <IConfigurationRoot>(configuration);
context.Configuration = configuration;
Settings.Bootstrap(new WebHostBuilderContext
{
HostingEnvironment = _hostingEnvironment,
Configuration = configuration
});
var listener = new DiagnosticListener("Microsoft.AspNetCore");
Services.AddSingleton(listener);
Services.AddSingleton <DiagnosticSource>(listener);
Services.AddTransient <IApplicationBuilderFactory, ApplicationBuilderFactory>();
Services.AddTransient <IHttpContextFactory, HttpContextFactory>();
Services.AddScoped <IMiddlewareFactory, MiddlewareFactory>();
Services.AddOptions();
Services.AddLogging();
Services.AddSingleton <Microsoft.AspNetCore.Hosting.IApplicationLifetime, ApplicationLifetime>();
// Conjure up a RequestServices
// TODO -- want this to be optional
Services.AddTransient <IStartupFilter, AutoRequestServicesStartupFilter>();
foreach (var configureServices in _configureServicesDelegates)
{
configureServices(context, Services);
}
var all = _baseServices.Concat(ExtensionServices).Concat(_applicationServices);
var combined = new ServiceRegistry();
combined.AddRange(all);
combined.For <IDurableMessagingFactory>().UseIfNone <NulloDurableMessagingFactory>();
combined.For <IServer>().UseIfNone <NulloServer>();
return(combined);
}
/// <summary>
///
/// </summary>
/// <param name="services"></param>
/// <param name="logDirectory">log file path
/// <para>e.g. .Logs or wwwroor/logs or C:/wwwroot/logs</para>
/// </param>
public static void AddFileLog(this IServiceCollection services, string logDirectory = ".Logs")
{
if (!services.Any(x => x.ImplementationType == typeof(LOG.LoggerFactory)))
{
LOG.LoggerFactory.ServiceCollection = services;
if (string.IsNullOrEmpty(logDirectory))
{
logDirectory = ".Logs";
}
services.AddHttpContextAccessor();
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
Console.OutputEncoding = System.Text.Encoding.UTF8;
var _config = services.FirstOrDefault(x => x.ServiceType == typeof(IConfiguration))?.ImplementationInstance as IConfiguration;
if (_config == null)
{
_config = new ConfigurationBuilder()
.AddEnvironmentVariables("ASPNETCORE_")
.SetBasePath(AppContext.BaseDirectory)
.Build();
_config[WebHostDefaults.ContentRootKey] = AppContext.BaseDirectory;
services.AddSingleton(_config);
}
if (string.IsNullOrEmpty(_config[WebHostDefaults.ContentRootKey]))
{
_config[WebHostDefaults.ContentRootKey] = AppContext.BaseDirectory;
}
IHostingEnvironment environment = (IHostingEnvironment)services.FirstOrDefault(x => x.ServiceType == typeof(IHostingEnvironment))
?.ImplementationInstance;
if (environment == null)
{
WebHostOptions options = new WebHostOptions(_config, Assembly.GetEntryAssembly().GetName().Name);
environment = new HostingEnvironment();
environment.Initialize(AppContext.BaseDirectory, options);
services.TryAddSingleton <IHostingEnvironment>(environment);
}
if (string.IsNullOrEmpty(environment.WebRootPath))
{
var _contentPath = _config[WebHostDefaults.ContentRootKey];
var binIndex = _contentPath.LastIndexOf("\\bin\\");
if (binIndex > -1)
{
var contentPath = _contentPath.Substring(0, binIndex);
if (contentPath.IndexOf(environment.ApplicationName) > -1)
{
_config[WebHostDefaults.ContentRootKey] = contentPath;
environment.ContentRootPath = contentPath;
environment.WebRootPath = System.IO.Path.Combine(contentPath, "wwwroot");
}
}
else
{
environment.WebRootPath = System.IO.Path.Combine(_config["ContentRoot"], "wwwroot");
}
}
if (Path.IsPathRooted(logDirectory))
{
LoggerSettings.LogDirectory = logDirectory;
}
else
{
LoggerSettings.LogDirectory = Path.Combine(_config["ContentRoot"], logDirectory);
}
if (!Directory.Exists(LoggerSettings.LogDirectory))
{
Directory.CreateDirectory(LoggerSettings.LogDirectory);
}
var path = Path.Combine(LoggerSettings.LogDirectory, LoggerSettings.LogJsonFileName);
if (!File.Exists(path))
{
File.AppendAllText(path, LoggerSettings.LoggingJsonContent);
}
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder
.SetBasePath(environment.ContentRootPath)
.AddJsonFile(path, true, true);
var configuration = configurationBuilder.Build();
services.RemoveAll <ILoggerProviderConfigurationFactory>();
services.RemoveAll(typeof(ILoggerProviderConfiguration <>));
var type = typeof(ILoggerProviderConfigurationFactory).Assembly.DefinedTypes
.SingleOrDefault(t => t.Name == "LoggingConfiguration");
services.RemoveAll(type);
services.AddLogging(x =>
{
x.AddConfiguration(configuration);
if (!x.Services.Any(t => t.ServiceType == typeof(ILoggerProvider)))
{
x.AddConsole();
}
x.Services.RemoveAll <IConfigureOptions <Logging.LoggerFilterOptions> >();
x.Services.AddSingleton <IConfigureOptions <Logging.LoggerFilterOptions> >(new LOG.LoggerFilterConfigureOptions(configuration));
});
services.Replace(ServiceDescriptor.Singleton <ILoggerFactory, LOG.LoggerFactory>());
}
}
private void ScanAssemblyAndRegisterStartup(HostBuilderContext context, IServiceCollection services, WebHostBuilderContext webhostContext, WebHostOptions webHostOptions)
{
try
{
var startupType = StartupLoader.FindStartupType(webHostOptions.StartupAssembly !, webhostContext.HostingEnvironment.EnvironmentName);
UseStartup(startupType, context, services);
}
catch (Exception ex) when(webHostOptions.CaptureStartupErrors)
{
var capture = ExceptionDispatchInfo.Capture(ex);
services.Configure <GenericWebHostServiceOptions>(options =>
{
options.ConfigureApplication = app =>
{
// Throw if there was any errors initializing startup
capture.Throw();
};
});
}
}
/// <summary>
///
/// </summary>
/// <param name="services"></param>
/// <param name="logAction">logAction</param>
/// <para>e.g. .Logs or wwwroor/logs or C:/wwwroot/logs</para>
public static IServiceCollection AddFileLog(this IServiceCollection services, Action <LogOptions> logAction = null)
{
bool flag = !services.Any((ServiceDescriptor x) => x.ImplementationType == typeof(LoggerFactory));
if (flag)
{
LogOptions logOptions = new LogOptions();
if (logAction != null)
{
logAction(logOptions);
}
services.Replace(ServiceDescriptor.Transient <IApplicationBuilderFactory, DefaultApplicationBuilderFactory>());
LoggerSettings.Format = logOptions.Format;
LoggerFactory.ServiceCollection = services;
bool flag2 = string.IsNullOrEmpty(logOptions.LogDirectory);
if (flag2)
{
logOptions.LogDirectory = ".Logs";
}
services.AddHttpContextAccessor();
services.AddSingleton <ILogAdapter, FileLogAdapter>();
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
Console.OutputEncoding = Encoding.UTF8;
ServiceDescriptor serviceDescriptor = services.FirstOrDefault((ServiceDescriptor x) => x.ServiceType == typeof(IConfiguration));
IConfiguration _config = ((serviceDescriptor != null) ? serviceDescriptor.ImplementationInstance : null) as IConfiguration;
bool flag3 = _config == null;
if (flag3)
{
_config = FileConfigurationExtensions.SetBasePath(EnvironmentVariablesExtensions.AddEnvironmentVariables(new ConfigurationBuilder(), "ASPNETCORE_"), AppContext.BaseDirectory).Build();
_config[WebHostDefaults.ContentRootKey] = AppContext.BaseDirectory;
services.AddSingleton(_config);
}
bool flag4 = string.IsNullOrEmpty(_config[WebHostDefaults.ContentRootKey]);
if (flag4)
{
_config[WebHostDefaults.ContentRootKey] = AppContext.BaseDirectory;
}
ServiceDescriptor serviceDescriptor2 = services.FirstOrDefault((ServiceDescriptor x) => x.ServiceType == typeof(IHostingEnvironment));
IHostingEnvironment environment = (IHostingEnvironment)((serviceDescriptor2 != null) ? serviceDescriptor2.ImplementationInstance : null);
bool flag5 = environment == null;
if (flag5)
{
WebHostOptions options = new WebHostOptions(_config, Assembly.GetEntryAssembly().GetName().Name);
environment = new HostingEnvironment();
HostingEnvironmentExtensions.Initialize(environment, AppContext.BaseDirectory, options);
services.TryAddSingleton(environment);
}
bool flag6 = string.IsNullOrEmpty(environment.WebRootPath);
if (flag6)
{
string _contentPath = _config[WebHostDefaults.ContentRootKey];
int binIndex = _contentPath.LastIndexOf("\\bin\\");
bool flag7 = binIndex > -1;
if (flag7)
{
string contentPath = _contentPath.Substring(0, binIndex);
bool flag8 = contentPath.IndexOf(environment.ApplicationName) > -1;
if (flag8)
{
_config[WebHostDefaults.ContentRootKey] = contentPath;
environment.ContentRootPath = contentPath;
environment.WebRootPath = Path.Combine(contentPath, "wwwroot");
}
else
{
environment.WebRootPath = _contentPath;
}
}
else
{
environment.WebRootPath = Path.Combine(_config["ContentRoot"], "wwwroot");
}
}
bool flag9 = Path.IsPathRooted(logOptions.LogDirectory);
if (flag9)
{
LoggerSettings.LogDirectory = logOptions.LogDirectory;
}
else
{
LoggerSettings.LogDirectory = Path.Combine(_config["ContentRoot"], logOptions.LogDirectory);
}
bool flag10 = !Directory.Exists(LoggerSettings.LogDirectory);
if (flag10)
{
Directory.CreateDirectory(LoggerSettings.LogDirectory);
}
string path = Path.Combine(LoggerSettings.LogDirectory, "_logging.json");
bool flag11 = !File.Exists(path);
if (flag11)
{
File.AppendAllText(path, "{\"Rules\":[{\"CategoryName\":\"Default\",\"LogLevel\":\"Information\",\"LogType\":\"All\",\"TraceCount\":5}]}");
}
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
JsonConfigurationExtensions.AddJsonFile(FileConfigurationExtensions.SetBasePath(configurationBuilder, environment.ContentRootPath), path, true, true);
IConfigurationRoot configuration = configurationBuilder.Build();
services.RemoveAll <ILoggerProviderConfigurationFactory>();
services.RemoveAll(typeof(ILoggerProviderConfiguration <>));
TypeInfo type = typeof(ILoggerProviderConfigurationFactory).Assembly.DefinedTypes.SingleOrDefault((TypeInfo t) => t.Name == "LoggingConfiguration");
services.RemoveAll(type);
LoggingServiceCollectionExtensions.AddLogging(services, delegate(ILoggingBuilder x)
{
x.AddConfiguration(configuration);
//bool flag13 = !x.Services.Any((ServiceDescriptor t) => t.ServiceType == typeof(ILoggerProvider));
//if (flag13)
//{
// ConsoleLoggerExtensions.AddConsole(x);
//}
x.Services.RemoveAll <IConfigureOptions <LoggerFilterOptions> >();
x.Services.AddSingleton(new LoggerFilterConfigureOptions(configuration));
});
services.Replace(ServiceDescriptor.Singleton <ILoggerFactory, LoggerFactory>());
services.Replace(ServiceDescriptor.Singleton <DiagnosticSource>(new DefaultDiagnosticListener()));
bool flag12 = services.IsHttpRequest();
if (flag12)
{
MarkdownFileMiddleware.SaveResourceFiles(environment.WebRootPath);
}
DefaultApplicationBuilderFactory.OnCreateBuilder(new Action <IApplicationBuilder, object>(LoggerExtensions.UseFileLog), logOptions);
}
return(services);
}
public WebHostBuilderWrap() : base()
{
_options2 = new WebHostOptions(_config, Assembly.GetEntryAssembly()?.GetName().Name);
}