public CosmosDbService(CosmosDbSettings AConfiguration)
{
var LAccount = AConfiguration.Account;
var LKey = AConfiguration.Key;
FDatabaseName = AConfiguration.DatabaseName;
FCosmosClient = new CosmosClient(LAccount, LKey, new CosmosClientOptions()
{
SerializerOptions = new CosmosSerializationOptions()
{
PropertyNamingPolicy = CosmosPropertyNamingPolicy.CamelCase
}
});
FContainer = null;
FDefaultThroughput = 400;
}
public static IServiceCollection AddCosmosDb(this IServiceCollection builder, IConfiguration config, string collectionNameOverride = null)
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
if (!string.IsNullOrWhiteSpace(collectionNameOverride))
{
cosmosDbSettings.CollectionName = collectionNameOverride;
}
builder.AddSingleton <CosmosDbSettings>(cosmosDbSettings);
builder
.AddSingleton <CosmosRepository>();
return(builder);
}
private CosmosDbConnection(CosmosDbSettings connectionSettings)
{
if (connectionSettings == null)
{
throw new Exception("Database Settings Not Found");
}
if (string.IsNullOrWhiteSpace(connectionSettings.Endpoint))
{
throw new Exception("Database Endpoint Not Found");
}
if (string.IsNullOrWhiteSpace(connectionSettings.Key))
{
throw new Exception("Database Authorization Key Not Found");
}
ConnectionSettings = connectionSettings;
DocumentClient = new DocumentClient(new Uri(connectionSettings.Endpoint), connectionSettings.Key);
DocumentClient.OpenAsync(); // to avoid startup latency
}
public static (CosmosDbContext cosmosContext, Container Container) GetCosmosContextAndContainer(this object callingClass)
{
var config = AppSettings.GetConfiguration();
var connectionString = config.GetConnectionString(CosmosConnectionName);
var dbSettings = new CosmosDbSettings(connectionString, callingClass.GetType().Name);
var builder = new DbContextOptionsBuilder <CosmosDbContext>()
.UseCosmos(
dbSettings.ConnectionString,
dbSettings.DatabaseName);
var cosmosContext = new CosmosDbContext(builder.Options);
var cosmosClient = cosmosContext.Database.GetCosmosClient();
var database = cosmosClient.GetDatabase(dbSettings.DatabaseName);
var container = database.GetContainer(nameof(CosmosDbContext));
return(cosmosContext, container);
}
public void TestAccessCosmosEmulatorWithLogging()
{
//SETUP
var config = AppSettings.GetConfiguration();
var connectionString = config.GetConnectionString(CosmosSetupHelpers.CosmosConnectionName);
var dbSettings = new CosmosDbSettings(connectionString, GetType().Name);
var builder = new DbContextOptionsBuilder <CosmosDbContext>()
.UseCosmos(
dbSettings.ConnectionString,
dbSettings.DatabaseName)
.LogTo(_output.WriteLine, LogLevel.Information);
using var context = new CosmosDbContext(builder.Options);
//ATTEMPT
context.Database.EnsureCreated();
//VERIFY
}
public static DbContextOptions <TContext> GetCosmosDbOptions <TContext>(this object callingClass)
where TContext : DbContext
{
var config = AppSettings.GetConfiguration();
var connectionString = config.GetConnectionString(CosmosConnectionName);
var dbSettings = new CosmosDbSettings(connectionString, callingClass.GetType().Name);
var builder = new DbContextOptionsBuilder <TContext>()
.UseCosmos(
dbSettings.ConnectionString,
dbSettings.DatabaseName);
//var builder2 = new DbContextOptionsBuilder
// <CosmosDbContext>()
// .UseCosmos(
// "connection string...",
// "MyCosmosDatabase");
//var x = builder2.Options;
return(builder.Options);
}
public void ConfigureServices(IServiceCollection services)
{
// Configurations
IConfigurationRoot configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile($"local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
// Use a singleton Configuration throughout the application
services.AddSingleton <IConfiguration>(configuration);
// Singleton instance. See example usage in SendGridEmailService: inject IOptions<SendGridEmailSettings> in SendGridEmailService constructor
services.Configure <SendGridEmailSettings>(configuration.GetSection("SendGridEmailSettings"));
// if default ILogger is desired instead of Serilog
//services.AddLogging();
// configure serilog
Serilog.Core.Logger logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.WriteTo.Console()
.WriteTo.File("C:\\Logs\\AzureFunctions.Starter\\log-StaterFunction.txt", rollingInterval: RollingInterval.Day)
.CreateLogger();
services.AddLogging(lb => lb.AddSerilog(logger));
//Register SendGrid Email
services.AddScoped <IEmailService, SendGridEmailService>();
// Bind database-related bindings
CosmosDbSettings cosmosDbConfig = configuration.GetSection("ConnectionStrings:CleanArchitectureCosmosDB").Get <CosmosDbSettings>();
// register CosmosDB client and data repositories
services.AddCosmosDb(cosmosDbConfig.EndpointUrl,
cosmosDbConfig.PrimaryKey,
cosmosDbConfig.DatabaseName,
cosmosDbConfig.Containers);
services.AddScoped <IToDoItemRepository, ToDoItemRepository>();
}
private void ConfigureCosmosDb(IServiceCollection services)
{
ICosmosDbSettings cosmosDbSettings = new CosmosDbSettings(Configuration.GetSection("CosmosDb"), (Configuration.GetSection("KeyVault")));
services.AddSingleton(cosmosDbSettings);
services.AddSingleton <IDocumentClient>(x => new DocumentClient(cosmosDbSettings.Endpoint, cosmosDbSettings.AuthKey));
services.AddSingleton <IBackendDatabaseService, CosmosDbService>();
services.AddSingleton <IDynamicQueries, CosmosDbDynamicQueries>();
services.AddSingleton <IServiceProvidersOrchestrator, ServiceProvidersOrchestrator>();
IA2JSettings a2jSettings = new A2JSettings(Configuration.GetSection("A2JSettings"));
services.AddSingleton(a2jSettings);
// Inject the Service Providers at runtime
var assembly = Assembly.LoadFrom(Assembly.GetExecutingAssembly().Location);
var integrationAdaptersClassNames = Configuration.GetSection("IntegrationAdaptersFullyQualifiedClassNames").Get <List <string> >();
foreach (var className in integrationAdaptersClassNames)
{
services.AddSingleton(typeof(IServiceProviderAdapter), assembly.GetType(className));
}
}
public CosmosDbPolicies(CosmosDbSettings cosmosDbSettings, ILogger <CosmosDbPolicies> logger)
{
_logger = logger;
var cosmosDbOperationTimeout =
cosmosDbSettings.DefaultCosmosOperationTimeout <= 0 ? defaultCosmosOperationTimeout : cosmosDbSettings.DefaultCosmosInterimRequestTimeout;
var cosmosDbInterimRequestTimeout =
cosmosDbSettings.DefaultCosmosInterimRequestTimeout <= 0 ? defaultCosmosInterimRequestTimeout : cosmosDbSettings.DefaultCosmosInterimRequestTimeout;
// Handle CosmosException Only,
// If the status code is not 429, try 3 times with 2 seconds inbetween by default,
// If it is 429, inspect the retry after value and retry then.
ResiliencePolicy = Policy.Handle <CosmosException>()
.WaitAndRetryAsync(3, sleepDurationProvider: (retryCount, response, context) =>
{
if (response is CosmosException cosmosException &&
cosmosException.StatusCode == System.Net.HttpStatusCode.TooManyRequests &&
cosmosException.RetryAfter.HasValue)
{
return(cosmosException.RetryAfter.Value);
}
return(TimeSpan.FromSeconds(cosmosDbInterimRequestTimeout));
}, onRetryAsync: async(exception, timeSpan, rretryCount, pollyContext) =>
private void BuildCosmosDbSettings(IServiceCollection services, IConfigurationRoot configuration)
{
var cosmosSettings = new CosmosDbSettings
{
DatabaseId = configuration["CosmosDatabaseId"],
EndpointUri = configuration["EndpointUri"],
PrimaryKey = configuration["PrimaryKey"]
};
var cosmosCollectionSettings = new CosmosDbCollectionSettings
{
CoursesCollectionId = configuration["CoursesCollectionId"],
CoursesMigrationReportCollectionId = configuration["CoursesMigrationReportCollectionId"],
ProviderCollectionId = configuration["ProviderCollectionId"],
DfcReportCollectionId = configuration["DfcReportCollectionId"],
AuditCollectionId = configuration["AuditCollectionId"],
ApprenticeshipMigrationReportCollectionId = configuration["ApprenticeshipMigrationReportCollectionId"],
ApprenticeshipCollectionId = configuration["ApprenticeshipCollectionId"],
ApprenticeshipDfcReportCollection = configuration["ApprenticeshipDfcReportCollectionId"]
};
services.AddSingleton <CosmosDbSettings>(cosmosSettings);
services.AddSingleton <CosmosDbCollectionSettings>(cosmosCollectionSettings);
}
public static void InitialiseDocumentClient(CosmosDbSettings cosmosDbSettings)
{
_documentClient = CosmosHelper.Parse(cosmosDbSettings.ConnectionString);
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <OnDataDefinitionChanges>();
builder.AddSingleton <OnEditCaluclationEvent>();
builder.AddSingleton <OnEditSpecificationEvent>();
builder.AddSingleton <IScenariosRepository, ScenariosRepository>();
builder.AddSingleton <IScenariosService, ScenariosService>();
builder.AddSingleton <IScenariosSearchService, ScenariosSearchService>();
builder
.AddSingleton <IValidator <CreateNewTestScenarioVersion>, CreateNewTestScenarioVersionValidator>();
builder
.AddSingleton <ISpecificationsRepository, SpecificationsRepository>();
builder
.AddSingleton <IBuildProjectRepository, BuildProjectRepository>();
builder
.AddSingleton <ICalcsRepository, CalcsRepository>();
builder
.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
builder
.AddSingleton <IDatasetRepository, DatasetRepository>();
builder
.AddSingleton <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddSingleton <IVersionRepository <TestScenarioVersion>, VersionRepository <TestScenarioVersion> >((ctx) =>
{
CosmosDbSettings scenariosVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", scenariosVersioningDbSettings);
scenariosVersioningDbSettings.CollectionName = "tests";
CosmosRepository resultsRepostory = new CosmosRepository(scenariosVersioningDbSettings);
return(new VersionRepository <TestScenarioVersion>(resultsRepostory));
});
builder.AddCalcsInterServiceClient(config);
builder.AddSpecificationsInterServiceClient(config);
builder.AddDatasetsInterServiceClient(config);
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder.AddCosmosDb(config, "tests");
}
else
{
builder.AddCosmosDb(config);
}
builder.AddJobsInterServiceClient(config);
builder.AddSearch(config);
builder.AddServiceBus(config);
builder.AddCaching(config);
builder.AddApplicationInsights(config, "CalculateFunding.Functions.Scenarios");
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Scenarios");
builder.AddLogging("CalculateFunding.Functions.Scenarios");
builder.AddTelemetry();
builder.AddFeatureToggling(config);
builder.AddPolicySettings(config);
builder.AddSingleton <IScenariosResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
BulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
Policy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
return(new ScenariosResiliencePolicies()
{
CalcsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
DatasetRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ScenariosRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy)
});
});
return(builder.BuildServiceProvider());
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <OnCosmosDbDiagnosticsReceived>();
builder.AddSingleton <OnScaleUpCosmosDbCollection>();
builder.AddSingleton <OnIncrementalScaleDownCosmosDbCollection>();
builder.AddSingleton <OnScaleDownCosmosDbCollection>();
builder.AddSingleton <ICosmosDbScalingRepositoryProvider, CosmosDbScalingRepositoryProvider>();
builder.AddSingleton <ICosmosDbScalingService, CosmosDbScalingService>();
builder.AddSingleton <ICosmosDbScalingRequestModelBuilder, CosmosDbScalingRequestModelBuilder>();
builder.AddSingleton <ICosmosDbThrottledEventsFilter, CosmosDbThrottledEventsFilter>();
builder.AddSingleton <CalculationProviderResultsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "calculationresults";
CosmosRepository cosmosRepostory = new CosmosRepository(cosmosDbSettings);
return(new CalculationProviderResultsScalingRepository(cosmosRepostory));
});
builder.AddSingleton <ProviderSourceDatasetsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "providerdatasets";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new ProviderSourceDatasetsScalingRepository(cosmosRepository));
});
builder.AddSingleton <CalculationsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "calcs";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new CalculationsScalingRepository(cosmosRepository));
});
builder.AddSingleton <JobsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "jobs";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new JobsScalingRepository(cosmosRepository));
});
builder.AddSingleton <DatasetAggregationsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "datasetaggregations";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new DatasetAggregationsScalingRepository(cosmosRepository));
});
builder.AddSingleton <DatasetsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "datasets";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new DatasetsScalingRepository(cosmosRepository));
});
builder.AddSingleton <ProfilingScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "profiling";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new ProfilingScalingRepository(cosmosRepository));
});
builder.AddSingleton <SpecificationsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "specs";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new SpecificationsScalingRepository(cosmosRepository));
});
builder.AddSingleton <TestResultsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "testresults";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new TestResultsScalingRepository(cosmosRepository));
});
builder.AddSingleton <TestsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "tests";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new TestsScalingRepository(cosmosRepository));
});
builder.AddSingleton <UsersScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "users";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new UsersScalingRepository(cosmosRepository));
});
builder.AddSingleton <PublishedProviderResultsScalingRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "publishedproviderresults";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new PublishedProviderResultsScalingRepository(cosmosRepository));
});
builder.AddSingleton <ICosmosDbScalingConfigRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.CollectionName = "cosmosscalingconfig";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new CosmosDbScalingConfigRepository(cosmosRepository));
});
builder.AddCaching(config);
builder.AddJobsInterServiceClient(config);
builder.AddServiceBus(config);
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.CosmosDbScaling");
builder.AddLogging("CalculateFunding.Functions.CosmosDbScaling", config);
builder.AddTelemetry();
builder.AddFeatureToggling(config);
builder.AddSingleton <ICosmosDbScallingResilliencePolicies>(m =>
{
PolicySettings policySettings = builder.GetPolicySettings(config);
BulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
CosmosDbScallingResilliencePolicies resiliencePolicies = new CosmosDbScallingResilliencePolicies()
{
ScalingRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ScalingConfigRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProvider = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy)
};
return(resiliencePolicies);
});
return(builder.BuildServiceProvider());
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
// These registrations of the functions themselves are just for the DebugQueue. Ideally we don't want these registered in production
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder.AddScoped <OnTestSpecificationProviderResultsCleanup>();
builder.AddScoped <OnEditSpecificationEvent>();
builder.AddScoped <OnTestExecution>();
builder.AddScoped <OnDeleteTestResults>();
builder.AddScoped <OnDeleteTestResultsFailure>();
}
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder
.AddSingleton <IGherkinParserService, GherkinParserService>();
builder
.AddSingleton <IGherkinParser, GherkinParser>();
builder
.AddSingleton <ICodeMetadataGeneratorService, ReflectionCodeMetadataGenerator>();
builder
.AddSingleton <IStepParserFactory, StepParserFactory>();
builder.AddSingleton <ITestResultsRepository, TestResultsRepository>((ctx) =>
{
CosmosDbSettings testResultsDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", testResultsDbSettings);
testResultsDbSettings.ContainerName = "testresults";
CosmosRepository providersCosmosRepostory = new CosmosRepository(testResultsDbSettings);
EngineSettings engineSettings = ctx.GetService <EngineSettings>();
ILogger logger = ctx.GetService <ILogger>();
return(new TestResultsRepository(providersCosmosRepostory, logger, engineSettings));
});
builder
.AddSingleton <IScenariosRepository, ScenariosRepository>();
builder
.AddScoped <ITestEngineService, TestEngineService>();
builder
.AddSingleton <ITestEngine, Services.TestRunner.TestEngine>();
builder
.AddSingleton <IGherkinExecutor, GherkinExecutor>();
builder
.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder.AddSingleton <ICosmosRepository, CosmosRepository>();
builder.AddSingleton <IProviderSourceDatasetsRepository, ProviderSourceDatasetsRepository>((ctx) =>
{
CosmosDbSettings providersDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", providersDbSettings);
providersDbSettings.ContainerName = "providerdatasets";
CosmosRepository providersCosmosRepostory = new CosmosRepository(providersDbSettings);
EngineSettings engineSettings = ctx.GetService <EngineSettings>();
return(new ProviderSourceDatasetsRepository(providersCosmosRepostory, engineSettings));
});
builder.AddSingleton <IProviderResultsRepository, ProviderResultsRepository>((ctx) =>
{
CosmosDbSettings providersDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", providersDbSettings);
providersDbSettings.ContainerName = "calculationresults";
CosmosRepository providersCosmosRepostory = new CosmosRepository(providersDbSettings);
return(new ProviderResultsRepository(providersCosmosRepostory));
});
builder.AddSingleton <ITestResultsSearchService, TestResultsSearchService>();
builder.AddSingleton <ITestResultsCountsService, TestResultsCountsService>();
builder.AddSingleton <IJobManagement, JobManagement>();
builder.AddSingleton <IDeadletterService, DeadletterService>();
MapperConfiguration mappingConfiguration = new MapperConfiguration(c =>
{
c.AddProfile <TestEngineMappingProfile>();
});
builder
.AddSingleton(mappingConfiguration.CreateMapper());
builder.AddScoped <ITestResultsService, TestResultsService>();
builder.AddSearch(config);
builder
.AddSingleton <ISearchRepository <TestScenarioResultIndex>, SearchRepository <TestScenarioResultIndex> >();
builder.AddSpecificationsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddScenariosInterServiceClient(config);
builder.AddCalculationsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddProvidersInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddJobsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddCaching(config);
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.TestEngine", TelemetryChannelType.Sync);
builder.AddApplicationInsightsServiceName(config, "CalculateFunding.Functions.TestEngine");
builder.AddLogging("CalculateFunding.Functions.TestEngine");
builder.AddServiceBus(config, "testengine");
builder.AddTelemetry();
builder.AddEngineSettings(config);
builder.AddPolicySettings(config);
builder.AddFeatureToggling(config);
builder.AddSingleton((Func <IServiceProvider, ITestRunnerResiliencePolicies>)((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
AsyncPolicy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
ResiliencePolicies resiliencePolicies = new ResiliencePolicies()
{
CalculationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProviderRepository = redisPolicy,
ProviderResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ProviderSourceDatasetsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ScenariosRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(new[] { totalNetworkRequestsPolicy, redisPolicy }),
SpecificationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
TestResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
TestResultsSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy)
};
return(resiliencePolicies);
}));
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new JobManagementResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
});
});
builder.AddScoped <IUserProfileProvider, UserProfileProvider>();
return(builder.BuildServiceProvider());
}
public static IServiceProvider BuildServiceProvider(string collectionName)
{
IServiceCollection builder = new ServiceCollection();
builder.AddApplicationInsightsTelemetryClient(Configuration, ServiceName);
builder.AddLogging(serviceName: ServiceName);
builder.AddSingleton <IProducerConsumerFactory, ProducerConsumerFactory>();
builder.AddPolicySettings(Configuration);
builder.AddSingleton <IJobManagement, JobManagement>();
builder.AddSingleton <IJobTracker, JobTracker>();
builder.AddJobsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddServiceBus(Configuration);
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddSingleton <ICosmosRepository>(ctx =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.ContainerName = collectionName;
return(new CosmosRepository(cosmosDbSettings));
});
builder.AddSingleton <IPublishingResiliencePolicies>(ctx =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers
.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new ResiliencePolicies
{
JobsApiClient = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedFundingRepository = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedIndexSearchResiliencePolicy = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
BlobClient = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddSingleton <IJobManagementResiliencePolicies>(ctx =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers
.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new JobManagementResiliencePolicies
{
JobsApiClient = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddSingleton <IPublishedFundingUndoCosmosRepository, PublishedFundingUndoCosmosRepository>();
builder.AddSingleton <IPublishedFundingUndoBlobStoreRepository>(ctx =>
{
BlobStorageOptions settings = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", settings);
settings.ContainerName = "publishedproviderversions";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(settings);
return(new PublishedFundingUndoBlobStoreRepository(new CommonBlobClient(blobContainerRepository),
ctx.GetService <IPublishingResiliencePolicies>(),
ctx.GetService <ILogger>()));
});
builder.AddSingleton <IPublishedFundingUndoJobCreation, PublishedFundingUndoJobCreation>();
builder.AddSingleton <IPublishedFundingUndoTaskFactoryLocator, PublishedFundingUndoTaskFactoryLocator>();
builder.AddSingleton <IDsgRollBackCosmosDocumentsJob, DsgRollBackCosmosDocumentsJob>();
builder.AddSingleton <IPublishedFundingUndoTaskFactory, DsgRollBackTaskFactory>();
builder.AddSingleton <IRollBackDsg, RollBackDsg>();
return(builder.BuildServiceProvider());
}
public static IServiceCollection ConfigureToolBox(this IServiceCollection services, CosmosDbSettings cosmosDbSettings)
{
var cosmosSettings = new CosmosStoreSettings(
cosmosDbSettings.DatabaseId,
cosmosDbSettings.URL,
cosmosDbSettings.PrimaryKey);
services.AddCosmosStore <MeUser>(cosmosSettings, "Users");
services.AddCosmosStore <Location>(cosmosSettings, "Locations");
services.AddCosmosStore <Examination>(cosmosSettings, "Examinations");
services.AddScoped <IDocumentClientFactory, DocumentClientFactory>();
services.AddScoped <IDatabaseAccess, DatabaseAccess>();
services.AddScoped <IUserConnectionSettings>(s => new UserConnectionSettings(
new Uri(cosmosDbSettings.URL),
cosmosDbSettings.PrimaryKey,
cosmosDbSettings.DatabaseId));
services.AddScoped <IAsyncQueryHandler <UserRetrievalByIdQuery, MeUser>, UserRetrievalByIdService>();
services.AddScoped <IAsyncQueryHandler <UserUpdateQuery, MeUser>, UserUpdateService>();
services.AddScoped <IAsyncQueryHandler <UsersRetrievalQuery, IEnumerable <MeUser> >, UsersRetrievalService>();
services.AddScoped <ImpersonateUserService>();
services.AddScoped <GenerateConfigurationService>();
services.AddScoped <ImportDocumentService>();
services.AddScoped <GetLocationTreeService>();
return(services);
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder
.AddSingleton <IHealthChecker, ControllerResolverHealthCheck>();
builder.AddSingleton <ICosmosRepository, CosmosRepository>();
builder.AddSingleton <ICosmosDbScalingService, CosmosDbScalingService>();
builder.AddSingleton <ICosmosDbScalingRepositoryProvider, CosmosDbScalingRepositoryProvider>();
builder.AddSingleton <ICosmosDbScalingRequestModelBuilder, CosmosDbScalingRequestModelBuilder>();
builder.AddSingleton <ICosmosDbThrottledEventsFilter, CosmosDbThrottledEventsFilter>();
builder.AddSingleton <IValidator <ScalingConfigurationUpdateModel>, ScalingConfigurationUpdateModelValidator>();
builder.AddSingleton <ICosmosDbScalingConfigRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.ContainerName = "cosmosscalingconfig";
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new CosmosDbScalingConfigRepository(cosmosRepository));
});
builder.AddSingleton <IJobManagement, JobManagement>();
builder.AddFeatureToggling(Configuration);
builder.AddServiceBus(Configuration);
builder.AddSearch(Configuration);
builder.AddCaching(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddPolicySettings(Configuration);
builder.AddSingleton <ICosmosDbScalingResiliencePolicies>(m =>
{
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(Configuration);
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
CosmosDbScalingResiliencePolicies resiliencePolicies = new CosmosDbScalingResiliencePolicies()
{
ScalingRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ScalingConfigRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProvider = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy)
};
return(resiliencePolicies);
});
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(Configuration);
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new JobManagementResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
});
});
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Apis.CosmosDbScaling");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.CosmosDbScaling");
builder.AddLogging("CalculateFunding.Apis.CosmosDbScaling");
builder.AddTelemetry();
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "CosmosDbScaling Microservice API", version: "v1");
}
}
/// <summary>
/// Configure Queries.
/// </summary>
/// <param name="services">Services.</param>
/// <param name="cosmosDbSettings">Cosmos Database Settings.</param>
private void ConfigureQueries(IServiceCollection services, CosmosDbSettings cosmosDbSettings)
{
services.AddSingleton <ILocationConnectionSettings>(s => new LocationConnectionSettings(
new Uri(cosmosDbSettings.URL),
cosmosDbSettings.PrimaryKey,
cosmosDbSettings.DatabaseId));
services.AddSingleton <IExaminationConnectionSettings>(s => new ExaminationConnectionSettings(
new Uri(cosmosDbSettings.URL),
cosmosDbSettings.PrimaryKey,
cosmosDbSettings.DatabaseId));
services.AddSingleton <IUserConnectionSettings>(s => new UserConnectionSettings(
new Uri(cosmosDbSettings.URL),
cosmosDbSettings.PrimaryKey,
cosmosDbSettings.DatabaseId));
services.AddSingleton <IUserSessionConnectionSettings>(s => new UserSessionConnectionSettings(
new Uri(cosmosDbSettings.URL),
cosmosDbSettings.PrimaryKey,
cosmosDbSettings.DatabaseId));
services.AddSingleton <IMELoggerConnectionSettings>(s => new MELoggerConnectionSettings(
new Uri(cosmosDbSettings.URL),
cosmosDbSettings.PrimaryKey,
cosmosDbSettings.DatabaseId));
// Examination services
services.AddScoped(s => new ExaminationsQueryExpressionBuilder());
services
.AddScoped <IAsyncQueryHandler <CreateMELoggerQuery, LogMessageActionDefault>, CreateMELoggerService>();
services
.AddScoped <IAsyncQueryHandler <ExaminationsRetrievalQuery, ExaminationsOverview>,
ExaminationsDashboardService>();
services.AddScoped <IAsyncQueryHandler <CreateExaminationQuery, Examination>, CreateExaminationService>();
services
.AddScoped <IAsyncQueryHandler <ExaminationRetrievalQuery, Examination>, ExaminationRetrievalService>();
services
.AddScoped <IAsyncQueryHandler <ExaminationsRetrievalQuery, IEnumerable <Examination> >,
ExaminationsRetrievalService>();
services.AddScoped <IAsyncQueryHandler <UpdateExaminationUrgencySortQuery, bool>, UpdateExaminationUrgencySortService>();
services.AddScoped <IAsyncQueryHandler <NullQuery, bool>, ExaminationMigrationService>();
services.AddScoped <LocationMigrationService, LocationMigrationService>();
services.AddScoped <IAsyncQueryHandler <DuplicateExaminationByNhsNumberRetrievalQuery, Examination>, DuplicateExaminationByNhsNumberService>();
services
.AddScoped <IAsyncQueryHandler <ExaminationRetrievalQuery, Examination>, ExaminationRetrievalService>();
services
.AddScoped <IAsyncQueryHandler <ExaminationsRetrievalQuery, IEnumerable <Examination> >,
ExaminationsRetrievalService>();
services.AddScoped <IAsyncQueryHandler <CreateEventQuery, EventCreationResult>, CreateEventService>();
services
.AddScoped <IAsyncQueryHandler <FinanceQuery, IEnumerable <Examination> >,
FinanceService>();
// Medical team services
services.AddScoped <IAsyncUpdateDocumentHandler, MedicalTeamUpdateService>();
// Case Outcome Services
services.AddScoped <IAsyncQueryHandler <CloseCaseQuery, string>, CloseCaseService>();
services.AddScoped <IAsyncQueryHandler <CoronerReferralQuery, string>, CoronerReferralService>();
services.AddScoped <IAsyncQueryHandler <SaveOutstandingCaseItemsQuery, string>, SaveOutstandingCaseItemsService>();
services.AddScoped <IAsyncQueryHandler <ConfirmationOfScrutinyQuery, Examination>, ConfirmationOfScrutinyService>();
services.AddScoped <IAsyncQueryHandler <VoidCaseQuery, Examination>, VoidCaseService>();
// Patient details services
services
.AddScoped <IAsyncQueryHandler <PatientDetailsUpdateQuery, Examination>, PatientDetailsUpdateService>();
// User services
services.AddScoped <IAsyncQueryHandler <CreateUserQuery, MeUser>, CreateUserService>();
services.AddScoped <IAsyncQueryHandler <UserRetrievalByEmailQuery, MeUser>, UserRetrievalByEmailService>();
services.AddScoped <IAsyncQueryHandler <UserRetrievalByOktaIdQuery, MeUser>, UserRetrievalByOktaIdService>();
services.AddScoped <IAsyncQueryHandler <UserRetrievalByIdQuery, MeUser>, UserRetrievalByIdService>();
services.AddScoped <IAsyncQueryHandler <UserUpdateQuery, MeUser>, UserUpdateService>();
services.AddScoped <IAsyncQueryHandler <UserUpdateOktaQuery, MeUser>, UserUpdateOktaService>();
services.AddScoped <IAsyncQueryHandler <InvalidUserPermissionQuery, bool>, InvalidUserPermissionUpdateService>();
services.AddScoped <IOktaClient, OktaClient>();
// User session services
services.AddScoped <IAsyncQueryHandler <UserSessionUpdateOktaTokenQuery, MeUserSession>, UserSessionUpdateOktaTokenService>();
services.AddScoped <IAsyncQueryHandler <UserSessionRetrievalByOktaIdQuery, MeUserSession>, UserSessionRetrievalByOktaIdService>();
services.AddScoped <IAsyncQueryHandler <ExaminationByNhsNumberRetrievalQuery, Examination>, ExaminationByNhsNumberRetrievalService>();
// Used for roles; but is being abused to pass null and get all users.
services.AddScoped <IAsyncQueryHandler <UsersRetrievalQuery, IEnumerable <MeUser> >, UsersRetrievalService>();
services
.AddScoped <IAsyncQueryHandler <UsersRetrievalByRoleLocationQuery, IEnumerable <MeUser> >,
UsersRetrievalByRoleLocationQueryService>();
// Location Services
services.AddScoped <IAsyncQueryHandler <LocationRetrievalByIdQuery, Location>, LocationIdService>();
services
.AddScoped <IAsyncQueryHandler <LocationsRetrievalByQuery, IEnumerable <Location> >, LocationsQueryService
>();
services
.AddScoped <IAsyncQueryHandler <LocationParentsQuery, IEnumerable <Location> >, LocationParentsQueryService
>();
services
.AddScoped <IAsyncQueryHandler <LocationsParentsQuery, IDictionary <string, IEnumerable <Location> > >,
LocationsParentsQueryService>();
services
.AddScoped <IAsyncQueryHandler <LocationsRetrievalByIdQuery, IEnumerable <Location> >, LocationsRetrievalByIdService
>();
services
.AddScoped <IAsyncQueryHandler <UpdateLocationIsMeOfficeQuery, Location>, UpdateLocationIsMeOfficeService
>();
}
public static async Task <BookRepository> InitializeCosmosClientInstanceAsync(CosmosDbSettings cosmosDbSettings)
{
string databaseName = cosmosDbSettings.DatabaseName;
string containerName = cosmosDbSettings.ContainerName;
string account = cosmosDbSettings.Account;
string key = cosmosDbSettings.Key;
CosmosClient client = new CosmosClient(account, key);
BookRepository bookRepository = new BookRepository(client, cosmosDbSettings);
DatabaseResponse database = await client
.CreateDatabaseIfNotExistsAsync(databaseName)
.ConfigureAwait(false);
await database.Database
.CreateContainerIfNotExistsAsync(containerName, "/bookId")
.ConfigureAwait(false);
return(bookRepository);
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
// These registrations of the functions themselves are just for the DebugQueue. Ideally we don't want these registered in production
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder.AddScoped <OnEditSpecificationEvent>();
}
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder
.AddSingleton <IUserService, UserService>()
.AddSingleton <IHealthChecker, UserService>();
builder
.AddSingleton <IFundingStreamPermissionService, FundingStreamPermissionService>()
.AddSingleton <IHealthChecker, FundingStreamPermissionService>();
builder.AddSingleton <IValidator <UserCreateModel>, UserCreateModelValidator>();
builder.AddSingleton <IUserRepository, UserRepository>((ctx) =>
{
CosmosDbSettings usersDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", usersDbSettings);
usersDbSettings.ContainerName = "users";
CosmosRepository usersCosmosRepostory = new CosmosRepository(usersDbSettings);
return(new UserRepository(usersCosmosRepostory));
});
MapperConfiguration mappingConfig = new MapperConfiguration(c => c.AddProfile <UsersMappingProfile>());
builder.AddSingleton(mappingConfig.CreateMapper());
builder.AddSingleton <IVersionRepository <FundingStreamPermissionVersion>, VersionRepository <FundingStreamPermissionVersion> >((ctx) =>
{
CosmosDbSettings versioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", versioningDbSettings);
versioningDbSettings.ContainerName = "users";
CosmosRepository versioningRepository = new CosmosRepository(versioningDbSettings);
return(new VersionRepository <FundingStreamPermissionVersion>(versioningRepository, new NewVersionBuilderFactory <FundingStreamPermissionVersion>()));
});
builder.AddPolicySettings(config);
builder.AddSingleton <IUsersResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new UsersResiliencePolicies
{
FundingStreamPermissionVersionRepositoryPolicy = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
CacheProviderPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy),
SpecificationApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
UserRepositoryPolicy = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
});
});
builder.AddCaching(config);
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Users");
builder.AddApplicationInsightsServiceName(config, "CalculateFunding.Functions.Users");
builder.AddLogging("CalculateFunding.Functions.Users");
builder.AddServiceBus(config, "users");
builder.AddTelemetry();
builder.AddSpecificationsInterServiceClient(config);
builder.AddScoped <IUserProfileProvider, UserProfileProvider>();
return(builder.BuildServiceProvider());
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddHttpCachingMvc();
builder.AddQueryProviderAndExtractorForViewModelMvc <
FundingStructure,
TemplateMetadataContentsTimedETagProvider,
TemplateMatadataContentsTimedETagExtractor>(false);
builder.AddSingleton <IFundingStructureService, FundingStructureService>()
.AddSingleton <IValidator <UpdateFundingStructureLastModifiedRequest>, UpdateFundingStructureLastModifiedRequestValidator>();
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder
.AddSingleton <IHealthChecker, ControllerResolverHealthCheck>();
builder.AddSingleton <IQueueCreateSpecificationJobActions, QueueCreateSpecificationJobAction>();
builder.AddSingleton <IQueueEditSpecificationJobActions, QueueEditSpecificationJobActions>();
builder.AddSingleton <IQueueDeleteSpecificationJobActions, QueueDeleteSpecificationJobAction>();
builder.AddSingleton <ISpecificationsRepository, SpecificationsRepository>((ctx) =>
{
CosmosDbSettings specsVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", specsVersioningDbSettings);
specsVersioningDbSettings.ContainerName = "specs";
CosmosRepository resultsRepostory = new CosmosRepository(specsVersioningDbSettings);
return(new SpecificationsRepository(resultsRepostory));
});
builder
.AddSingleton <ISpecificationsService, SpecificationsService>()
.AddSingleton <IHealthChecker, SpecificationsService>();
builder.AddSingleton <ISpecificationIndexer, SpecificationIndexer>();
builder.AddSingleton <IProducerConsumerFactory, ProducerConsumerFactory>();
builder.AddSingleton <ISpecificationIndexingService, SpecificationIndexingService>();
builder
.AddSingleton <IJobManagement, JobManagement>();
builder.AddSingleton <IValidator <SpecificationCreateModel>, SpecificationCreateModelValidator>();
builder.AddSingleton <IValidator <SpecificationEditModel>, SpecificationEditModelValidator>();
builder.AddSingleton <IValidator <AssignDefinitionRelationshipMessage>, AssignDefinitionRelationshipMessageValidator>();
builder.AddSingleton <IValidator <AssignSpecificationProviderVersionModel>, AssignSpecificationProviderVersionModelValidator>();
builder
.AddSingleton <ISpecificationsSearchService, SpecificationsSearchService>()
.AddSingleton <IHealthChecker, SpecificationsSearchService>();
builder.AddSingleton <IResultsRepository, ResultsRepository>();
builder
.AddSingleton <ISpecificationsReportService, SpecificationsReportService>()
.AddSingleton <IHealthChecker, SpecificationsReportService>();
builder.AddSingleton <ITemplateMetadataResolver>((ctx) =>
{
TemplateMetadataResolver resolver = new TemplateMetadataResolver();
TemplateMetadataGenerator schema10Generator = new TemplateMetadataGenerator(ctx.GetService <ILogger>());
resolver.Register("1.0", schema10Generator);
return(resolver);
});
builder
.AddSingleton <LocalIBlobClient, LocalBlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "providerversions";
return(new LocalBlobClient(storageSettings));
});
builder.AddSingleton <ISpecificationTemplateVersionChangedHandler, SpecificationTemplateVersionChangedHandler>();
builder
.AddSingleton <IBlobClient, BlobClient>((ctx) =>
{
BlobStorageOptions storageSettings = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "providerversions";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(storageSettings);
return(new BlobClient(blobContainerRepository));
});
builder.AddSingleton <IVersionRepository <Models.Specs.SpecificationVersion>, VersionRepository <Models.Specs.SpecificationVersion> >((ctx) =>
{
CosmosDbSettings specsVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", specsVersioningDbSettings);
specsVersioningDbSettings.ContainerName = "specs";
CosmosRepository resultsRepostory = new CosmosRepository(specsVersioningDbSettings);
return(new VersionRepository <Models.Specs.SpecificationVersion>(resultsRepostory, new NewVersionBuilderFactory <SpecificationVersion>()));
});
MapperConfiguration mappingConfig = new MapperConfiguration(
c =>
{
c.AddProfile <SpecificationsMappingProfile>();
}
);
builder.AddFeatureToggling(Configuration);
builder.AddSingleton(mappingConfig.CreateMapper());
builder.AddServiceBus(Configuration);
builder.AddSearch(Configuration);
builder
.AddSingleton <ISearchRepository <SpecificationIndex>, SearchRepository <SpecificationIndex> >();
builder.AddCaching(Configuration);
builder.AddResultsInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddGraphInterServiceClient(Configuration);
builder.AddCalculationsInterServiceClient(Configuration);
builder.AddProvidersInterServiceClient(Configuration);
builder.AddPoliciesInterServiceClient(Configuration);
builder.AddDatasetsInterServiceClient(Configuration);
builder.AddPolicySettings(Configuration);
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(Configuration);
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
builder.AddSingleton <ISpecificationsResiliencePolicies>((ctx) =>
{
Polly.AsyncPolicy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
return(new SpecificationsResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PoliciesApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CalcsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProvidersApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
DatasetsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SpecificationsSearchRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SpecificationsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ResultsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProvider = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) =>
{
return(new JobManagementResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Apis.Specs");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.Specs");
builder.AddLogging("CalculateFunding.Apis.Specs");
builder.AddTelemetry();
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "Specs Microservice API");
}
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder
.AddSingleton <IHealthChecker, ControllerResolverHealthCheck>();
builder.AddSingleton <IScenariosRepository, ScenariosRepository>((ctx) =>
{
CosmosDbSettings scenariosVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", scenariosVersioningDbSettings);
scenariosVersioningDbSettings.ContainerName = "tests";
CosmosRepository resultsRepostory = new CosmosRepository(scenariosVersioningDbSettings);
return(new ScenariosRepository(resultsRepostory));
});
builder
.AddSingleton <IScenariosService, ScenariosService>()
.AddSingleton <IHealthChecker, ScenariosService>();
builder
.AddSingleton <IScenariosSearchService, ScenariosSearchService>()
.AddSingleton <IHealthChecker, ScenariosSearchService>();
builder.AddSingleton <IJobManagement, JobManagement>();
builder
.AddSingleton <IValidator <CreateNewTestScenarioVersion>, CreateNewTestScenarioVersionValidator>();
builder
.AddSingleton <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddSingleton <IVersionRepository <TestScenarioVersion>, VersionRepository <TestScenarioVersion> >((ctx) =>
{
CosmosDbSettings scenariosVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", scenariosVersioningDbSettings);
scenariosVersioningDbSettings.ContainerName = "tests";
CosmosRepository resultsRepostory = new CosmosRepository(scenariosVersioningDbSettings);
return(new VersionRepository <TestScenarioVersion>(resultsRepostory, new NewVersionBuilderFactory <TestScenarioVersion>()));
});
builder
.AddSingleton <ICalcsRepository, CalcsRepository>();
builder
.AddSingleton <ICancellationTokenProvider, HttpContextCancellationProvider>();
builder
.AddSingleton <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
MapperConfiguration scenariosConfig = new MapperConfiguration(c =>
{
c.AddProfile <DatasetsMappingProfile>();
});
builder
.AddSingleton(scenariosConfig.CreateMapper());
builder.AddCalculationsInterServiceClient(Configuration);
builder.AddSpecificationsInterServiceClient(Configuration);
builder.AddDatasetsInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddSearch(Configuration);
builder
.AddSingleton <ISearchRepository <ScenarioIndex>, SearchRepository <ScenarioIndex> >();
builder
.AddSingleton <ISearchRepository <TestScenarioResultIndex>, SearchRepository <TestScenarioResultIndex> >();
builder.AddServiceBus(Configuration);
builder.AddCaching(Configuration);
builder.AddFeatureToggling(Configuration);
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.Scenarios");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.Scenarios");
builder.AddLogging("CalculateFunding.Api.Scenarios");
builder.AddTelemetry();
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
builder.AddPolicySettings(Configuration);
builder.AddSingleton <IScenariosResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
AsyncPolicy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
return(new ScenariosResiliencePolicies()
{
CalcsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
DatasetsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ScenariosRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SpecificationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ScenariosApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
});
});
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new JobManagementResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
});
});
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "Scenarios Microservice API");
}
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddSingleton <IValidator <SetFundingStreamCurrentProviderVersionRequest>, SetFundingStreamCurrentProviderVersionRequestValidator>();
builder.AddSingleton <IFundingStreamProviderVersionService, FundingStreamProviderVersionService>();
builder
.AddSingleton <IHealthChecker, ControllerResolverHealthCheck>();
builder.AddCaching(Configuration);
builder
.AddSingleton <IProviderVersionService, ProviderVersionService>()
.AddSingleton <IHealthChecker, ProviderVersionService>();
builder
.AddSingleton <IProviderVersionSearchService, ProviderVersionSearchService>()
.AddSingleton <IHealthChecker, ProviderVersionSearchService>();
builder
.AddSingleton <IJobManagement, JobManagement>();
builder
.AddSingleton <IScopedProvidersService, ScopedProvidersService>()
.AddSingleton <IHealthChecker, ScopedProvidersService>();
builder
.AddSingleton <IProviderVersionUpdateCheckService, ProviderVersionUpdateCheckService>();
builder.AddSingleton <IValidator <ProviderVersionViewModel>, UploadProviderVersionValidator>();
builder.AddSearch(this.Configuration);
builder
.AddSingleton <ISearchRepository <ProvidersIndex>, SearchRepository <ProvidersIndex> >();
builder
.AddSingleton <IBlobClient, BlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "providerversions";
return(new BlobClient(storageSettings));
});
builder.AddSingleton <IProviderVersionsMetadataRepository, ProviderVersionsMetadataRepository>(
ctx =>
{
CosmosDbSettings specRepoDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", specRepoDbSettings);
specRepoDbSettings.ContainerName = "providerversionsmetadata";
CosmosRepository cosmosRepository = new CosmosRepository(specRepoDbSettings);
return(new ProviderVersionsMetadataRepository(cosmosRepository));
});
builder.AddPolicySettings(Configuration);
MapperConfiguration providerVersionsConfig = new MapperConfiguration(c =>
{
c.AddProfile <ProviderVersionsMappingProfile>();
});
builder
.AddSingleton(providerVersionsConfig.CreateMapper());
builder.AddPoliciesInterServiceClient(Configuration);
builder.AddResultsInterServiceClient(Configuration);
builder.AddSpecificationsInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.Providers");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.Providers");
builder.AddLogging("CalculateFunding.Api.Providers");
builder.AddTelemetry();
builder.AddServiceBus(Configuration);
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(Configuration);
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
ProvidersResiliencePolicies resiliencePolicies = CreateResiliencePolicies(totalNetworkRequestsPolicy);
builder.AddSingleton <IJobManagementResiliencePolicies>(resiliencePolicies);
builder.AddSingleton <IProvidersResiliencePolicies>(resiliencePolicies);
builder
.AddSingleton <IFileSystemCache, FileSystemCache>()
.AddSingleton <IFileSystemAccess, FileSystemAccess>()
.AddSingleton <IFileSystemCacheSettings, FileSystemCacheSettings>();
builder
.AddSingleton <IProviderVersionServiceSettings>(ctx =>
{
ProviderVersionServiceSettings settings = new ProviderVersionServiceSettings();
Configuration.Bind("providerversionservicesettings", settings);
return(settings);
});
builder
.AddSingleton <IScopedProvidersServiceSettings>(ctx =>
{
ScopedProvidersServiceSettings settings = new ScopedProvidersServiceSettings();
Configuration.Bind("scopedprovidersservicesetting", settings);
return(settings);
});
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHealthCheckMiddleware();
builder.AddHttpContextAccessor();
builder.AddSearch(Configuration);
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "Provider Microservice API");
}
}
public CosmosDbRepository(CosmosDbSettings settings)
{
_settings = settings;
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <CalcsAddRelationshipToBuildProject>();
builder.AddSingleton <OnCalcsCreateDraftEvent>();
builder.AddSingleton <OnCalcsInstructAllocationResultsFailure>();
builder.AddSingleton <OnCalcsInstructAllocationResults>();
builder.AddSingleton <OnCalculationAggregationsJobCompleted>();
builder.AddSingleton <OnDataDefinitionChanges>();
builder.AddSingleton <OnEditCalculationSpecificationEvent>();
builder.AddSingleton <OnEditSpecificationEvent>();
builder.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder.AddSingleton <ICalculationService, CalculationService>();
builder.AddSingleton <ICalculationsSearchService, CalculationSearchService>();
builder.AddSingleton <ICalculationCodeReferenceUpdate, CalculationCodeReferenceUpdate>();
builder.AddSingleton <ITokenChecker, TokenChecker>();
builder.AddSingleton <IValidator <Calculation>, CalculationModelValidator>();
builder.AddSingleton <IPreviewService, PreviewService>();
builder.AddSingleton <ICompilerFactory, CompilerFactory>();
builder.AddSingleton <IDatasetRepository, DatasetRepository>();
builder.AddSingleton <IJobService, JobService>();
builder
.AddSingleton <CSharpCompiler>()
.AddSingleton <VisualBasicCompiler>()
.AddSingleton <VisualBasicSourceFileGenerator>();
builder.AddSingleton <ISourceFileGeneratorProvider, SourceFileGeneratorProvider>();
builder.AddSingleton <IValidator <PreviewRequest>, PreviewRequestModelValidator>();
builder.AddSingleton <IProviderResultsRepository, ProviderResultsRepository>();
builder.AddSingleton <ISpecificationRepository, SpecificationRepository>();
builder.AddSingleton <IBuildProjectsService, BuildProjectsService>();
builder.AddSingleton <IBuildProjectsRepository, BuildProjectsRepository>();
builder.AddSingleton <ICodeMetadataGeneratorService, ReflectionCodeMetadataGenerator>();
builder.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
builder.AddSingleton <ISourceCodeService, SourceCodeService>();
builder.AddSingleton <IJobHelperService, JobHelperService>();
builder
.AddSingleton <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddSingleton <ISourceFileRepository, SourceFileRepository>(ctx =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
config.Bind("CommonStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "source";
return(new SourceFileRepository(blobStorageOptions));
});
builder.AddSingleton <IVersionRepository <CalculationVersion>, VersionRepository <CalculationVersion> >((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.CollectionName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new VersionRepository <CalculationVersion>(resultsRepostory));
});
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder.AddCosmosDb(config, "calcs");
}
else
{
builder.AddCosmosDb(config);
}
builder.AddFeatureToggling(config);
builder.AddSearch(config);
builder.AddServiceBus(config);
builder.AddResultsInterServiceClient(config);
builder.AddSpecificationsInterServiceClient(config);
builder.AddDatasetsInterServiceClient(config);
builder.AddJobsInterServiceClient(config);
builder.AddCaching(config);
builder.AddEngineSettings(config);
builder.AddApplicationInsights(config, "CalculateFunding.Functions.Calcs");
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Calcs");
builder.AddLogging("CalculateFunding.Functions.Calcs");
builder.AddTelemetry();
PolicySettings policySettings = builder.GetPolicySettings(config);
ResiliencePolicies resiliencePolicies = CreateResiliencePolicies(policySettings);
builder.AddSingleton <ICalcsResiliencePolicies>(resiliencePolicies);
builder.AddSingleton <IJobHelperResiliencePolicies>(resiliencePolicies);
return(builder.BuildServiceProvider());
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder
.AddSingleton <OnTestSpecificationProviderResultsCleanup>();
builder
.AddSingleton <OnEditSpecificationEvent>();
builder
.AddSingleton <OnTestExecution>();
builder
.AddSingleton <IBuildProjectRepository, BuildProjectRepository>();
builder
.AddSingleton <IGherkinParserService, GherkinParserService>();
builder
.AddSingleton <IGherkinParser, GherkinParser>();
builder
.AddSingleton <ICodeMetadataGeneratorService, ReflectionCodeMetadataGenerator>();
builder
.AddSingleton <IStepParserFactory, StepParserFactory>();
builder
.AddSingleton <ITestResultsRepository, TestResultsRepository>();
builder
.AddSingleton <ISpecificationRepository, SpecificationRepository>();
builder
.AddSingleton <IScenariosRepository, ScenariosRepository>();
builder
.AddSingleton <ITestEngineService, Services.TestRunner.Services.TestEngineService>();
builder
.AddSingleton <ITestEngine, Services.TestRunner.TestEngine>();
builder
.AddSingleton <IGherkinExecutor, GherkinExecutor>();
builder
.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder.AddSingleton <IProviderService, ProviderService>();
builder.AddSingleton <ICosmosRepository, CosmosRepository>();
builder.AddSingleton <IProviderSourceDatasetsRepository, ProviderSourceDatasetsRepository>((ctx) =>
{
CosmosDbSettings providersDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", providersDbSettings);
providersDbSettings.CollectionName = "providerdatasets";
CosmosRepository providersCosmosRepostory = new CosmosRepository(providersDbSettings);
EngineSettings engineSettings = ctx.GetService <EngineSettings>();
return(new ProviderSourceDatasetsRepository(providersCosmosRepostory, engineSettings));
});
builder.AddSingleton <IProviderResultsRepository, ProviderResultsRepository>((ctx) =>
{
CosmosDbSettings providersDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", providersDbSettings);
providersDbSettings.CollectionName = "calculationresults";
CosmosRepository providersCosmosRepostory = new CosmosRepository(providersDbSettings);
ICacheProvider cacheProvider = ctx.GetService <ICacheProvider>();
return(new ProviderResultsRepository(providersCosmosRepostory));
});
builder.AddSingleton <ITestResultsSearchService, TestResultsSearchService>();
builder.AddSingleton <ITestResultsCountsService, TestResultsCountsService>();
MapperConfiguration resultsMappingConfiguration = new MapperConfiguration(c =>
{
c.AddProfile <ResultsMappingProfile>();
c.AddProfile <ProviderMappingProfile>();
});
builder
.AddSingleton(resultsMappingConfiguration.CreateMapper());
builder.AddSingleton <ITestResultsService, TestResultsService>();
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder.AddCosmosDb(config, "testresults");
}
else
{
builder.AddCosmosDb(config);
}
builder.AddSearch(config);
builder.AddSpecificationsInterServiceClient(config);
builder.AddScenariosInterServiceClient(config);
builder.AddCalcsInterServiceClient(config);
builder.AddResultsInterServiceClient(config);
builder.AddCaching(config);
builder.AddApplicationInsights(config, "CalculateFunding.Functions.TestEngine");
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.TestEngine", TelemetryChannelType.Sync);
builder.AddLogging("CalculateFunding.Functions.TestEngine");
builder.AddTelemetry();
builder.AddEngineSettings(config);
builder.AddPolicySettings(config);
builder.AddFeatureToggling(config);
builder.AddSingleton <ITestRunnerResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
BulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
Policy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
ResiliencePolicies resiliencePolicies = new ResiliencePolicies()
{
BuildProjectRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProviderRepository = redisPolicy,
ProviderResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ProviderSourceDatasetsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ScenariosRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(new[] { totalNetworkRequestsPolicy, redisPolicy }),
SpecificationRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
TestResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
TestResultsSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy)
};
return(resiliencePolicies);
});
return(builder.BuildServiceProvider());
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddSingleton <ICalculationResultsRepository, CalculationResultsRepository>();
builder
.AddSingleton <IResultsService, ResultsService>()
.AddSingleton <IHealthChecker, ResultsService>();
builder
.AddSingleton <IPublishedResultsService, PublishedResultsService>()
.AddSingleton <IHealthChecker, PublishedResultsService>();
builder
.AddSingleton <IResultsSearchService, ResultsSearchService>()
.AddSingleton <IHealthChecker, ResultsSearchService>();
builder
.AddSingleton <IProviderCalculationResultsSearchService, ProviderCalculationResultsSearchService>()
.AddSingleton <IHealthChecker, ProviderCalculationResultsSearchService>();
builder
.AddSingleton <ICalculationProviderResultsSearchService, CalculationProviderResultsSearchService>()
.AddSingleton <IHealthChecker, CalculationProviderResultsSearchService>();
builder.AddSingleton <IProviderImportMappingService, ProviderImportMappingService>();
builder
.AddSingleton <IAllocationNotificationsFeedsSearchService, AllocationNotificationsFeedsSearchService>();
builder.AddSingleton <IProviderVariationAssemblerService, ProviderVariationAssemblerService>();
MapperConfiguration resultsConfig = new MapperConfiguration(c =>
{
c.AddProfile <DatasetsMappingProfile>();
c.AddProfile <ResultServiceMappingProfile>();
});
builder
.AddSingleton(resultsConfig.CreateMapper());
builder.AddSingleton <ICalculationResultsRepository, CalculationResultsRepository>((ctx) =>
{
CosmosDbSettings calssDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", calssDbSettings);
calssDbSettings.CollectionName = "calculationresults";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(calssDbSettings);
return(new CalculationResultsRepository(calcsCosmosRepostory));
});
builder.AddSingleton <IProviderSourceDatasetRepository, ProviderSourceDatasetRepository>((ctx) =>
{
CosmosDbSettings provDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", provDbSettings);
provDbSettings.CollectionName = "providerdatasets";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(provDbSettings);
return(new ProviderSourceDatasetRepository(calcsCosmosRepostory));
});
builder.AddSingleton <IPublishedProviderResultsRepository, PublishedProviderResultsRepository>((ctx) =>
{
CosmosDbSettings resultsDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", resultsDbSettings);
resultsDbSettings.CollectionName = "publishedproviderresults";
CosmosRepository resultsRepostory = new CosmosRepository(resultsDbSettings);
return(new PublishedProviderResultsRepository(resultsRepostory));
});
builder.AddSingleton <IProviderChangesRepository, ProviderChangesRepository>((ctx) =>
{
CosmosDbSettings resultsDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", resultsDbSettings);
resultsDbSettings.CollectionName = "publishedproviderchanges";
CosmosRepository resultsRepostory = new CosmosRepository(resultsDbSettings);
ILogger logger = ctx.GetService <ILogger>();
return(new ProviderChangesRepository(resultsRepostory, logger));
});
builder.AddSingleton <IProviderCalculationResultsReIndexerService, ProviderCalculationResultsReIndexerService>();
builder.AddSingleton <IValidator <MasterProviderModel>, MasterProviderModelValidator>();
builder
.AddSingleton <ISpecificationsRepository, SpecificationsRepository>();
builder
.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder
.AddSingleton <IPublishedProviderResultsAssemblerService, PublishedProviderResultsAssemblerService>();
builder.AddSingleton <IPublishedProviderResultsSettings, PublishedProviderResultsSettings>((ctx) =>
{
PublishedProviderResultsSettings settings = new PublishedProviderResultsSettings();
Configuration.Bind("PublishedProviderResultsSettings", settings);
return(settings);
});
builder.AddSingleton <IVersionRepository <PublishedAllocationLineResultVersion>, VersionRepository <PublishedAllocationLineResultVersion> >((ctx) =>
{
CosmosDbSettings versioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", versioningDbSettings);
versioningDbSettings.CollectionName = "publishedproviderresults";
CosmosRepository resultsRepostory = new CosmosRepository(versioningDbSettings);
return(new VersionRepository <PublishedAllocationLineResultVersion>(resultsRepostory));
});
builder
.AddSingleton <IBlobClient, BlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "datasets";
return(new BlobClient(storageSettings));
});
builder.AddUserProviderFromRequest();
builder.AddSearch(Configuration);
builder.AddServiceBus(Configuration);
builder.AddCaching(Configuration);
builder.AddApplicationInsights(Configuration, "CalculateFunding.Api.Results");
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.Results");
builder.AddLogging("CalculateFunding.Api.Results");
builder.AddTelemetry();
builder.AddSpecificationsInterServiceClient(Configuration);
builder.AddCalcsInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddPolicySettings(Configuration);
builder.AddHttpContextAccessor();
builder.AddFeatureToggling(Configuration);
builder.AddSingleton <IPublishedAllocationLineLogicalResultVersionService, PublishedAllocationLineLogicalResultVersionService>();
builder.AddSingleton <IResultsResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
BulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new ResiliencePolicies()
{
CalculationProviderResultsSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
ResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ResultsSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
SpecificationsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
AllocationNotificationFeedSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
ProviderProfilingRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedProviderCalculationResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
PublishedProviderResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
CalculationsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProviderChangesRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ProviderCalculationResultsSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
CsvBlobPolicy = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
});
});
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHealthCheckMiddleware();
ServiceProvider = builder.BuildServiceProvider();
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder
.AddSingleton <IHealthChecker, ControllerResolverHealthCheck>();
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder
.AddSingleton <IUserService, UserService>()
.AddSingleton <IHealthChecker, UserService>();
builder
.AddSingleton <IFundingStreamPermissionService, FundingStreamPermissionService>()
.AddSingleton <IHealthChecker, FundingStreamPermissionService>();
builder.AddSingleton <IValidator <UserCreateModel>, UserCreateModelValidator>();
builder.AddSingleton <IUserRepository, UserRepository>((ctx) =>
{
CosmosDbSettings usersDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", usersDbSettings);
usersDbSettings.ContainerName = "users";
CosmosRepository usersCosmosRepostory = new CosmosRepository(usersDbSettings);
return(new UserRepository(usersCosmosRepostory));
});
MapperConfiguration mappingConfig = new MapperConfiguration(c => c.AddProfile <UsersMappingProfile>());
builder.AddSingleton(mappingConfig.CreateMapper());
builder.AddSingleton <IVersionRepository <FundingStreamPermissionVersion>, VersionRepository <FundingStreamPermissionVersion> >((ctx) =>
{
CosmosDbSettings versioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", versioningDbSettings);
versioningDbSettings.ContainerName = "users";
CosmosRepository versioningRepository = new CosmosRepository(versioningDbSettings);
return(new VersionRepository <FundingStreamPermissionVersion>(versioningRepository, new NewVersionBuilderFactory <FundingStreamPermissionVersion>()));
});
builder.AddPolicySettings(Configuration);
builder.AddSingleton <IUsersResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new UsersResiliencePolicies
{
FundingStreamPermissionVersionRepositoryPolicy = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
CacheProviderPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy),
SpecificationApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
UserRepositoryPolicy = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
});
});
builder.AddCaching(Configuration);
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.Users");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.Users");
builder.AddLogging("CalculateFunding.Api.Users");
builder.AddTelemetry();
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
builder.AddSpecificationsInterServiceClient(Configuration);
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "Users Microservice API");
}
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddSingleton <ISpecificationsRepository, SpecificationsRepository>();
builder
.AddSingleton <ISpecificationsService, SpecificationsService>()
.AddSingleton <IHealthChecker, SpecificationsService>();
builder.AddSingleton <IValidator <PolicyCreateModel>, PolicyCreateModelValidator>();
builder.AddSingleton <IValidator <PolicyEditModel>, PolicyEditModelValidator>();
builder.AddSingleton <IValidator <CalculationCreateModel>, CalculationCreateModelValidator>();
builder.AddSingleton <IValidator <SpecificationCreateModel>, SpecificationCreateModelValidator>();
builder.AddSingleton <IValidator <CalculationEditModel>, CalculationEditModelValidator>();
builder.AddSingleton <IValidator <SpecificationEditModel>, SpecificationEditModelValidator>();
builder.AddSingleton <IValidator <AssignDefinitionRelationshipMessage>, AssignDefinitionRelationshipMessageValidator>();
builder
.AddSingleton <ISpecificationsSearchService, SpecificationsSearchService>()
.AddSingleton <IHealthChecker, SpecificationsSearchService>();
builder.AddSingleton <IResultsRepository, ResultsRepository>();
builder.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder.AddSingleton <IFundingService, FundingService>();
builder.AddSingleton <ICosmosRepository, CosmosRepository>();
builder.AddSingleton <IVersionRepository <SpecificationVersion>, VersionRepository <SpecificationVersion> >((ctx) =>
{
CosmosDbSettings specsVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", specsVersioningDbSettings);
specsVersioningDbSettings.CollectionName = "specs";
CosmosRepository resultsRepostory = new CosmosRepository(specsVersioningDbSettings);
return(new VersionRepository <SpecificationVersion>(resultsRepostory));
});
MapperConfiguration mappingConfig = new MapperConfiguration(c => c.AddProfile <SpecificationsMappingProfile>());
builder.AddFeatureToggling(Configuration);
builder.AddSingleton(mappingConfig.CreateMapper());
builder.AddUserProviderFromRequest();
builder.AddCosmosDb(Configuration);
builder.AddServiceBus(Configuration);
builder.AddSearch(Configuration);
builder.AddCaching(Configuration);
builder.AddResultsInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddCalcsInterServiceClient(Configuration);
builder.AddPolicySettings(Configuration);
builder.AddSingleton <ISpecificationsResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
BulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
Polly.Policy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
return(new SpecificationsResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddApplicationInsights(Configuration, "CalculateFunding.Api.Specs");
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Apis.Specs");
builder.AddLogging("CalculateFunding.Apis.Specs");
builder.AddTelemetry();
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddSingleton <IScenariosRepository, ScenariosRepository>();
builder
.AddSingleton <IScenariosService, ScenariosService>()
.AddSingleton <IHealthChecker, ScenariosService>();
builder
.AddSingleton <IScenariosSearchService, ScenariosSearchService>()
.AddSingleton <IHealthChecker, ScenariosSearchService>();
builder
.AddSingleton <IValidator <CreateNewTestScenarioVersion>, CreateNewTestScenarioVersionValidator>();
builder
.AddSingleton <ISpecificationsRepository, SpecificationsRepository>();
builder
.AddSingleton <IBuildProjectRepository, BuildProjectRepository>();
builder
.AddSingleton <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddSingleton <IVersionRepository <TestScenarioVersion>, VersionRepository <TestScenarioVersion> >((ctx) =>
{
CosmosDbSettings scenariosVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", scenariosVersioningDbSettings);
scenariosVersioningDbSettings.CollectionName = "tests";
CosmosRepository resultsRepostory = new CosmosRepository(scenariosVersioningDbSettings);
return(new VersionRepository <TestScenarioVersion>(resultsRepostory));
});
builder
.AddSingleton <ICalcsRepository, CalcsRepository>();
builder
.AddSingleton <ICancellationTokenProvider, HttpContextCancellationProvider>();
builder.AddSingleton <IDatasetRepository, DatasetRepository>();
builder
.AddSingleton <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddUserProviderFromRequest();
builder.AddCalcsInterServiceClient(Configuration);
builder.AddSpecificationsInterServiceClient(Configuration);
builder.AddDatasetsInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddCosmosDb(Configuration);
builder.AddSearch(Configuration);
builder.AddServiceBus(Configuration);
builder.AddCaching(Configuration);
builder.AddFeatureToggling(Configuration);
builder.AddApplicationInsights(Configuration, "CalculateFunding.Api.Scenarios");
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.Scenarios");
builder.AddLogging("CalculateFunding.Api.Scenarios");
builder.AddTelemetry();
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
builder.AddPolicySettings(Configuration);
builder.AddSingleton <IScenariosResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
BulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
Policy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
return(new ScenariosResiliencePolicies()
{
CalcsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
DatasetRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
}
