private static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureHostConfiguration(configurationBuilder => {
configurationBuilder.AddCommandLine(args);
})
.ConfigureAppConfiguration((ctx, builder) =>
{
builder.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile($"appsettings.{ctx.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();
})
.UseSerilog((ctx, cfg) =>
{
var credentials = new NoAuthCredentials(ctx.Configuration.GetConnectionString("loki"));
cfg.MinimumLevel.Verbose()
.Enrich.FromLogContext()
.Enrich.WithProperty("Application", ctx.HostingEnvironment.ApplicationName)
.Enrich.WithProperty("Environment", ctx.HostingEnvironment.EnvironmentName)
.WriteTo.Console(new RenderedCompactJsonFormatter())
.WriteTo.LokiHttp(credentials);
})
.ConfigureServices((hostContext, services) =>
{
services.AddSingleton <IEventDeserializer>(new JsonEventDeserializer(new[]
{
typeof(CustomerCreated).Assembly
}));
services.AddHttpClient <ICustomersApiClient, CustomersApiClient>("customersApiClient", (ctx, httpClient) =>
{
var config = ctx.GetRequiredService <IConfiguration>();
var endpoint = config["CustomersApi"];
httpClient.BaseAddress = new System.Uri(endpoint);
})
.AddPolicyHandler(HttpClientPolicies.GetRetryPolicy());
services.AddSingleton <INotificationsFactory, NotificationsFactory>();
services.AddSingleton <INotificationsService, FakeNotificationsService>();
services.AddSingleton(ctx =>
{
var kafkaConnStr = hostContext.Configuration.GetConnectionString("kafka");
var eventsTopicName = hostContext.Configuration["eventsTopicName"];
var groupName = hostContext.Configuration["eventsTopicGroupName"];
return(new EventConsumerConfig(kafkaConnStr, eventsTopicName, groupName));
});
services.AddHostedService(ctx =>
{
var logger = ctx.GetRequiredService <ILogger <EventConsumer <Account, Guid> > >();
var eventsDeserializer = ctx.GetRequiredService <IEventDeserializer>();
var consumerConfig = ctx.GetRequiredService <EventConsumerConfig>();
var notificationsFactory = ctx.GetRequiredService <INotificationsFactory>();
var notificationsService = ctx.GetRequiredService <INotificationsService>();
var consumer = new EventConsumer <Account, Guid>(eventsDeserializer, consumerConfig, logger);
return(new AccountEventsWorker(notificationsFactory, notificationsService, consumer, logger));
});
});
private static void AddConnectorsHttpClients(IServiceCollection services,
Dictionary <string, string> supplierPaths)
{
foreach (var(supplierKey, basePath) in supplierPaths)
{
services.AddHttpClient(supplierKey, client =>
{
client.BaseAddress = client.BaseAddress = new Uri(basePath);
client.DefaultRequestHeaders.Add("Accept", "application/json");
client.Timeout = TimeSpan.FromMinutes(10);
}).SetHandlerLifetime(TimeSpan.FromMinutes(10))
.AddPolicyHandler(HttpClientPolicies.GetStandardRetryPolicy())
.AddHttpMessageHandler <ProtectedApiBearerTokenHandler>();
}
}
public void ConfigureServices(IServiceCollection services)
{
var serializationSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.None
};
JsonConvert.DefaultSettings = () => serializationSettings;
using var vaultClient = StartupHelper.CreateVaultClient(Configuration);
vaultClient.Login(GetFromEnvironment("Vault:Token")).Wait();
var jobsSettings = vaultClient.Get(Configuration["Identity:JobsOptions"]).Result;
var clientSecret = jobsSettings[Configuration["Identity:Secret"]];
var edoSettings = vaultClient.Get(Configuration["Edo:EdoOptions"]).Result;
var authorityUrl = edoSettings[Configuration["Identity:Authority"]];
var edoApiUrl = edoSettings[Configuration["Edo:Api"]];
var supplierPaths = vaultClient.Get(Configuration["Suppliers:Paths"]).Result
.Where(i => i.Key != "enabledConnectors")
.ToDictionary(i => i.Key, j => j.Value);
IEnumerable <string> enabledSuppliers;
var supplierSettingsFromEnvironment = Environment.GetEnvironmentVariable("SUPPLIERS");
if (supplierSettingsFromEnvironment != null)
{
enabledSuppliers = supplierSettingsFromEnvironment.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
}
else
{
var updaterOptions = vaultClient.Get(Configuration["Suppliers:Options"]).Result;
enabledSuppliers = updaterOptions["enabled"].Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
}
var connectionString = StartupHelper.GetDbConnectionString(vaultClient, Configuration);
services.AddDbContext <LocationUpdaterContext>(options =>
{
options.UseNpgsql(
connectionString,
b => b.UseNetTopologySuite());
options.EnableSensitiveDataLogging(false);
options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
});
services.AddTransient <ProtectedApiBearerTokenHandler>();
services.AddSingleton <TokenProvider>();
services.AddTransient <JsonSerializer>();
services.Configure <TokenRequestSettings>(options =>
{
var uri = new Uri(new Uri(authorityUrl), "/connect/token");
options.TokenRequestUrl = uri.ToString();
options.ClientId = Configuration["Identity:ClientId"];
options.ClientSecret = clientSecret;
options.Scopes = new[] { "edo", "connectors" };
var disableCachingSetting = Environment.GetEnvironmentVariable("DISABLE_TOKEN_CACHE");
options.IsCachingDisabled = bool.TryParse(disableCachingSetting, out var disableCache) && disableCache;
});
services.AddHttpClient(HttpClientNames.Identity, client =>
{
client.BaseAddress = new Uri(authorityUrl);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).AddPolicyHandler(HttpClientPolicies.GetStandardRetryPolicy());
services.AddHttpClient(HttpClientNames.EdoApi, client =>
{
client.BaseAddress = new Uri(edoApiUrl);
client.Timeout = TimeSpan.FromMinutes(5);
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5))
.AddPolicyHandler(HttpClientPolicies.GetStandardRetryPolicy())
.AddHttpMessageHandler <ProtectedApiBearerTokenHandler>();
AddConnectorsHttpClients(services, supplierPaths);
services.Configure <UpdaterOptions>(o =>
{
var batchSizeSetting = Environment.GetEnvironmentVariable("BATCH_SIZE");
o.BatchSize = int.TryParse(batchSizeSetting, out var batchSize)
? batchSize
: 2000;
var requestDelaySetting = Environment.GetEnvironmentVariable("REQUEST_DELAY");
o.UploadRequestDelay = int.TryParse(requestDelaySetting, out var requestDelayMilliseconds)
? TimeSpan.FromMilliseconds(requestDelayMilliseconds)
: TimeSpan.FromMilliseconds(150);
o.Suppliers = enabledSuppliers;
o.UpdateMode = Enum.TryParse <UpdateMode>(Environment.GetEnvironmentVariable("UPDATE_MODE"), out var updateMode)
? updateMode
: UpdateMode.Differential;
});
services.AddHostedService <LocationUpdaterHostedService>();
services.AddNameNormalizationServices();
services.AddHttpClient();
services.AddHealthChecks();
}
