/// <summary>
/// Creates a custom HostBuilder for the DebugProxyLauncher so that we can inject
/// only the needed configurations.
/// </summary>
/// <param name="args">Command line arguments passed in</param>
/// <param name="browserHost">Host where browser is listening for debug connections</param>
/// <returns><see cref="IHostBuilder" /></returns>
public static IHostBuilder CreateDefaultBuilder(string[] args, string browserHost)
{
var builder = new HostBuilder();
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
if (args != null)
{
config.AddCommandLine(args);
}
config.SetBasePath(Directory.GetCurrentDirectory());
config.AddJsonFile("blazor-debugproxysettings.json", optional: true, reloadOnChange: true);
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
logging.AddEventSourceLogger();
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
// By default we bind to a dyamic port
// This can be overridden using an option like "--urls http://localhost:9500"
webBuilder.UseUrls("http://127.0.0.1:0");
})
.ConfigureServices(serviceCollection =>
{
serviceCollection.AddSingleton(new DebugProxyOptions
{
BrowserHost = browserHost
});
});
return(builder);
}
public TestFixture()
{
HostBuilder = new HostBuilder()
.ConfigureWebHost(webHost =>
{
// Add TestServer
webHost.UseTestServer();
webHost.UseStartup <Startup>();
});
HostBuilder.ConfigureAppConfiguration(config =>
{
var integrationConfig = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
config.AddConfiguration(integrationConfig);
});
Host = HostBuilder.StartAsync().Result;
JwtBearerTokenSettings = (IOptions <JwtBearerTokenSettings>)Host.Services.GetService(typeof(IOptions <JwtBearerTokenSettings>));
}
public static async Task Main(string[] args)
{
var builder = new HostBuilder();
builder.ConfigureAppConfiguration((hostingContext, configuration) => {
configuration.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();
});
builder.ConfigureServices((hostingContext, services) => {
services.AddOptions();
services.Configure <FileLoggerConfig>(hostingContext.Configuration.GetSection("FileLoggerConfig"));
services.Configure <RabbitMQConfig>(hostingContext.Configuration.GetSection("RabbitMQ"));
services.Configure <MongoDBConfig>(hostingContext.Configuration.GetSection("MongoDB"));
services.Configure <SqlServerDBConfig>(hostingContext.Configuration.GetSection("SqlServer"));
//services.AddSingleton<ILoggerFactory, FileLoggerFactory>();
services.AddSingleton <IHostedService, MessagesProcessor>();
});
await builder.RunConsoleAsync();
}
private static IHost CreateHost()
{
var builder = new HostBuilder();
builder.ConfigureAppConfiguration((context, builder) =>
{
builder.Sources.Clear();
builder
.SetBasePath(AppContext.BaseDirectory)
.AddJsonFile("appsettings.json", optional: false)
.AddEnvironmentVariables();
});
builder.ConfigureServices((context, builder) =>
{
builder.AddLogging(c => c.AddConsole()).Configure <LoggerFilterOptions>(cfg => cfg.MinLevel = LogLevel.Debug);
builder.AddScoped <Provider>();
builder.Configure <Settings>(context.Configuration.GetSection("Settings"));
});
return(builder.Build());
}
public static IHost Build()
{
var host = new HostBuilder();
host.ConfigureAppConfiguration(c =>
{
c.AddJsonFile("appsettings.json", optional: true);
c.AddEnvironmentVariables();
/*
* c.AddSystemsManager(configureSource =>
* {
* configureSource.Path = "/parameterstoredemo";
* configureSource.Optional = false;
* });
*/
});
host.ConfigureServices((c, s) =>
{
s.Configure <AppConfig>(c.Configuration);
s.AddDefaultAWSOptions(c.Configuration.GetAWSOptions());
s.AddAWSService <IAmazonDynamoDB>();
s.AddTransient <IDynamoDBContext, DynamoDBContext>();
s.AddTransient <IValidator <Create>, CreateValidator>();
s.AddLogging(x =>
{
x.AddConsole();
x.AddAWSProvider();
x.SetMinimumLevel(LogLevel.Information);
});
});
return(host.Build());
}
static async Task Main(string[] args)
{
var builder = new HostBuilder()
.ConfigureAppConfiguration(config =>
config.AddJsonFile("config.json")
.AddEnvironmentVariables())
.ConfigureLogging(log => log.AddConsole())
.ConfigureServices(services =>
{
services.AddSingleton <IHostedService, QueueProcessorService>();
services.AddHttpClient <ImportantBackend>()
.AddTransientHttpErrorPolicy(pb => pb.RetryAsync(5))
.AddTransientHttpErrorPolicy(pb => pb.CircuitBreaker(5, TimeSpan.FromSeconds(5)));
});
var configPath = Environment.GetEnvironmentVariable("ConfigPath");
if (!string.IsNullOrEmpty(configPath))
{
builder.ConfigureAppConfiguration(config => config.AddKeyPerFile(configPath, true));
}
await builder.Build().RunAsync();
}
static void Main(string[] args)
{
var builder = new HostBuilder();
builder.ConfigureAppConfiguration(b =>
{
b.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();
b.Build();
});
builder.ConfigureWebJobs(b =>
{
b.AddAzureStorageCoreServices();
b.AddServiceBus();
b.AddTimers();
});
builder.ConfigureServices((context, services) =>
{
services.AddScoped <IPipeFactory <TranslateTextPipeModel>, TranslateTextPipeFactory>();
services.AddScoped(typeof(IPipeService <>), typeof(QueuePipeService <>));
services.AddScoped <ITranslateTextService, TranslateTextService>();
services.AddHostedService <TranslateTextServiceBusListener>();
});
var host = builder.Build();
using (host)
{
host.Run();
}
}
/// <summary>
/// Application enrty point.
/// </summary>
/// <param name="args">Command line arguments.</param>
private static Int32 Main(String[] args)
{
try {
var assembly = Assembly.GetEntryAssembly() ?? Assembly.GetCallingAssembly();
Log.Warn($"{assembly.VersionString()} (build: {assembly.BuildString()})");
// NOTE: .NET Core 3.x CommandLineConfigurationProvider does not support "parameters with no value"
// See also: https://github.com/aspnet/Configuration/issues/780
var isConsoleMode = (Array.IndexOf(args, "--console") >= 0);
if (isConsoleMode)
{
args = args.Where(a => a != "--console").ToArray();
}
//
// Set-up application Host
//
var builder = new HostBuilder()
.ConfigureHostConfiguration((config) => config
.AddEnvironmentVariables("NETCORE_").AddCommandLine(args));
//
// Configure application components
//
builder
.ConfigureAppConfiguration((_, config) => config
.SetBasePath(AppDomain.CurrentDomain.BaseDirectory))
.ConfigureAppConfiguration((hostContext, config) => config
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true))
.ConfigureLogging((hostContext, logging) => logging
.AddConfiguration(hostContext.Configuration.GetSection("Logging"))
.ClearProviders().AddNLog())
.ConfigureServices((hostContext, services) => services
.AddOptions()
.Configure <HostOptions>(hostContext.Configuration.GetSection("Host")))
.ConfigureDataProviders()
.ConfigureApiHost()
.ConfigureServicesHost()
.ConfigureAppConfiguration((_, config) => config
.AddCommandLine(args));
//
// Configure Service vs Console
//
if (!isConsoleMode)
{
// IMPORTANT: Update working directory when running as a Windows Service
System.IO.Directory.SetCurrentDirectory(System.AppDomain.CurrentDomain.BaseDirectory);
builder
.ConfigureServices((_, services) => services.AddSingleton <IHostLifetime, Service>());
}
else
{
builder
// HACK: Supress startup messages written by HostBuilder directly into Console!
.ConfigureServices((hostContext, services) => services
// TODO: Find where is this SH*T is read from config by default!
// See also: https://github.com/aspnet/Extensions/issues/1103
.Configure <ConsoleLifetimeOptions>(hostContext.Configuration.GetSection("Console")))
.UseConsoleLifetime();
}
//
// Execute
//
builder.Build().Run();
Log.Warn("Done.");
Log.Info(String.Empty);
Log.Info(String.Empty);
Log.Info(String.Empty);
} catch (Exception ex) {
try {
Log.Error(ex, ex.Message);
} catch (Exception) {
//
// NOTE: Keep console output in place in case someone screw logs configuration
//
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine();
Console.Error.WriteLine($"FATAL: {ex.DetailedMessage()}");
Console.Error.WriteLine();
Console.ResetColor();
}
return(-1);
} finally {
NLog.LogManager.Shutdown();
}
return(0);
}
static async Task Main(string[] args)
{
var builder = new HostBuilder();
builder.ConfigureHostConfiguration(configuration =>
{
configuration.SetBasePath(Directory.GetCurrentDirectory());
configuration.AddJsonFile("hostsettings.json", true);
configuration.AddEnvironmentVariables(prefix: "NYBUS_");
configuration.AddCommandLine(args);
});
builder.ConfigureAppConfiguration((context, configuration) =>
{
configuration.AddJsonFile("appsettings.json", true);
configuration.AddJsonFile($"appsettings.{context.HostingEnvironment.EnvironmentName}.json", true);
configuration.AddEnvironmentVariables(prefix: "NYBUS_");
configuration.AddCommandLine(args);
});
builder.ConfigureServices((context, services) =>
{
services.AddHostedService <NybusHostedService>();
services.AddNybus(nybus =>
{
nybus.UseConfiguration(context.Configuration);
nybus.UseRabbitMqBusEngine(rabbitMq =>
{
rabbitMq.UseConfiguration();
rabbitMq.Configure(configuration => configuration.CommandQueueFactory = new StaticQueueFactory("QueueProcessor"));
});
nybus.SubscribeToCommand <TranslateEducationCommand>();
});
services.AddDefaultAWSOptions(context.Configuration.GetAWSOptions("AWS"));
services.AddAWSService <IAmazonTranslate>();
services.AddAWSService <IAmazonS3>();
services.AddHttpClient();
//services.AddTransient(sp => sp.GetRequiredService<IHttpClientFactory>().CreateClient());
services.Configure <TranslateOptions>(context.Configuration.GetSection("Translator"));
//services.AddCommandHandler<SingleTranslateCommandHandler>();
services.AddCommandHandler <ImprovedTranslateCommandHandler>();
services.AddSingleton <IEducationProfileDownloader, HttpClientEducationProfileDownloader>();
services.AddSingleton <ITextExtractor, HtmlTextExtractor>();
services.AddSingleton <ITranslator, AmazonTranslateTranslator>();
services.AddSingleton <ITranslationPersister, AmazonS3TranslationPersister>();
services.AddHttpClient <IEducationProfileDownloader, HttpClientEducationProfileDownloader>();
});
builder.ConfigureLogging((context, logging) =>
{
logging.AddConfiguration(context.Configuration.GetSection("Logging"));
logging.AddAWSProvider(context.Configuration.GetAWSLoggingConfigSection());
logging.AddConsole();
});
var host = builder.Build();
await host.RunAsync();
}
static void Main(string[] args)
{
HostBuilder builder = new HostBuilder();
// Allows us to read the configuration file from current directory
// (remember to copy those files to the OutputDirectory in VS)
builder.UseContentRoot(Directory.GetCurrentDirectory());
builder.ConfigureWebJobs(b =>
{
b.AddAzureStorageCoreServices();
b.AddServiceBus(); // Support service bus triggers and bindings
});
// This step allows the environment variables to be read BEFORE the rest of the configuration
// This is useful in configuring the hosting environment in debug, by setting the
// ENVIRONMENT variable in VS
builder.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables();
});
// Read the configuration from json file
builder.ConfigureAppConfiguration((context, config) =>
{
IHostingEnvironment env = context.HostingEnvironment;
config
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
config.AddEnvironmentVariables();
});
// Configure logging (you can use the config here, via context.Configuration)
builder.ConfigureLogging((context, loggingBuilder) =>
{
loggingBuilder.AddConfiguration(context.Configuration.GetSection("Logging"));
loggingBuilder.AddConsole();
// If this key exists in any config, use it to enable App Insights
var appInsightsKey = context.Configuration["APPINSIGHTS_INSTRUMENTATIONKEY"];
if (!string.IsNullOrEmpty(appInsightsKey))
{
loggingBuilder.AddApplicationInsights(appInsightsKey);
}
});
// Register dependency injected services
builder.ConfigureServices(services =>
{
services.AddTransient <ISimpleService, SimpleService>();
});
builder.UseConsoleLifetime();
IHost host = builder.Build();
using (host)
{
host.Run(); // Start a continuously running WebJob
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HostBuilder"/> class with pre-configured defaults.
/// </summary>
/// <returns></returns>
public static IHostBuilder CreateDefaultBuilder()
{
var builder = new HostBuilder();
builder.UseContentRoot(Directory.GetCurrentDirectory());
builder.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables(prefix: "ASPNETCORE_");
});
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
var env = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
if (env.IsDevelopment() && !string.IsNullOrEmpty(env.ApplicationName))
{
var appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
if (appAssembly != null)
{
config.AddUserSecrets(appAssembly, optional: true);
}
}
config.AddEnvironmentVariables();
})
.ConfigureLogging((context, logging) =>
{
var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
// IMPORTANT: This needs to be added *before* configuration is loaded, this lets
// the defaults be overridden by the configuration.
if (isWindows)
{
// Default the EventLogLoggerProvider to warning or above
logging.AddFilter <EventLogLoggerProvider>(level => level >= LogLevel.Warning);
// Add the EventLogLoggerProvider on windows machines
logging.AddEventLog();
}
})
.UseSerilog((context, logger) =>
{
ConsoleSwitch.MinimumLevel = context.Configuration.GetValue <LogEventLevel>("Serilog:LevelSwitches:$consoleSwitch");
FileSwitch.MinimumLevel = context.Configuration.GetValue <LogEventLevel>("Serilog:LevelSwitches:$fileSwitch");
logger.ReadFrom.Configuration(context.Configuration)
.Enrich.FromLogContext()
.WriteTo.File(
"Logs/log-.log",
levelSwitch: FileSwitch,
rollingInterval: RollingInterval.Day,
outputTemplate: "{Timestamp: HH:mm:ss.fff zzz} {SourceContext} [{Level:u3}] {Message:lj}{NewLine}{Exception}")
.WriteTo.Console(
levelSwitch: ConsoleSwitch,
theme: AnsiConsoleTheme.Code,
outputTemplate: "{Timestamp: HH:mm:ss} [{Level:u3}] {Message:lj}{NewLine}");
})
.UseDefaultServiceProvider((context, options) =>
{
var isDevelopment = context.HostingEnvironment.IsDevelopment();
options.ValidateScopes = isDevelopment;
options.ValidateOnBuild = isDevelopment;
});
return(builder);
}
private static HostBuilder CreateDefaultBuilder(string[] args)
{
// Host.CreateDefaultBuilder() is not available before .netcore 3.0.
// So this is a copied from https://github.com/dotnet/extensions
var builder = new HostBuilder();
builder.UseContentRoot(Directory.GetCurrentDirectory());
builder.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables(prefix: "DOTNET_");
if (args != null)
{
config.AddCommandLine(args);
}
});
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
IHostingEnvironment env = hostingContext.HostingEnvironment;
env.ApplicationName = Assembly.GetEntryAssembly()?.GetName().Name;
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
if (env.IsDevelopment() && !string.IsNullOrEmpty(env.ApplicationName))
{
var appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
if (appAssembly != null)
{
config.AddUserSecrets(appAssembly, optional: true);
}
}
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
});
builder.ConfigureLogging((hostingContext, logging) =>
{
bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
// IMPORTANT: This needs to be added *before* configuration is loaded, this lets
// the defaults be overridden by the configuration.
if (isWindows)
{
// Default the EventLogLoggerProvider to warning or above
logging.AddFilter <EventLogLoggerProvider>(level => level >= LogLevel.Warning);
}
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
logging.AddEventSourceLogger();
if (isWindows)
{
// Add the EventLogLoggerProvider on windows machines
logging.AddEventLog();
}
});
var options = new ServiceProviderOptions();
builder.UseServiceProviderFactory(new DefaultServiceProviderFactory(options));
return(builder);
}
internal static IHostBuilder CreateHostBuilder(string[] args)
{
IHostBuilder hostBuilder = new HostBuilder();
//承载系统自身的配置：
hostBuilder.ConfigureHostConfiguration(hostConfigurationBuilder =>
{
hostConfigurationBuilder.AddJsonFile("commandLineMappings.json", false, false);
Environment.SetEnvironmentVariable(HostDefaults.EnvironmentKey, Environment.GetEnvironmentVariable(Global.EnvironmentKey));
hostConfigurationBuilder.AddEnvironmentVariables();
});
//应用配置:
hostBuilder.ConfigureAppConfiguration((hostBuilderContext, configurationBuilder) =>
{
Global.HostingEnvironment = hostBuilderContext.HostingEnvironment;
//json文件：
configurationBuilder.AddJsonFile("appsettings.json", false, true)
.AddJsonFile($"appsettings.{hostBuilderContext.HostingEnvironment.EnvironmentName}.json", true, true)
.AddJsonFile("exp.json", false, true)
.AddJsonFile("donateCoinCanContinueStatus.json", false, true);
//用户机密：
if (hostBuilderContext.HostingEnvironment.IsDevelopment())
{
//Assembly assembly = Assembly.Load(new AssemblyName(hostBuilderContext.HostingEnvironment.ApplicationName));
Assembly assembly = typeof(Program).Assembly;
if (assembly != null)
{
configurationBuilder.AddUserSecrets(assembly, true);
}
}
//环境变量：
configurationBuilder.AddExcludeEmptyEnvironmentVariables("Ray_");
//命令行：
if (args != null && args.Length > 0)
{
configurationBuilder.AddCommandLine(args, hostBuilderContext.Configuration
.GetSection("CommandLineMappings")
.Get <Dictionary <string, string> >());
}
});
//日志:
hostBuilder.ConfigureLogging((hostBuilderContext, loggingBuilder) =>
{
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(hostBuilderContext.Configuration)
.CreateLogger();
SelfLog.Enable(x => System.Console.WriteLine(x ?? ""));
}).UseSerilog();
//DI容器:
hostBuilder.ConfigureServices((hostContext, services) =>
{
Global.ConfigurationRoot = (IConfigurationRoot)hostContext.Configuration;
//HostedService：
services.AddHostedService <BiliBiliToolHostedService>();
services.AddBiliBiliConfigs(hostContext.Configuration);
services.AddBiliBiliClientApi(hostContext.Configuration);
services.AddDomainServices();
services.AddAppServices();
});
return(hostBuilder);
}
static async Task Main(string[] args)
{
var argsSet = new HashSet <string>(args);
if (argsSet.Contains(HelpOptions[0]) || argsSet.Contains(HelpOptions[1]))
{
ShowHelp();
return;
}
var isService = argsSet.Contains(RunAsServiceOptions[0]) || argsSet.Contains(RunAsServiceOptions[1]);
Directory.SetCurrentDirectory(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
var logger = LogManager.LoadConfiguration("NLog.config").GetCurrentClassLogger();
try
{
var builder = new HostBuilder();
builder.ConfigureAppConfiguration((context, config) =>
{
config.SetBasePath(Directory.GetCurrentDirectory());
config.AddYamlFile("config.yml");
});
builder.ConfigureServices(services =>
{
services.AddSingleton(
new LoggerFactory().AddNLog(new NLogProviderOptions
{
CaptureMessageTemplates = true,
CaptureMessageProperties = true
}));
services.AddSingleton(typeof(ILogger <>), typeof(Logger <>));
services.AddSingleton(typeof(ILogger), c =>
{
var factory = c.GetRequiredService <ILoggerFactory>();
return(factory.CreateLogger("main"));
});
services.AddLogging(b =>
{
b.ClearProviders();
b.SetMinimumLevel(LogLevel.Trace);
});
services.AddSingleton(c =>
{
var config = c.GetService <IConfiguration>();
var emailConfigSection = config.GetChildren().FirstOrDefault(x => x.Key == "EmailConfiguration");
if (emailConfigSection == null)
{
return(null);
}
var emailConfiguration = new EmailConfiguration();
emailConfigSection.Bind(emailConfiguration);
return(emailConfiguration);
});
services.AddSingleton(c =>
{
var config = c.GetService <IConfiguration>();
var monitoringConfiguration = new MonitoringConfiguration();
config.Bind(monitoringConfiguration);
return(monitoringConfiguration);
});
services.AddSingleton <IAlertChannel, EmailAlertChannel>();
services.AddSingleton <IAlertNotifier, AlertNotifier>();
services.AddHostedService <MonitoringService>();
});
if (isService)
{
await builder.RunAsServiceAsync();
}
else
{
await builder.RunConsoleAsync();
}
}
catch (AppMonkeyBusinessException e)
{
logger.Warn($"{AppName} stopped. {e.Message}");
}
catch (Exception e)
{
logger.Error(e, $"Critical error occured in {AppName}");
}
finally
{
LogManager.Shutdown();
}
}
private static HostBuilder BuildHostConfiguration()
{
HostBuilder hostBuilder = new HostBuilder();
hostBuilder.ConfigureAppConfiguration((hostContext, builder) =>
{
builder.AddJsonFile("appsettings.json");
//Add environment specific configuration files.
var environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
if (!string.IsNullOrWhiteSpace(environmentName))
{
builder.AddJsonFile($"appsettings.{environmentName}.json", optional: true);
}
var tempConfig = builder.Build();
string kvServiceUri = tempConfig["KeyVaultSettings:ServiceUri"];
if (!string.IsNullOrWhiteSpace(kvServiceUri))
{
var secretClient = new SecretClient(new Uri(kvServiceUri), new DefaultAzureCredential(
new DefaultAzureCredentialOptions {
ManagedIdentityClientId = tempConfig["ESSManagedIdentity:ClientId"]
}));
builder.AddAzureKeyVault(secretClient, new KeyVaultSecretManager());
}
#if DEBUG
//Add development overrides configuration
builder.AddJsonFile("appsettings.local.overrides.json", true, true);
#endif
//Add environment variables
builder.AddEnvironmentVariables();
Program.ConfigurationBuilder = builder.Build();
})
.ConfigureLogging((hostContext, builder) =>
{
builder.AddConfiguration(ConfigurationBuilder.GetSection("Logging"));
#if DEBUG
builder.AddSerilog(new LoggerConfiguration()
.WriteTo.File("Logs/UKHO.ExchangeSetService.FulfilmentServiceLogs-.txt", rollingInterval: RollingInterval.Day, outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss} [{Level}] [{SourceContext}] {Message}{NewLine}{Exception}")
.MinimumLevel.Information()
.MinimumLevel.Override("UKHO", LogEventLevel.Debug)
.CreateLogger(), dispose: true);
#endif
builder.AddConsole();
//Add Application Insights if needed (if key exists in settings)
string instrumentationKey = ConfigurationBuilder["APPINSIGHTS_INSTRUMENTATIONKEY"];
if (!string.IsNullOrEmpty(instrumentationKey))
{
builder.AddApplicationInsightsWebJobs(o => o.InstrumentationKey = instrumentationKey);
}
EventHubLoggingConfiguration eventhubConfig = ConfigurationBuilder.GetSection("EventHubLoggingConfiguration").Get <EventHubLoggingConfiguration>();
if (!string.IsNullOrWhiteSpace(eventhubConfig.ConnectionString))
{
builder.AddEventHub(config =>
{
config.Environment = eventhubConfig.Environment;
config.DefaultMinimumLogLevel =
(LogLevel)Enum.Parse(typeof(LogLevel), eventhubConfig.MinimumLoggingLevel, true);
config.MinimumLogLevels["UKHO"] =
(LogLevel)Enum.Parse(typeof(LogLevel), eventhubConfig.UkhoMinimumLoggingLevel, true);
config.EventHubConnectionString = eventhubConfig.ConnectionString;
config.EventHubEntityPath = eventhubConfig.EntityPath;
config.System = eventhubConfig.System;
config.Service = eventhubConfig.Service;
config.NodeName = eventhubConfig.NodeName;
config.AdditionalValuesProvider = additionalValues =>
{
additionalValues["_AssemblyVersion"] = AssemblyVersion;
};
});
}
})
.ConfigureServices((hostContext, services) =>
{
var buildServiceProvider = services.BuildServiceProvider();
services.Configure <EssFulfilmentStorageConfiguration>(ConfigurationBuilder.GetSection("EssFulfilmentStorageConfiguration"));
services.Configure <CacheConfiguration>(ConfigurationBuilder.GetSection("CacheConfiguration"));
services.Configure <QueuesOptions>(ConfigurationBuilder.GetSection("QueuesOptions"));
services.Configure <SalesCatalogueConfiguration>(ConfigurationBuilder.GetSection("SalesCatalogue"));
services.AddScoped <IEssFulfilmentStorageConfiguration, EssFulfilmentStorageConfiguration>();
services.AddScoped <ISalesCatalogueStorageService, SalesCatalogueStorageService>();
services.AddScoped <IFulfilmentDataService, FulfilmentDataService>();
services.AddScoped <IMonitorHelper, MonitorHelper>();
services.AddScoped <IAzureBlobStorageService, AzureBlobStorageService>();
services.AddScoped <IAzureBlobStorageClient, AzureBlobStorageClient>();
services.AddScoped <IAzureMessageQueueHelper, AzureMessageQueueHelper>();
services.AddScoped <IAzureTableStorageClient, AzureTableStorageClient>();
services.AddScoped <IFileShareServiceCache, FileShareServiceCache>();
var retryCount = Convert.ToInt32(ConfigurationBuilder["RetryConfiguration:RetryCount"]);
var sleepDuration = Convert.ToDouble(ConfigurationBuilder["RetryConfiguration:SleepDuration"]);
services.AddHttpClient <IFileShareServiceClient, FileShareServiceClient>(client =>
{
client.BaseAddress = new Uri(ConfigurationBuilder["FileShareService:BaseUrl"]);
var productHeaderValue = new ProductInfoHeaderValue(ExchangeSetServiceUserAgent, AssemblyVersion);
client.DefaultRequestHeaders.UserAgent.Add(productHeaderValue);
client.Timeout = TimeSpan.FromMinutes(Convert.ToDouble(ConfigurationBuilder["FileShareService:TimeOutInMins"]));
})
.AddPolicyHandler((services, request) => CommonHelper.GetRetryPolicy(services.GetService <ILogger <IFileShareServiceClient> >(), "File Share", EventIds.RetryHttpClientFSSRequest, retryCount, sleepDuration));
services.AddHttpClient <ISalesCatalogueClient, SalesCatalogueClient>(client =>
{
client.BaseAddress = new Uri(ConfigurationBuilder["SalesCatalogue:BaseUrl"]);
var productHeaderValue = new ProductInfoHeaderValue(ExchangeSetServiceUserAgent, AssemblyVersion);
client.DefaultRequestHeaders.UserAgent.Add(productHeaderValue);
})
.AddPolicyHandler((services, request) => CommonHelper.GetRetryPolicy(services.GetService <ILogger <ISalesCatalogueClient> >(), "Sales Catalogue", EventIds.RetryHttpClientSCSRequest, retryCount, sleepDuration));
services.AddHttpClient <ICallBackClient, CallBackClient>();
services.AddSingleton <IAuthFssTokenProvider, AuthFssTokenProvider>();
services.AddSingleton <IAuthScsTokenProvider, AuthScsTokenProvider>();
services.AddScoped <IFileShareService, FileShareService>();
services.AddScoped <IFulfilmentFileShareService, FulfilmentFileShareService>();
services.AddScoped <IFulfilmentAncillaryFiles, FulfilmentAncillaryFiles>();
services.AddScoped <IFileSystemHelper, FileSystemHelper>();
services.AddScoped <ISalesCatalogueService, SalesCatalogueService>();
services.AddScoped <IFulfilmentSalesCatalogueService, FulfilmentSalesCatalogueService>();
services.AddSingleton <ISmallExchangeSetInstance, SmallExchangeSetInstance>();
services.AddSingleton <IMediumExchangeSetInstance, MediumExchangeSetInstance>();
services.AddSingleton <ILargeExchangeSetInstance, LargeExchangeSetInstance>();
services.AddScoped <IFulfilmentCallBackService, FulfilmentCallBackService>();
services.Configure <FileShareServiceConfiguration>(ConfigurationBuilder.GetSection("FileShareService"));
services.Configure <EssManagedIdentityConfiguration>(ConfigurationBuilder.GetSection("ESSManagedIdentity"));
services.Configure <EssCallBackConfiguration>(ConfigurationBuilder.GetSection("ESSCallBackConfiguration"));
services.AddDistributedMemoryCache();
// Add App Insights Telemetry Filter
var telemetryConfiguration = buildServiceProvider.GetRequiredService <TelemetryConfiguration>();
var telemetryProcessorChainBuilder = telemetryConfiguration.TelemetryProcessorChainBuilder;
telemetryProcessorChainBuilder.Use(next => new AzureDependencyFilterTelemetryProcessor(next));
telemetryProcessorChainBuilder.Build();
})
.ConfigureWebJobs(b =>
{
b.AddAzureStorageCoreServices();
b.AddAzureStorage();
});
return(hostBuilder);
}
private static Task Main(string[] args)
{
var host = new HostBuilder();
host.ConfigureAppConfiguration(configureDelegate: (ctx, config) =>
{
config.AddJsonFile(path: "settings.json");
config.AddEnvironmentVariables();
config.AddCommandLine(args: args);
});
host.ConfigureLogging(configureLogging: (_, logging) =>
{
logging.AddConsole(configure: options => { options.TimestampFormat = "O"; });
});
host.UseConsoleLifetime();
host.ConfigureServices(configureDelegate: (ctx, services) =>
{
services.Configure <MongodbSettings>(config: ctx.Configuration.GetSection(key: "mongodb"));
services.AddSingleton <IMongodbSettings>(implementationFactory: sp =>
sp.GetRequiredService <IOptions <MongodbSettings> >().Value);
services.Configure <RabbitmqSettings>(config: ctx.Configuration.GetSection(key: "rabbitmq"));
services.AddSingleton <IRabbitmqSettings>(implementationFactory: sp =>
sp.GetRequiredService <IOptions <RabbitmqSettings> >().Value);
services.AddSingleton <ISagaRepository <OrderState> >(implementationFactory: sp =>
{
var mongodb = sp.GetRequiredService <IMongodbSettings>();
return(new MongoDbSagaRepository <OrderState>(
connectionString: mongodb.ConnectionString,
database: mongodb.DatabaseName,
collectionName: "order-sagas"
));
});
services.AddSingleton(implementationFactory: sp =>
{
var repository = sp.GetRequiredService <ISagaRepository <OrderState> >();
return(Bus.Factory.CreateUsingRabbitMq(configure: cfg =>
{
var rabbitmq = sp.GetRequiredService <IRabbitmqSettings>();
cfg.Host(
hostAddress: new Uri(uriString: rabbitmq.Uri),
configure: hc =>
{
hc.Username(username: rabbitmq.UserName);
hc.Password(password: rabbitmq.UserPassword);
}
);
cfg.ReceiveEndpoint(
queueName: "order",
configureEndpoint: e =>
e.StateMachineSaga(stateMachine: new OrderStateMachine(), repository: repository)
);
}));
}
);
services.AddHostedService <MassTransitService>();
});
EndpointConvention.Map <LogOrder>(
destinationAddress: new Uri(uriString: "exchange:contracts:LogOrder"));
return(host.RunConsoleAsync());
}
/// <summary>
/// See appsettings.json for where to configure various settings required by this console app
/// (user-secrets in dev, Azure app service Connection Strings and Application Settings in production)
/// </summary>
static async Task Main(string[] args)
{
var builder = new HostBuilder();
IConfiguration configuration = null;
builder.ConfigureHostConfiguration(configHost =>
{
configHost.SetBasePath(Directory.GetCurrentDirectory());
configHost.AddJsonFile("hostsettings.json", optional: true);
//Need to manually read ASPNETCORE_ENVIRONMENT or else it'll default to Production
//See: https://github.com/aspnet/AspNetCore/issues/4150
configHost.AddInMemoryCollection(new[] { new KeyValuePair <string, string>(
HostDefaults.EnvironmentKey, System.Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")) });
configHost.AddEnvironmentVariables();
});
builder.ConfigureAppConfiguration((hostContext, configApp) =>
{
configApp.SetBasePath(Directory.GetCurrentDirectory());
configApp.AddJsonFile("appsettings.json", optional: true);
configApp.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", optional: true);
configApp.AddEnvironmentVariables();
if (hostContext.HostingEnvironment.EnvironmentName.ToLower() == "development")
{
configApp.AddUserSecrets <Program>();
}
configuration = configApp.Build();
});
builder.ConfigureWebJobs(b =>
{
b.AddAzureStorageCoreServices();
b.AddAzureStorage();
});
builder.ConfigureLogging((context, b) =>
{
b.AddConsole();
});
builder.ConfigureServices((context, serviceCollection) =>
{
//Need to do this or later when IConfiguration is injected, it'll be missing our user secrets configured for dev above
serviceCollection.AddSingleton <IConfiguration>(configuration);
serviceCollection.AddDbContext <NewAlbumsDbContext>(options =>
options.UseSqlServer(configuration.GetConnectionString("Default")));
serviceCollection.GenericServicesSimpleSetup <NewAlbumsDbContext>(
new GenericServicesConfig
{
NoErrorOnReadSingleNull = true
},
Assembly.GetAssembly(typeof(BaseAppService))
);
serviceCollection.AddAutoMapper(typeof(IArtistAppService));
//NewsAlbums.Application services
serviceCollection.AddTransient <ISpotifyAppService, SpotifyAppService>();
serviceCollection.AddTransient <IArtistAppService, ArtistAppService>();
serviceCollection.AddTransient <IAlbumAppService, AlbumAppService>();
serviceCollection.AddTransient <ISubscriberAppService, SubscriberAppService>();
serviceCollection.AddTransient <ISubscriptionAppService, SubscriptionAppService>();
//NewAlbums.Core managers
serviceCollection.AddTransient <EmailManager>();
serviceCollection.AddTransient <TemplateManager>();
serviceCollection.AddTransient <IPathProvider, PathProvider>();
var serviceProvider = serviceCollection.BuildServiceProvider();
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
string configFileName = "log4net.config";
if (context.HostingEnvironment.EnvironmentName.ToLower() != "development")
{
configFileName = "log4net.azure.config";
}
//Set the retrieved loggerFactory (which is used by ASP.NET logging messages) as the singleton instance to use everywhere
NewAlbumsLogging.ConfigureLogger(loggerFactory, configFileName);
});
//Set the App_Data directory so we can retrieve it later. https://stackoverflow.com/a/48357218
//string currentDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
AppDomain.CurrentDomain.SetData("DataDirectory", Path.Combine(Directory.GetCurrentDirectory(), "App_Data"));
var host = builder.Build();
using (host)
{
await host.StartAsync();
var jobHost = host.Services.GetService(typeof(IJobHost)) as JobHost;
await jobHost.CallAsync(typeof(Functions).GetMethod("ProcessNewSpotifyAlbums"));
await host.StopAsync();
}
}
// Remove overloaded CreateDefaultBuilder method because it's not used
/// <summary>
/// Initializes a new instance of the <see cref="HostBuilder"/> class with pre-configured defaults.
/// </summary>
/// <remarks>
/// The following defaults are applied to the returned <see cref="HostBuilder"/>:
/// <list type="bullet">
/// <item><description>set the <see cref="IHostEnvironment.ContentRootPath"/> to the result of <see cref="Directory.GetCurrentDirectory()"/></description></item>
/// <item><description>load host <see cref="IConfiguration"/> from "DOTNET_" prefixed environment variables</description></item>
/// <item><description>load host <see cref="IConfiguration"/> from supplied command line args</description></item>
/// <item><description>load app <see cref="IConfiguration"/> from 'appsettings.json' and 'appsettings.[<see cref="IHostEnvironment.EnvironmentName"/>].json'</description></item>
/// <item><description>load app <see cref="IConfiguration"/> from User Secrets when <see cref="IHostEnvironment.EnvironmentName"/> is 'Development' using the entry assembly</description></item>
/// <item><description>load app <see cref="IConfiguration"/> from environment variables</description></item>
/// <item><description>load app <see cref="IConfiguration"/> from supplied command line args</description></item>
/// <item><description>configure the <see cref="ILoggerFactory"/> to log to the console, debug, and event source output</description></item>
/// </list>
/// </remarks>
/// <param name="args">The command line args.</param>
/// <returns>The initialized <see cref="IHostBuilder"/>.</returns>
public static IHostBuilder CreateDefaultBuilder(string[] args)
{
var builder = new HostBuilder();
builder.UseContentRoot(Directory.GetCurrentDirectory());
builder.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables(prefix: "DOTNET_");
if (args != null)
{
config.AddCommandLine(args);
}
});
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
var env = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
if (env.IsDevelopment() && !string.IsNullOrEmpty(env.ApplicationName))
{
var appAssembly = Assembly.Load(new AssemblyName(env.ApplicationName));
if (appAssembly != null)
{
config.AddUserSecrets(appAssembly, optional: true);
}
}
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
})
.ConfigureLogging((hostingContext, logging) =>
{
var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
// IMPORTANT: This needs to be added *before* configuration is loaded, this lets
// the defaults be overridden by the configuration.
if (isWindows)
{
// Default the EventLogLoggerProvider to warning or above
logging.AddFilter <EventLogLoggerProvider>(level => level >= LogLevel.Warning);
}
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
logging.AddEventSourceLogger();
if (isWindows)
{
// Add the EventLogLoggerProvider on windows machines
logging.AddEventLog();
}
});
// Remove UseDefaultServiceProvider because method isn't available in .NET Core 2.2
return(builder);
}
static void Main(string[] args)
{
var host = new HostBuilder();
// 環境パスのDOTNETCORE_ENVIRONMENTを取得
var environment = Environment.GetEnvironmentVariable("DOTNETCORE_ENVIRONMENT") ?? "Development";
// 環境の設定
host.UseEnvironment(environment);
// ホストの構成
host.ConfigureHostConfiguration(config =>
{
// Microsoft.Extensions.Configuration
config.SetBasePath(Directory.GetCurrentDirectory());
// Microsoft.Extensions.Configuration.EnvironmentVariables
// 環境変数の先頭文字列"EnvironmentSettingModel_"の変数を取り込む.
// 取り込んだ環境変数の名前は"EnvironmentSettingModel_"の部分がトリミングされる
config.AddEnvironmentVariables(prefix: "EnvironmentSettingModel_");
// Microsoft.Extensions.Configuration.JSON
config.AddJsonFile($"Settings/setting.json");
// 環境変数DOTNETCORE_ENVIRONMENTの設定値を使用する。
config.AddJsonFile($"Settings/setting.{environment}.json");
config.AddJsonFile($"Settings/loggingSetting.json");
// Microsoft.Extensions.Configuration.Ini
config.AddIniFile("Settings/setting.ini");
// Microsoft.Extensions.Configuration.XML
config.AddXmlFile("Settings/setting.xml");
// Microsoft.Extensions.Configuration.Memory
config.AddInMemoryCollection(new Dictionary <string, string>()
{
{ "InMemoryMessage", "Hello InMemoryCollection!" }
});
// Microsoft.Extensions.Configuration.CommandLine
config.AddCommandLine(args);
});
// アプリケーションの構成
host.ConfigureAppConfiguration((hostContext, config) =>
{
var env = hostContext.HostingEnvironment;
if (env.IsDevelopment())
{
// Microsoft.Extensions.Configuration.UserSecrets
config.AddUserSecrets <Program>();
}
});
// サービスの構成
host.ConfigureServices((hostContext, config) =>
{
// Microsoft.Extensions.Configuration
config.Configure <IniSettingModel>(hostContext.Configuration.GetSection("IniSettingModel"));
config.Configure <JsonSettingModel>(hostContext.Configuration.GetSection("JsonSettingModel"));
config.Configure <XmlSettingModel>(hostContext.Configuration.GetSection("XmlSettingModel"));
config.Configure <UserSecretSettingModel>(hostContext.Configuration.GetSection("UserSecretSettingModel"));
config.Configure <CommandLineSettingModel>(hostContext.Configuration.GetSection("CommandLineSettingModel"));
// こういった方法でも使用可能
var message = hostContext.Configuration.GetValue <String>("UserSecretSettingModel:Message");
var messageModel1 = hostContext.Configuration.GetSection("UserSecretSettingModel").Get <BaseSettingModel>();
var messageModel2 = hostContext.Configuration.GetValue <UserSecretSettingModel>("UserSecretSettingModel");
var messageModel3 = new BaseSettingModel();
hostContext.Configuration.GetSection("UserSecretSettingModel").Bind(messageModel3);
// ConnectionStringだけは別途関数がある
// var connectionString = hostContext.Configuration.GetConnectionString ("DefaultConnection");
// Microsoft.Extensions.DependencyInjection
config.AddHostedService <SampleService>();
// BackgroundServiceの場合
// config.AddHostedService<SampleBackgroundService> ();
// その他サービスのDI
config.AddTransient <IHoge, LoudHoge>();
});
// ロギングの構成
host.ConfigureLogging((hostContext, config) =>
{
// config系の設定を初期化
config.ClearProviders();
// appsettings.jsonに記載した設定を反映
config.AddConfiguration(hostContext.Configuration.GetSection("Logging"));
// 今回は上記ファイルで指定してるのでコメントアウト.
// 出力するLogの最低レベルを指定
// config.SetMinimumLevel (LogLevel.Trace);
// Microsofot系のLogはInformation以下のレベルは出力しない
// config.AddFilter ("Microsoft", LogLevel.Information);
// Microsoft.Extensions.Logging.Console
config.AddConsole();
// Microsoft.Extensions.Logging.Debug
config.AddDebug();
// Microsoft.Extensions.Logging.EventLog
config.AddEventLog();
// Microsoft.Extensions.Logging.EventSource
// これはEvent Tracing for Windows (ETW)によるLoggin.
config.AddEventSourceLogger();
//Microsoft.Extensions.Logging.TraceSource
Trace.AutoFlush = true;
var sourceSwitch = new SourceSwitch("sample")
{
Level = SourceLevels.All
};
var listener = new TextWriterTraceListener("Trace.log");
config.AddTraceSource(sourceSwitch, listener);
});
host.UseConsoleLifetime();
// 起動方法
// host.RunConsoleAsync();
// host.Start();
host.Build().Run();
// host.Build().Start();
// host.Build().StartAsync();
}
public ConsoleHost(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
.MinimumLevel.Override("System", LogEventLevel.Warning)
.MinimumLevel.Override("CoinbasePro", LogEventLevel.Information)
.MinimumLevel.Override("Microsoft.Azure.KeyVault", LogEventLevel.Verbose)
.MinimumLevel.Override("CoinbasePro.Application.RabbitMq", LogEventLevel.Verbose)
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var builder = new HostBuilder().UseConsoleLifetime();
builder.ConfigureHostConfiguration(config => {
config.AddEnvironmentVariables(); // pulls environment name from Properties/launchSettings.json
});
builder.ConfigureLogging((hostingContext, config) => {
config.AddSerilog();
});
builder.ConfigureAppConfiguration((hostContext, configurationBuilder) =>
{
var env = hostContext.HostingEnvironment;
configurationBuilder.SetBasePath(env.ContentRootPath);
// These files are copied to bin in the build, so needs rebuild to push changes into app
configurationBuilder.AddJsonFile("appsettings.json", optional: false, true);
configurationBuilder.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
configurationBuilder.AddEnvironmentVariables();
if (args != null)
{
configurationBuilder.AddCommandLine(args);
}
var builtConfig = configurationBuilder.Build();
Register.AddAzureKeyVault(builtConfig, configurationBuilder);
});
builder.ConfigureServices((hostContext, services) =>
{
// --------------------------------------------
// Coinbase Pro log-on credentials, usually these should be saved in the Azure Key vault so they're never exposed
// without Azure, comment out the azureServiceTokenProvider part above and use the app config file directly
services.AddSingleton <IAuthenticator>(new Authenticator(hostContext.Configuration["apiKey"]
, hostContext.Configuration["apiSecret"]
, hostContext.Configuration["passPhrase"]));
// Customise the HttpClient to ensure we don't ever get HTTP 429 rate limit errors
services.AddSingleton <IHttpClient>(new RateLimitedHttpClient(3, 2.1));
services.AddSingleton <ICoinbaseProClient, CoinbaseProClient>();
// --------------------------------------------
// The IStartupWorkflow controls the startup order of services in order
// the ensure inter dependencies receive events or data correctly
// As all the services are not yet in Github ensure CandleMonitor can still start
// so use StartupWorkflow.ForCandleMonitorOnly()
services.AddSingleton(sp => StartupWorkflow.ForCandleMonitorOnly());
// Usually SQL Server would be used (sql scripts not in Github yet)
//services.AddSingleton<ICandleProvider, SqlServerCandleProvider>();
//services.AddTransient<ICandleMonitorFeedProvider, SqlServerCandleMonitorFeed>();
// Instead use the CSV route for ease of demonstration
services.AddSingleton <ICandleProvider, CsvCandleProvider>();
// Setup the markets to pull data for
services.AddTransient <ICandleMonitorFeedProvider>(sp => new CsvCandleMonitorFeed(new List <CandleMonitorFeeds>()
{
new CandleMonitorFeeds(ProductType.BtcUsd, CandleGranularity.Hour1),
new CandleMonitorFeeds(ProductType.EthUsd, CandleGranularity.Hour1),
new CandleMonitorFeeds(ProductType.EthEur, CandleGranularity.Minutes15),
new CandleMonitorFeeds(ProductType.DaiUsdc, CandleGranularity.Hour1)
})
);
// Use the event driven candle production / consumption
services.AddSingleton <CandleProducerConsumer>();
services.AddSingleton <ICandleProducer>(x => x.GetRequiredService <CandleProducerConsumer>());
services.AddSingleton <ICandleConsumer>(x => x.GetRequiredService <CandleProducerConsumer>());
// Add the hosted services
services.AddSingleton <ICandleMonitor, CandleMonitor>();
services.AddHostedService <HostedService <ICandleMonitor> >();
//// Finish up and add database
// services.AddDbContext<CryptoDbX>(options =>
// {
// options.UseSqlServer(hostContext.Configuration.GetConnectionString("MyDbConnection"),
// // retry https://blogs.msdn.microsoft.com/cesardelatorre/2017/03/26/using-resilient-entity-framework-core-sql-connections-and-transactions-retries-with-exponential-backoff/
// sqlServerOptionsAction: sqlOptions =>
// {
// sqlOptions.EnableRetryOnFailure(
// maxRetryCount: 5,
// maxRetryDelay: TimeSpan.FromSeconds(30),
// errorNumbersToAdd: null);
// });
// options.EnableSensitiveDataLogging(Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") != "Production");
// });
services.Configure <AppSetting>(hostContext.Configuration);
// All calls to services.Configure *MUST* have come before this
ServiceProvider = services.BuildServiceProvider();
});
_host = builder.Build();
//// Automatically perform database migration
//serviceProvider.GetService<CryptoXContext>().Database.Migrate();
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
RegistryKey key = Registry.LocalMachine.OpenSubKey(Constants.BaseKey, false);
if (!(key?.GetValue("Configured", 0) is int value) || value == 0)
{
return(Host.CreateDefaultBuilder().ConfigureServices((hostContext, services) =>
{
services.AddHostedService <UnconfiguredHost>();
})
.UseWindowsService()
.ConfigureAccessManagerLogging());
}
var host = new HostBuilder();
host.UseContentRoot(Directory.GetCurrentDirectory());
string basePath = key?.GetValue("BasePath") as string;
host.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables(prefix: "DOTNET_");
if (args != null)
{
config.AddCommandLine(args);
}
});
host.UseNLog();
host.ConfigureAppConfiguration((hostingContext, config) =>
{
config.ConfigureAppSettings();
if (args != null)
{
config.AddCommandLine(args);
}
});
host.ConfigureAccessManagerLogging();
host.UseDefaultServiceProvider((context, options) =>
{
var isDevelopment = context.HostingEnvironment.IsDevelopment();
options.ValidateScopes = isDevelopment;
options.ValidateOnBuild = isDevelopment;
});
host.ConfigureWebHostDefaults(webBuilder =>
{
var httpsysConfig = new ConfigurationBuilder().ConfigureAppSettings().Build();
webBuilder.UseHttpSys(httpsysConfig);
webBuilder.UseStartup <Startup>();
});
host.UseWindowsService();
return(host);
}
static void Main(string[] args)
{
var host = new HostBuilder();
// 環境パスのDOTNETCORE_ENVIRONMENTを取得
var environment = Environment.GetEnvironmentVariable("DOTNETCORE_ENVIRONMENT") ?? "Development";
// 環境の設定
host.UseEnvironment(environment);
// ホストの構成
host.ConfigureHostConfiguration(config =>
{
// Microsoft.Extensions.Configuration
config.SetBasePath(Directory.GetCurrentDirectory());
// Microsoft.Extensions.Configuration.EnvironmentVariables
// 環境変数の先頭文字列"EnvironmentSettingModel_"の変数を取り込む.
// 取り込んだ環境変数の名前は"EnvironmentSettingModel_"の部分がトリミングされる
config.AddEnvironmentVariables(prefix: "EnvironmentSettingModel_");
// Microsoft.Extensions.Configuration.JSON
// 環境変数DOTNETCORE_ENVIRONMENTの設定値を使用する。
config.AddJsonFile($"Settings/setting.json");
// 同じ定義は後に読み込んだ方で上書きされる
config.AddJsonFile($"Settings/setting.{environment}.json");
// Microsoft.Extensions.Configuration.Ini
config.AddIniFile("Settings/setting.ini");
// Microsoft.Extensions.Configuration.XML
config.AddXmlFile("Settings/setting.xml");
// Microsoft.Extensions.Configuration.Memory
config.AddInMemoryCollection(new Dictionary <string, string>()
{
{ "InMemoryMessage", "Hello InMemoryCollection!" }
});
// Microsoft.Extensions.Configuration.CommandLine
config.AddCommandLine(args);
});
// アプリケーションの構成
host.ConfigureAppConfiguration((hostContext, config) =>
{
var env = hostContext.HostingEnvironment;
if (env.IsDevelopment())
{
// Microsoft.Extensions.Configuration.UserSecrets
config.AddUserSecrets <Program>();
}
});
// サービスの構成
host.ConfigureServices((hostContext, config) =>
{
// Microsoft.Extensions.DependencyInjection
config.AddHostedService <SampleService>();
// Microsoft.Extensions.Options.ConfigurationExtensions
config.Configure <IniSettingModel>(hostContext.Configuration.GetSection("IniSettingModel"));
config.Configure <JsonSettingModel>(hostContext.Configuration.GetSection("JsonSettingModel"));
config.Configure <XmlSettingModel>(hostContext.Configuration.GetSection("XmlSettingModel"));
config.Configure <UserSecretModel>(hostContext.Configuration.GetSection("UserSecretSettingModel"));
config.Configure <CommandLineSettingModel>(hostContext.Configuration.GetSection("CommandLineSettingModel"));
// こういった方法でも使用可能
var message = hostContext.Configuration.GetValue <String>("UserSecretSettingModel:Message");
var messageModel1 = hostContext.Configuration.GetSection("UserSecretSettingModel").Get <BaseSettingModel>();
var messageModel2 = hostContext.Configuration.GetValue <UserSecretModel>("UserSecretSettingModel");
var messageModel3 = new BaseSettingModel();
hostContext.Configuration.GetSection("UserSecretSettingModel").Bind(messageModel3);
});
host.UseConsoleLifetime().Build().Run();
}
public static IHost BuildHost(
DatabaseType databaseType,
RelationLocatorStrategy strategy,
IEnumerable <string> configJsonFilenames,
Action <ContainerBuilder> builderAction = null,
Action <IClaptrapBootstrapperBuilder> bootstrapperAction = null,
Action <HostBuilder> configureHostBuilder = null)
{
var hostBuilder = new HostBuilder();
hostBuilder
.ConfigureAppConfiguration(configurationBuilder =>
{
configurationBuilder
.AddJsonFile("configs/appsettings.json")
.AddJsonFile($"configs/db_configs/claptrap.{databaseType:G}.json".ToLower())
.AddJsonFile($"configs/db_configs/claptrap.{databaseType:G}.{strategy:G}.json".ToLower());
foreach (var filename in configJsonFilenames)
{
configurationBuilder.AddJsonFile(filename);
}
configurationBuilder.AddEnvironmentVariables();
})
.ConfigureServices(collection =>
{
collection.AddLogging(logging =>
{
logging.ClearProviders();
logging.SetMinimumLevel(LogLevel.Trace);
logging.AddNLog();
});
})
.UseServiceProviderFactory(context =>
{
return(new AutofacServiceProviderFactory(builder =>
{
var loggerFactory = new ServiceCollection()
.AddLogging(logging =>
{
logging.SetMinimumLevel(LogLevel.Trace);
logging.AddConsole();
})
.BuildServiceProvider()
.GetRequiredService <ILoggerFactory>();
var claptrapBootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder(loggerFactory)
.ScanClaptrapModule()
.AddConfiguration(context.Configuration)
.ScanClaptrapDesigns(new[]
{
typeof(IAccount),
typeof(Account),
typeof(IAccountBalanceMinion),
typeof(AccountBalanceMinion),
typeof(IAccountHistoryBalanceMinion),
typeof(AccountHistoryBalanceMinion)
})
.ConfigureClaptrapDesign(x =>
x.ClaptrapOptions.EventCenterOptions.EventCenterType = EventCenterType.None);
bootstrapperAction?.Invoke(claptrapBootstrapperBuilder);
var claptrapBootstrapper =
(AutofacClaptrapBootstrapper)claptrapBootstrapperBuilder
.Build();
claptrapBootstrapper.Boot(builder);
builder.RegisterType <Account>()
.AsSelf()
.InstancePerDependency();
builder.RegisterType <AccountBalanceMinion>()
.AsSelf()
.InstancePerDependency();
builderAction?.Invoke(builder);
}));
})
.ConfigureServices((_, collection) => { collection.AddClaptrapServerOptions(); });
configureHostBuilder?.Invoke(hostBuilder);
var host = hostBuilder.Build();
return(host);
}
public static void ConfigureBuilder(HostBuilder builder, string[] args = null,
Action <SpiderOptions> configureDelegate = null)
{
builder.UseContentRoot(Directory.GetCurrentDirectory());
builder.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables("DOTNET_");
if (args == null)
{
return;
}
config.AddCommandLine(args);
});
builder.ConfigureAppConfiguration(
(hostingContext, config) =>
{
var hostingEnvironment = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json", true, true)
.AddJsonFile("appsettings." + hostingEnvironment.EnvironmentName + ".json", true, true);
if (hostingEnvironment.IsDevelopment() && !string.IsNullOrEmpty(hostingEnvironment.ApplicationName))
{
var assembly = Assembly.Load(new AssemblyName(hostingEnvironment.ApplicationName));
config.AddUserSecrets(assembly, true);
}
config.AddEnvironmentVariables();
var list = new List <string> {
"--DOTNET_SPIDER_MODEL", "LOCAL"
};
if (args != null)
{
list.AddRange(args);
}
config.AddCommandLine(list.ToArray());
}).ConfigureLogging((hostingContext, logging) =>
{
var num = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? 1 : 0;
if (num != 0)
{
logging.AddFilter <EventLogLoggerProvider>(
level => level >= LogLevel.Warning);
}
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
logging.AddEventSourceLogger();
if (num == 0)
{
return;
}
logging.AddEventLog();
}).ConfigureServices((context, services) =>
{
var configuration = context.Configuration;
if (configuration != null)
{
services.Configure <SpiderOptions>(configuration);
}
if (configureDelegate != null)
{
services.Configure(configureDelegate);
}
services.AddHttpClient();
services.AddHostedService <PrintArgumentService>();
services.AddAgent <HttpClientDownloader>();
services.TryAddSingleton <IStatisticsClient, StatisticsClient>();
services.TryAddSingleton <DependenceServices>();
services.TryAddSingleton <IRequestHasher, RequestHasher>();
services.TryAddSingleton <IHashAlgorithmService, MurmurHashAlgorithmService>();
}).UseDefaultServiceProvider((context, options) =>
{
var flag = context.HostingEnvironment.IsDevelopment();
options.ValidateScopes = flag;
options.ValidateOnBuild = flag;
});
}
public static async Task Main(string[] args)
{
var builder = new HostBuilder();
// allows us to read the configuration file from current directory
// (remember to copy those files to the OutputDirectory in VS)
builder.UseContentRoot(Directory.GetCurrentDirectory());
// configure things like batch size, service bus, etc..
builder.ConfigureWebJobs(b =>
{
b
.AddAzureStorageCoreServices()
.AddAzureStorage(options =>
{
options.BatchSize = 1;
options.MaxDequeueCount = 1;
})
;
});
// this step allows the env variable to be read BEFORE the rest of the configuration
// => this is useful to configure the hosting environment in debug, by setting the
// ENVIRONMENT variable in VS
builder.ConfigureHostConfiguration(config =>
{
config.AddEnvironmentVariables();
});
// reads the configuration from json file
builder.ConfigureAppConfiguration((context, config) =>
{
var env = context.HostingEnvironment;
// Adding command line as a configuration source
config
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: true);
config.AddEnvironmentVariables();
if (args != null)
{
config.AddCommandLine(args);
}
});
// configure logging (you can use the config here, via context.Configuration)
builder.ConfigureLogging((context, loggingBuilder) =>
{
loggingBuilder.AddConfiguration(context.Configuration.GetSection("Logging"));
loggingBuilder.AddConsole();
// If this key exists in any config, use it to enable App Insights
var appInsightsKey = context.Configuration["APPINSIGHTS_INSTRUMENTATIONKEY"];
if (!string.IsNullOrEmpty(appInsightsKey))
{
loggingBuilder.AddApplicationInsights(o => o.InstrumentationKey = appInsightsKey);
}
});
// inject dependencies via DI
builder.ConfigureServices((context, services) =>
{
services.AddSingleton <INameResolver>(new QueueNameResolver("test"));
services.AddDbContextPool <DbContext>(options =>
options.UseSqlServer(context.Configuration.GetConnectionString("DbContext"))
);
});
// finalize host config
builder.UseConsoleLifetime();
var host = builder.Build();
using (host)
{
await host.RunAsync();
}
}
private async Task <TestInput> setup(string envName = "Test")
{
Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", envName);
var hostBuilder = new HostBuilder();
var host = await hostBuilder
.ConfigureAppConfiguration
(
(hostingContext, config) =>
{
config.UseXtiConfiguration(hostingContext.HostingEnvironment, new string[] { });
}
)
.ConfigureWebHost(webBuilder =>
{
webBuilder
.UseTestServer()
.ConfigureServices((context, services) =>
{
services.AddSingleton <CurrentAction>();
services.AddSingleton <TestAuthOptions>();
services
.AddAuthentication("Test")
.AddScheme <AuthenticationSchemeOptions, TestAuthHandler>
(
"Test",
options => { }
);
services.AddAuthorization(options =>
{
options.DefaultPolicy =
new AuthorizationPolicyBuilder("Test")
.RequireAuthenticatedUser()
.Build();
});
services.AddFakesForXtiWebApp(context.Configuration);
services.AddSingleton <FakeAppContext>();
services.AddSingleton <ISourceAppContext>(sp => sp.GetRequiredService <FakeAppContext>());
services.AddSingleton <CachedAppContext>();
services.AddSingleton <IAppContext>(sp => sp.GetRequiredService <CachedAppContext>());
services.AddSingleton <FakeUserContext>();
services.AddSingleton <ISourceUserContext>(sp => sp.GetRequiredService <FakeUserContext>());
services.AddSingleton <CachedUserContext>();
services.AddSingleton <IUserContext>(sp => sp.GetRequiredService <CachedUserContext>());
services.AddSingleton(sp => FakeInfo.AppKey);
services.AddSingleton <FakeAppOptions>();
services.AddScoped <FakeAppApiFactory>();
services.AddScoped <AppApiFactory>(sp => sp.GetRequiredService <FakeAppApiFactory>());
services.AddSingleton <IAnonClient, FakeAnonClient>();
services.AddScoped <FakeAppSetup>();
})
.Configure(app =>
{
app.UseAuthentication();
app.UseAuthorization();
app.UseXti();
app.Run(async(c) =>
{
var currentAction = c.RequestServices.GetRequiredService <CurrentAction>();
currentAction.TempLog = c.RequestServices.GetRequiredService <TempLog>();
await currentAction.Action(c);
});
});
})
.StartAsync();
var setup = host.Services.GetRequiredService <FakeAppSetup>();
await setup.Run(AppVersionKey.Current);
var userContext = host.Services.GetRequiredService <FakeUserContext>();
userContext.AddUser(new AppUserName("xartogg"));
return(new TestInput(host));
}
public static async Task Main(string[] args)
{
var hostBuilder = new HostBuilder();
var environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
if (environmentName != null)
{
hostBuilder.UseEnvironment(environmentName);
}
hostBuilder.ConfigureAppConfiguration((hostContext, configApp) =>
{
configApp.SetBasePath(Directory.GetCurrentDirectory());
configApp.AddJsonFile("appsettings.json", optional: true);
configApp.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", optional: true);
configApp.AddCommandLine(args);
})
.ConfigureLogging((hostContext, configLogging) =>
{
configLogging.AddConfiguration(hostContext.Configuration.GetSection("Logging"));
configLogging.AddConsole();
configLogging.AddDebug();
})
.ConfigureServices((hostContext, services) =>
{
var executorBuilder = services.AddWorkerExecutor(new Uri("https://localhost:44338/"));
executorBuilder
.AddTaskType <Tasks.TestTask>();
executorBuilder
.MapTaskHandler <Tasks.TestTask, Handlers.TestTaskHandler>();
})
.UseConsoleLifetime();
var host = hostBuilder.Build();
using (host)
{
await host.StartAsync();
while (true)
{
var v = Console.ReadLine();
if (string.IsNullOrEmpty(v))
{
await host.StopAsync();
break;
}
else
{
using (var scope = host.Services.CreateScope())
{
var tasks = scope.ServiceProvider.GetRequiredService <ITaskService>();
var taskId = await tasks.PushTaskAsync(new Tasks.TestTask());
Console.WriteLine($"Add task {taskId}");
}
}
}
}
Console.ReadLine();
}
/// <summary>
/// 初始化系统
/// </summary>
/// <param name="args"></param>
public static void Init(string[] args)
{
IHostBuilder hostBuilder = new HostBuilder();
//承载系统自身的配置：
hostBuilder.ConfigureHostConfiguration(hostConfigurationBuilder =>
{
hostConfigurationBuilder.AddJsonFile("commandLineMappings.json", false, false);
Environment.SetEnvironmentVariable(HostDefaults.EnvironmentKey, Environment.GetEnvironmentVariable(Global.EnvironmentKey));
hostConfigurationBuilder.AddEnvironmentVariables();
});
//应用配置:
hostBuilder.ConfigureAppConfiguration((hostBuilderContext, configurationBuilder) =>
{
Global.HostingEnvironment = hostBuilderContext.HostingEnvironment;
configurationBuilder.AddJsonFile("appsettings.json", false, true)
.AddJsonFile($"appsettings.{hostBuilderContext.HostingEnvironment.EnvironmentName}.json", true, true)
.AddJsonFile("exp.json", false, true)
.AddJsonFile("donateCoinCanContinueStatus.json", false, true);
if (hostBuilderContext.HostingEnvironment.IsDevelopment())
{
//Assembly assembly = Assembly.Load(new AssemblyName(hostBuilderContext.HostingEnvironment.ApplicationName));
Assembly assembly = typeof(Program).Assembly;
if (assembly != null)
{
configurationBuilder.AddUserSecrets(assembly, true);
}
}
configurationBuilder.AddExcludeEmptyEnvironmentVariables("Ray_");
if (args != null && args.Length > 0)
{
configurationBuilder.AddCommandLine(args, hostBuilderContext.Configuration
.GetSection("CommandLineMappings")
.Get <Dictionary <string, string> >());
}
});
//日志:
hostBuilder.ConfigureLogging((hostBuilderContext, loggingBuilder) =>
{
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(hostBuilderContext.Configuration)
.CreateLogger();
}).UseSerilog();
//DI容器:
hostBuilder.ConfigureServices((hostContext, services) =>
{
Global.ConfigurationRoot = (IConfigurationRoot)hostContext.Configuration;
services.AddBiliBiliConfigs(hostContext.Configuration);
services.AddBiliBiliClientApi(hostContext.Configuration);
services.AddDomainServices();
services.AddAppServices();
});
IHost host = hostBuilder.UseConsoleLifetime().Build();
Global.ServiceProviderRoot = host.Services;
}
public IHostBuilder ConfigureAppConfiguration(Action <HostBuilderContext, IConfigurationBuilder> configureDelegate)
{
_hostBuilder.ConfigureAppConfiguration(configureDelegate);
return(this);
}
/// <summary>
/// Specify the startup type to be used by the host
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="builder"></param>
/// <returns></returns>
public static HostBuilder UseStartup <T>(this HostBuilder builder, Func <HostBuilderContext, IEnumerable <FileInfo> > jsonConfigFiles = null) where T : AppStartup
{
//config builder
builder.ConfigureAppConfiguration((h, g) =>
{
var files = jsonConfigFiles?.Invoke(h);
if (files.IsNotNullOrEmpty())
{
foreach (var file in files)
{
if (file.Exists)
{
g.AddConfiguration(new ConfigurationBuilder().SetBasePath(h.HostingEnvironment.ContentRootPath).AddJsonFile(file.FullName, true, true).Build());
}
else
{
throw new System.IO.FileNotFoundException(string.Format("找不到文件{0}", file.FullName));
}
}
}
builder.Properties["Never.Hosting.Extension.IConfigurationBuilder"] = g;
});
//config ioc
builder.ConfigureServices((h, i) =>
{
var ctors = from n in typeof(T).GetConstructors(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
let parameters = n.GetParameters()
let length = parameters.Length
select new { ctor = n, parameters = parameters, length = length };
foreach (var ctor in ctors.OrderByDescending(t => t.length))
{
var paramters = new List <object>(ctor.length);
foreach (var p in ctor.parameters)
{
if (p.ParameterType == typeof(HostBuilderContext))
{
paramters.Add(h);
continue;
}
if (p.ParameterType == typeof(IServiceCollection))
{
paramters.Add(i);
continue;
}
if (p.ParameterType == typeof(IHostingEnvironment))
{
paramters.Add(h.HostingEnvironment);
continue;
}
if (p.ParameterType == typeof(IConfiguration))
{
paramters.Add(h.Configuration);
continue;
}
if (p.ParameterType == typeof(IConfigurationBuilder))
{
var config = builder.Properties["Never.Hosting.Extension.IConfigurationBuilder"] as IConfigurationBuilder;
builder.Properties.Remove("Never.Hosting.Extension.IConfigurationBuilder");
paramters.Add(config);
continue;
}
throw new Exception(string.Format("the parameter type {0} can not resolve in {1} cotrs", p.ParameterType, typeof(T)));
}
var start = (T)ctor.ctor.Invoke(paramters.ToArray());
if (start == null)
{
return;
}
var provider = start.ConfigureServices(i);
//config serviceprivider
builder.UseServiceProviderFactory(new ServiceProviderFactory(provider));
}
});
return(builder);
}
