public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseUrls("http://localhost:8080")
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
var restartTime = 0;
Restart:
try
{
host.Run();
}
catch (Exception ex)
{
Logger.Error("Unhandled exception occured while host is running.", ex);
if (restartTime <= MaxRestartTime)
{
restartTime++;
Logger.Info("Trying to restart...");
goto Restart;
}
}
ClearUp();
}
public static void Main(string[] args)
{
while (true)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
var lifetime = (IApplicationLifetime)host.Services.GetService(typeof(IApplicationLifetime));
Task.Run(() =>
{
while (true)
{
var line = Console.ReadLine();
if (line == "r")
{
Console.WriteLine("Restarting");
lifetime.StopApplication();
break;
}
}
});
host.Run();
}
}
public static int Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("KestrelHelloWorld <url to host>");
return 1;
}
var url = new Uri(args[0]);
Args = string.Join(" ", args);
var host = new WebHostBuilder()
.UseServer("Microsoft.AspNetCore.Server.Kestrel")
.UseUrls(url.ToString())
.UseStartup<Startup>()
.Build();
ServerCancellationTokenSource = new CancellationTokenSource();
// shutdown server after 20s.
var shutdownTask = Task.Run(async () =>
{
await Task.Delay(20000);
ServerCancellationTokenSource.Cancel();
});
host.Run(ServerCancellationTokenSource.Token);
shutdownTask.Wait();
return 0;
}
public async Task MiddlewareSkippedIfTokenIsMissing()
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.UseSetting("PORT", "12345")
.UseSetting("APPL_PATH", "/")
.UseIISIntegration()
.Configure(app =>
{
app.Run(context =>
{
var auth = context.Features.Get<IHttpAuthenticationFeature>();
Assert.Null(auth);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
var req = new HttpRequestMessage(HttpMethod.Get, "");
req.Headers.TryAddWithoutValidation("MS-ASPNETCORE-TOKEN", "TestToken");
var response = await server.CreateClient().SendAsync(req);
Assert.True(assertsExecuted);
response.EnsureSuccessStatusCode();
}
public static void Main(string[] args)
{
var configuration = new ConfigurationBuilder()
.AddJsonFile(HostingJsonFileName, optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.AddCommandLine(args)
.Build();
var host = new WebHostBuilder()
.UseConfiguration(configuration)
.UseContentRoot(Directory.GetCurrentDirectory())
.UseKestrel(
options =>
{
// TODO: for Kestrel to serve HTTPS, a certificate is required
//options.UseHttps()
// Do not add the Server HTTP header when using the Kestrel Web Server.
options.AddServerHeader = false;
})
// $Start-WebServer-IIS$
.UseIISIntegration()
// $End-WebServer-IIS$
.UseStartup<Startup>()
.Build();
host.Run();
}
TestServer GetServer()
{
var bldr = new WebHostBuilder()
.Configure(app => app.UseMetaWeblog("/livewriter"))
.ConfigureServices( svcs => svcs.AddMetaWeblog<TestMetaWeblogService>());
return new TestServer(bldr);
}
public static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.AddEnvironmentVariables(prefix: "ASPNETCORE_")
.AddJsonFile("hosting.json", optional: true)
.Build();
var host = new WebHostBuilder()
.UseConfiguration(config) // Default set of configurations to use, may be subsequently overridden
//.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory()) // Override the content root with the current directory
.UseUrls("http://*:1000", "https://*:902")
.UseEnvironment("Development")
.UseWebRoot("public")
.ConfigureServices(services =>
{
// Configure services that the application can see
services.AddSingleton<IMyCustomService, MyCustomService>();
})
.Configure(app =>
{
// Write the application inline, this won't call any startup class in the assembly
app.Use(next => context =>
{
return next(context);
});
})
.Build();
host.Run();
}
public static void Main(string[] args)
{
try
{
var host = new WebHostBuilder()
.UseKestrel(options =>
{
options.UseHttps(@"..\..\certificates\localhost_ssl.pfx", "pass@word1");
options.NoDelay = true;
//I use this to get rid of SSL errors, feel free to remove it.
IConnectionFilter prevFilter = options.ConnectionFilter ?? new NoOpConnectionFilter();
options.ConnectionFilter = new IgnoreSslErrorsConnectionFilter(prevFilter);
}
)
.UseUrls("https://localhost:5000")
.UseContentRoot(Directory.GetCurrentDirectory());
host.UseStartup<Startup>();
var webHost = host.Build();
webHost.Run();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
Console.ReadKey();
}
}
public static void Main(string[] args)
{
var currentDirectory = Directory.GetCurrentDirectory();
var host = new WebHostBuilder()
.UseIISIntegration()
.UseKestrel()
.UseContentRoot(currentDirectory)
.UseStartup<Startup>()
.Build();
using (host)
{
using (var cts = new CancellationTokenSource())
{
host.Run((services) =>
{
var orchardHost = new OrchardHost(
services,
System.Console.In,
System.Console.Out,
args);
orchardHost
.RunAsync()
.Wait();
cts.Cancel();
}, cts.Token, "Application started. Press Ctrl+C to shut down.");
}
}
}
public static void Main(string[] args)
{
var configBuilder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("hosting.json");
var configuration = configBuilder.Build();
var hostBuilder = new WebHostBuilder();
// set urls and environment
hostBuilder
.UseUrls(configuration["urls"])
.UseEnvironment(configuration["environment"]);
// set other common things
hostBuilder
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>();
var host = hostBuilder.Build();
host.Run();
}
public async Task MiddlewareRejectsRequestIfTokenHeaderIsMissing()
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.UseSetting("TOKEN", "TestToken")
.UseSetting("PORT", "12345")
.UseSetting("APPL_PATH", "/")
.UseIISIntegration()
.Configure(app =>
{
app.Run(context =>
{
var auth = context.Features.Get<IHttpAuthenticationFeature>();
Assert.Null(auth);
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
var req = new HttpRequestMessage(HttpMethod.Get, "");
var response = await server.CreateClient().SendAsync(req);
Assert.False(assertsExecuted);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task InnerServiceNotAvailableOutsideIsolation() {
// Arrange
var builder = new WebHostBuilder()
.Configure(app => {
app.Isolate(
// Configure the isolated pipeline.
map => { },
// Configure the isolated services.
services => services.AddSingleton(new ValueService("Dummy")));
app.Run(async context => {
var service = context.RequestServices.GetService<ValueService>();
await context.Response.WriteAsync(service?.Value ?? "<null>");
});
});
var server = new TestServer(builder);
var client = server.CreateClient();
// Act
var response = await client.GetStringAsync("/");
// Assert
Assert.Equal("<null>", response);
}
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseStartup<TestStartup>()
.Build();
host.Run();
}
public static void Main(string[] args)
{
if (Debugger.IsAttached)
{
Environment.SetEnvironmentVariable(
"ASPNETCORE_ENVIRONMENT",
EnvironmentName.Development);
}
var config = new ConfigurationBuilder()
.AddJsonFile("hosting.json", optional: true)
.AddEnvironmentVariables("ASPNETCORE_")
.AddCommandLine(args)
.Build();
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseConfiguration(config)
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
host.Run();
}
public static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
var host = new WebHostBuilder()
.UseKestrel()
.UseConfiguration(config)
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>()
.Build();
// Delete UNIX pipe if it exists at startup (eg. previous process crashed before cleaning it up)
var addressFeature = host.ServerFeatures.Get<IServerAddressesFeature>();
var url = ServerAddress.FromUrl(addressFeature.Addresses.First());
if (url.IsUnixPipe && File.Exists(url.UnixPipePath))
{
Console.WriteLine("UNIX pipe {0} already existed, deleting it.", url.UnixPipePath);
File.Delete(url.UnixPipePath);
}
host.Run();
}
static HelloWorldMiddlewareTest()
{
var builder = new WebHostBuilder();
builder.UseStartup<HelloWorldMiddleware.Startup>();
Server = new TestServer(builder);
Client = Server.CreateClient();
}
static LargeContentMiddlewareTest()
{
var builder = new WebHostBuilder();
builder.UseStartup<LargeContentMiddleware.Startup>();
Server = new TestServer(builder);
Client = Server.CreateClient();
}
public async Task BufferResponseWithManualContentLength_NotReplaced()
{
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseResponseBuffering();
app.Run(async context =>
{
context.Response.ContentLength = 12;
Assert.False(context.Response.HasStarted);
Assert.True(context.Response.Body.CanSeek);
await context.Response.WriteAsync("Hello World");
Assert.False(context.Response.HasStarted);
Assert.True(context.Response.Body.CanSeek);
});
});
var server = new TestServer(builder);
var response = await server.CreateClient().GetAsync("");
response.EnsureSuccessStatusCode();
Assert.Equal("Hello World", await response.Content.ReadAsStringAsync());
IEnumerable<string> values;
Assert.True(response.Content.Headers.TryGetValues("Content-Length", out values));
Assert.Equal("12", values.FirstOrDefault());
}
public async Task XForwardedForDefaultSettingsChangeRemoteIpAndPort()
{
var assertsExecuted = false;
var builder = new WebHostBuilder()
.Configure(app =>
{
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor
});
app.Run(context =>
{
Assert.Equal("11.111.111.11", context.Connection.RemoteIpAddress.ToString());
Assert.Equal(9090, context.Connection.RemotePort);
// No Original set if RemoteIpAddress started null.
Assert.False(context.Request.Headers.ContainsKey("X-Original-For"));
// Should have been consumed and removed
Assert.False(context.Request.Headers.ContainsKey("X-Forwarded-For"));
assertsExecuted = true;
return Task.FromResult(0);
});
});
var server = new TestServer(builder);
var req = new HttpRequestMessage(HttpMethod.Get, "");
req.Headers.Add("X-Forwarded-For", "11.111.111.11:9090");
await server.CreateClient().SendAsync(req);
Assert.True(assertsExecuted);
}
static BigViewsTest()
{
var builder = new WebHostBuilder();
builder.UseStartup<BigViews.Startup>();
builder.UseProjectOf<BigViews.Startup>();
Server = new TestServer(builder);
Client = Server.CreateClient();
}
static MediumApiTest()
{
var builder = new WebHostBuilder();
builder.UseStartup<MediumApi.Startup>();
builder.UseProjectOf<MediumApi.Startup>();
Server = new TestServer(builder);
Client = Server.CreateClient();
}
static HelloWorldMvcTest()
{
var builder = new WebHostBuilder();
builder.UseStartup<HelloWorldMvc.Startup>();
builder.UseProjectOf<HelloWorldMvc.Startup>();
Server = new TestServer(builder);
Client = Server.CreateClient();
}
static LargeStaticViewTest()
{
var builder = new WebHostBuilder();
builder.UseStartup<LargeStaticView.Startup>();
builder.UseProjectOf<LargeStaticView.Startup>();
Server = new TestServer(builder);
Client = Server.CreateClient();
}
public static void Main(string[] args)
{
var builder = new WebHostBuilder()
.UseKestrel()
.UseStartup<Startup>()
.Build();
builder.Run();
}
public static void Main(string[] args)
{
var host = new WebHostBuilder().UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup<Startup>()
.Build();
host.Run();
}
public static void Main(string[] args)
{
var application = new WebHostBuilder()
.UseConfiguration(WebHostConfiguration.GetDefault(args))
.UseStartup<Startup>()
.Build();
application.Run();
}
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseDefaultConfiguration(args)
.UseStartup<Startup>()
.Build();
host.Run();
}
// Entry point for the application.
public static void Main(string[] args)
{
var host = new WebHostBuilder()
//.UseKestrel()
.UseStartup<StartupHelloWorld>()
.Build();
host.Run();
}
public CustomGrantClient()
{
var builder = new WebHostBuilder()
.UseStartup<Startup>();
var server = new TestServer(builder);
_handler = server.CreateHandler();
_client = server.CreateClient();
}
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseUrls("http://*:5001")
.UseStartup<Startup>()
.Build();
host.Run();
}