public IHostingEngine Build() { var configBuider = new ConfigurationBuilder(); configBuider.AddInMemoryCollection(new Dictionary<string, string> {{"server.urls", uri}}); var builder = new WebHostBuilder(configBuider.Build()); builder.UseStartup(app => { new Startup().ConfigureApplication(app); }, services => { new ServiceConfigurer(documentStore).ConfigureServices(services); }); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); return builder.Build(); }
protected override void OnStart(string[] args) { try { var configProvider = new MemoryConfigurationProvider(); configProvider.Add("server.urls", "http://localhost:5000"); var config = new ConfigurationBuilder() .Add(configProvider) .Build(); var builder = new WebHostBuilder(config); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); builder.UseServices(services => services.AddMvc()); builder.UseStartup(appBuilder => { appBuilder.UseDefaultFiles(); appBuilder.UseStaticFiles(); appBuilder.UseMvc(); }); var hostingEngine = builder.Build(); _application = hostingEngine.Start(); } catch (Exception ex) { Debug.WriteLine("error in OnStart: " + ex); throw; } }
protected override void OnStart(string[] args) { Log("WWWService started."); try { var builder = new WebHostBuilder(Configuration); builder.UseServer("Microsoft.AspNet.Server.WebListener"); builder.UseStartup<Program>(); var appBuilder = builder.Build(); appBuilder.Start(); } catch(Exception x) { Log("WWWService Exception: "+x.Message); if (x.InnerException != null) Log("WWWService Exception: "+x.InnerException.Message); if (x is System.Reflection.ReflectionTypeLoadException) { var typeLoadException = x as ReflectionTypeLoadException; var loaderExceptions = typeLoadException.LoaderExceptions; foreach (var l in loaderExceptions) { Log("WWWService TypeLoadException: "+l.Message); } } } }
protected override void OnStart(string[] args) { var config = new ConfigurationBuilder() .SetBasePath(_applicationEnvironment.ApplicationBasePath) .AddJsonFile($@"{_applicationEnvironment.ApplicationBasePath}\config.json") .AddEnvironmentVariables() .Build(); var builder = new WebHostBuilder(config); builder.UseServer("Microsoft.AspNet.Server.WebListener"); builder.UseServices(services => services.AddMvc()); builder.UseStartup(appBuilder => { appBuilder.UseDefaultFiles(); appBuilder.UseStaticFiles(); appBuilder.UseMvc(routes => { routes.MapRoute( null, "{controller}/{action}", new { controller = "Home", action = "Index" }); }); }); _hostingEngine = builder.Build(); _shutdownServerDisposable = _hostingEngine.Start(); }
protected override void OnStart(string[] args) { try { var temp = new ConfigurationBuilder() .AddJsonFile("config.json") .AddJsonFile("hosting.json", true) .Build(); var configProvider = new MemoryConfigurationProvider(); configProvider.Add("server.urls", temp["WebServerAddress"]); configProvider.Add("webroot", temp.Get<string>("webroot", "wwwroot")); var config = new ConfigurationBuilder() .Add(configProvider) .Build(); var builder = new WebHostBuilder(config); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); builder.UseStartup<Startup>(); var hostingEngine = builder.Build(); _application = hostingEngine.Start(); } catch (Exception ex) { Debug.WriteLine("error in OnStart: " + ex); throw; } }
public async Task RegisterAddresses_Success(string addressInput, string[] testUrls) { var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary<string, string> { { "server.urls", addressInput } }) .Build(); var hostBuilder = new WebHostBuilder(config); hostBuilder.UseServer("Microsoft.AspNet.Server.Kestrel"); hostBuilder.UseStartup(ConfigureEchoAddress); using (var app = hostBuilder.Build().Start()) { using (var client = new HttpClient()) { foreach (var testUrl in testUrls) { var responseText = await client.GetStringAsync(testUrl); Assert.Equal(testUrl, responseText); } } } }
public async Task LargeDownload() { var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary<string, string> { { "server.urls", "http://localhost:8792/" } }) .Build(); var hostBuilder = new WebHostBuilder(config); hostBuilder.UseServer("Microsoft.AspNet.Server.Kestrel"); hostBuilder.UseStartup(app => { app.Run(async context => { var bytes = new byte[1024]; for (int i = 0; i < bytes.Length; i++) { bytes[i] = (byte)i; } context.Response.ContentLength = bytes.Length * 1024; for (int i = 0; i < 1024; i++) { await context.Response.Body.WriteAsync(bytes, 0, bytes.Length); } }); }); using (var app = hostBuilder.Build().Start()) { using (var client = new HttpClient()) { var response = await client.GetAsync("http://localhost:8792/"); response.EnsureSuccessStatusCode(); var responseBody = await response.Content.ReadAsStreamAsync(); // Read the full response body var total = 0; var bytes = new byte[1024]; var count = await responseBody.ReadAsync(bytes, 0, bytes.Length); while (count > 0) { for (int i = 0; i < count; i++) { Assert.Equal(total % 256, bytes[i]); total++; } count = await responseBody.ReadAsync(bytes, 0, bytes.Length); } } } }
protected virtual DbContext TryCreateContextFromStartup(Type type, string startupAssemblyName) { var hostBuilder = new WebHostBuilder(_services); if (startupAssemblyName != null) { hostBuilder.UseStartup(startupAssemblyName); } var appServices = hostBuilder.Build().ApplicationServices; return (DbContext)appServices.GetService(type); }
public async Task DoWork(CancellationToken ctx) { var configuration = new ConfigurationBuilder() .AddGlobalConfigSources() .Build(); var builder = new WebHostBuilder(configuration.GetSection("Hosting")); var engine = builder.Build(); using (engine.Start()) { await Task.Delay(Timeout.Infinite, ctx); } }
public static IServiceProvider CreateServiceProvider(Action<IServiceCollection> configure) { var host = new WebHostBuilder() .UseServer(new ServerFactory()) .UseStartup( _ => { }, services => { services.AddSignalR(); configure(services); return services.BuildServiceProvider(); }); return host.Build().ApplicationServices; }
public async Task LargeUpload() { var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary<string, string> { { "server.urls", "http://localhost:8791/" } }) .Build(); var hostBuilder = new WebHostBuilder(config); hostBuilder.UseServer("Microsoft.AspNet.Server.Kestrel"); hostBuilder.UseStartup(app => { app.Run(async context => { // Read the full request body var total = 0; var bytes = new byte[1024]; var count = await context.Request.Body.ReadAsync(bytes, 0, bytes.Length); while (count > 0) { for (int i = 0; i < count; i++) { Assert.Equal(total % 256, bytes[i]); total++; } count = await context.Request.Body.ReadAsync(bytes, 0, bytes.Length); } await context.Response.WriteAsync(total.ToString(CultureInfo.InvariantCulture)); }); }); using (var app = hostBuilder.Build().Start()) { using (var client = new HttpClient()) { var bytes = new byte[1024 * 1024]; for (int i = 0; i < bytes.Length; i++) { bytes[i] = (byte)i; } var response = await client.PostAsync("http://localhost:8791/", new ByteArrayContent(bytes)); response.EnsureSuccessStatusCode(); var sizeString = await response.Content.ReadAsStringAsync(); Assert.Equal(sizeString, bytes.Length.ToString(CultureInfo.InvariantCulture)); } } }
protected override void OnStart(string[] args) { var builder = new WebHostBuilder(ConfigHandler.Configuration); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); builder.UseServices(services => services.AddMvc()); builder.UseStartup(appBuilder => { appBuilder.UseDefaultFiles(); appBuilder.UseStaticFiles(); appBuilder.UseMvc(); }); _application = builder.Build().Start(); }
/// <summary> /// Default constructor that AWS Lambda will invoke. /// </summary> public APIGatewayProxyFunction() { var builder = new WebHostBuilder(); Init(builder); // Add the API Gateway services in case the override Init method didn't add it. UseApiGateway will // not add anything if API Gateway has already been added. builder.UseApiGateway(); _host = builder.Build(); _host.Start(); _server = _host.Services.GetService(typeof(Microsoft.AspNetCore.Hosting.Server.IServer)) as APIGatewayServer; }
public static void Main(string[] args) { var hostBuilder = new WebHostBuilder() .UseKestrel() .UseUrls("http://0.0.0.0:5001/") .UseContentRoot(Directory.GetCurrentDirectory()) .UseStartup <Startup>(); Console.WriteLine("urls: {0}", hostBuilder.GetSetting("urls")); var host = hostBuilder.Build(); host.Run(); }
public void have_enabled_database_migrations_by_default() { var webhost = new WebHostBuilder() .UseStartup <DefaultStartup>() .ConfigureServices(services => { services.AddHealthChecksUI() .AddInMemoryStorage(); }); var serviceProvider = webhost.Build().Services; var UISettings = serviceProvider.GetService <IOptions <Settings> >().Value; UISettings.DisableMigrations.Should().Be(false); }
public void SetUp() { // Use Kestrel to Host the Controller: var builder = new WebHostBuilder() .UseKestrel() .UseStartup <Startup>() .UseUrls("http://localhost:8081") .UseContentRoot(Directory.GetCurrentDirectory()); // Build the Host: this.host = builder.Build(); // And... Ignite! host.Start(); }
public static void Main(string[] args) { IWebHostBuilder builder = new WebHostBuilder(); builder.ConfigureServices(s => { }); builder.UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseStartup <Startup>(); var host = builder.Build(); host.Run(); }
public async Task DoesNotThrowObjectDisposedExceptionFromWriteAsyncAfterConnectionIsAborted() { var tcs = new TaskCompletionSource <object>(); var loggerProvider = new HandshakeErrorLoggerProvider(); var hostBuilder = new WebHostBuilder() .UseKestrel(options => { options.Listen(new IPEndPoint(IPAddress.Loopback, 0), listenOptions => { listenOptions.UseHttps(TestResources.TestCertificatePath, "testPassword"); }); }) .ConfigureLogging(builder => builder.AddProvider(loggerProvider)) .Configure(app => app.Run(async httpContext => { httpContext.Abort(); try { await httpContext.Response.WriteAsync($"hello, world"); tcs.SetResult(null); } catch (Exception ex) { tcs.SetException(ex); } })); using (var host = hostBuilder.Build()) { host.Start(); using (var socket = await HttpClientSlim.GetSocket(new Uri($"https://127.0.0.1:{host.GetPort()}/"))) using (var stream = new NetworkStream(socket, ownsSocket: false)) using (var sslStream = new SslStream(stream, true, (sender, certificate, chain, errors) => true)) { await sslStream.AuthenticateAsClientAsync("127.0.0.1", clientCertificates : null, enabledSslProtocols : SslProtocols.Tls11 | SslProtocols.Tls12, checkCertificateRevocation : false); var request = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\nHost:\r\n\r\n"); await sslStream.WriteAsync(request, 0, request.Length); await sslStream.ReadAsync(new byte[32], 0, 32); } } await tcs.Task.TimeoutAfter(TimeSpan.FromSeconds(10)); }
public static void Main(string[] args) { Args = args; Console.WriteLine(); Console.WriteLine("ASP.NET Core Benchmarks"); Console.WriteLine("-----------------------"); Console.WriteLine($"Current directory: {Directory.GetCurrentDirectory()}"); Console.WriteLine($"WebHostBuilder loading from: {typeof(WebHostBuilder).GetTypeInfo().Assembly.Location}"); var config = new ConfigurationBuilder() .AddJsonFile("hosting.json", optional: true) .AddEnvironmentVariables(prefix: "ASPNETCORE_") .AddCommandLine(args) .Build(); var webHostBuilder = new WebHostBuilder() .UseContentRoot(Directory.GetCurrentDirectory()) .UseConfiguration(config) .UseStartup <Startup>() .ConfigureServices(services => services .AddSingleton(new ConsoleArgs(args)) .AddSingleton <IScenariosConfiguration, ConsoleHostScenariosConfiguration>() .AddSingleton <Scenarios>() ) .UseDefaultServiceProvider( (context, options) => options.ValidateScopes = context.HostingEnvironment.IsDevelopment()) .UseKestrel(); var threadCount = GetThreadCount(config); webHostBuilder.UseSockets(x => { if (threadCount > 0) { x.IOQueueCount = threadCount; } Console.WriteLine($"Using Sockets with {x.IOQueueCount} threads"); }); var webHost = webHostBuilder.Build(); Console.WriteLine($"Server GC is currently {(GCSettings.IsServerGC ? "ENABLED" : "DISABLED")}"); webHost.Run(); }
public static void Main(string[] args) { var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddJsonFile("ocelot.json", true, false) .AddEnvironmentVariables() .AddCommandLine(args); if (args != null) { configurationBuilder.AddCommandLine(args); } var hostingconfig = configurationBuilder.Build(); var url = hostingconfig[addressKey] ?? defaultAddress; IWebHostBuilder builder = new WebHostBuilder(); builder.ConfigureServices(s => { s.AddSingleton(builder); }); builder.UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseConfiguration(hostingconfig) //.ConfigureAppConfiguration((hostingContext, config) => //{ // config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath); // var env = hostingContext.HostingEnvironment; // //config.AddOcelot(); // config.AddEnvironmentVariables(); //}) .ConfigureLogging((hostingContext, logging) => { logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging")); logging.AddConsole(); logging.AddDebug(); }) .UseIISIntegration() .UseMetricsWebTracking() .UseMetricsEndpoints() .UseNLog() .UseUrls(url) .UseStartup <Startup>(); var host = builder.Build(); host.Run(); }
public void initialize_configuration_using_AddHealthChecksUI_setup_fluent_api() { var healthCheckName = "api1"; var healthCheckUri = "http://api1/health"; var webhookName = "webhook1"; var webhookUri = "http://webhook1/sample"; var webhookPayload = "payload1"; var webhookRestorePayload = "restoredpayload1"; var evaluationTimeInSeconds = 180; var minimumSeconds = 30; var webhost = new WebHostBuilder() .UseStartup <DefaultStartup>() .ConfigureServices(services => { services.AddHealthChecksUI(setupSettings: settings => { settings .DisableDatabaseMigrations() .AddHealthCheckEndpoint(name: healthCheckName, uri: healthCheckUri) .AddWebhookNotification(name: webhookName, uri: webhookUri, payload: webhookPayload, restorePayload: webhookRestorePayload) .SetEvaluationTimeInSeconds(evaluationTimeInSeconds) .SetMinimumSecondsBetweenFailureNotifications(minimumSeconds); }).AddInMemoryStorage(); }); var serviceProvider = webhost.Build().Services; var UISettings = serviceProvider.GetService <IOptions <Settings> >().Value; UISettings.EvaluationTimeInSeconds.Should().Be(evaluationTimeInSeconds); UISettings.MinimumSecondsBetweenFailureNotifications.Should().Be(minimumSeconds); UISettings.Webhooks.Count.Should().Be(1); UISettings.HealthChecks.Count.Should().Be(1); var healthcheck = UISettings.HealthChecks[0]; healthcheck.Name.Should().Be(healthCheckName); healthcheck.Uri.Should().Be(healthCheckUri); var webhook = UISettings.Webhooks[0]; webhook.Name.Should().Be(webhookName); webhook.Uri.Should().Be(webhookUri); webhook.Payload.Should().Be(webhookPayload); webhook.RestoredPayload.Should().Be(webhookRestorePayload); }
public void support_combined_configuration_from_fluent_api_and_settings_key() { var healthCheckName = "api2"; var healthCheckUri = "http://api2/healthz"; var webhookName = "webhook2"; var webhookUri = "http://webhook2"; var webhookPayload = "payload1"; var webhost = new WebHostBuilder() .ConfigureAppConfiguration(conf => { conf.Sources.Clear(); var path = Path.Combine("Functional", "Configuration", "appsettings.json"); conf.AddJsonFile(path, false); }).ConfigureServices(services => { services.AddHealthChecksUI(setupSettings: setup => { setup .AddHealthCheckEndpoint(name: healthCheckName, uri: healthCheckUri) .AddWebhookNotification(name: webhookName, uri: webhookUri, payload: webhookPayload) .SetMinimumSecondsBetweenFailureNotifications(200); }); }); var serviceProvider = webhost.Build().Services; var UISettings = serviceProvider.GetService <IOptions <Settings> >().Value; UISettings.MinimumSecondsBetweenFailureNotifications.Should().Be(200); UISettings.EvaluationTimeInSeconds.Should().Be(20); UISettings.Webhooks.Count.Should().Be(2); UISettings.HealthChecks.Count.Should().Be((2)); var healthCheck1 = UISettings.HealthChecks[0]; var healthCheck2 = UISettings.HealthChecks[1]; var webHook1 = UISettings.Webhooks[0]; var webHook2 = UISettings.Webhooks[1]; healthCheck1.Name.Should().Be("api1"); healthCheck1.Uri.Should().Be("http://api1/healthz"); healthCheck2.Name.Should().Be("api2"); healthCheck2.Uri.Should().Be("http://api2/healthz"); webHook1.Name.Should().Be("webhook1"); webHook1.Uri.Should().Be("http://webhook1"); webHook2.Name.Should().Be(webhookName); webHook2.Uri.Should().Be(webhookUri); }
public static IWebHost CreateWebHost() { var webHostBuilder = new WebHostBuilder() .UseLoggerFactory(_loggerFactory) .UseConfiguration(Configuration) .UseKestrel(options => { //options.UseConnectionLogging(); }) .UseContentRoot(Directory.GetCurrentDirectory()) .UseStartup <Startup>(); var webHost = webHostBuilder.Build(); var serverAddresses = webHost.ServerFeatures.Get <IServerAddressesFeature>(); string pipeName = _startupOptions.WriteServerUrlsToPipe; if (pipeName != null) { NamedPipeClientStream pipe; try { pipe = new NamedPipeClientStream(".", pipeName, PipeDirection.Out); pipe.Connect(10000); } catch (IOException ex) { _logger.LogCritical(0, ex, $"Requested to write server.urls to pipe '{pipeName}', but it is not a valid pipe handle."); throw; } catch (TimeoutException ex) { _logger.LogCritical(0, ex, $"Requested to write server.urls to pipe '{pipeName}', but timed out while trying to connect to pipe."); throw; } var applicationLifetime = webHost.Services.GetService <IApplicationLifetime>(); applicationLifetime.ApplicationStarted.Register(() => Task.Run(() => { using (pipe) { string serverUriStr = JsonConvert.SerializeObject(serverAddresses.Addresses); _logger.LogTrace($"Writing server.urls to pipe '{pipeName}':{Environment.NewLine}{serverUriStr}"); var serverUriData = Encoding.UTF8.GetBytes(serverUriStr); pipe.Write(serverUriData, 0, serverUriData.Length); pipe.Flush(); } _logger.LogTrace($"Wrote server.urls to pipe '{pipeName}'."); })); } return(webHost); }
public void ItDoesWork() { var host = new WebHostBuilder() .UseServer(new EmptyServer()) .UseStartup <Startup>(); var services = host.Build().Services; Assert.IsType <SqlStore <User> >(services.GetRequiredService <IStore <User> >()); Assert.IsType <SqlStore <Invoice> >(services.GetRequiredService <IStore <Invoice> >()); Assert.IsType <SqlStore <Payment> >(services.GetRequiredService <IStore <Payment> >()); Assert.Throws <ArgumentException>(() => { services.GetRequiredService <IStore <int> >(); }); }
public static void Main(string[] args) { var config = new ConfigurationBuilder() .AddCommandLine(new[] { "--server.urls", "http://localhost:8111" }); var builder = new WebHostBuilder() .UseConfiguration(config.Build()) .UseStartup(typeof(Startup)) .UseServer("Microsoft.AspNetCore.Server.Kestrel"); using (var app = builder.Build()) { app.Start(); AppLifeTime = (IApplicationLifetime)app.Services.GetService(typeof(IApplicationLifetime)); AppLifeTime.ApplicationStopping.WaitHandle.WaitOne(); } }
public void UseCloudHosting_UsesServerPort() { Environment.SetEnvironmentVariable("SERVER_PORT", "42"); var hostBuilder = new WebHostBuilder() .UseStartup <TestServerStartup>() .UseKestrel(); hostBuilder.UseCloudHosting(); var server = hostBuilder.Build(); var addresses = server.ServerFeatures.Get <IServerAddressesFeature>(); Assert.Contains("http://*:42", addresses.Addresses); Environment.SetEnvironmentVariable("SERVER_PORT", null); }
public void UseCloudHosting_SeesTyePortsAndUsesAspNetCoreURL() { Environment.SetEnvironmentVariable("ASPNETCORE_URLS", "http://*:80;https://*:443"); Environment.SetEnvironmentVariable("PORT", "88;4443"); var hostBuilder = new WebHostBuilder() .UseStartup <TestServerStartup>() .UseKestrel(); hostBuilder.UseCloudHosting(); var server = hostBuilder.Build(); var addresses = server.ServerFeatures.Get <IServerAddressesFeature>(); Assert.Contains("http://*:80", addresses.Addresses); Assert.Contains("https://*:443", addresses.Addresses); }
public async Task TestHelloWorld() { var builder = new WebHostBuilder().Configure(app => app.UseMvc()) .ConfigureServices(svc => svc.AddMvc().AddApplicationPart(Assembly.GetAssembly(typeof(EndToEndApiController)))) .UseServer(new CustomListenerHost(new TestListener("test-get"))); var host = builder.Build(); await host.StartAsync(); var client = new HttpClient(new DialMessageHandler(new TestDialer("test-get"))); var result = await client.GetStringAsync("http://localhost/api/e2e-tests/hello-world"); Assert.Equal("Hello World", result); await host.StopAsync(); }
private static void RunHost() { var hostBuilder = new WebHostBuilder() .UseKestrel() .UseIISIntegration() .UseEnvironment(AppInfo.Configuration) .UseContentRoot(Directory.GetCurrentDirectory()) .UseWebRoot(Path.Combine(Directory.GetCurrentDirectory(), AppInfo.FileServer?.PublicRootPath ?? "wwwroot")) .UseUrls(AppInfo.HostUrl) .UseStartup <Startup>(); var host = hostBuilder.Build(); host.Run(); }
public static void Main(string[] args) { var host = new WebHostBuilder() .UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseIISIntegration() .UseStartup <Startup>() .UseApplicationInsights(); host.CaptureStartupErrors(true); host.UseSetting("detailedErrors", "true"); host.Build().Run(); }
public void WebHostAddCloudFoundryConfiguration_Adds() { // arrange var hostbuilder = new WebHostBuilder(); hostbuilder.Configure(builder => { }); // act hostbuilder.AddCloudFoundryConfiguration(); var host = hostbuilder.Build(); // assert var cfg = host.Services.GetService(typeof(IConfiguration)) as IConfigurationRoot; Assert.Contains(cfg.Providers, ctype => ctype is CloudFoundryConfigurationProvider); }
public void AspNetCoreShouldBeOperational() { var builder = new WebHostBuilder() .UseKestrel() .UseStartup <Startup>(); var host = builder.Build(); host.Start(); var address = host.ServerFeatures.Get <IServerAddressesFeature>(); var addr = address.Addresses.First().ToString(); var transport = new HttpClientTransport(addr + "/rpc"); var resp = transport.SendMessageAsync(new byte[] { 1, 2 }).Result; Assert.True(resp.SequenceEqual(new byte[] { 2, 1 })); host.Services.GetService <IApplicationLifetime>().StopApplication(); }
public void LibuvTransportCanBeManuallySelectedIndependentOfOrder() { var hostBuilder = new WebHostBuilder() .UseKestrel() .UseLibuv() .Configure(app => { }); Assert.IsType <LibuvTransportFactory>(hostBuilder.Build().Services.GetService <IConnectionListenerFactory>()); var hostBuilderReversed = new WebHostBuilder() .UseLibuv() .UseKestrel() .Configure(app => { }); Assert.IsType <LibuvTransportFactory>(hostBuilderReversed.Build().Services.GetService <IConnectionListenerFactory>()); }
public void allow_disable_running_database_migrations_in_ui_setup() { var webhost = new WebHostBuilder() .UseStartup <DefaultStartup>() .ConfigureServices(services => { services .AddHealthChecksUI(setup => setup.DisableDatabaseMigrations()) .AddInMemoryStorage(); }); var serviceProvider = webhost.Build().Services; var UISettings = serviceProvider.GetService <IOptions <Settings> >().Value; UISettings.DisableMigrations.Should().Be(true); }
public static void Main(string[] args) { var builder = new WebHostBuilder() .UseStartup <Startup>() .UseUrls("http://*:8080;https://*:8081") .UseKestrel(options => { options.UseHttps("testCert.pfx", "testPassword"); }); var host = builder.Build(); Console.WriteLine("Listening on https://*:8080 and https://*:8081 ..."); host.Run(); }
public static void Main(string[] args) { IWebHostBuilder builder = new WebHostBuilder(); builder.ConfigureServices(s => { s.AddSingleton(builder); }); builder.UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseUrls("http://*:8000") .UseStartup <Startup>(); var host = builder.Build(); host.Run(); }
public void fail_to_register_sql_server_with_no_connection_string() { var hostBuilder = new WebHostBuilder() .ConfigureAppConfiguration(config => { config.Sources.Clear(); config.AddInMemoryCollection(new List <KeyValuePair <string, string> > { new KeyValuePair <string, string>("storage_provider", StorageProviderEnum.SqlServer.ToString()) }); }) .UseStartup <Startup>(); Assert.Throws <ArgumentNullException>(() => hostBuilder.Build()); }
public static void Main(string[] args) { Console.WriteLine("Running demo with Kestrel."); //This is our webhostBuiler var builder = new WebHostBuilder() //.UseContentRoot(Directory.GetCurrentDirectory()) .UseStartup <Startup>() .UseKestrel() .UseUrls("http://localhost:5000"); //Build the webhost var host = builder.Build(); //run host.Run(); }
public void register_server_addresses_service_to_resolve_relative_uris_using_application_builder() { var webHostBuilder = new WebHostBuilder() .UseKestrel() .ConfigureServices(services => { services. AddHealthChecksUI(); }).Configure(app => app.UseHealthChecksUI()); var serviceProvider = webHostBuilder.Build().Services; var serverAddressesService = serviceProvider.GetRequiredService <ServerAddressesService>(); serverAddressesService.Should().NotBeNull(); serverAddressesService.Addresses.Should().NotBeNull(); }
public LocService ObtenerLocService() { var builder = new WebHostBuilder() .UseStartup <Startup>() .ConfigureAppConfiguration((context, config) => { config.SetBasePath(Path.Combine( Directory.GetCurrentDirectory(), "..", "..", "..", "..", "CaducaRest")); config.AddJsonFile("appsettings.json"); }); var scope = builder.Build().Services.CreateScope(); return(scope.ServiceProvider .GetRequiredService <LocService>()); }
public void SocketsTransportCanBeManuallySelectedIndependentOfOrder() { var hostBuilder = new WebHostBuilder() .UseKestrel() .UseSockets() .Configure(app => { }); Assert.IsType <SocketTransportFactory>(hostBuilder.Build().Services.GetService <ITransportFactory>()); var hostBuilderReversed = new WebHostBuilder() .UseSockets() .UseKestrel() .Configure(app => { }); Assert.IsType <SocketTransportFactory>(hostBuilderReversed.Build().Services.GetService <ITransportFactory>()); }
public void fail_with_invalid_storage_provider_value() { var hostBuilder = new WebHostBuilder() .ConfigureAppConfiguration(config => { config.Sources.Clear(); config.AddInMemoryCollection(new List <KeyValuePair <string, string> > { new KeyValuePair <string, string>("storage_provider", "invalidvalue") }); }) .UseStartup <Startup>(); Assert.Throws <ArgumentException>(() => hostBuilder.Build()); }
public static void Main(string[] args) { var config = new ConfigurationBuilder() .AddInMemoryCollection(new [] { new KeyValuePair<string, string>("Server.Urls", "http://localhost:2100") }) .Build(); var host = new WebHostBuilder(config, true) .UseStartup<Startup>() .UseServices(ConfigureServices) .UseServer("Microsoft.AspNet.Server.Kestrel"); var hostingEngine = host.Build(); _website = hostingEngine.Start(); Console.WriteLine("hai"); Console.ReadKey(); }
protected override void OnStart(string[] args) { _log.WriteEntry("Program > OnStart > Enter"); try { var builder = new WebHostBuilder(_serviceProvider, Configuration); builder.UseServer("Microsoft.AspNet.Server.WebListener"); _hostingEngine = builder.Build(); _shutdownServerDisposable = _hostingEngine.Start(); } catch (Exception ex) { _log.WriteEntry(ex.Message); } _log.WriteEntry("Program > OnStart > Exit"); }
protected override void OnStart(string[] args) { var configSource = new MemoryConfigurationSource(); configSource.Add("server.urls", "http://localhost:5000"); var config = new ConfigurationBuilder(configSource).Build(); var builder = new WebHostBuilder(_serviceProvider, config); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); builder.UseServices(services => services.AddMvc()); builder.UseStartup(appBuilder => { appBuilder.UseDefaultFiles(); appBuilder.UseStaticFiles(); appBuilder.UseMvc(); }); _hostingEngine = builder.Build(); _shutdownServerDisposable = _hostingEngine.Start(); }
public void Start() { var configSource = new JsonConfigurationProvider($@"{_applicationEnvironment.ApplicationBasePath}\config.json"); var config = new ConfigurationBuilder() .Add(configSource) .Build(); var builder = new WebHostBuilder(config); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); builder.UseServices(services => services.AddMvc()); builder.UseStartup(appBuilder => { appBuilder.UseDefaultFiles(); appBuilder.UseStaticFiles(); appBuilder.UseMvc(); }); _application = builder.Build().Start(); }
public async Task ZeroToTenThreads(int threadCount) { var config = new ConfigurationBuilder() .AddInMemoryCollection(new Dictionary<string, string> { { "server.urls", "http://localhost:8790/" } }) .Build(); var hostBuilder = new WebHostBuilder(config); hostBuilder.UseServer("Microsoft.AspNet.Server.Kestrel"); hostBuilder.UseStartup(app => { var serverInfo = app.ServerFeatures.Get<IKestrelServerInformation>(); serverInfo.ThreadCount = threadCount; app.Run(context => { return context.Response.WriteAsync("Hello World"); }); }); using (var app = hostBuilder.Build().Start()) { using (var client = new HttpClient()) { // Send 20 requests just to make sure we don't get any failures var requestTasks = new List<Task<string>>(); for (int i = 0; i < 20; i++) { var requestTask = client.GetStringAsync("http://localhost:8790/"); requestTasks.Add(requestTask); } foreach (var result in await Task.WhenAll(requestTasks)) { Assert.Equal("Hello World", result); } } } }
protected override void OnStart(string[] args) { var configSource = new JsonConfigurationProvider($@"{_applicationEnvironment.ApplicationBasePath}\config.json"); var config = new ConfigurationBuilder().Add(configSource).Build(); var builder = new WebHostBuilder(config); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); builder.UseServices(services => services.AddMvc()); builder.UseStartup(appBuilder => { appBuilder.UseStaticFiles(); appBuilder.UseMvc(routes => { routes.MapRoute( "Default", "{controller}/{action}", new { controller = "home", action = "index" }); }); }); _hostingEngine = builder.Build(); _shutdownServerDisposable = _hostingEngine.Start(); }
public static void Main(string[] args) { var hostingConfig = new ConfigurationBuilder() .AddJsonFile("hosting.json", optional: true) .AddEnvironmentVariables() .AddEnvironmentVariables(prefix: "ASPNET_") .AddCommandLine(args) .Build(); var hostBuilder = new WebHostBuilder(hostingConfig, captureStartupErrors: true); hostBuilder.UseStartup(typeof(Startup)); var host = hostBuilder.Build(); using (var app = host.Start()) { // Echo out the addresses we're listening on var hostingEnv = app.Services.GetRequiredService<IHostingEnvironment>(); Console.WriteLine("Hosting environment: " + hostingEnv.EnvironmentName); var serverAddresses = app.ServerFeatures.Get<IServerAddressesFeature>(); if (serverAddresses != null) { foreach (var address in serverAddresses.Addresses) { Console.WriteLine("Now listening on: " + address); } } Console.WriteLine("Application started. Press Ctrl+C to shut down."); var appLifetime = app.Services.GetRequiredService<IApplicationLifetime>(); // Run the interaction on a separate thread as we don't have Console.KeyAvailable on .NET Core so can't // do a pre-emptive check before we call Console.ReadKey (which blocks, hard) var interactiveThread = new Thread(() => { Console.WriteLine(); Console.WriteLine("Press 'C' to force GC or any other key to display GC stats"); while (true) { var key = Console.ReadKey(intercept: true); if (key.Key == ConsoleKey.C) { Console.WriteLine(); Console.Write("Forcing GC..."); GC.Collect(); Console.WriteLine(" done!"); } else { Console.WriteLine(); Console.WriteLine($"Allocated: {GetAllocatedMemory()}"); Console.WriteLine($"Gen 0: {GC.CollectionCount(0)}, Gen 1: {GC.CollectionCount(1)}, Gen 2: {GC.CollectionCount(2)}"); } } }); // Handle Ctrl+C in order to gracefully shutdown the web server Console.CancelKeyPress += (sender, eventArgs) => { Console.WriteLine(); Console.WriteLine("Shutting down application..."); appLifetime.StopApplication(); eventArgs.Cancel = true; }; interactiveThread.Start(); appLifetime.ApplicationStopping.WaitHandle.WaitOne(); } }
protected override void OnStart(string[] args) { try { var configProvider = new MemoryConfigurationProvider(); configProvider.Add("server.urls", "http://localhost:5000"); var config = new ConfigurationBuilder() .Add(configProvider) .Build(); var builder = new WebHostBuilder(config); builder.UseServer("Microsoft.AspNet.Server.Kestrel"); builder.UseServices(services => { services.AddMvc(opts => { // none }); }); builder.UseStartup(appBuilder => { appBuilder.Use(async (ctx, next) => { try { await next(); } catch (Exception ex) { Console.WriteLine(ex); } }); appBuilder.UseDefaultFiles(); appBuilder.UseStaticFiles(); appBuilder.UseMvc(); //if (env.IsDevelopment()) { appBuilder.UseBrowserLink(); appBuilder.UseDeveloperExceptionPage(); appBuilder.UseDatabaseErrorPage(); } }); var hostingEngine = builder.Build(); _application = hostingEngine.Start(); } catch (Exception ex) { Debug.WriteLine("error in OnStart: " + ex); throw; } }
private DbContext TryCreateContextUsingAppCode(Type dbContextType, ModelType startupType) { var hostBuilder = new WebHostBuilder(); if (startupType != null) { var reflectedStartupType = dbContextType.GetTypeInfo().Assembly.GetType(startupType.FullName); if (reflectedStartupType != null) { hostBuilder.UseStartup(reflectedStartupType); } } var appServices = hostBuilder.Build().ApplicationServices; return appServices.GetService(dbContextType) as DbContext; }