private static void BuildOptions(KestrelServerOptions options)
{
var certPath = Environment.GetEnvironmentVariable("WWWCERT");
var certificate = !string.IsNullOrWhiteSpace(certPath)
? new X509Certificate2(certPath, Environment.GetEnvironmentVariable("WWWKEY"))
: null;
var environment = (IHostingEnvironment)options.ApplicationServices.GetService(typeof(IHostingEnvironment));
if (environment.IsDevelopment())
{
options.Listen(IPAddress.Loopback, 5000);
options.Listen(IPAddress.Loopback, 5001, listenOptions =>
{
listenOptions.UseHttps();
});
}
else
{
options.Listen(IPAddress.Any, 80);
options.Listen(IPAddress.Any, 443, listenOptions =>
{
listenOptions.UseHttps(certificate);
});
}
}
internal static void SetKestrelOptions(WebHostBuilderContext context, KestrelServerOptions options)
{
var hostConfiguration = context.Configuration.GetSection(WebApiConfiguration.SectionName)
.Get <WebApiConfiguration>();
if (hostConfiguration == null)
{
return;
}
options.Listen(IPAddress.Any, hostConfiguration.PortNumber);
if (!hostConfiguration.HttpsPort.HasValue)
{
return;
}
var certificatePath = Path.Combine(Directory.GetCurrentDirectory(), hostConfiguration.CertificatePath);
if (!File.Exists(certificatePath))
{
throw new FileNotFoundException("Файл сертификата для HTTPS не найден");
}
options.Listen(IPAddress.Any, hostConfiguration.HttpsPort.Value, listenOptions =>
{
listenOptions.UseHttps();
});
}
private static void SetHost(KestrelServerOptions options, HostSettings hostSettings)
{
foreach (var endpoint in hostSettings.Endpoints.Values)
{
if (!endpoint.IsEnabled)
{
continue;
}
var address = IPAddress.Parse(endpoint.Address);
switch (endpoint.Scheme.ToUpperInvariant())
{
case Http:
options.Listen(address, endpoint.Port);
break;
case Https:
options.Listen(address, endpoint.Port, opt => opt.UseHttps(GetHttpsConnectionOptions()));
break;
default:
throw new NotImplementedException($"The scheme [{endpoint.Scheme}] is not supported.");
}
}
}
private static void SetHttpsAndUrls(KestrelServerOptions kestrelOptions, IWireMockMiddlewareOptions wireMockMiddlewareOptions, IEnumerable <HostUrlDetails> urlDetails)
{
foreach (var urlDetail in urlDetails)
{
if (urlDetail.IsHttps)
{
kestrelOptions.Listen(System.Net.IPAddress.Any, urlDetail.Port, listenOptions =>
{
if (wireMockMiddlewareOptions.CustomCertificateDefined)
{
listenOptions.UseHttps(CertificateLoader.LoadCertificate(
wireMockMiddlewareOptions.X509StoreName,
wireMockMiddlewareOptions.X509StoreLocation,
wireMockMiddlewareOptions.X509ThumbprintOrSubjectName,
wireMockMiddlewareOptions.X509CertificateFilePath,
wireMockMiddlewareOptions.X509CertificatePassword,
urlDetail.Host)
);
}
else
{
listenOptions.UseHttps();
}
});
}
else
{
kestrelOptions.Listen(System.Net.IPAddress.Any, urlDetail.Port);
}
}
}
public static void ConfigureEndpoints(this KestrelServerOptions options)
{
var configuration = options.ApplicationServices.GetRequiredService <IConfiguration>();
var environment = options.ApplicationServices.GetRequiredService <IHostingEnvironment>();
var hostHttp = configuration.GetSection("HttpServer:Endpoints:Http:Host")?.Value;
var portHostHttp = configuration.GetSection("HttpServer:Endpoints:Http:Port")?.Value;
var hostHttps = configuration.GetSection("HttpServer:Endpoints:Https:Host")?.Value;
var portHostHttps = configuration.GetSection("HttpServer:Endpoints:Https:Port")?.Value;
var storeName = configuration.GetSection("HttpServer:Endpoints:Https:StoreName")?.Value;
var storeLocation = configuration.GetSection("HttpServer:Endpoints:Https:StoreLocation")?.Value;
var certificateName = configuration.GetSection("HttpServer:Endpoints:Https:Name")?.Value;
if (!string.IsNullOrEmpty(portHostHttp))
{
options.Listen(IPAddress.Any, Convert.ToInt32(portHostHttp));
}
if (!string.IsNullOrEmpty(portHostHttps))
{
var endpoint = new EndpointConfiguration()
{
StoreLocation = storeLocation,
StoreName = storeName,
Name = certificateName
};
var certificate = LoadCertificate(endpoint, environment);
options.Listen(IPAddress.Any, Convert.ToInt32(portHostHttps), c => c.UseHttps(certificate));
}
}
private static void ConfigHttps(KestrelServerOptions options)
{
options.Listen(IPAddress.Any, 5000, listenOptions =>
{
//填入pfx文件路径和指定的密码
string pfxFile = Path.Combine(Directory.GetCurrentDirectory(), "demoweb.pfx");
listenOptions.UseHttps(pfxFile, "demo1234");
});
//http服务端口
options.Listen(IPAddress.Any, 5001);
}
public void NoDelayDefaultsToTrue()
{
var o1 = new KestrelServerOptions();
o1.Listen(IPAddress.Loopback, 0);
o1.Listen(IPAddress.Loopback, 0, d =>
{
d.NoDelay = false;
});
Assert.True(o1.ListenOptions[0].NoDelay);
Assert.False(o1.ListenOptions[1].NoDelay);
}
public static KestrelServerOptions ListenHttpAndGrpcProtocols(
this KestrelServerOptions options,
IConfiguration config,
string appId)
{
options.Limits.MinRequestBodyDataRate = null;
options.Listen(IPAddress.Any, config.GetHttpPort(appId));
options.Listen(IPAddress.Any,
config.GetGrpcPort(appId),
listenOptions => { listenOptions.Protocols = HttpProtocols.Http2; });
return(options);
}
public void ConfigureEndpointDefaultsAppliesToNewEndpoints()
{
var options = new KestrelServerOptions();
options.ListenLocalhost(5000);
Assert.True(options.ListenOptions[0].NoDelay);
options.ConfigureEndpointDefaults(opt =>
{
opt.NoDelay = false;
});
options.Listen(new IPEndPoint(IPAddress.Loopback, 5000), opt =>
{
// ConfigureEndpointDefaults runs before this callback
Assert.False(opt.NoDelay);
});
Assert.False(options.ListenOptions[1].NoDelay);
options.ListenLocalhost(5000, opt =>
{
Assert.False(opt.NoDelay);
opt.NoDelay = true; // Can be overriden
});
Assert.True(options.ListenOptions[2].NoDelay);
options.ListenAnyIP(5000, opt =>
{
Assert.False(opt.NoDelay);
});
Assert.False(options.ListenOptions[3].NoDelay);
}
public static void UseHttps(this KestrelServerOptions options)
{
var config = options.ApplicationServices.GetRequiredService <IConfiguration>();
var server = config.GetSection("ServerOptions");
options.Listen(IPAddress.Any, 443, listenOptions => listenOptions.UseHttps(server["CertPath"]));
}
/// <summary>
/// 配置Kestrel
/// </summary>
private static void SetHost(KestrelServerOptions options)
{
var address = IPAddress.Parse("0.0.0.0");
options.Listen(address, 8880);
options.UseSystemd();
}
public static void ConfigureServer(this KestrelServerOptions options)
{
string host = "localhost";
var ipAddresses = new List <IPAddress>();
if (host == "localhost")
{
ipAddresses.Add(IPAddress.Any);
ipAddresses.Add(IPAddress.IPv6Any);
}
else if (IPAddress.TryParse(host, out var address))
{
ipAddresses.Add(address);
}
//else
//{
// ipAddresses.Add(IPAddress.IPv6Any);
//}
foreach (var address in ipAddresses)
{
options.Listen(address, GlobalSettings.PORT,
listenOptions =>
{
if (GlobalSettings.IS_HTTPS)
{
X509Certificate2 certificate = LoadCertificate();
listenOptions.UseHttps(certificate);
}
});
}
}
private static void ConfigureKestrel(KestrelServerOptions options, SettingsModel settings)
{
options.AddServerHeader = false;
var(httpPorts, httpsPorts) = GetPorts(settings);
foreach (var port in httpPorts)
{
options.Listen(IPAddress.Any, port);
}
foreach (var port in httpsPorts)
{
options.Listen(IPAddress.Any, port,
listenOptions =>
listenOptions.UseHttps(settings.Web.PfxPath, settings.Web.PfxPassword));
}
}
public async Task RunAsync(int port, int threadCount)
{
var lifetime = new ApplicationLifetime(NullLoggerFactory.Instance.CreateLogger <ApplicationLifetime>());
Console.CancelKeyPress += (sender, e) => lifetime.StopApplication();
var libuvOptions = new LibuvTransportOptions
{
ThreadCount = threadCount
};
var libuvTransport = new LibuvTransportFactory(
Options.Create(libuvOptions),
lifetime,
NullLoggerFactory.Instance);
var serverOptions = new KestrelServerOptions();
serverOptions.Listen(IPAddress.Any, port);
var server = new KestrelServer(Options.Create(serverOptions),
libuvTransport,
NullLoggerFactory.Instance);
await server.StartAsync(this, CancellationToken.None);
Console.WriteLine($"Server listening on http://*:{port} with {libuvOptions.ThreadCount} thread(s)");
lifetime.ApplicationStopping.WaitHandle.WaitOne();
await server.StopAsync(CancellationToken.None);
}
/// <summary>
/// Configure Kestrel to run consistantly across the Sentinel
/// Web and Api projects.
/// </summary>
/// <param name="options"></param>
/// <param name="hostingEnvironment">Hosting Environment Properites</param>
/// <param name="configuration">Configuration Properties</param>
/// <param name="localPort">Choose the port for this service to function on</param>
public static void Configure(KestrelServerOptions options,
IHostingEnvironment hostingEnvironment,
IConfiguration configuration,
int localPort)
{
try
{
Log.Information("Setting Kestrel Server Options");
// var sslCertificate = SOME CONFIGURATION TO GET CERTIFICATES FOR HTTPS
//var port = hostingEnvironment.IsEnvironment(EnvironmentTypes.Local)
// ? localPort
// : 443;
options.Listen(IPAddress.Any, localPort, listenOptions =>
{
listenOptions.NoDelay = true;
//listenOptions.UseHttps(sslCertificate);
});
}
catch (Exception exception)
{
Log.Fatal(exception, "Host terminated unexpectedly! -- {Message}", exception.Message);
}
}
public void ConfigureEndpointDefaultsAppliesToNewEndpoints()
{
var options = new KestrelServerOptions();
options.ListenLocalhost(5000);
Assert.Equal(HttpProtocols.Http1AndHttp2, options.CodeBackedListenOptions[0].Protocols);
options.ConfigureEndpointDefaults(opt =>
{
opt.Protocols = HttpProtocols.Http1;
});
options.Listen(new IPEndPoint(IPAddress.Loopback, 5000), opt =>
{
// ConfigureEndpointDefaults runs before this callback
Assert.Equal(HttpProtocols.Http1, opt.Protocols);
});
Assert.Equal(HttpProtocols.Http1, options.CodeBackedListenOptions[1].Protocols);
options.ListenLocalhost(5000, opt =>
{
Assert.Equal(HttpProtocols.Http1, opt.Protocols);
opt.Protocols = HttpProtocols.Http2; // Can be overriden
});
Assert.Equal(HttpProtocols.Http2, options.CodeBackedListenOptions[2].Protocols);
options.ListenAnyIP(5000, opt =>
{
opt.Protocols = HttpProtocols.Http2;
});
Assert.Equal(HttpProtocols.Http2, options.CodeBackedListenOptions[3].Protocols);
}
static async Task Main(string[] args)
{
var socketTransportOptions = new SocketTransportOptions();
var socketTransportFactory = new SocketTransportFactory(Options.Create(socketTransportOptions), NullLoggerFactory.Instance);
var kestrelServerOptions = new KestrelServerOptions();
kestrelServerOptions.Listen(IPAddress.Any, 8080);
kestrelServerOptions.AddServerHeader = false;
using var kestrelServer = new KestrelServer(Options.Create(kestrelServerOptions), socketTransportFactory, NullLoggerFactory.Instance);
await kestrelServer.StartAsync(new HttpApplication(), CancellationToken.None);
Console.WriteLine("Listening on:");
foreach (var address in kestrelServer.Features.Get <IServerAddressesFeature>().Addresses)
{
Console.WriteLine(" - " + address);
}
Console.WriteLine("Process CTRL+C to quit");
var wh = new ManualResetEventSlim();
Console.CancelKeyPress += (sender, e) => wh.Set();
wh.Wait();
}
private static void Listen(KestrelServerOptions options, IConfigurationRoot config, string url)
{
var urlPrefix = UrlPrefix.Create(url);
var endpoint = CreateIPEndPoint(urlPrefix);
options.Listen(endpoint, listenOptions =>
{
var connectionFilter = GetConnectionFilter(config);
if (connectionFilter != null)
{
listenOptions.ConnectionAdapters.Add(connectionFilter);
}
#if !NETCOREAPP2_0 && !NETCOREAPP2_1
if (Protocol.Equals("h2", StringComparison.OrdinalIgnoreCase))
{
listenOptions.Protocols = HttpProtocols.Http1AndHttp2;
}
else if (Protocol.Equals("h2c", StringComparison.OrdinalIgnoreCase))
{
listenOptions.Protocols = HttpProtocols.Http2;
}
#endif
if (urlPrefix.IsHttps)
{
listenOptions.UseHttps("testCert.pfx", "testPassword");
}
});
}
public static void UseSslIfFileExists(this KestrelServerOptions options, int port, string pfxFilePath, string password = null)
{
if (File.Exists(pfxFilePath))
{
options.Listen(IPAddress.Any, port, listen => listen.UseHttps(pfxFilePath, password));
}
}
private static void ipConfig(KestrelServerOptions o)
{
var portStr = CmdHelper.QueryParameter("-p", "8080");
if (!int.TryParse(portStr, out int port))
{
port = 9001;
}
var ip = CmdHelper.QueryParameter("-ip", "localhost");
Console.WriteLine(ip);
if (ip.ToLower() == "any")
{
Console.WriteLine("ListenAnyIP");
o.ListenAnyIP(port);
}
else if (ip == "127.0.0.1" || ip.ToLower() == "localhost")
{
Console.WriteLine("ListenLocalhost");
o.ListenLocalhost(port);
}
else
{
Console.WriteLine("Listen");
o.Listen(System.Net.IPAddress.Parse(ip), port);
}
}
/// <summary>
/// 配置Kestrel
/// </summary>
private static void SetHost(KestrelServerOptions options)
{
var address = IPAddress.Parse("0.0.0.0");
options.Listen(address, ServiceConfigInfo.HttpPort);
options.UseSystemd();
}
private static void ConfigKestrel(KestrelServerOptions opts)
{
opts.Listen(IPAddress.Parse("192.168.10.82"), 10000, listenOptions =>
{
//填入之前iis中生成的pfx文件路径和指定的密码
listenOptions.UseHttps(@"F:\Git\Snail.Release\Snail.Release\wwwroot\crt\webrtc1.pfx", "chennanfei");
});
}
private static void ConfigureKestrel(WebHostBuilderContext context, KestrelServerOptions serverOptions)
{
Log.Debug("ConfigureKestrel");
var config = context.Configuration.Get <StartUpConfiguration>();
config.SetDefaultSettings();
var listenIp = IPAddress.Parse(config.ListeningIP);
if (config.HttpPort.HasValue && config.HttpPort.Value != 0)
{
serverOptions.Listen(listenIp, config.HttpPort.Value, listenOptions =>
{
listenOptions.Protocols = HttpProtocols.Http1AndHttp2;
});
}
if (config.HttpsPort.HasValue && config.HttpsPort.Value != 0)
{
var certPath = PathHelper.GetFullPath(config.HttpsCertPath);
Log.Debug(certPath);
serverOptions.Listen(listenIp, config.HttpsPort.Value, listenOptions =>
{
listenOptions.Protocols = HttpProtocols.Http1AndHttp2;
listenOptions.UseHttps(PathHelper.GetFullPath(config.HttpsCertPath), config.HttpsCertPassword);
});
}
var adminListenIp = IPAddress.Parse(config.AdminSettings.ListeningIP);
serverOptions.Listen(adminListenIp, config.AdminSettings.HttpsPort, options =>
{
options.Protocols = HttpProtocols.Http1AndHttp2;
options.UseHttps(PathHelper.GetFullPath(config.AdminSettings.HttpsCertPath),
config.AdminSettings.HttpsCertPassword);
});
var idpListenIp = IPAddress.Parse(config.IdpSettings.ListeningIP);
serverOptions.Listen(idpListenIp, config.IdpSettings.HttpsPort, options =>
{
options.Protocols = HttpProtocols.Http1AndHttp2;
options.UseHttps(PathHelper.GetFullPath(config.IdpSettings.HttpsCertPath), config.IdpSettings.HttpsCertPassword);
});
}
/// <summary>
/// Add the certificates for the https endpoints
/// </summary>
/// <param name="options">Input options</param>
public static void ConfigureEndpoints(this KestrelServerOptions options)
{
var environment = options.ApplicationServices.GetRequiredService <IHostingEnvironment>();
var endpoints = new List <EndpointConfiguration>
{
new EndpointConfiguration
{
Host = "localhost",
Port = 5001,
Scheme = "https",
StoreName = "My",
StoreLocation = "CurrentUser",
},
new EndpointConfiguration
{
Host = "localhost",
Port = 5000,
Scheme = "http",
},
};
foreach (var endpoint in endpoints)
{
var config = endpoint;
var port = config.Port ?? (config.Scheme == "https" ? 443 : 80);
var ipAddresses = new List <IPAddress>();
if (config.Host == "localhost")
{
ipAddresses.Add(IPAddress.IPv6Loopback);
ipAddresses.Add(IPAddress.Loopback);
}
else if (IPAddress.TryParse(config.Host, out var address))
{
ipAddresses.Add(address);
}
else
{
ipAddresses.Add(IPAddress.IPv6Any);
}
foreach (var address in ipAddresses)
{
options.Listen(
address,
port,
listenOptions =>
{
if (config.Scheme == "https")
{
var certificate = LoadCertificate(config, environment);
listenOptions.UseHttps(certificate);
}
});
}
}
}
public static void ConfigureEndpoints(this KestrelServerOptions options)
{
if (options is null)
{
return;
}
var configuration = options.ApplicationServices.GetRequiredService <IConfiguration>();
var environment = options.ApplicationServices.GetRequiredService <IHostEnvironment>();
var endpoints = configuration.GetSection("HttpServer:Endpoints")
.GetChildren()
.ToDictionary(
section => section.Key,
section =>
{
var endpoint = new EndpointConfiguration();
section.Bind(endpoint);
return(endpoint);
}
);
foreach (var endpoint in endpoints)
{
var config = endpoint.Value;
var port = config.Port ?? (config.Scheme == "https" ? 443 : 80);
var ipAddresses = new List <IPAddress>();
if (config.Host == "localhost")
{
ipAddresses.Add(IPAddress.IPv6Loopback);
ipAddresses.Add(IPAddress.Loopback);
}
else if (IPAddress.TryParse(config.Host, out var address))
{
ipAddresses.Add(address);
}
else
{
ipAddresses.Add(IPAddress.IPv6Any);
}
foreach (var address in ipAddresses)
{
options.Listen(
address,
port,
listenOptions =>
{
if (config.Scheme == "https")
{
var certificate = LoadCertificate(config);
listenOptions.UseHttps(certificate);
}
});
}
}
}
/// <summary>
/// 配置Kestrel
/// </summary>
private static void SetHost(KestrelServerOptions options)
{
var address = IPAddress.Parse("0.0.0.0");
options.Listen(address, ServiceConfigInfo.HttpPort);
options.UseSystemd();
options.Limits.KeepAliveTimeout = TimeSpan.FromSeconds(30);
options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(30);
}
private static void SetKestrelConfiguration(KestrelServerOptions options, IConfiguration configuration)
{
var portsConfig = configuration.GetSection("Ports");
int httpPort = portsConfig.GetValue <int>("Http");
options.Listen(IPAddress.Any, httpPort, listenOptions =>
{
listenOptions.Protocols = HttpProtocols.Http1AndHttp2;
});
}
private static void ConfigureKestrel(KestrelServerOptions options)
{
options.Listen(
IPAddress.Any,
31337,
builder =>
{
// TODO
});
}
protected override void ConfigureKestrel(KestrelServerOptions options)
{
options.Listen(EndPoint, listneOptions =>
{
byte[] pfx = ResourceManager.GetResourceBytes("server.pfx");
var pfxCert = new X509Certificate2(pfx, "minime");
listneOptions.UseHttps(pfxCert);
});
}
protected override void ConfigureKestrel(KestrelServerOptions options, string hostname)
{
var certificate = _certificateFactory.GenerateCertificate(hostname);
options.Listen(IPAddress.Loopback, 0, listener => listener.UseHttps(https =>
{
https.ServerCertificate = certificate;
https.ClientCertificateMode = ClientCertificateMode.AllowCertificate;
https.AllowAnyClientCertificate();
}));
}