public static WebHostBuilder UseProjectOf <TStartup>(this WebHostBuilder builder) { var startupAssembly = typeof(TStartup).GetTypeInfo().Assembly; var applicationName = startupAssembly.GetName().Name; var webRoot = GetProjectDirectoryOf(startupAssembly); builder.ConfigureServices(services => { var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize( webRoot, new WebHostOptions { ApplicationName = applicationName, Environment = "Production" }); services.AddSingleton <IHostingEnvironment>(hostingEnvironment); var manager = new ApplicationPartManager(); manager.ApplicationParts.Add(new AssemblyPart(startupAssembly)); services.AddSingleton(manager); }); return(builder); }
public Func <IServiceCollection, IServiceProvider> InitializeServices(Assembly startupAssembly, Func <IServiceCollection, IServiceProvider> buildServices) { var applicationName = startupAssembly.GetName().Name; var applicationRoot = GetApplicationRoot(applicationName); #if DNX451 AppDomain.CurrentDomain.SetData("APP_CONTEXT_BASE_DIRECTORY", applicationRoot); #endif var applicationEnvironment = PlatformServices.Default.Application; var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize(applicationRoot, null); var assemblyProvider = new StaticAssemblyProvider(); assemblyProvider.CandidateAssemblies.Add(startupAssembly); return(services => { services.AddInstance <IApplicationEnvironment>(new TestApplicationEnvironment(applicationEnvironment, applicationName, applicationRoot)); services.AddInstance <IHostingEnvironment>(hostingEnvironment); // Inject a custom assembly provider. Overrides AddMvc() because that uses TryAdd(). services.AddInstance <IAssemblyProvider>(assemblyProvider); return buildServices(services); }); }
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 static WebHostBuilder UseProjectOf <TStartup>(this WebHostBuilder builder) { var libraryManager = DnxPlatformServices.Default.LibraryManager; var applicationName = typeof(TStartup).GetTypeInfo().Assembly.GetName().Name; var library = libraryManager.GetLibrary(applicationName); var webRoot = Path.GetDirectoryName(library.Path); var assemblyProvider = new StaticAssemblyProvider(); assemblyProvider.CandidateAssemblies.Add(typeof(TStartup).Assembly); builder.ConfigureServices(services => { var applicationEnvironment = new TestApplicationEnvironment( PlatformServices.Default.Application, applicationName, webRoot); services.AddSingleton <IApplicationEnvironment>(applicationEnvironment); var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize( webRoot, new WebHostOptions { Environment = "Production", }, configuration: null); services.AddSingleton <IHostingEnvironment>(hostingEnvironment); services.AddSingleton <IAssemblyProvider>(assemblyProvider); }); return(builder); }
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 void OverridesEnvironmentFromConfig() { var env = new HostingEnvironment(); env.EnvironmentName = "SomeName"; env.Initialize("DummyApplication", Path.GetFullPath("."), new WebHostOptions(){ Environment = "NewName" }); Assert.Equal("NewName", env.EnvironmentName); }
public void DefaultsToNullFileProvider() { var env = new HostingEnvironment(); env.Initialize("DummyApplication", Path.GetFullPath(Path.Combine("testroot", "wwwroot")), new WebHostOptions()); Assert.Equal(Path.GetFullPath(Path.Combine("testroot", "wwwroot")), env.ContentRootPath); Assert.Null(env.WebRootPath); Assert.IsAssignableFrom<PhysicalFileProvider>(env.ContentRootFileProvider); Assert.IsAssignableFrom<NullFileProvider>(env.WebRootFileProvider); }
public void SetsFullPathToWwwroot() { var env = new HostingEnvironment(); env.Initialize("DummyApplication", Path.GetFullPath("."), new WebHostOptions(){ WebRoot = "testroot" }); Assert.Equal(Path.GetFullPath("."), env.ContentRootPath); Assert.Equal(Path.GetFullPath("testroot"), env.WebRootPath); Assert.IsAssignableFrom<PhysicalFileProvider>(env.ContentRootFileProvider); Assert.IsAssignableFrom<PhysicalFileProvider>(env.WebRootFileProvider); }
public void DefaultsToNullFileProvider() { IWebHostEnvironment env = new HostingEnvironment(); env.Initialize(Path.GetFullPath(Path.Combine("testroot", "wwwroot")), CreateWebHostOptions()); Assert.Equal(Path.GetFullPath(Path.Combine("testroot", "wwwroot")), env.ContentRootPath); Assert.Null(env.WebRootPath); Assert.IsAssignableFrom <PhysicalFileProvider>(env.ContentRootFileProvider); Assert.IsAssignableFrom <NullFileProvider>(env.WebRootFileProvider); }
public void DefaultsToWwwrootSubdir() { var env = new HostingEnvironment(); env.Initialize("DummyApplication", Path.GetFullPath("testroot"), new WebHostOptions()); Assert.Equal(Path.GetFullPath("testroot"), env.ContentRootPath); Assert.Equal(Path.GetFullPath(Path.Combine("testroot", "wwwroot")), env.WebRootPath); Assert.IsAssignableFrom <PhysicalFileProvider>(env.ContentRootFileProvider); Assert.IsAssignableFrom <PhysicalFileProvider>(env.WebRootFileProvider); }
private IHostingEnvironment CreateHostingEnvironment() { var hostingEnvironment = new HostingEnvironment(); var appEnvironment = PlatformServices.Default.Application; var applicationName = typeof(Startup).GetTypeInfo().Assembly.GetName().Name; hostingEnvironment.Initialize(applicationName, appEnvironment.ApplicationBasePath, new WebHostOptions()); return(hostingEnvironment); }
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 void OverridesEnvironmentFromConfig() { IWebHostEnvironment env = new HostingEnvironment(); env.EnvironmentName = "SomeName"; env.Initialize(Path.GetFullPath("."), new WebHostOptions() { Environment = "NewName" }); Assert.Equal("NewName", env.EnvironmentName); }
public void SetsFullPathToWwwroot() { IWebHostEnvironment env = new HostingEnvironment(); env.Initialize(Path.GetFullPath("."), new WebHostOptions() { WebRoot = "testroot" }); Assert.Equal(Path.GetFullPath("."), env.ContentRootPath); Assert.Equal(Path.GetFullPath("testroot"), env.WebRootPath); Assert.IsAssignableFrom <PhysicalFileProvider>(env.ContentRootFileProvider); Assert.IsAssignableFrom <PhysicalFileProvider>(env.WebRootFileProvider); }
public void OverridesEnvironmentFromConfig() { var env = new HostingEnvironment() { EnvironmentName = "SomeName" }; env.Initialize("DummyApplication", new HostOptions() { Environment = "NewName" }); Assert.Equal("NewName", env.EnvironmentName); }
static Bootstrap() { ServiceLogManager.SetProvider(() => new Log4NetServiceLog("Dagent")); ServiceLocatorManager.SetProvider(() => new UnityServiceLocator()) // new MicroServiceLocator()) .Register(r => { ConfigurationManagerEx.GetSection <HostingSection>("hosting").Configure(r); var appSection = ConfigurationManagerEx.GetSection <AppSection>("appSection").Configure(r); if (appSection.Log4Net) { XmlConfigurator.Configure(); } HostingEnvironment.Initialize(); }); var o = ServiceLocatorManager.Current; }
private static void AddTestServices( IServiceCollection services, string applicationWebSiteName, string applicationPath, Action <IServiceCollection> configureServices) { applicationPath = applicationPath ?? WebsitesDirectoryPath; // Get current IApplicationEnvironment; likely added by the host. var provider = services.BuildServiceProvider(); var originalEnvironment = provider.GetRequiredService <IApplicationEnvironment>(); // When an application executes in a regular context, the application base path points to the root // directory where the application is located, for example MvcSample.Web. However, when executing // an application as part of a test, the ApplicationBasePath of the IApplicationEnvironment points // to the root folder of the test project. // To compensate for this, we need to calculate the original path and override the application // environment value so that components like the view engine work properly in the context of the // test. var applicationBasePath = CalculateApplicationBasePath( originalEnvironment, applicationWebSiteName, applicationPath); var environment = new TestApplicationEnvironment( originalEnvironment, applicationWebSiteName, applicationBasePath); services.AddInstance <IApplicationEnvironment>(environment); var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize(applicationBasePath, config: null); services.AddInstance <IHostingEnvironment>(hostingEnvironment); // Injecting a custom assembly provider. Overrides AddMvc() because that uses TryAdd(). var assemblyProvider = CreateAssemblyProvider(applicationWebSiteName); services.AddInstance(assemblyProvider); // Avoid using pooled memory, we don't have a guarantee that our services will get disposed. services.AddInstance <IHttpResponseStreamWriterFactory>(new TestHttpResponseStreamWriterFactory()); if (configureServices != null) { configureServices(services); } }
public void OverridesEnvironmentFromConfig() { IWebHostEnvironment env = new HostingEnvironment(); env.EnvironmentName = "SomeName"; var webHostOptions = CreateWebHostOptions( new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary <string, string>() { [WebHostDefaults.EnvironmentKey] = "NewName" }).Build()); env.Initialize(Path.GetFullPath("."), webHostOptions); Assert.Equal("NewName", env.EnvironmentName); }
public void SetsFullPathToWwwroot() { IWebHostEnvironment env = new HostingEnvironment(); var webHostOptions = CreateWebHostOptions( new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary <string, string>() { [WebHostDefaults.WebRootKey] = "testroot" }).Build()); env.Initialize(Path.GetFullPath("."), webHostOptions); Assert.Equal(Path.GetFullPath("."), env.ContentRootPath); Assert.Equal(Path.GetFullPath("testroot"), env.WebRootPath); Assert.IsAssignableFrom <PhysicalFileProvider>(env.ContentRootFileProvider); Assert.IsAssignableFrom <PhysicalFileProvider>(env.WebRootFileProvider); }
IHostingEnvironment GetModuleHostingEnvironment() { var moduleAssemblyName = ModuleStartupType.GetTypeInfo().Assembly.GetName().Name; var moduleEnv = new HostingEnvironment(); var contentRootPath = Path.Combine(PlatformServices.Default.Application.ApplicationBasePath, "Modules", moduleAssemblyName); if (!Directory.Exists(contentRootPath)) { Directory.CreateDirectory(contentRootPath); } moduleEnv.Initialize( applicationName: moduleAssemblyName, contentRootPath: contentRootPath, options: new WebHostOptions() { Environment = _env.EnvironmentName }); return(moduleEnv); }
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); }
private Func <IServiceCollection, IServiceProvider> InitializeServices( Assembly startupAssembly, Func <IServiceCollection, IServiceProvider> buildServices) { var applicationServices = CallContextServiceLocator.Locator.ServiceProvider; var libraryManager = applicationServices.GetRequiredService <ILibraryManager>(); // When an application executes in a regular context, the application base path points to the root // directory where the application is located, for example .../samples/MvcSample.Web. However, when // executing an application as part of a test, the ApplicationBasePath of the IApplicationEnvironment // points to the root folder of the test project. // To compensate, we need to calculate the correct project path and override the application // environment value so that components like the view engine work properly in the context of the test. var applicationName = startupAssembly.GetName().Name; var library = libraryManager.GetLibrary(applicationName); var applicationRoot = Path.GetDirectoryName(library.Path); var applicationEnvironment = applicationServices.GetRequiredService <IApplicationEnvironment>(); return((services) => { services.AddInstance <IApplicationEnvironment>( new TestApplicationEnvironment(applicationEnvironment, applicationName, applicationRoot)); var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize(applicationRoot, null); services.AddInstance <IHostingEnvironment>(hostingEnvironment); // Inject a custom assembly provider. Overrides AddMvc() because that uses TryAdd(). var assemblyProvider = new StaticAssemblyProvider(); assemblyProvider.CandidateAssemblies.Add(startupAssembly); services.AddInstance <IAssemblyProvider>(assemblyProvider); AddAdditionalServices(services); return buildServices(services); }); }
public static void Main(string[] args) { PlatformServices ps = PlatformServices.Default; IApplicationEnvironment env = ps.Application; IConfigurationBuilder builder = new ConfigurationBuilder() .AddEnvironmentVariables() .SetBasePath(env.ApplicationBasePath); IHostingEnvironment hostingEnv = new HostingEnvironment(); hostingEnv.Initialize(env.ApplicationBasePath, builder.Build()); if (hostingEnv.IsDevelopment()) { Console.WriteLine("Loading from UserSecret store"); builder.AddUserSecrets(); } else { Console.WriteLine("Loading from jsons directory"); builder.AddJsonFile(@"..\..\..\..\..\..\MechHisui-jsons\secrets.json"); } IConfiguration config = builder.Build(); var client = new DiscordClient(conf => { conf.AppName = "MechHisui"; conf.AppVersion = "0.3.0"; conf.LogLevel = LogSeverity.Info; //conf.UseLargeThreshold = true; }); //client.Disconnected += (s, e) => Environment.Exit(0); Console.CancelKeyPress += async(s, e) => await RegisterCommands.Disconnect(client, config); //Display all log messages in the console client.Log.Message += (s, e) => Console.WriteLine($"{DateTime.Now} - [{e.Severity}] {e.Source}: {e.Message} {e.Exception}"); //Add a ModuleService and CommandService client.AddService(new ModuleService()); client.UsingCommands(conf => { conf.AllowMentionPrefix = true; conf.HelpMode = HelpMode.Public; conf.PrefixChar = '.'; }); //register commands client.RegisterAddChannelCommand(config); client.RegisterDeleteCommand(config); client.RegisterDisconnectCommand(config); if (!Debugger.IsAttached) { client.RegisterEvalCommand(config); } //client.RegisterImageCommand(config); client.RegisterInfoCommand(config); client.RegisterKnownChannelsCommand(config); client.RegisterLearnCommand(config); client.RegisterPickCommand(config); //client.RegisterRecordingCommand(config); client.RegisterResetCommand(config); client.RegisterRollCommand(config); client.RegisterThemeCommand(config); client.RegisterWhereCommand(config); client.RegisterXmasCommand(config); client.RegisterAPCommand(config); client.RegisterDailyCommand(config); client.RegisterEventCommand(config); client.RegisterFriendsCommand(config); client.RegisterLoginBonusCommand(config); client.RegisterStatsCommands(config); client.RegisterQuartzCommand(config); client.RegisterZoukenCommand(config); client.RegisterHisuiBetsCommands(config); client.RegisterSecretHitler(config); client.RegisterTriviaCommand(config); Responses.InitResponses(config); int lastcode = 0; if (args.Length > 0 && Int32.TryParse(args[0], out lastcode) && lastcode != 0) { Console.WriteLine($"Last exit code was {lastcode}"); } client.MessageUpdated += async(s, e) => { if (!(await e.Channel.DownloadMessages(10, e.Before.Id, Relative.After)).Any(m => m.IsAuthor)) { var msgReceived = typeof(DiscordClient).GetMethod("OnMessageReceived", BindingFlags.NonPublic | BindingFlags.Instance); msgReceived.Invoke(s, new object[] { e.After }); //client.OnMessageReceived(e.After); } }; try { //Convert our sync method to an async one and block the Main function until the bot disconnects client.ExecuteAndWait(async() => { //Connect to the Discord server using our email and password await client.Connect(config["Email"], config["Password"]); Console.WriteLine($"Logged in as {client.CurrentUser.Name}"); Console.WriteLine($"MH v. 0.3.0"); //Use a channel whitelist client.GetService <ModuleService>().Add( new ChannelWhitelistModule( Helpers.ConvertStringArrayToULongArray( //config["API_testing"] //config["LTT_general"], //config["LTT_testing"], config["FGO_playground"], config["FGO_Hgames"], config["FGO_events"], config["FGO_general"] ) ), nameof(ChannelWhitelistModule), ModuleFilter.ChannelWhitelist ); if (!client.Servers.Any()) { Console.WriteLine("Not a member of any server"); } else { foreach (var prChannel in client.PrivateChannels) { if (prChannel.Id == UInt64.Parse(config["PrivChat"])) { client.MessageReceived += (new Responder(prChannel, client).Respond); } } foreach (var channel in Helpers.IterateChannels(client.Servers, printServerNames: true, printChannelNames: true)) { if (!channel.IsPrivate && Helpers.IsWhilested(channel, client)) { //Console.CancelKeyPress += async (s, e) => await client.SendMessage(channel, config["Goodbye"]); client.MessageReceived += (new Responder(channel, client).Respond); if (channel.Id != UInt64.Parse(config["API_testing"])) { if (Debugger.IsAttached) { // await channel.SendMessage("MechHisui started in debug mode. Not all commands will be available."); } else if (lastcode != -1 && channel.Id != UInt64.Parse(config["FGO_events"])) { await channel.SendMessage(config["Hello"]); } } } } if (!Debugger.IsAttached) { client.AddNewHisuiBetsUsers(config); } Console.WriteLine($"Started up at {DateTime.Now}."); } }); } catch (Exception ex) { File.AppendAllText(Path.Combine(config["Logs"], "crashlogs.txt"), $"{DateTime.Now} - {ex.Message}\n{ex.StackTrace}\n"); Environment.Exit(-1); } }
public static void Main(string[] args) { PlatformServices ps = PlatformServices.Default; IApplicationEnvironment env = ps.Application; //Console.WriteLine($"Base: {env.ApplicationBasePath}"); IConfigurationBuilder builder = new ConfigurationBuilder() .AddEnvironmentVariables() .SetBasePath(env.ApplicationBasePath); IHostingEnvironment hostingEnv = new HostingEnvironment(); hostingEnv.Initialize(env.ApplicationBasePath, builder.Build()); if (hostingEnv.IsDevelopment()) { Console.WriteLine("Loading from UserSecret store"); builder.AddUserSecrets(); } else { Console.WriteLine("Loading from jsons directory"); builder.AddJsonFile(@"..\..\..\..\GudakoBot-jsons\secrets.json"); } IConfiguration config = builder.Build(); ulong owner = UInt64.Parse(config["Owner"]); ulong fgogen = UInt64.Parse(config["FGO_general"]); Console.WriteLine("Loading chat lines..."); LoadLines(config); Console.WriteLine($"Loaded {Randomlines.Count()} lines."); var client = new DiscordClient(conf => { conf.AppName = "GudakoBot"; conf.CacheToken = true; conf.LogLevel = /*Debugger.IsAttached ? LogSeverity.Verbose :*/ LogSeverity.Warning; //conf.UseLargeThreshold = true; }); //Display all log messages in the console client.Log.Message += (s, e) => Console.WriteLine($"[{e.Severity}] {e.Source}: {e.Message}"); client.MessageReceived += (s, e) => { if (e.Message.User.Id == owner && e.Message.Text == "-new") { Console.WriteLine($"{DateTime.Now}: Reloading lines"); LoadLines(config); e.Channel.SendMessage(Randomlines.Last()); timer.Change(TimeSpan.FromMinutes(30), TimeSpan.FromMinutes(30)); } }; client.ExecuteAndWait(async() => { //Connect to the Discord server using our email and password await client.Connect(config["Email"], config["Password"]); //client.Token = (await client.Send(new LoginRequest { Email = config["Email"], Password = config["Password"] })).Token; Console.WriteLine($"Logged in as {client.CurrentUser.Name}"); Console.WriteLine($"Started up at {DateTime.Now}."); var rng = new Random(); timer = new Timer(async s => { var channel = client.GetChannel(fgogen); if (channel == null) { Console.WriteLine($"Channel was null. Waiting for next interval."); } else { Console.WriteLine($"{DateTime.Now}: Sending message."); Randomlines = Randomlines.Shuffle(); await channel.SendMessage(Randomlines.ElementAt(rng.Next(maxValue: Randomlines.Count()))); } }, null, TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(30)); }); }
/// <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 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); } }