protected override void ConfigureBuilder(IWebHostBuilder builder) {
builder.UseKestrel(kestrel => {
kestrel.ThreadCount = 20; // Due to tabs etc..
using (var s = WindowsApiPortHandlerBase.GetApiStream("server.pfx"))
kestrel.UseHttps(new X509Certificate2(s.ToBytes(), "localhost"));
});
builder.UseStartup<AspStartup>();
}
public ServiceFabricWebHostBuilder(string[] args)
{
Console.WriteLine("ServiceFabricWebHostBuilder: Constructor");
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
_builder = new WebHostBuilder()
.UseConfiguration(config);
RunInServiceFabric = string.Equals(_builder.GetSetting("fabric"), "true", StringComparison.OrdinalIgnoreCase);
Console.WriteLine("RunInServiceFabric: " + RunInServiceFabric);
if (RunInServiceFabric)
{
_fabricRuntime = FabricRuntime.Create();
Console.WriteLine("FabricRuntime initialized");
}
}
public AssistantBuilder UseWebHostBuilder(IWebHostBuilder webHostBuilder)
{
this.webHostBuilder = webHostBuilder;
return(this);
}
/// <inheritdoc/>
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseContentRoot(".").UseStartup <TestStartup>();
base.ConfigureWebHost(builder);
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
ConfigureWebHostCalled.Add("ConfigureWebHost");
base.ConfigureWebHost(builder);
}
public static IWebHostBuilder AddSomeMiddleware(this IWebHostBuilder builder)
{
return(builder);
}
/// <summary> /// Setup https for Kestrel. The certificate will try to find from Persional,TrustedPublisher,TrustedPeople,Root and CertificateAuthority by Thumbprint. /// </summary> /// <param name="hostBuilder"></param> /// <param name="port">the port of https</param> /// <param name="thumbprint">certificate thumbprint</param> /// <exception cref="ArgumentNullException">if certificate is not found</exception> /// <returns></returns> public static IWebHostBuilder UseKestrelHttps(this IWebHostBuilder hostBuilder, int port, string thumbprint) => hostBuilder.UseKestrelHttps(port, () => TryGetCertificateFromStore(thumbprint));
public static IWebHostBuilder UseKestrelHttps(this IWebHostBuilder hostBuilder, int port, string certificatePath, string password) => hostBuilder.UseKestrelHttps(port, () => new X509Certificate2(certificatePath, password));
public static IWebHostBuilder UsePort(this IWebHostBuilder builder)
{
var port = Environment.GetEnvironmentVariable("PORT");
return(string.IsNullOrEmpty(port) ? builder : builder.UseUrls($"http://+:{port}"));
}
private void CustomWebHostBuilder(IWebHostBuilder builder)
{
builder.ConfigureTestServices(ServicesConfiguration);
}
public static IWebHostBuilder UseStartup(this IWebHostBuilder builder, IStartup startup) => builder .ConfigureServices(services => services.AddSingleton(startup)) .UseSetting(WebHostDefaults.ApplicationKey, startup.GetType().AssemblyQualifiedName);
/// <summary>
/// Configures iis integration. .net core v2.2 integrates more iis options
/// </summary>
/// <param name="webHostBuilder"></param>
private static void ConfigureIIS(ref IWebHostBuilder webHostBuilder)
{
webHostBuilder.UseIISIntegration();
}
/// <summary>
/// Web 主机注入StartupFilter 和 HostStartup
/// </summary>
/// <param name="webBuilder">Web主机构建器</param>
/// <param name="assemblyName">外部程序集名称</param>
/// <returns>IWebHostBuilder</returns>
public static IWebHostBuilder Inject(this IWebHostBuilder webBuilder, string assemblyName = nameof(Fur))
{
webBuilder.UseSetting(WebHostDefaults.HostingStartupAssembliesKey, assemblyName);
return(webBuilder);
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder
.UseSolutionRelativeContentRoot("src/CleanArchitecture1.Web")
.ConfigureServices(services =>
{
// Remove the app's ApplicationDbContext registration.
var descriptor = services.SingleOrDefault(
d => d.ServiceType ==
typeof(DbContextOptions <AppDbContext>));
if (descriptor != null)
{
services.Remove(descriptor);
}
// Add ApplicationDbContext using an in-memory database for testing.
services.AddDbContext <AppDbContext>(options =>
{
options.UseInMemoryDatabase("InMemoryDbForTesting");
});
//// Create a new service provider.
//var serviceProvider = new ServiceCollection()
// .AddEntityFrameworkInMemoryDatabase()
// .BuildServiceProvider();
//// Add a database context (AppDbContext) using an in-memory
//// database for testing.
//services.AddDbContext<AppDbContext>(options =>
//{
// options.UseInMemoryDatabase("InMemoryDbForTesting");
// options.UseInternalServiceProvider(serviceProvider);
//});
services.AddScoped <IDomainEventDispatcher, NoOpDomainEventDispatcher>();
// Build the service provider.
var sp = services.BuildServiceProvider();
// Create a scope to obtain a reference to the database
// context (AppDbContext).
using (var scope = sp.CreateScope())
{
var scopedServices = scope.ServiceProvider;
var db = scopedServices.GetRequiredService <AppDbContext>();
var logger = scopedServices
.GetRequiredService <ILogger <CustomWebApplicationFactory <TStartup> > >();
// Ensure the database is created.
db.Database.EnsureCreated();
try
{
// Seed the database with test data.
SeedData.PopulateTestData(db);
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred seeding the " +
$"database with test messages. Error: {ex.Message}");
}
}
});
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.UseStartup <TStartup>();
builder.UseEnvironment("Testing");
}
public static IWebHostBuilder UseSeriLogging(this IWebHostBuilder webHostBuilder, string applicationName = null) => webHostBuilder.UseSerilog((context, loggerConfiguration) =>
public static IWebHostBuilder UseAlteredHttps(this IWebHostBuilder builder) => builder
.AlteredConfigure(app => app
.UseHsts()
.UseHttpsRedirection()
);
protected override TestServer CreateServer(IWebHostBuilder builder)
{
var server = base.CreateServer(builder);
return(server);
}
public static IWebHostBuilder UseKestrelHttps(this IWebHostBuilder hostBuilder, int port, X509Certificate2 certificate) => hostBuilder.UseKestrelHttps(port, () => certificate);
void IHostingStartup.Configure(IWebHostBuilder builder)
{
builder.ConfigureServices((serviceCollection) => {
serviceCollection.AddDevExpressBlazor();
});
}
private static void ConfigureWebHostBuilder(IWebHostBuilder builder) =>
builder.UseStartup<TStartup>();
/// <summary>
/// Specify the startup type to be used by the web host.
/// </summary>
/// <param name="hostBuilder">The <see cref="IWebHostBuilder"/> to configure.</param>
/// <typeparam name ="TStartup">The type containing the startup methods for the application.</typeparam>
/// <returns>The <see cref="IWebHostBuilder"/>.</returns>
public static IWebHostBuilder UseStartup <TStartup>(this IWebHostBuilder hostBuilder) where TStartup : class
{
return(hostBuilder.UseStartup(typeof(TStartup)));
}
/// <summary>
/// 注册消息处理实现类
/// </summary>
/// <param name="builder"></param>
/// <returns></returns>
public static IWebHostBuilder RegisterMessageHandler(this IWebHostBuilder builder)
{
string assemblyName = Assembly.GetEntryAssembly().GetName().Name;
return(builder.RegisterMessageHandler(assemblyName));
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
base.ConfigureWebHost(builder);
builder.UseEnvironment("Production");
}
protected override TestServer CreateServer(IWebHostBuilder builder)
{
CreateServerCalled = true;
return(base.CreateServer(builder));
}
/// <summary>
/// The builder has configuration, logging and Amazon API Gateway already configured. The startup class
/// needs to be configured in this method using the UseStartup<>() method.
/// </summary>
/// <param name="builder"></param>
protected override void Init(IWebHostBuilder builder)
{
builder
.UseStartup <Startup>();
}
public void Configure(IWebHostBuilder builder)
{
builder.ConfigureServices((context, services) =>
{
services.AddDbContext <IdentityDbContext>(options =>
{
options.UseSqlServer(context.Configuration.GetConnectionString("IdentityDbContextConnection"));
options.UseOpenIddict();
//options.UseInMemoryDatabase(Guid.NewGuid().ToString())
});
//services.AddDefaultIdentity<AppUser>()
// .AddEntityFrameworkStores<IdentityDbContext>();
services.AddIdentity <AppUser, IdentityRole>()
.AddEntityFrameworkStores <IdentityDbContext>()
.AddDefaultTokenProviders()
.AddDefaultUI();
services.AddAuthentication()
.AddJwtBearer(options => {
var siningKeys = new List <SigningCredentials>();
siningKeys.AddDevelopmentCertificate();
options.TokenValidationParameters.IssuerSigningKey = siningKeys.Select(c => c.Key).First();
options.TokenValidationParameters.RoleClaimType = OpenIddictConstants.Claims.Role;
options.TokenValidationParameters.NameClaimType = OpenIddictConstants.Claims.Name;
options.TokenValidationParameters.ValidAudience = "resource_server";
options.TokenValidationParameters.ValidIssuer = "https://localhost:44370/";
})
.AddFacebook(facebookOptions =>
{
facebookOptions.AppId = context.Configuration["Authentication:Facebook:AppId"];
facebookOptions.AppSecret = context.Configuration["Authentication:Facebook:AppSecret"];
}).AddTwitter(twitterOptions =>
{
twitterOptions.ConsumerKey = context.Configuration["Authentication:Twitter:ConsumerKey"];
twitterOptions.ConsumerSecret = context.Configuration["Authentication:Twitter:ConsumerSecret"];
})
.AddGoogle(googleOptions =>
{
googleOptions.ClientId = context.Configuration["Authentication:Google:ClientId"];
googleOptions.ClientSecret = context.Configuration["Authentication:Google:ClientSecret"];
}).AddMicrosoftAccount(microsoftOptions =>
{
microsoftOptions.ClientId = context.Configuration["Authentication:Microsoft:ApplicationId"];
microsoftOptions.ClientSecret = context.Configuration["Authentication:Microsoft:Password"];
});
services.Configure <IdentityOptions>(options =>
{
options.Password.RequiredLength = 8;
options.Lockout.MaxFailedAccessAttempts = 10;
options.Lockout.AllowedForNewUsers = true;
options.SignIn.RequireConfirmedEmail = true;
options.User.RequireUniqueEmail = true;
});
//services.ConfigureApplicationCookie(options => {
// options.AccessDeniedPath = "/Identity/Account/AccessDenied";
// options.Cookie.HttpOnly = true;
// options.ExpireTimeSpan = TimeSpan.FromMinutes(20);
// options.LoginPath = "/Identity/Account/Login";
// options.LogoutPath = "/Identity/Account/Logout";
//});
services.AddSingleton <IEmailSender, LoggerEmailSender>();
services.AddSingleton <ISmsSender, LoggerSmsSender>();
});
}
public static void Main(string[] args)
{
ProcessEnvironmentVariables();
ProcessCommandArgs(args);
ValidateParameters();
Smoker = new Smoker.Test(Config.FileList, Config.Host);
// run one test iteration
if (!Config.RunLoop && !Config.RunWeb)
{
if (!Smoker.Run().Result)
{
Environment.Exit(-1);
}
return;
}
IWebHost host = null;
// configure web server
if (Config.RunWeb)
{
// use the default web host builder + startup
IWebHostBuilder builder = WebHost.CreateDefaultBuilder(args)
.UseKestrel()
.UseStartup <Startup>()
.UseUrls("http://*:4122/");
// build the host
host = builder.Build();
}
using (CancellationTokenSource ctCancel = new CancellationTokenSource())
{
// setup ctl c handler
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e)
{
e.Cancel = true;
ctCancel.Cancel();
Console.WriteLine("Ctl-C Pressed - Starting shutdown ...");
// give threads a chance to shutdown
Thread.Sleep(500);
// end the app
Environment.Exit(0);
};
// run tests in config.RunLoop
if (Config.RunLoop)
{
TaskRunner tr;
for (int i = 0; i < Config.Threads; i++)
{
tr = new TaskRunner {
TokenSource = ctCancel
};
tr.Task = Smoker.RunLoop(i, App.Config, tr.TokenSource.Token);
TaskRunners.Add(tr);
}
}
// run the web server
if (Config.RunWeb)
{
try
{
Console.WriteLine($"Version: {Helium.Version.AssemblyVersion}");
host.Run();
Console.WriteLine("Web server shutdown");
}
catch (Exception ex)
{
Console.WriteLine($"Web Server Exception\n{ex}");
}
return;
}
// run the task loop
if (Config.RunLoop && TaskRunners.Count > 0)
{
// Wait for all tasks to complete
List <Task> tasks = new List <Task>();
foreach (var trun in TaskRunners)
{
tasks.Add(trun.Task);
}
// wait for ctrl c
Task.WaitAll(tasks.ToArray());
}
}
}
public void Configure(IWebHostBuilder builder)
{
builder.ConfigureServices((context, services) => {
});
}
/// <summary>
/// Configures the port and base path the server should listen on when running behind AspNetCoreModule.
/// The app will also be configured to capture startup errors.
/// </summary>
/// <param name="hostBuilder"></param>
/// <returns></returns>
public static IWebHostBuilder UseIISIntegration(this IWebHostBuilder hostBuilder)
{
if (hostBuilder == null)
{
throw new ArgumentNullException(nameof(hostBuilder));
}
// Check if `UseIISIntegration` was called already
if (hostBuilder.GetSetting(nameof(UseIISIntegration)) != null)
{
return(hostBuilder);
}
var port = hostBuilder.GetSetting(ServerPort) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{ServerPort}");
var path = hostBuilder.GetSetting(ServerPath) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{ServerPath}");
var pairingToken = hostBuilder.GetSetting(PairingToken) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{PairingToken}");
var iisAuth = hostBuilder.GetSetting(IISAuth) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{IISAuth}");
var websocketsSupported = hostBuilder.GetSetting(IISWebSockets) ?? Environment.GetEnvironmentVariable($"ASPNETCORE_{IISWebSockets}");
bool isWebSocketsSupported;
if (!bool.TryParse(websocketsSupported, out isWebSocketsSupported))
{
// If the websocket support variable is not set, we will always fallback to assuming websockets are enabled.
isWebSocketsSupported = (Environment.OSVersion.Version >= new Version(6, 2));
}
if (!string.IsNullOrEmpty(port) && !string.IsNullOrEmpty(path) && !string.IsNullOrEmpty(pairingToken))
{
// Set flag to prevent double service configuration
hostBuilder.UseSetting(nameof(UseIISIntegration), true.ToString());
var enableAuth = false;
if (string.IsNullOrEmpty(iisAuth))
{
// back compat with older ANCM versions
enableAuth = true;
}
else
{
// Lightup a new ANCM variable that tells us if auth is enabled.
foreach (var authType in iisAuth.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
if (!string.Equals(authType, "anonymous", StringComparison.OrdinalIgnoreCase))
{
enableAuth = true;
break;
}
}
}
var address = "http://127.0.0.1:" + port;
hostBuilder.CaptureStartupErrors(true);
hostBuilder.ConfigureServices(services =>
{
// Delay register the url so users don't accidentally overwrite it.
hostBuilder.UseSetting(WebHostDefaults.ServerUrlsKey, address);
hostBuilder.PreferHostingUrls(true);
services.AddSingleton <IServerIntegratedAuth>(_ => new ServerIntegratedAuth()
{
IsEnabled = enableAuth,
AuthenticationScheme = IISDefaults.AuthenticationScheme
});
services.AddSingleton <IStartupFilter>(new IISSetupFilter(pairingToken, new PathString(path), isWebSocketsSupported));
services.Configure <ForwardedHeadersOptions>(options =>
{
options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
});
services.Configure <IISOptions>(options =>
{
options.ForwardWindowsAuthentication = enableAuth;
});
services.AddAuthenticationCore();
});
}
return(hostBuilder);
}
protected abstract void ConfigureBuilder(IWebHostBuilder builder);
public void Configure(IWebHostBuilder builder)
{
builder.ConfigureServices((context, services) =>
{
services.AddDbContext <TroydonFitnessIdentityContext>(options =>
options.UseSqlServer(
context.Configuration.GetConnectionString("TroydonFitnessIdentityContextConnection")));
services.AddIdentity <TroydonFitnessWebsiteUser, IdentityRole>(options =>
{
options.SignIn.RequireConfirmedAccount = true;
options.SignIn.RequireConfirmedEmail = true;
})
// .AddRoles<ApplicationRole>()
.AddEntityFrameworkStores <TroydonFitnessIdentityContext>()
.AddClaimsPrincipalFactory <AdditionalUserClaimsPrincipalFactory>() // trial
//.AddEntityFrameworkStores<ProductContext>() TODO: see if we need to connect to product db to interact with it using
.AddDefaultTokenProviders();
// config email verification
services.AddScoped <IUserClaimsPrincipalFactory <TroydonFitnessWebsiteUser>,
AdditionalUserClaimsPrincipalFactory>();
// add authorization
services.AddAuthorization(config =>
{
// this policy will apply to users that try to make an order without filling up their profile page with enough data
config.AddPolicy("OrderSuppsAndEquip", policyBuilder =>
{
policyBuilder.RequireCustomClaim(JwtClaimTypes.GivenName);
policyBuilder.RequireCustomClaim(JwtClaimTypes.FamilyName);
policyBuilder.RequireCustomClaim(JwtClaimTypes.BirthDate);
policyBuilder.RequireCustomClaim("AddressLine2");
policyBuilder.RequireCustomClaim("City");
policyBuilder.RequireCustomClaim("State");
policyBuilder.RequireCustomClaim("Zip");
policyBuilder.RequireCustomClaim(JwtClaimTypes.EmailVerified);
policyBuilder.RequireCustomClaim(JwtClaimTypes.PhoneNumber);
});
// this policy will apply to users that try to make an order without filling up their profile page with enough data
config.AddPolicy("OrderPT", policyBuilder =>
{
policyBuilder.RequireCustomClaim(JwtClaimTypes.GivenName);
policyBuilder.RequireCustomClaim(JwtClaimTypes.FamilyName);
policyBuilder.RequireCustomClaim(JwtClaimTypes.BirthDate);
policyBuilder.RequireCustomClaim("AddressLine2");
policyBuilder.RequireCustomClaim("City");
policyBuilder.RequireCustomClaim("State");
policyBuilder.RequireCustomClaim("Zip");
policyBuilder.RequireCustomClaim(JwtClaimTypes.EmailVerified);
policyBuilder.RequireCustomClaim(JwtClaimTypes.PhoneNumber);
policyBuilder.RequireCustomClaim("Bodyfat");
policyBuilder.RequireCustomClaim(JwtClaimTypes.Gender);
policyBuilder.RequireCustomClaim("Height");
policyBuilder.RequireCustomClaim("Weight");
policyBuilder.RequireCustomClaim("ActivityType");
});
// TODO: Test if this will allow both admin and master admin access to somefeatures
config.AddPolicy("ElevatedRights", policyBuilder =>
{
policyBuilder.RequireClaim(JwtClaimTypes.Role, "Master Admin", JwtClaimTypes.Role, "Admin");
});
// master admin policy allows admins access to full CRUD functionality
config.AddPolicy("RequireMasterAdministratorRole", policyBuilder =>
{
policyBuilder.RequireClaim(JwtClaimTypes.Role, "Master Admin");
});
});
services.AddScoped <IAuthorizationHandler, CustomRequireClaimHandler>();
services.Configure <IdentityOptions>(options =>
{
// Default SignIn settings.
options.SignIn.RequireConfirmedEmail = false;
options.SignIn.RequireConfirmedPhoneNumber = false;
// Password settings.
options.Password.RequireDigit = false;
options.Password.RequireLowercase = true;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequiredLength = 6;
options.Password.RequiredUniqueChars = 1;
// Lockout settings.
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(60);
options.Lockout.MaxFailedAccessAttempts = 5;
options.Lockout.AllowedForNewUsers = true;
// User settings.
options.User.AllowedUserNameCharacters =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
options.User.RequireUniqueEmail = true;
});
services.ConfigureApplicationCookie(options =>
{
// Cookie settings
options.Cookie.HttpOnly = true;
options.ExpireTimeSpan = TimeSpan.FromDays(5);
options.Cookie.Name = "TroydonFitnessCookies";
options.LoginPath = "/Identity/Account/Login";
options.LogoutPath = $"/Identity/Account/Logout";
options.AccessDeniedPath = "/Identity/Account/AccessDenied";
options.ReturnUrlParameter = CookieAuthenticationDefaults.ReturnUrlParameter;
options.SlidingExpiration = true;
});
services.Configure <PasswordHasherOptions>(option =>
{
option.IterationCount = 12000;
});
services.Configure <DataProtectionTokenProviderOptions>(options =>
options.TokenLifespan = TimeSpan.FromHours(3));
});
}
public virtual IWebHostBuilder ConfigureHost(IWebHostBuilder host, string[] urlBases)
{
return host.UseKestrel()
.UseContentRoot(System.IO.Directory.GetCurrentDirectory())
.UseWebRoot(System.IO.Directory.GetCurrentDirectory())
.UseStartup<Startup>()
.UseUrls(urlBases);
}
public static IWebHostBuilder UseAppMetrics(this IWebHostBuilder webHostBuilder)
{
if (_initialized)
{
return(webHostBuilder);
}
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()
.UseMetricsWebTracking()
.UseMetrics((context, options) =>
{
var metricsOptions = context.Configuration.GetOptions <MetricsOptions>("metrics");
if (!metricsOptions.Enabled)
{
return;
}
if (!metricsOptions.PrometheusEnabled)
{
return;
}
options.EndpointOptions = endpointOptions =>
{
switch (metricsOptions.PrometheusFormatter?.ToLowerInvariant() ?? string.Empty)
{
case "protobuf":
endpointOptions.MetricsEndpointOutputFormatter =
new MetricsPrometheusProtobufOutputFormatter();
break;
default:
endpointOptions.MetricsEndpointOutputFormatter =
new MetricsPrometheusTextOutputFormatter();
break;
}
};
}));
}
