public static IApplicationBuilder UseRewriterToForceHttpsRedirect(this IApplicationBuilder app, IConfigurationRoot configuration, RewriteOptions rewriteOptions = null)
{
rewriteOptions = rewriteOptions ?? new RewriteOptions();
var section = configuration.GetSection(nameof(HostingConfiguration));
var config = new HostingConfiguration();
section.Bind(config);
if (config.ForceHttpsRedirect)
{
rewriteOptions.Rules.Insert(0, new RedirectToHttpsRule
{
SSLPort = config.HttpsPort,
StatusCode = 301
});
}
if (rewriteOptions.Rules.Any())
{
app.UseRewriter(rewriteOptions);
}
return(app);
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="hostingConfig">Hosting config</param>
/// <param name="httpContextAccessor">HTTP context accessor</param>
public WebHelper(IHttpContextAccessor httpContextAccessor,
ICustomFileProvider fileProvider,
HostingConfiguration hostingConfig)
{
_httpContextAccessor = httpContextAccessor;
_fileProvider = fileProvider;
_hostingConfig = hostingConfig;
}
public async static Task Main()
{
IHostingConfiguration hostingConfiguration = new HostingConfiguration();
Console.Write("Preparing test server...");
var seedSize = await InitTests(hostingConfiguration).ConfigureAwait(false);
Console.WriteLine($"Done with seed {seedSize}");
(ITestCase TestCase, ITestCaseSource TestSource, ITestCaseSourceItem Item)[] tests = PrepareTestCases(seedSize);
protected override IWebHost CreateHost(HostingConfiguration config, string contentRoot)
{
return(new WebHostBuilder()
.UseKestrel()
.UseUrls(config.BaseUrl)
.UseContentRoot(contentRoot)
.UseIISIntegration()
.UseStartup <Startup>()
.Build());
}
public ValuesController(
ILogger <ValuesController> logger,
IOptions <HostingConfiguration> options,
//IOptionsMonitor<HostingConfiguration> optionsAccessor,
IOptionsSnapshot <HostingConfiguration> snapshotOptionsAccessor)
{
_logger = logger;
_options = options.Value;
//_optionsAccessor = optionsAccessor.CurrentValue;
_snapshotOptions = snapshotOptionsAccessor.Value;
}
public static string GetUrls(this HostingConfiguration config)
{
var urls = GetUrl("http", config.BaseUrl, config.HttpPort.ToString());
if (config.IsSslEnabled)
{
urls += ";";
urls += GetUrl("https", config.BaseUrl, config.HttpsPort.ToString());
}
return(urls);
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args)
{
var hostingConfiguration = new HostingConfiguration();
return(WebHost.CreateDefaultBuilder(args)
.ConfigureLogging(builder =>
{
builder.AddFilter <ApplicationInsightsLoggerProvider>("", LogLevel.Error);
builder.AddFilter <ApplicationInsightsLoggerProvider>("Common.Api.Class.HomeControllerLogCategory",
LogLevel.Information);
builder.AddApplicationInsights("555b5423-78ac-4329-929c-f5f93439f3c7");
})
.UseUrls(hostingConfiguration.GetUrlToUse())
.UseStartup <Startup>());
}
// user arbitrary thread
HostingPeer IEngine.NewHostingPeer(HostingConfiguration config, VcallSubsystem core)
{
var timeout = TimeSpan.FromMilliseconds(_self.vconfig.Timeouts.HostingOpening);
int addressInUseRetries = 0;
for (;;)
{
var hosting = new HostingPeer(config, core);
string uri = make_dynamic_uri(hosting.Tag, config.HostingRole);
try
{
hosting.Start(uri, timeout);
return hosting;
}
catch (Exception ex)
{
if (ex.IsConsequenceOf<AddressAlreadyInUseException>())
{
addressInUseRetries++;
if (addressInUseRetries <= _self.vconfig.AddressInUseRetries)
{
warn("Dynamic URI '{0}' is in use; trying other one (retries={1})", uri, addressInUseRetries);
continue;
}
lock (_self.mutex)
_self.counters.Vcall_Error_AddressInUse++;
throw Helpers.MakeNew<VcallException>(ex, _log,
"hosting.{0}: Failed to listen on '{1}'; probably the TCP port is constantly in use (retries={2})", hosting.Tag, uri, addressInUseRetries);
}
lock (_self.mutex)
_self.counters.Vcall_Error_NewHostingFailed++;
throw;
}
}
}
public ServiceDiscovery(HostingConfiguration config, string contentRoot) : base(config, contentRoot)
{
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="hostingConfig">Hosting config</param>
/// <param name="httpContextAccessor">HTTP context accessor</param>
public WebHelper(HostingConfiguration hostingConfig, IHttpContextAccessor httpContextAccessor)
{
_hostingConfig = hostingConfig;
_httpContextAccessor = httpContextAccessor;
}
public static void AddSharedKestrelOptions(this KestrelServerOptions options, HostingConfiguration config)
{
options.AddServerHeader = false;
if (!config.IsSslEnabled)
{
return;
}
var certificate = CertificateHelper.GetCertificate(config.CertificateFile, config.CertificatePassword, config.CertificateThumbprint);
options.UseHttps(certificate);
}
// user arbitrary thread
IHosting IVcallSubsystem.NewHosting(HostingConfiguration config)
{
if (config == null)
config = new HostingConfiguration();
if (config.ProxyRole == null) config.ProxyRole = _self.vconfig.ProxyRole;
if (config.HostingRole == null) config.HostingRole = _self.vconfig.HostingRole;
if (config.SubscribeToProxy_RetryTimeout == null) config.SubscribeToProxy_RetryTimeout = _self.vconfig.Timeouts.ProxyHostingSubscriptionRetry;
HostingPeer peer;
using (Context.With(_countersDb))
{
peer = _engine.NewHostingPeer(config, this);
}
string callbackUri = peer.ListeningUri;
_self.resolver.Publish(callbackUri, config.HostingRole, peer.Tag);
_self.resolver.Subscribe(peer.HandlePublisher, peer.Tag);
lock (_self.mutex)
{
_self.repo.Add(peer);
_self.counters.Vcall_Event_NewHosting++;
}
trace("hosting.{0} is started", peer.Tag);
var hosting = new Hosting(peer, this, config);
peer.Subscribe(hosting.HandleNewProxy);
return hosting;
}
