public static IWebHostBuilder UseOpenShiftIntegration(this IWebHostBuilder builder, Action <OpenShiftIntegrationOptions> configureOptions)
{
if (configureOptions == null)
{
throw new ArgumentNullException(nameof(configureOptions));
}
if (PlatformEnvironment.IsOpenShift)
{
// Clear the urls. We'll explicitly configure Kestrel depending on the options.
builder.UseUrls(new string[] { });
builder.ConfigureServices(services =>
{
services.Configure(configureOptions);
services.AddSingleton <OpenShiftCertificateLoader>();
services.AddSingleton <IConfigureOptions <KestrelServerOptions>, KestrelOptionsSetup>();
services.AddSingleton <IHostedService, OpenShiftCertificateExpiration>();
});
}
else
{
builder.ConfigureKestrel(opt =>
{
opt.ListenLocalhost(5023, o => o.Protocols = HttpProtocols.Http2);
});
}
return(builder);
}
public void Configure(IWebHostBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
ClearStartupHookEnvironmentVariable();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
uint listenFd;
try
{
var listenFdAsString = Environment.GetEnvironmentVariable("ZOCKET_LISTEN_FD");
listenFd = uint.Parse(listenFdAsString);
builder.ConfigureKestrel(options =>
{
options.ListenHandle(listenFd);
});
}
catch (FormatException)
{
return;
}
// We do this to prevent leaking a socket
fcntl(Convert.ToInt32(listenFd), F_SETFD, FD_CLOEXEC);
}
}
/// <summary>
/// 应用配置
/// </summary>
/// <param name="webBuilder"></param>
/// <param name="config"></param>
public static void DeployConfig(IWebHostBuilder webBuilder, KestrelConfig config)
{
// 判断是否启用Kestrel服务
if (config.Enable)
{
webBuilder.ConfigureKestrel(options => {
// 判断是否启用HTTP配置
if (config.HttpEnable)
{
// 填入配置中的监听端口
options.Listen(IPAddress.Any, config.HttpPort);
}
// 判断是否启用HTTPS配置
if (config.HttpsEnable)
{
// 填入配置中的监听端口
options.Listen(IPAddress.Any, config.HttpsPort, listenOptions => {
// 填入配置中的pfx文件路径和指定的密码
listenOptions.UseHttps(config.HttpsPfxPath, config.HttpsPfxPwd);
});
}
});
}
}
public static IWebHostBuilder ConfigureGrpcServer(this IWebHostBuilder webBuilder)
{
webBuilder.ConfigureServices(services =>
{
services.AddGrpc(options =>
{
options.Interceptors.Add <GlobalServerExceptionInterceptor>();
options.Interceptors.Add <GlobalServerLoggerInterceptor>();
});
services.AddSingleton <MessageOrchestrator>();
});
webBuilder.ConfigureKestrel((context, options) =>
{
var grpcPort = context.Configuration.GetValue <int>("RpcServer:Port", -1);
if (grpcPort <= 0)
{
throw new ConfigurationErrorsException("RpcServer.Port is missing");
}
options.ListenLocalhost(grpcPort, o => o.Protocols = HttpProtocols.Http2);
options.ListenLocalhost(grpcPort - 100, o => o.Protocols = HttpProtocols.Http1);
});
return(webBuilder);
}
public static void SplitHttpProtocolsIfDevelopment(this IWebHostBuilder webBuilder)
{
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var isDevelopment = environment == Environments.Development;
if (isDevelopment)
{
var url = Environment.GetEnvironmentVariable("ASPNETCORE_URLS");
if (string.IsNullOrWhiteSpace(url))
{
throw new InvalidOperationException("Application Url must not be empty");
}
var uri = new Uri(url);
if (!string.Equals(uri.Scheme, "http"))
{
throw new InvalidOperationException("Application Url must be HTTP in dev mode");
}
webBuilder.ConfigureKestrel(options =>
{
options.ListenAnyIP(uri.Port, o => o.Protocols = HttpProtocols.Http2);
options.ListenAnyIP(uri.Port * 10, o => o.Protocols = HttpProtocols.Http1);
});
}
}
public static IWebHost BuildWebHost(string[] args)
{
IWebHostBuilder webHostBuilder = WebHost.CreateDefaultBuilder(args);
webHostBuilder.ConfigureKestrel(
options =>
{
options.AddServerHeader = false;
//options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(10);
})
.ConfigureAppConfiguration(ConfigureAppConfiguration)
.CaptureStartupErrors(true) // Add this line to capture startup errors
.UseEnvironment(Config.EnvironmentName) //Set the environment name
.UseSetting(
WebHostDefaults.DetailedErrorsKey,
"true") //When enabled (or when the Environment is set to Development), the app captures detailed exceptions.
.ConfigureServices(
services => services
.AddAutofac()); /// This call allows for ConfigureContainer to be supported in Startup with a strongly-typed ContainerBuilder
if (!string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("PORT")))
{
webHostBuilder.UseUrls($"http://0.0.0.0:{Environment.GetEnvironmentVariable("PORT")}/");
}
webHostBuilder.UseStartup <Startup>();
SetupSerilogLogger(webHostBuilder);
return(webHostBuilder.Build());
}
public static void ConfigureKestrelHost(this IWebHostBuilder builder)
{
builder.ConfigureKestrel(serverOptions =>
{
serverOptions.Listen(IPAddress.Any, 5050, listenOptions =>
{
listenOptions.UseHttps();
listenOptions.Protocols = HttpProtocols.Http1;
});
});
}
protected override void Configure(IWebHostBuilder builder)
{
builder.ConfigureKestrel(options =>
{
options.Listen(IPAddress.Any, 8443, listenOptions =>
{
listenOptions.Protocols = HttpProtocols.Http2;
listenOptions.UseConnectionLogging();
});
});
}
private static void ConfigureInsecureHttp2Listener(IWebHostBuilder webBuilder)
{
// Makes Grpc.Core client with ChannelCredentials.Insecure work
webBuilder.ConfigureKestrel(options =>
{
// This endpoint will use HTTP/2 and HTTPS on port 5001.
options.Listen(IPAddress.Any, 5001, listenOptions =>
{
listenOptions.Protocols = HttpProtocols.Http2;
});
});
}
/// <summary>
/// Configures the Kestrel HTTPS end point. The mechanism is:
/// - Get the port from appSettings to allow for easy changing,
/// - Get the certificate from the Azure Key Vault to allow for centralisation and sharing
/// amongst multiple virtual machines.
/// </summary>
private static void ConfigureHttps(IWebHostBuilder webBuilder)
{
webBuilder.ConfigureKestrel(serverOptions =>
{
if (TlsCertificate != null)
{
serverOptions.ConfigureHttpsDefaults(listenOptions =>
{
listenOptions.ServerCertificate = TlsCertificate;
});
}
});
}
private static void setting(IWebHostBuilder webBuilder)
{
string[] urls = { "http://localhost:8080" };//, "https://localhost:8012" };
//讀取設定檔
var configuration = AppSettingsUtility.getInstance().builder.Build();
var str_urls = configuration["server.urls"];
if (!String.IsNullOrWhiteSpace(str_urls))
{
urls = str_urls.Split(";");
}
Console.WriteLine("urls " + urls[0]);
var str_KeepAliveTimeout = configuration["KestrelSetting:KeepAliveTimeout"];
var str_RequestHeadersTimeout = configuration["KestrelSetting:RequestHeadersTimeout"];
//HTTP持久連線的時間。
int keepAliveTimeout;
int.TryParse(str_KeepAliveTimeout, out keepAliveTimeout);
keepAliveTimeout = (keepAliveTimeout <= 0) ? 2 * 60 : keepAliveTimeout;
//Server 處理一個封包最長的時間。
int requestHeadersTimeout = 30;
int.TryParse(str_RequestHeadersTimeout, out requestHeadersTimeout);
requestHeadersTimeout = (requestHeadersTimeout <= 0) ? 30 : requestHeadersTimeout;
System.Console.WriteLine($"keepAliveTimeout:{keepAliveTimeout} / requestHeadersTimeout:{requestHeadersTimeout}");
var runtime = configuration["server.Runtime"];
if (!String.IsNullOrEmpty(runtime) && runtime != "IIS")
{
webBuilder.ConfigureKestrel(serverOptions =>
{
serverOptions.AddServerHeader = false;
serverOptions.Limits.KeepAliveTimeout = TimeSpan.FromSeconds(keepAliveTimeout);
serverOptions.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(requestHeadersTimeout);
})
.UseUrls(urls)
.UseStartup <Startup>();
}
else
{
webBuilder.UseStartup <Startup>()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration();
}
}
/// <inheritdoc />
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
base.ConfigureWebHost(builder);
builder.ConfigureServices(ConfigureServicesForTests);
builder.ConfigureKestrel(
(p) => p.ConfigureHttpsDefaults(
(r) => r.ServerCertificate = new X509Certificate2("localhost-dev.pfx", "Pa55w0rd!")));
builder.UseUrls(ServerAddress.ToString());
// Allow the tests on the self-hosted server to link accounts via "Amazon"
builder.UseSetting("Site:Alexa:RedirectUrls:3", ServerAddress.ToString() + "manage/");
}
/// <inheritdoc />
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureLogging((loggingBuilder) => loggingBuilder.ClearProviders().AddXUnit(this))
.UseSolutionRelativeContentRoot(Path.Combine("src", "AdventOfCode"));
builder.ConfigureKestrel(
(p) => p.ConfigureHttpsDefaults(
(r) => r.ServerCertificate = new X509Certificate2("localhost-dev.pfx", "Pa55w0rd!")));
builder.UseEnvironment(Environments.Production)
.UseSolutionRelativeContentRoot(Path.Combine("src", "AdventOfCode.Site"));
// Configure the server address for the server to
// listen on for HTTPS requests on a dynamic port.
builder.UseUrls("https://127.0.0.1:0");
}
public static IWebHostBuilder ConfigureGenericWebHost(this IWebHostBuilder webHostBuilder)
{
webHostBuilder.ConfigureKestrel((context, serverOptions) =>
{
var kestrelSection = context.Configuration.GetSection("Kestrel");
serverOptions.Configure(kestrelSection);
// serverOptions.Listen(IPAddress.Loopback, 50000);
// serverOptions.Listen(IPAddress.Loopback, 50001,
// listenOptions =>
// {
// listenOptions.UseHttps("testCert.pfx",
// "testPassword");
// });
});
return webHostBuilder;
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureServices(
(services) => services.AddSingleton <IHttpMessageHandlerBuilderFilter, HttpRequestInterceptionFilter>(
(_) => new HttpRequestInterceptionFilter(Interceptor)));
builder.ConfigureAppConfiguration(ConfigureTests)
.ConfigureLogging((loggingBuilder) => loggingBuilder.ClearProviders().AddXUnit(this).AddDebug())
.UseContentRoot(GetContentRootPath());
builder.ConfigureKestrel(
(kestrelOptions) => kestrelOptions.ConfigureHttpsDefaults(
(connectionOptions) => connectionOptions.ServerCertificate = new X509Certificate2("localhost-dev.pfx", "Pa55w0rd!")));
builder.UseUrls(ServerAddress.ToString());
}
public static IWebHostBuilder ConfigureKestrel(this IWebHostBuilder webBuilder)
{
webBuilder.UseKestrel();
webBuilder.ConfigureKestrel((context, options) =>
{
var ports = new List <int>();
context.Configuration.GetSection("Ports").Bind(ports);
IPAddress ip = IPAddress.Parse("0.0.0.0");
foreach (int port in ports)
{
options.Listen(ip, port);
}
});
return(webBuilder);
}
private static void ConfigureWebHost(IWebHostBuilder builder)
{
// TODO Transfer to configuration
const string HostName = "+";
const int DefaultPort = 20270;
UriBuilder uriBuilder = new UriBuilder()
{
Host = HostName,
Port = DefaultPort,
Scheme = Uri.UriSchemeHttp
};
builder.UseUrls(uriBuilder.ToString());
builder.ConfigureKestrel(options => options.AddServerHeader = false);
builder.UseStartup <Startup>();
}
public static IWebHostBuilder ConfigureDynamicTlsWithVault(this IWebHostBuilder builder)
{
builder.ConfigureServices(services =>
{
services.AddSingleton <IServerCertificateProvider, VaultSharpServerCertificateProvider>();
});
return(builder.ConfigureKestrel(options =>
{
options.Listen(IPAddress.Any, 443, listenOptions =>
{
listenOptions.UseHttps(new HttpsConnectionAdapterOptions()
{
SslProtocols = System.Security.Authentication.SslProtocols.Tls12,
ServerCertificateSelector = options.ApplicationServices.GetService <IServerCertificateProvider>().ServerCertificateSelector,
});
});
}));
}
/// <summary>
/// Configures Kestrel Webserver with SSL certificate stored in KeyVault.
/// The usage is intended for containerized apps in public container registries where the certificates should not be a priori installed
/// </summary>
/// <param name="webHostBuilder">IWebHostBuilder</param>
/// <param name="keyVaultName">Optional keyVaultName, otherwise will be retrieved by ENV 'KeyVaultName'</param>
/// <param name="certificateName">Optional certificateName, otherwise will be retrieved by ENV 'CertificateName'</param>
/// <param name="portNumber">Optional portNumber, otherwise Standard HTTPS 443 will be used</param>
/// <param name="azureConnectionString">Optional azureConnectionString, otherwise will be retrieved by ENV 'AzureConnectionString'</param>
/// <returns>IWebHostBuilder instance</returns>
public static IWebHostBuilder ConfigureKestrelSSLFromKeyVault(this IWebHostBuilder webHostBuilder, string keyVaultName = null, string certificateName = null, int portNumber = 443, string azureConnectionString = null)
{
var keyVaultClient = PrepareKeyVaultClient(azureConnectionString);
LoadValues(ref keyVaultName, ref certificateName);
webHostBuilder
.ConfigureKestrel((context, options) =>
{
options.Listen(
new IPEndPoint(IPAddress.Any, portNumber),
listenOptions =>
{
listenOptions.KestrelServerOptions.AddServerHeader = false;
listenOptions.UseHttps(DownloadCertificateFromKeyVault(keyVaultClient, keyVaultName, certificateName));
});
});
return(webHostBuilder);
}
private static void ConfigureKestrel(IWebHostBuilder webHostBuilder)
{
webHostBuilder.ConfigureKestrel((ctx, options) =>
{
options.AddServerHeader = false;
var config = ctx.Configuration;
var useHttps = config.GetValue <bool>("KestrelOptions:UseSsl");
if (!useHttps)
{
return;
}
var certificate = config.GetValue <string>("KestrelOptions:Certificate");
var certificatePassword = config.GetValue <string>("KestrelOptions:CertificatePassword");
options.Listen(IPAddress.Any, 443, listenOptions =>
{
listenOptions.UseHttps(certificate, certificatePassword);
});
});
}
public static IWebHostBuilder ConfigureHomeCtlHostDefaults(this IWebHostBuilder builder)
{
var randomizedPort = PortRandomizer.GetRandomPort();
builder.ConfigureKestrel(options =>
{
options.ListenAnyIP(randomizedPort, listenOptions =>
{
listenOptions.Protocols = AspNetCore.Server.Kestrel.Core.HttpProtocols.Http2;
});
});
builder.ConfigureServices(svcs =>
{
svcs.Configure <HomeCtl.Host.HostOptions>(options => {
options.HostFile = "host.json";
options.HostPort = randomizedPort;
});
svcs.AddStartupService <HostRecordsService>();
svcs.AddStartupService <AppHost>(sP =>
sP.GetRequiredService <IOptions <HomeCtl.Host.HostOptions> >().Value.GetAppHost());
svcs.AddSingleton <EventBus>();
svcs.AddGrpc();
svcs.AddHostedService <HomeCtlHostService>();
svcs.AddSingleton <ApiServer>();
svcs.AddSingleton <EndpointConnectionManager>();
svcs.AddSingleton <IEndpointClientFactory>(sP =>
new ReuseSingleClientFactory(new System.Net.Http.HttpClient {
DefaultRequestVersion = new System.Version(2, 0)
}));
svcs.AddSingleton <IServerIdentityVerifier, GrpcIdentityVerifier>();
svcs.AddSingleton <IServerLivelinessMonitor, NetworkErrorLivelinessMonitor>();
svcs.AddSingleton <IServerLivelinessMonitor>(sP => new NetworkTimingLivelinessMonitor(sP.GetRequiredService <ApiServer>()));
});
return(builder);
}
public static void ConfigureWebApplication(IWebHostBuilder cfg)
{
var port = Environment.GetEnvironmentVariable("SERVICE_PORT") ?? "5000";
var servicePort = int.Parse(port);
// Setup a HTTP/2 endpoint without TLS.
cfg.ConfigureKestrel(options =>
{
// https://docs.microsoft.com/en-us/aspnet/core/grpc/troubleshoot?view=aspnetcore-5.0#unable-to-start-aspnet-core-grpc-app-on-macos
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
options.ListenLocalhost(servicePort, o => o.Protocols = HttpProtocols.Http2);
}
else
{
options.ListenAnyIP(servicePort, o => o.Protocols = HttpProtocols.Http2);
}
});
cfg.Configure((ctx, app) =>
{
if (ctx.HostingEnvironment.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGrpcService <PaycheckService>();
endpoints.MapGet("/", async context =>
{
await context.Response.WriteAsync("Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
});
});
});
}
/// <summary>
/// Configures Kestrel options but does not register an IServer.
/// </summary>
/// <param name="hostBuilder">
/// The <see cref="Microsoft.AspNetCore.Hosting.IWebHostBuilder" /> to configure.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if hostBuilder is null.
/// </exception>
/// <returns>
/// An <see cref="Microsoft.AspNetCore.Hosting.IWebHostBuilder" />
/// that can be used to further configure the WebHost services.
/// </returns>
public static IWebHostBuilder ConfigureKestrelHost(this IWebHostBuilder hostBuilder)
{
if (hostBuilder == null)
{
throw new ArgumentNullException(paramName: nameof(hostBuilder));
}
hostBuilder.ConfigureKestrel(options: serverOptions =>
{
serverOptions.Limits.MaxConcurrentConnections = 100;
serverOptions.Limits.MaxConcurrentUpgradedConnections = 100;
serverOptions.Limits.MaxRequestBodySize = 10 * 1024;
serverOptions.Limits.MinRequestBodyDataRate =
CreateMinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(value: 10));
serverOptions.Limits.MinResponseDataRate =
CreateMinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(value: 10));
serverOptions.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(value: 2);
serverOptions.Limits.RequestHeadersTimeout = TimeSpan.FromMinutes(value: 1);
});
return(hostBuilder);
}
public static void ForceHttp2IfNoTls(this IWebHostBuilder webBuilder)
{
var url = Environment.GetEnvironmentVariable("ASPNETCORE_URLS");
if (string.IsNullOrWhiteSpace(url))
{
throw new InvalidOperationException("Application Url must not be empty");
}
var uri = new Uri(url);
if (string.Equals(uri.Scheme, "https"))
{
return;
}
webBuilder.ConfigureKestrel(options =>
{
options.ListenAnyIP(uri.Port, o => o.Protocols = HttpProtocols.Http2);
// for metrics
options.ListenAnyIP(uri.Port * 10, o => o.Protocols = HttpProtocols.Http1);
});
}
public static IWebHostBuilder ConfigureTerraformPlugin(this IWebHostBuilder webBuilder, Action <IServiceCollection, ResourceRegistry> configureRegistry, int port = DefaultPort)
{
webBuilder.ConfigureKestrel(kestrel =>
{
var debugMode = kestrel.ApplicationServices.GetRequiredService <IOptions <TerraformPluginHostOptions> >().Value.DebugMode;
if (debugMode)
{
kestrel.ListenLocalhost(port, x => x.Protocols = HttpProtocols.Http2);
}
else
{
kestrel.ListenLocalhost(port, x => x.UseHttps(x =>
{
var certificate = kestrel.ApplicationServices.GetService <PluginHostCertificate>();
if (certificate == null)
{
throw new InvalidOperationException("Debug mode is not enabled, but no certificate was found.");
}
x.ServerCertificate = certificate.Certificate;
x.AllowAnyClientCertificate();
}));
}
});
webBuilder.UseStartup <Startup>();
webBuilder.ConfigureServices(services =>
{
services.AddOptions <TerraformPluginHostOptions>().ValidateDataAnnotations();
var registry = new ResourceRegistry();
services.AddSingleton(registry);
configureRegistry(services, registry);
});
return(webBuilder);
}
public static void Configure(IWebHostBuilder webBuilder)
{
webBuilder.ConfigureKestrel(options => options.AddServerHeader = false);
webBuilder.UseStartup <Startup>();
}
/// <summary>
/// Run the application
/// </summary>
/// <param name="cancelToken">Cancel token</param>
/// <returns>Task</returns>
public async virtual Task StartAsync(CancellationToken cancelToken)
{
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(Args);
builder.ConfigureLogging(logging =>
{
#if !DEBUG
logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Warning);
#endif
});
Dictionary <string, string> argsDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
if (Args.Length % 2 != 0)
{
throw new ArgumentException("Arg count must be even. Use a space in between parameter names and values");
}
for (int i = 0; i < Args.Length;)
{
argsDictionary[Args[i++]] = Args[i++].Trim();
}
builder.UseKestrel(c => c.AddServerHeader = false);
builder.UseIISIntegration();
builder.UseContentRoot(RootDirectory);
builder.UseConfiguration(Configuration);
argsDictionary.TryGetValue("--server.urls", out string serverUrl);
IConfigurationSection web = Configuration.GetSection("mailDemonWeb");
Authority = web["authority"];
string certPathWeb = web["sslCertificateFile"];
string certPathPrivateWeb = web["sslCertificatePrivateKeyFile"];
SecureString certPasswordWeb = web["sslCertificatePassword"]?.ToSecureString();
if (File.Exists(certPathWeb) && File.Exists(certPathPrivateWeb))
{
builder.ConfigureKestrel((opt) =>
{
opt.Listen((serverUrl == null ? System.Net.IPAddress.Any : System.Net.IPAddress.Parse(serverUrl)), 443, listenOptions =>
{
listenOptions.UseHttps((sslOpt) =>
{
sslOpt.ServerCertificateSelector = (ctx, name) =>
{
return(CertificateCache.Instance.LoadSslCertificateAsync(certPathWeb, certPathPrivateWeb, certPasswordWeb).Sync());
};
});
});
});
}
else if (serverUrl != null)
{
builder.UseUrls(serverUrl.Split(',', '|', ';'));
}
try
{
host = builder.ConfigureServices(services =>
{
services.AddSingleton <IStartup>(this);
}).Build();
}
catch (Exception ex)
{
MailDemonLog.Error(ex);
}
Recaptcha = new RecaptchaSettings(web["recaptchaSiteKey"], web["recaptchaSecretKey"]);
AdminLogin = new KeyValuePair <string, string>(web["adminUser"], web["adminPassword"]);
Task runTask = host.RunAsync(CancelToken);
// do not return the task until we know we are running, for tests for example, we don't want requests coming
// in until everything is setup and listening properly
if (!runningEvent.WaitOne(10000)) // if 10 seconds and not running, fail
{
throw new ApplicationException("Failed to start app " + GetType().Name);
}
await runTask;
}
public static IWebHostBuilder UseAppMetrics(this IWebHostBuilder webHostBuilder)
{
if (_initialized)
{
return(webHostBuilder);
}
webHostBuilder.ConfigureKestrel((context, options) =>
{
options.AllowSynchronousIO = true;
});
return(webHostBuilder
.ConfigureMetricsWithDefaults((context, builder) =>
{
var metricsOptions = context.Configuration.GetOptions <MetricsOptions>("metrics");
if (!metricsOptions.Enabled)
{
return;
}
_initialized = true;
builder.Configuration.Configure(cfg =>
{
var tags = metricsOptions.Tags;
if (tags == null)
{
return;
}
tags.TryGetValue("app", out var app);
tags.TryGetValue("env", out var env);
tags.TryGetValue("server", out var server);
cfg.AddAppTag(string.IsNullOrWhiteSpace(app) ? null : app);
cfg.AddEnvTag(string.IsNullOrWhiteSpace(env) ? null : env);
cfg.AddServerTag(string.IsNullOrWhiteSpace(server) ? null : server);
foreach (var tag in tags)
{
if (!cfg.GlobalTags.ContainsKey(tag.Key))
{
cfg.GlobalTags.Add(tag.Key, tag.Value);
}
}
}
);
if (metricsOptions.InfluxEnabled)
{
builder.Report.ToInfluxDb(o =>
{
o.InfluxDb.Database = metricsOptions.Database;
o.InfluxDb.BaseUri = new Uri(metricsOptions.InfluxUrl);
o.InfluxDb.CreateDataBaseIfNotExists = true;
o.FlushInterval = TimeSpan.FromSeconds(metricsOptions.Interval);
});
}
})
.UseHealth()
.UseHealthEndpoints(opts =>
{
opts.HealthEndpointEnabled = true;
opts.PingEndpointEnabled = true;
})
.UseMetricsWebTracking()
.UseMetrics((context, options) =>
{
var metricsOptions = context.Configuration.GetOptions <MetricsOptions>("metrics");
if (!metricsOptions.Enabled)
{
return;
}
if (!metricsOptions.PrometheusEnabled)
{
return;
}
options.EndpointOptions = endpointOptions =>
{
endpointOptions.MetricsEndpointOutputFormatter = (metricsOptions.PrometheusFormatter?.ToLowerInvariant() ?? string.Empty) switch
{
"protobuf" => new MetricsPrometheusProtobufOutputFormatter(),
_ => new MetricsPrometheusTextOutputFormatter(),
};
};
}));
}
public void Configure(IWebHostBuilder builder)
{
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
var settings = config.Build();
config.AddAzureAppConfiguration(options =>
{
options.Connect(settings["ConnectionStrings:AppConfig"])
// Load configuration values with no label
.Select(KeyFilter.Any, LabelFilter.Null)
// Override with any configuration values specific to current hosting env
.Select(KeyFilter.Any, hostingContext.HostingEnvironment.EnvironmentName)
.Select(KeyFilter.Any, "Dev-Certificate")
.ConfigureKeyVault(kv =>
{
kv.SetCredential(new DefaultAzureCredential());
});
});
var dict = new Dictionary <string, string>
{
{ "DevAccount_FromLibrary", "DEV_1111111-1111" },
{ "ProdAccount_FromLibrary", "PROD_2222222-2222" }
};
config.AddInMemoryCollection(dict);
});
builder.ConfigureKestrel((hostingContext, serverOptions) =>
{
Configuration = hostingContext.Configuration;
//var config = new CertificateConfiguration
//{
// UseLocalCertStore = Convert.ToBoolean(Configuration["CertificateConfiguration:UseLocalCertStore"]),
// CertificateThumbprint = Configuration["CertificateConfiguration:CertificateThumbprint"],
// DevelopmentCertificatePfx = Configuration["CertificateConfiguration:DevelopmentCertificatePfx"],
// DevelopmentCertificatePassword = Configuration["CertificateConfiguration:DevelopmentCertificatePassword"],
// KeyVaultEndpoint = Configuration["CertificateConfiguration:KeyVaultEndpoint"],
// CertificateNameKeyVault = Configuration["CertificateConfiguration:CertificateNameKeyVault"]
//};
var certificateKey = Environment.GetEnvironmentVariable("CERTIFICATE_KEY");
serverOptions.ConfigureHttpsDefaults(options =>
{
// read cert secret from app configuration with reference to keyvault
var certificateSecret = Configuration[certificateKey];
var secretValue = Convert.FromBase64String(certificateSecret);
var certificate = new X509Certificate2(secretValue);
options.ServerCertificate = certificate;
});
////var port = int.Parse(Environment.GetEnvironmentVariable("ASPNETCORE_HTTPS_PORT"));
//var port = int.Parse(Environment.GetEnvironmentVariable("ASPNETCORE_HTTPS_PORT"));
//serverOptions.Listen(IPAddress.IPv6Any, port, listenOptions =>
//{
// // read cert secret from app configuration with reference to keyvault
// var certificateSecret = Configuration[certificateKey];
// var secretValue = Convert.FromBase64String(certificateSecret);
// var certificate = new X509Certificate2(secretValue);
// listenOptions.UseHttps(certificate);
// //var certs = CertificateService.GetCertificates(config).GetAwaiter().GetResult();
// //listenOptions.UseHttps(certs.ActiveCertificate);
//});
});
}
/// <summary>
/// Configures Kestrel to listen to the port and address specified in the Functions Framework configuration.
/// </summary>
/// <param name="builder">The web host builder to configure.</param>
/// <returns>The original builder, for method chaining.</returns>
public static IWebHostBuilder ConfigureKestrelForFunctionsFramework(this IWebHostBuilder builder) =>
builder.ConfigureKestrel((context, serverOptions) =>
{
var options = FunctionsFrameworkOptions.FromConfiguration(context.Configuration);
serverOptions.Listen(options.GetIPAddress(), options.Port);
});
