public void Configure(IApplicationBuilder app, IHostEnvironment env, IApplicationLifetime appLifetime)
{
try
{
ApplicationContainer = app.ApplicationServices.GetAutofacRoot();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
app.UseCorrelation();
#if DEBUG
app.UseLykkeMiddleware(ServiceName, ex => ex.ToString());
#else
app.UseLykkeMiddleware(ServiceName, ex => new ErrorResponse {
ErrorMessage = ex.Message
});
#endif
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
app.UseSwagger();
app.UseSwaggerUI(a => a.SwaggerEndpoint("/swagger/v1/swagger.json", "Main Swagger"));
appLifetime.ApplicationStarted.Register(() => StartApplication().Wait());
appLifetime.ApplicationStopping.Register(() => StopApplication().Wait());
appLifetime.ApplicationStopped.Register(() => CleanUp().Wait());
var provider = new AnnotationsBasedMetamodelProvider();
EntityMetamodel.Configure(provider);
}
catch (Exception ex)
{
Log?.WriteFatalErrorAsync(nameof(Startup), nameof(ConfigureServices), "", ex).Wait();
throw;
}
}
public void Test_that_custom_service_provider_should_creates_object_which_implements_IStorageValueSerializer()
{
// Arrange
var type = typeof(SerializableTestType);
var property = typeof(TestTypeWithProperties).GetProperty(nameof(TestTypeWithProperties.AnnotatedSerializableType));
var serviceProviderMock = new Mock <IServiceProvider>();
serviceProviderMock
.Setup(x => x.GetService(It.IsAny <Type>()))
.Returns <Type>(t => new AnnotationsBasedMetamodelProviderTests());
IMetamodelProvider metamodelProvider = new AnnotationsBasedMetamodelProvider(serviceProviderMock.Object);
// Act
Assert.ThrowsException <InvalidOperationException>(() => metamodelProvider.TryGetTypeSerializer(type));
Assert.ThrowsException <InvalidOperationException>(() => metamodelProvider.TryGetPropertySerializer(property));
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
try
{
services.AddMvc()
.AddJsonOptions(options =>
{
options.SerializerSettings.ContractResolver =
new Newtonsoft.Json.Serialization.DefaultContractResolver();
});
services.AddSwaggerGen(options =>
{
options.DefaultLykkeConfiguration("v1", "SmsSender API");
});
var builder = new ContainerBuilder();
var appSettings = Configuration.LoadSettings <AppSettings>();
Log = CreateLogWithSlack(services, appSettings);
builder.RegisterModule(new ServiceModule(appSettings.Nested(x => x.SmsSenderService), Environment, Log));
builder.Populate(services);
ApplicationContainer = builder.Build();
var provider = new AnnotationsBasedMetamodelProvider();
EntityMetamodel.Configure(provider);
return(new AutofacServiceProvider(ApplicationContainer));
}
catch (Exception ex)
{
Log?.WriteFatalErrorAsync(nameof(Startup), nameof(ConfigureServices), "", ex).GetAwaiter().GetResult();
throw;
}
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
try
{
services.AddMvc()
.AddJsonOptions(options =>
{
options.SerializerSettings.Converters.Add(new StringEnumConverter());
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
});
services.AddSwaggerGen(options => { options.DefaultLykkeConfiguration(ApiVersion, ApiName); });
var settingsManager = Configuration.LoadSettings <AppSettings>(options =>
{
options.SetConnString(x => x.SlackNotifications.AzureQueue.ConnectionString);
options.SetQueueName(x => x.SlackNotifications.AzureQueue.QueueName);
options.SenderName = $"{AppEnvironment.Name} {AppEnvironment.Version}";
});
var appSettings = settingsManager.CurrentValue;
if (appSettings.MonitoringServiceClient != null)
{
_monitoringServiceUrl = appSettings.MonitoringServiceClient.MonitoringServiceUrl;
}
services.AddLykkeLogging(
settingsManager.ConnectionString(s => s.Bitcoin.Db.LogsConnString),
"BitcoinJobLog",
appSettings.SlackNotifications.AzureQueue.ConnectionString,
appSettings.SlackNotifications.AzureQueue.QueueName,
logging =>
{
logging.AddAdditionalSlackChannel("BlockChainIntegration");
logging.AddAdditionalSlackChannel("BlockChainIntegrationImportantMessages",
options => { options.MinLogLevel = LogLevel.Warning; });
});
var builder = new ContainerBuilder();
builder.Populate(services);
builder.RegisterModule(new BitcoinJobModule(settingsManager));
builder.RegisterModule(new RepositoryModule(settingsManager));
builder.RegisterModule(new ServiceModule(settingsManager));
ApplicationContainer = builder.Build();
var logFactory = ApplicationContainer.Resolve <ILogFactory>();
_log = logFactory.CreateLog(this);
_healthNotifier = ApplicationContainer.Resolve <IHealthNotifier>();
var provider = new AnnotationsBasedMetamodelProvider();
EntityMetamodel.Configure(provider);
return(new AutofacServiceProvider(ApplicationContainer));
}
catch (Exception ex)
{
if (_log == null)
{
Console.WriteLine(ex);
}
else
{
_log.Critical(ex);
}
throw;
}
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
try
{
var appSettings = Configuration.Get <AppSettings>();
services.AddAuthentication(opts =>
{
opts.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
opts.DefaultChallengeScheme = CookieAuthenticationDefaults.AuthenticationScheme;
})
.AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, o =>
{
o.LoginPath = new PathString("/Account/SignIn");
o.ExpireTimeSpan = TimeSpan.FromMinutes(int.Parse(Configuration["UserLoginTime"]));
});
services.AddAuthorization(options =>
{
options.DefaultPolicy = new AuthorizationPolicyBuilder(CookieAuthenticationDefaults.AuthenticationScheme).RequireAuthenticatedUser().Build();
});
services.AddMemoryCache();
services.AddMvc();
services.AddSwaggerGen(options =>
{
options.DefaultLykkeConfiguration("v1", "SettingsServiceV2 API");
options.OperationFilter <ApiKeyHeaderOperationFilter>();
});
var builder = new ContainerBuilder();
var settings = ConstantReloadingManager.From(appSettings);
services.AddLykkeLogging(
settings.ConnectionString(x => x.ConnectionString),
"SettingsServiceLog",
appSettings.SlackNotificationsConnString,
appSettings.SlackNotificationsQueueName
);
builder.RegisterModule(new AppModule(settings));
builder.RegisterModule(new DbModule(settings));
//builder.RegisterModule(new RabbitModule(settings, Log, _consoleLogger));
builder.Populate(services);
var provider = new AnnotationsBasedMetamodelProvider();
EntityMetamodel.Configure(provider);
ApplicationContainer = builder.Build();
Log = ApplicationContainer.Resolve <ILogFactory>().CreateLog(this);
HealthNotifier = ApplicationContainer.Resolve <IHealthNotifier>();
return(new AutofacServiceProvider(ApplicationContainer));
}
catch (Exception ex)
{
Log?.Critical(ex);
throw;
}
}
public static void RegisterDbModule(
this ContainerBuilder builder,
string connectionString,
string userConnectionString,
string secretsConnString)
{
var provider = new AnnotationsBasedMetamodelProvider();
EntityMetamodel.Configure(provider);
var conString = ConstantReloadingManager.From(connectionString);
var userConString = ConstantReloadingManager.From(userConnectionString);
var secretsConString = ConstantReloadingManager.From(secretsConnString);
builder.Register(c =>
new ServiceTokenRepository(
AzureTableStorage <ServiceTokenEntity> .Create(conString, "ServiceToken", c.Resolve <ILogFactory>())))
.As <IServiceTokenRepository>()
.SingleInstance();
builder.Register(c =>
new UserRepository(
AzureTableStorage <UserEntity> .Create(userConString, "User", c.Resolve <ILogFactory>())))
.As <IUserRepository>()
.SingleInstance();
builder.Register(c =>
new RoleRepository(
AzureTableStorage <RoleEntity> .Create(userConString, "Role", c.Resolve <ILogFactory>())))
.As <IRoleRepository>()
.SingleInstance();
builder.Register(c =>
new UserSignInHistoryRepository(
AzureTableStorage <UserSignInHistoryEntity> .Create(userConString, "UserSignInHistory", c.Resolve <ILogFactory>())))
.As <IUserSignInHistoryRepository>()
.SingleInstance();
builder.Register(c =>
new TokensRepository(
AzureTableStorage <TokenEntity> .Create(conString, "Tokens", c.Resolve <ILogFactory>())))
.As <ITokensRepository>()
.SingleInstance();
builder.Register(c =>
new KeyValuesRepository(
AzureTableStorage <KeyValueEntity> .Create(conString, "KeyValues", c.Resolve <ILogFactory>()),
c.Resolve <IKeyValueHistoryRepository>()))
.As <IKeyValuesRepository>()
.SingleInstance();
builder.Register(c =>
new KeyValuesRepository(
AzureTableStorage <KeyValueEntity> .Create(secretsConString, "SecretKeyValues", c.Resolve <ILogFactory>()),
c.Resolve <IKeyValueHistoryRepository>()))
.As <ISecretKeyValuesRepository>()
.SingleInstance();
builder.Register(c =>
new LockRepository(AzureTableStorage <LockEntity> .Create(conString, "Lock", c.Resolve <ILogFactory>())))
.As <ILockRepository>()
.SingleInstance();
builder.Register(c =>
new AccountTokenHistoryRepository(
AzureTableStorage <AccountTokenHistoryEntity> .Create(conString, "AccessTokenHistory", c.Resolve <ILogFactory>())))
.As <IAccountTokenHistoryRepository>()
.SingleInstance();
builder.Register(c =>
new ServiceTokenHistoryRepository(
AzureTableStorage <ServiceTokenHistoryEntity> .Create(conString, "ServiceTokenHistory", c.Resolve <ILogFactory>())))
.As <IServiceTokenHistoryRepository>()
.SingleInstance();
builder.Register(c =>
new RepositoriesRepository(
AzureTableStorage <RepositoryEntity> .Create(conString, "Repositories", c.Resolve <ILogFactory>())))
.As <IRepositoriesRepository>()
.SingleInstance();
builder.Register(c =>
new ConnectionUrlHistoryRepository(
AzureTableStorage <ConnectionUrlHistory> .Create(conString, "ConnectionUrlHistory", c.Resolve <ILogFactory>())))
.As <IConnectionUrlHistoryRepository>()
.SingleInstance();
builder.Register(c =>
new RepositoriesUpdateHistoryRepository(
AzureTableStorage <RepositoryUpdateHistoryEntity> .Create(conString, "RepositoryUpdateHistory", c.Resolve <ILogFactory>())))
.As <IRepositoriesUpdateHistoryRepository>()
.SingleInstance();
builder.Register(c =>
new NetworkRepository(
AzureTableStorage <NetworkEntity> .Create(conString, "Networks", c.Resolve <ILogFactory>())))
.As <INetworkRepository>()
.SingleInstance();
builder.Register(c =>
new UserActionHistoryRepository(
AzureTableStorage <UserActionHistoryEntity> .Create(userConString, "UserActionHistory", c.Resolve <ILogFactory>()),
new AzureBlobStorage(userConString.CurrentValue), "useractionhistoryparam"))
.As <IUserActionHistoryRepository>()
.SingleInstance();
builder.Register(c =>
new KeyValueHistoryRepository(
AzureTableStorage <KeyValueHistory> .Create(conString, "KeyValueHistory", c.Resolve <ILogFactory>()),
new AzureBlobStorage(conString.CurrentValue), "keyvaluehistory"))
.As <IKeyValueHistoryRepository>()
.SingleInstance();
builder.RegisterInstance(
new RepositoryDataRepository(new AzureBlobStorage(conString.CurrentValue), "settings", "history")
).As <IRepositoryDataRepository>().SingleInstance();
builder.RegisterInstance(
new JsonDataRepository(new AzureBlobStorage(conString.CurrentValue), "settings", "history", "generalsettings.json")
).As <IJsonDataRepository>().SingleInstance();
builder.RegisterInstance(
new AccessDataRepository(new AzureBlobStorage(conString.CurrentValue), "access", "accesshistory", "accessHistory.json")
).As <IAccessDataRepository>().SingleInstance();
}
