private static ResiliencePolicies CreateResiliencePolicies(PolicySettings policySettings)
{
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
ResiliencePolicies resiliencePolicies = new ResiliencePolicies()
{
CalculationProviderResultsSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
ResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ResultsSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
SpecificationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProviderProfilingRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedProviderCalculationResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
PublishedProviderResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
CalculationsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProviderCalculationResultsSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
ProviderChangesRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
PoliciesApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CalculationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
BlobClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProvider = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy)
};
return(resiliencePolicies);
}
private void InternalPublish(object @event, string exchangeName, string routingKey)
{
if (!_connection.IsConnected)
{
_connection.TryConnect(ResiliencePolicies.ConnectionPolicyFactory);
}
using (var channel = _connection.CreateModel())
{
_onSetRunner.RunIfSet(() => channel.ExchangeDeclare(exchange: exchangeName, type: _queueConfiguration.ExchangeType.ToString().ToLower(), durable: _queueConfiguration.DurableExchange));
string message;
if (@event is string)
{
message = (string)@event;
}
else
{
message = JsonConvert.SerializeObject(@event, GlobalSettings.SerializerSettings);
}
var body = Encoding.UTF8.GetBytes(message);
ResiliencePolicies.
ConnectionPolicyFactory(_eventBusConfiguration.Logger)
.Execute(() =>
{
channel.BasicPublish(exchange: exchangeName,
routingKey: routingKey,
basicProperties: null,
body: body);
});
}
}
public void TestBaseSetUp()
{
_validationResult = new ValidationResult();
SpecificationId = NewRandomString();
string providerId = NewRandomString();
ProviderIds = new[] { providerId };
FundingStreamId = NewRandomString();
FundingPeriodId = NewRandomString();
CorrelationId = NewRandomString();
User = NewUser();
Jobs = Substitute.For <TJobCreation>();
SpecificationIdValidator = Substitute.For <ISpecificationIdServiceRequestValidator>();
ProviderIdsValidator = Substitute.For <IPublishedProviderIdsServiceRequestValidator>();
SpecificationIdValidator.Validate(SpecificationId)
.Returns(_validationResult);
ProviderIdsValidator.Validate(Arg.Is <string[]>(_ => _.SequenceEqual(ProviderIds)))
.Returns(_validationResult);
Specifications = Substitute.For <ISpecificationsApiClient>();
ProviderService = Substitute.For <IProviderService>();
ResiliencePolicies = new ResiliencePolicies
{
SpecificationsRepositoryPolicy = Polly.Policy.NoOpAsync(),
PublishedFundingRepository = Polly.Policy.NoOpAsync()
};
FundingConfigurationService = Substitute.For <IFundingConfigurationService>();
}
private static ResiliencePolicies CreateResiliencePolicies(PolicySettings policySettings)
{
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
ResiliencePolicies resiliencePolicies = new ResiliencePolicies
{
CalculationResultsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProvidersApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedProviderVersionRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
SpecificationsRepositoryPolicy = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
BlobClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CalculationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedFundingRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(),
PoliciesApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProfilingApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
FundingFeedSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
PublishedFundingBlobRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedProviderSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
PublishedIndexSearchResiliencePolicy = PublishedIndexSearchResiliencePolicy.GeneratePublishedIndexSearch(),
SpecificationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProvider = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy)
};
return(resiliencePolicies);
}
public void SetUp()
{
_calculationsFeatureFlag = Substitute.For <ICalculationsFeatureFlag>();
_graphApiClient = Substitute.For <IGraphApiClient>();
ResiliencePolicies resiliencePolicies = new ResiliencePolicies {
GraphApiClientPolicy = Polly.Policy.NoOpAsync()
};
_graphRepository = new GraphRepository(_graphApiClient, resiliencePolicies, _calculationsFeatureFlag);
}
private void HandleAckException(Exception exception, string message, ulong deliveryTag, IModel channel, MessageHeaders messageHeaders)
{
try
{
_eventBusConfiguration.Logger.LogCritical(exception.ToString());
ResiliencePolicies.GeneralRetryPolicyFactory(_eventBusConfiguration.Logger)
.Execute(GetAckOnExceptionAction(message, deliveryTag, exception, channel, messageHeaders));
}
catch (Exception ex)
{
_eventBusConfiguration.Logger.LogCritical(ex.ToString());
}
}
private PublishedProviderIndexerService CreatePublishedProviderIndexerService(ILogger logger = null,
ISearchRepository <PublishedProviderIndex> searchRepository = null)
{
_resiliencePolicies = new ResiliencePolicies()
{
PublishedProviderSearchRepository = Policy.NoOpAsync(),
};
IConfiguration configuration = Substitute.For <IConfiguration>();
return(new PublishedProviderIndexerService(
logger ?? CreateLogger(),
searchRepository ?? CreateSearchRepository(),
_resiliencePolicies,
new PublishingEngineOptions(configuration)));
}
private TestResultsService CreateTestResultsService(
ITestResultsRepository testResultsRepository = null,
ISearchRepository <TestScenarioResultIndex> searchRepository = null,
IMapper mapper = null,
ILogger logger = null,
ITelemetry telemetry = null,
ResiliencePolicies policies = null,
IProviderService providerService = null)
{
return(new TestResultsService(
testResultsRepository ?? CreateTestResultsRepository(),
searchRepository ?? CreateSearchRespository(),
mapper ?? CreateMapper(),
logger ?? CreateLogger(),
telemetry ?? CreateTelemetry(),
policies ?? TestRunnerResilienceTestHelper.GenerateTestPolicies(),
providerService ?? CreateProviderService()
));
}
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());
}
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)
{
// 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 <OnProviderResultsSpecificationCleanup>();
builder.AddScoped <OnReIndexCalculationResults>();
builder.AddScoped <OnCalculationResultsCsvGeneration>();
builder.AddScoped <OnCalculationResultsCsvGenerationTimer>();
builder.AddScoped <OnMergeSpecificationInformationForProviderWithResults>();
builder.AddScoped <OnMergeSpecificationInformationForProviderWithResultsFailure>();
builder.AddScoped <OnDeleteCalculationResults>();
builder.AddScoped <OnDeleteCalculationResultsFailure>();
builder.AddScoped <OnSearchIndexWriterEventTrigger>();
builder.AddScoped <OnSearchIndexWriterEventTriggerFailure>();
}
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddSingleton <ISpecificationsWithProviderResultsService, SpecificationsWithProviderResultsService>();
builder.AddSingleton <IProducerConsumerFactory, ProducerConsumerFactory>();
builder.AddSingleton <IConfiguration>(config);
builder.AddSingleton <ICalculationResultsRepository, CalculationResultsRepository>();
builder.AddSingleton <IResultsService, ResultsService>();
builder.AddSingleton <IJobManagement, JobManagement>();
builder.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder.AddSingleton <IDeadletterService, DeadletterService>();
builder.AddSingleton <IProviderCalculationResultsReIndexerService, ProviderCalculationResultsReIndexerService>();
builder.AddTransient <ICsvUtils, CsvUtils>();
builder
.AddTransient <IProviderResultsCsvGeneratorService, ProviderResultsCsvGeneratorService>()
.AddTransient <IHealthChecker, ProviderResultsCsvGeneratorService>();
builder.AddTransient <IProviderResultsToCsvRowsTransformation, ProviderResultsToCsvRowsTransformation>();
builder.AddSingleton <IFileSystemAccess, FileSystemAccess>();
builder.AddSingleton <IFileSystemCacheSettings, FileSystemCacheSettings>();
builder
.AddSingleton <ISearchIndexWriterSettings, SearchIndexWriterSettings>((ctx) =>
{
IConfigurationSection setttingConfig = config.GetSection("searchIndexWriterSettings");
return(new SearchIndexWriterSettings(setttingConfig));
});
builder.AddSingleton <CommonStorage.IBlobClient>(ctx =>
{
CommonStorage.BlobStorageOptions options = new CommonStorage.BlobStorageOptions();
config.Bind("AzureStorageSettings", options);
options.ContainerName = "calcresults";
CommonStorage.IBlobContainerRepository blobContainerRepository = new CommonStorage.BlobContainerRepository(options);
return(new CommonStorage.BlobClient(blobContainerRepository));
});
builder.AddScoped <ISearchIndexProcessorFactory, SearchIndexProcessorFactory>();
builder.AddScoped <ISearchIndexDataReader <ProviderResultDataKey, ProviderResult>, ProviderCalculationResultsIndexDataReader>();
builder.AddScoped <ISearchIndexTrasformer <ProviderResult, ProviderCalculationResultsIndex>, ProviderCalculationResultsIndexTransformer>();
builder.AddScoped <ISearchIndexProcessor, ProviderCalculationResultsIndexProcessor>();
builder.AddScoped <ISearchIndexWriterService, SearchIndexWriterService>();
builder.AddCaching(config);
builder.AddSingleton <ICalculationResultsRepository, CalculationResultsRepository>((ctx) =>
{
CosmosDbSettings calssDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calssDbSettings);
calssDbSettings.ContainerName = "calculationresults";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(calssDbSettings);
EngineSettings engineSettings = ctx.GetService <EngineSettings>();
return(new CalculationResultsRepository(calcsCosmosRepostory, engineSettings));
});
builder.AddSingleton <IProviderSourceDatasetRepository, ProviderSourceDatasetRepository>((ctx) =>
{
CosmosDbSettings provDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", provDbSettings);
provDbSettings.ContainerName = "providerdatasets";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(provDbSettings);
return(new ProviderSourceDatasetRepository(calcsCosmosRepostory));
});
builder
.AddSingleton <IBlobClient, AzureStorage.BlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
config.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "calcresults";
return(new AzureStorage.BlobClient(storageSettings));
});
builder.AddSearch(config);
builder
.AddSingleton <ISearchRepository <ProviderCalculationResultsIndex>, SearchRepository <ProviderCalculationResultsIndex> >();
builder.AddServiceBus(config, "results");
builder.AddCaching(config);
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Results");
builder.AddApplicationInsightsServiceName(config, "CalculateFunding.Functions.Results");
builder.AddLogging("CalculateFunding.Functions.Results");
builder.AddTelemetry();
builder.AddEngineSettings(config);
builder.AddCalculationsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddSpecificationsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddJobsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddProvidersInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddPoliciesInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
MapperConfiguration resultsConfig = new MapperConfiguration(c =>
{
c.AddProfile <ResultsMappingProfile>();
});
builder.AddSingleton(resultsConfig.CreateMapper());
builder.AddFeatureToggling(config);
builder.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(config);
ResiliencePolicies resultsResiliencePolicies = CreateResiliencePolicies(policySettings);
builder.AddSingleton <IResultsResiliencePolicies>(resultsResiliencePolicies);
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) =>
{
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new JobManagementResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddScoped <IUserProfileProvider, UserProfileProvider>();
return(builder.BuildServiceProvider());
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddFeatureManagement();
builder.AddSingleton <IConfiguration>(ctx => 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 <CalcsAddRelationshipToBuildProject>();
builder.AddScoped <OnCalcsInstructAllocationResultsFailure>();
builder.AddScoped <OnCalcsInstructAllocationResults>();
builder.AddScoped <OnCalculationAggregationsJobCompleted>();
builder.AddScoped <OnDataDefinitionChanges>();
builder.AddScoped <OnApplyTemplateCalculations>();
builder.AddScoped <OnApplyTemplateCalculationsFailure>();
builder.AddScoped <OnReIndexSpecificationCalculationRelationships>();
builder.AddScoped <OnReIndexSpecificationCalculationRelationshipsFailure>();
builder.AddScoped <OnDeleteCalculations>();
builder.AddScoped <OnDeleteCalculationsFailure>();
builder.AddScoped <OnUpdateCodeContextCache>();
builder.AddScoped <OnUpdateCodeContextCacheFailure>();
builder.AddScoped <OnApproveAllCalculations>();
builder.AddScoped <OnApproveAllCalculationsFailure>();
}
builder.AddSingleton <IFundingLineRoundingSettings, FundingLineRoundingSettings>();
builder.AddScoped <IApplyTemplateCalculationsService, ApplyTemplateCalculationsService>();
builder.AddSingleton <ICalculationsRepository, CalculationsRepository>((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.ContainerName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new CalculationsRepository(resultsRepostory));
});
builder.AddScoped <ICalculationService, CalculationService>()
.AddScoped <IInstructionAllocationJobCreation, InstructionAllocationJobCreation>()
.AddScoped <ICreateCalculationService, CreateCalculationService>();
builder.AddSingleton <ICalculationNameInUseCheck, CalculationNameInUseCheck>();
builder.AddSingleton <ICalculationsSearchService, CalculationSearchService>();
builder.AddSingleton <ICalculationCodeReferenceUpdate, CalculationCodeReferenceUpdate>();
builder.AddSingleton <IValidator <Calculation>, CalculationModelValidator>();
builder.AddScoped <IPreviewService, PreviewService>();
builder.AddSingleton <ICompilerFactory, CompilerFactory>();
//builder.AddSingleton<IDatasetRepository, DatasetRepository>();
builder.AddScoped <IJobService, JobService>();
builder.AddScoped <IApproveAllCalculationsJobAction, ApproveAllCalculationsJobAction>();
builder
.AddSingleton <CSharpCompiler>()
.AddSingleton <VisualBasicCompiler>()
.AddSingleton <VisualBasicSourceFileGenerator>();
builder.AddSingleton <ISourceFileGeneratorProvider, SourceFileGeneratorProvider>();
builder.AddSingleton <IValidator <PreviewRequest>, PreviewRequestModelValidator>();
builder.AddScoped <IBuildProjectsService, BuildProjectsService>();
builder.AddSingleton <IBuildProjectsRepository, BuildProjectsRepository>((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.ContainerName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new BuildProjectsRepository(resultsRepostory));
});
builder.AddSingleton <ICodeMetadataGeneratorService, ReflectionCodeMetadataGenerator>();
builder.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
builder.AddSingleton <ISourceCodeService, SourceCodeService>();
builder.AddScoped <IDeadletterService, DeadletterService>();
builder.AddScoped <IJobManagement, JobManagement>();
MapperConfiguration calculationsConfig = new MapperConfiguration(c =>
{
c.AddProfile <CalculationsMappingProfile>();
});
builder
.AddSingleton(calculationsConfig.CreateMapper());
builder.AddScoped <IReIndexGraphRepository, ReIndexGraphRepository>();
builder.AddScoped <ISpecificationCalculationAnalysis, SpecificationCalculationAnalysis>();
builder.AddScoped <IReIndexSpecificationCalculationRelationships, ReIndexSpecificationCalculationRelationships>();
builder.AddScoped <ICalculationAnalysis, CalculationAnalysis>();
builder
.AddScoped <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddScoped <ICalculationEngineRunningChecker, CalculationEngineRunningChecker>();
builder.AddScoped <IValidator <CalculationCreateModel>, CalculationCreateModelValidator>();
builder.AddScoped <IApproveAllCalculationsService, ApproveAllCalculationsService>();
builder
.AddScoped <IDatasetReferenceService, DatasetReferenceService>();
builder
.AddScoped <IValidator <CalculationEditModel>, CalculationEditModelValidator>();
builder.AddSingleton <ISourceFileRepository, SourceFileRepository>(ctx =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
config.Bind("AzureStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "source";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(blobStorageOptions);
return(new SourceFileRepository(blobContainerRepository));
});
builder.AddSingleton <IVersionRepository <CalculationVersion>, VersionRepository <CalculationVersion> >((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.ContainerName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new VersionRepository <CalculationVersion>(resultsRepostory, new NewVersionBuilderFactory <CalculationVersion>()));
});
builder.AddFeatureToggling(config);
builder.AddSearch(config);
builder
.AddSingleton <ISearchRepository <CalculationIndex>, SearchRepository <CalculationIndex> >();
builder
.AddSingleton <ISearchRepository <ProviderCalculationResultsIndex>, SearchRepository <ProviderCalculationResultsIndex> >();
builder.AddServiceBus(config, "calcs");
builder.AddScoped <ICalculationsFeatureFlag, CalculationsFeatureFlag>();
builder.AddScoped <IGraphRepository, GraphRepository>();
builder.AddScoped <IUserProfileProvider, UserProfileProvider>();
builder.AddProvidersInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddSpecificationsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddDatasetsInterServiceClient(config);
builder.AddJobsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddGraphInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddPoliciesInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddResultsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddCalcEngineInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddCaching(config);
builder.AddEngineSettings(config);
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Calcs");
builder.AddApplicationInsightsServiceName(config, "CalculateFunding.Functions.Calcs");
builder.AddLogging("CalculateFunding.Functions.Calcs");
builder.AddTelemetry();
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(config);
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
ResiliencePolicies resiliencePolicies = CreateResiliencePolicies(totalNetworkRequestsPolicy);
builder.AddSingleton <ICalcsResiliencePolicies>(resiliencePolicies);
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) => new JobManagementResiliencePolicies()
{
JobsApiClient = resiliencePolicies.JobsApiClient,
});
builder.AddScoped <ICodeContextCache, CodeContextCache>()
.AddScoped <ICodeContextBuilder, CodeContextBuilder>();
return(builder.BuildServiceProvider());
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <OnCreateAllocationLineResultStatusUpdates>();
builder.AddSingleton <OnCreateAllocationLineResultStatusUpdatesFailure>();
builder.AddSingleton <OnCreateInstructAllocationLineResultStatusUpdates>();
builder.AddSingleton <OnCreateInstructAllocationLineResultStatusUpdatesFailure>();
builder.AddSingleton <OnFetchProviderProfileEvent>();
builder.AddSingleton <OnFetchProviderProfileFailure>();
builder.AddSingleton <OnMigrateFeedIndexIdEvent>();
builder.AddSingleton <OnMigrateResultVersionsEvent>();
builder.AddSingleton <OnProviderResultsPublishedEvent>();
builder.AddSingleton <OnProviderResultsPublishedFailure>();
builder.AddSingleton <OnProviderResultsSpecificationCleanup>();
builder.AddSingleton <OnReIndexAllocationNotificationFeeds>();
builder.AddSingleton <OnReIndexCalculationResults>();
builder.AddSingleton <OnCalculationResultsCsvGeneration>();
builder.AddSingleton <OnCalculationResultsCsvGenerationTimer>();
builder.AddSingleton <ICalculationResultsRepository, CalculationResultsRepository>();
builder.AddSingleton <IResultsService, ResultsService>();
builder.AddSingleton <IPublishedResultsService, PublishedResultsService>();
builder.AddSingleton <IResultsSearchService, ResultsSearchService>();
builder.AddSingleton <ICalculationProviderResultsSearchService, CalculationProviderResultsSearchService>();
builder.AddSingleton <IProviderImportMappingService, ProviderImportMappingService>();
builder.AddSingleton <IAllocationNotificationsFeedsSearchService, AllocationNotificationsFeedsSearchService>();
builder.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder.AddSingleton <IValidator <MasterProviderModel>, MasterProviderModelValidator>();
builder.AddSingleton <IProviderVariationAssemblerService, ProviderVariationAssemblerService>();
builder.AddSingleton <IProviderVariationsService, ProviderVariationsService>();
builder.AddSingleton <IProviderService, ProviderService>();
builder.AddSingleton <IJobHelperService, JobHelperService>();
builder.AddSingleton <IProviderCalculationResultsReIndexerService, ProviderCalculationResultsReIndexerService>();
builder.AddSingleton <IProviderVariationsStorageRepository, ProviderVariationsStorageRepository>((ctx) =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
config.Bind("CommonStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "providervariations";
return(new ProviderVariationsStorageRepository(blobStorageOptions));
});
MapperConfiguration resultsConfig = new MapperConfiguration(c =>
{
c.AddProfile <DatasetsMappingProfile>();
c.AddProfile <ResultServiceMappingProfile>();
c.AddProfile <ProviderMappingProfile>();
});
builder
.AddSingleton(resultsConfig.CreateMapper());
builder.AddCaching(config);
builder.AddSingleton <ICalculationResultsRepository, CalculationResultsRepository>((ctx) =>
{
CosmosDbSettings calssDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calssDbSettings);
calssDbSettings.CollectionName = "calculationresults";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(calssDbSettings);
return(new CalculationResultsRepository(calcsCosmosRepostory));
});
builder.AddSingleton <IProviderSourceDatasetRepository, ProviderSourceDatasetRepository>((ctx) =>
{
CosmosDbSettings provDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", provDbSettings);
provDbSettings.CollectionName = "providerdatasets";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(provDbSettings);
return(new ProviderSourceDatasetRepository(calcsCosmosRepostory));
});
builder.AddSingleton <IPublishedProviderResultsRepository, PublishedProviderResultsRepository>((ctx) =>
{
CosmosDbSettings resultsDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", resultsDbSettings);
resultsDbSettings.CollectionName = "publishedproviderresults";
CosmosRepository resultsRepostory = new CosmosRepository(resultsDbSettings);
return(new PublishedProviderResultsRepository(resultsRepostory));
});
builder.AddSingleton <IProviderChangesRepository, ProviderChangesRepository>((ctx) =>
{
CosmosDbSettings cosmosSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosSettings);
cosmosSettings.CollectionName = "publishedproviderchanges";
CosmosRepository resultsRepostory = new CosmosRepository(cosmosSettings);
ILogger logger = ctx.GetService <ILogger>();
return(new ProviderChangesRepository(resultsRepostory, logger));
});
builder
.AddSingleton <ISpecificationsRepository, SpecificationsRepository>();
builder
.AddSingleton <IPublishedProviderResultsAssemblerService, PublishedProviderResultsAssemblerService>();
builder.AddSingleton <IPublishedProviderResultsSettings, PublishedProviderResultsSettings>((ctx) =>
{
PublishedProviderResultsSettings settings = new PublishedProviderResultsSettings();
config.Bind("PublishedProviderResultsSettings", settings);
return(settings);
});
builder.AddSingleton <IVersionRepository <PublishedAllocationLineResultVersion>, VersionRepository <PublishedAllocationLineResultVersion> >((ctx) =>
{
CosmosDbSettings versioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", versioningDbSettings);
versioningDbSettings.CollectionName = "publishedproviderresults";
CosmosRepository resultsRepostory = new CosmosRepository(versioningDbSettings);
return(new VersionRepository <PublishedAllocationLineResultVersion>(resultsRepostory));
});
builder
.AddSingleton <IBlobClient, AzureStorage.BlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
config.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "calculationresultscsv";
return(new AzureStorage.BlobClient(storageSettings));
});
builder.AddSearch(config);
builder.AddServiceBus(config);
builder.AddCaching(config);
builder.AddApplicationInsights(config, "CalculateFunding.Functions.Results");
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Results");
builder.AddLogging("CalculateFunding.Functions.Results");
builder.AddTelemetry();
builder.AddCalcsInterServiceClient(config);
builder.AddSpecificationsInterServiceClient(config);
builder.AddJobsInterServiceClient(config);
builder.AddResultsInterServiceClient(config);
builder.AddFeatureToggling(config);
builder.AddSingleton <IPublishedAllocationLineLogicalResultVersionService, PublishedAllocationLineLogicalResultVersionService>();
builder.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
builder.AddSingleton <IAzureBearerTokenProxy, AzureBearerTokenProxy>();
builder.AddHttpClient(HttpClientKeys.Profiling,
c =>
{
ApiClientConfigurationOptions opts = new ApiClientConfigurationOptions();
config.Bind("providerProfilingClient", opts);
SetDefaultApiClientConfigurationOptions(c, opts, builder);
})
.ConfigurePrimaryHttpMessageHandler(() => new ApiClientHandler())
.AddTransientHttpErrorPolicy(c => c.WaitAndRetryAsync(retryTimeSpans))
.AddTransientHttpErrorPolicy(c => c.CircuitBreakerAsync(numberOfExceptionsBeforeCircuitBreaker, circuitBreakerFailurePeriod));
builder.AddSingleton <IProfilingApiClient>((ctx) =>
{
IFeatureToggle featureToggle = ctx.GetService <IFeatureToggle>();
bool enableMockProvider = featureToggle.IsProviderProfilingServiceDisabled();
if (enableMockProvider)
{
return(new MockProviderProfilingRepository());
}
else
{
IHttpClientFactory httpClientFactory = ctx.GetService <IHttpClientFactory>();
ILogger logger = ctx.GetService <ILogger>();
ICancellationTokenProvider cancellationTokenProvider = ctx.GetService <ICancellationTokenProvider>();
IAzureBearerTokenProxy azureBearerTokenProxy = ctx.GetService <IAzureBearerTokenProxy>();
ICacheProvider cacheProvider = ctx.GetService <ICacheProvider>();
AzureBearerTokenOptions azureBearerTokenOptions = new AzureBearerTokenOptions();
config.Bind("providerProfilingAzureBearerTokenOptions", azureBearerTokenOptions);
AzureBearerTokenProvider bearerTokenProvider = new AzureBearerTokenProvider(azureBearerTokenProxy, cacheProvider, azureBearerTokenOptions);
return(new ProfilingApiClient(httpClientFactory, HttpClientKeys.Profiling, logger, bearerTokenProvider, cancellationTokenProvider));
}
});
PolicySettings policySettings = builder.GetPolicySettings(config);
ResiliencePolicies resultsResiliencePolicies = CreateResiliencePolicies(policySettings);
builder.AddSingleton <IResultsResiliencePolicies>(resultsResiliencePolicies);
builder.AddSingleton <IJobHelperResiliencePolicies>(resultsResiliencePolicies);
return(builder.BuildServiceProvider());
}
private static IServiceProvider Register(IServiceCollection builder,
IConfigurationRoot config)
{
builder.AddSingleton <IFundingLineRoundingSettings, FundingLineRoundingSettings>();
builder.AddSingleton <IBatchProfilingOptions, BatchProfilingOptions>();
builder.AddSingleton <IBatchProfilingService, BatchProfilingService>();
builder.AddSingleton <IProducerConsumerFactory, ProducerConsumerFactory>();
builder.AddSingleton <IReProfilingResponseMapper, ReProfilingResponseMapper>();
builder.AddSingleton <IReProfilingRequestBuilder, ReProfilingRequestBuilder>();
builder.AddSingleton <IBatchUploadValidationService, BatchUploadValidationService>();
builder.AddSingleton <IBatchUploadReaderFactory, BatchUploadReaderFactory>();
builder.AddSingleton <IValidator <BatchUploadValidationRequest>, BatchUploadValidationRequestValidation>();
ISqlSettings sqlSettings = new SqlSettings();
config.Bind("saSql", sqlSettings);
builder.AddSingleton(sqlSettings);
builder.AddSingleton <ISqlPolicyFactory, SqlPolicyFactory>();
builder.AddScoped <ISqlConnectionFactory, SqlConnectionFactory>();
builder.AddScoped <IDataTableImporter, DataTableImporter>();
builder.AddScoped <ISqlImportContextBuilder, SqlImportContextBuilder>();
builder.AddScoped <ISqlImporter, SqlImporter>();
builder.AddScoped <ISqlImportService, SqlImportService>();
builder.AddScoped <ISqlNameGenerator, SqlNameGenerator>();
builder.AddScoped <ISqlSchemaGenerator, SqlSchemaGenerator>();
builder.AddScoped <IQaSchemaService, QaSchemaService>();
builder.AddScoped <IQaRepository, QaRepository>();
builder.AddSingleton <ITemplateMetadataResolver>(ctx =>
{
TemplateMetadataResolver resolver = new TemplateMetadataResolver();
ILogger logger = ctx.GetService <ILogger>();
TemplateMetadataSchema10.TemplateMetadataGenerator schema10Generator = new TemplateMetadataSchema10.TemplateMetadataGenerator(logger);
resolver.Register("1.0", schema10Generator);
TemplateMetadataSchema11.TemplateMetadataGenerator schema11Generator = new TemplateMetadataSchema11.TemplateMetadataGenerator(logger);
resolver.Register("1.1", schema11Generator);
return(resolver);
});
builder.AddSingleton <ICosmosRepository, CosmosRepository>();
CosmosDbSettings settings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", settings);
settings.ContainerName = "publishedfunding";
builder.AddSingleton(settings);
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddFeatureManagement();
builder.AddSingleton <IConfiguration>(ctx => config);
builder
.AddScoped <IPublishedFundingQueryBuilder, PublishedFundingQueryBuilder>();
builder
.AddSingleton <IPublishingEngineOptions>(_ => new PublishingEngineOptions(config));
builder.AddSingleton <IPublishedFundingRepository, PublishedFundingRepository>((ctx) =>
{
CosmosDbSettings calssDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calssDbSettings);
calssDbSettings.ContainerName = "publishedfunding";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(calssDbSettings);
IPublishedFundingQueryBuilder publishedFundingQueryBuilder = ctx.GetService <IPublishedFundingQueryBuilder>();
return(new PublishedFundingRepository(calcsCosmosRepostory, publishedFundingQueryBuilder));
});
builder.AddSingleton <IPublishedFundingBulkRepository, PublishedFundingBulkRepository>((ctx) =>
{
CosmosDbSettings settings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", settings);
settings.ContainerName = "publishedfunding";
IPublishingEngineOptions publishingEngineOptions = ctx.GetService <IPublishingEngineOptions>();
CosmosRepository calcsCosmosRepository = new CosmosRepository(settings, publishingEngineOptions.AllowBatching ? new CosmosClientOptions
{
ConnectionMode = ConnectionMode.Direct,
RequestTimeout = new TimeSpan(0, 0, 15),
MaxRequestsPerTcpConnection = publishingEngineOptions.MaxRequestsPerTcpConnectionPublishedFundingCosmosBulkOptions,
MaxTcpConnectionsPerEndpoint = publishingEngineOptions.MaxTcpConnectionsPerEndpointPublishedFundingCosmosBulkOptions,
ConsistencyLevel = ConsistencyLevel.Eventual,
AllowBulkExecution = true
} : null);
IPublishingResiliencePolicies publishingResiliencePolicies = ctx.GetService <IPublishingResiliencePolicies>();
return(new PublishedFundingBulkRepository(publishingResiliencePolicies, publishingEngineOptions, calcsCosmosRepository));
});
CosmosDbSettings publishedfundingCosmosSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", publishedfundingCosmosSettings);
publishedfundingCosmosSettings.ContainerName = "publishedfunding";
builder.AddSingleton(publishedfundingCosmosSettings);
builder.AddSingleton <ICosmosRepository, CosmosRepository>();
builder.AddCaching(config);
builder.AddSearch(config);
builder
.AddSingleton <ISearchRepository <PublishedProviderIndex>, SearchRepository <PublishedProviderIndex> >();
builder
.AddSingleton <ISearchRepository <PublishedFundingIndex>, SearchRepository <PublishedFundingIndex> >();
// 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(_ => new OnRefreshFunding(_.GetService <ILogger>(),
_.GetService <IRefreshService>(),
_.GetService <IMessengerService>(),
_.GetService <IUserProfileProvider>(),
true));
builder.AddScoped(_ => new OnApproveAllProviderFunding(_.GetService <ILogger>(),
_.GetService <IApproveService>(),
_.GetService <IMessengerService>(),
_.GetService <IUserProfileProvider>(),
true));
builder.AddScoped(_ => new OnPublishAllProviderFunding(_.GetService <ILogger>(),
_.GetService <IPublishService>(),
_.GetService <IMessengerService>(),
_.GetService <IUserProfileProvider>(),
true));
builder.AddScoped <OnRunSqlImport>();
builder.AddScoped <OnRefreshFundingFailure>();
builder.AddScoped <OnApproveAllProviderFundingFailure>();
builder.AddScoped <OnPublishAllProviderFundingFailure>();
builder.AddScoped <OnPublishIntegrityCheck>();
builder.AddScoped <OnPublishIntegrityCheckFailure>();
builder.AddScoped <OnDeletePublishedProviders>();
builder.AddScoped <OnDeletePublishedProvidersFailure>();
builder.AddScoped <OnReIndexPublishedProviders>();
builder.AddScoped <OnGeneratePublishedFundingCsv>();
builder.AddScoped <OnGeneratePublishedFundingCsvFailure>();
builder.AddScoped <OnGeneratePublishedProviderEstateCsv>();
builder.AddScoped <OnGeneratePublishedProviderEstateCsvFailure>();
builder.AddScoped(_ => new OnApproveBatchProviderFunding(_.GetService <ILogger>(),
_.GetService <IApproveService>(),
_.GetService <IMessengerService>(),
_.GetService <IUserProfileProvider>(),
true));
builder.AddScoped <OnApproveBatchProviderFundingFailure>();
builder.AddScoped(_ => new OnPublishBatchProviderFunding(_.GetService <ILogger>(),
_.GetService <IPublishService>(),
_.GetService <IMessengerService>(),
_.GetService <IUserProfileProvider>(),
true));
builder.AddScoped <OnPublishBatchProviderFundingFailure>();
builder.AddScoped <OnPublishedFundingUndo>();
builder.AddScoped <OnBatchPublishedProviderValidation>();
builder.AddScoped <OnBatchPublishedProviderValidationFailure>();
}
builder.AddSingleton <ISpecificationService, SpecificationService>();
builder.AddSingleton <IProviderService, ProviderService>();
builder.AddSingleton <IPublishedFundingService, PublishedFundingService>();
builder.AddSingleton <IPoliciesService, PoliciesService>();
builder.AddSingleton <IPublishedFundingVersionDataService, PublishedFundingVersionDataService>();
builder.AddScoped <IRefreshService, RefreshService>();
builder.AddScoped <IVariationService, VariationService>();
builder.AddTransient <IRecordVariationErrors, VariationErrorRecorder>();
builder.AddTransient <IApplyProviderVariations, ProviderVariationsApplication>();
builder.AddTransient <IDetectProviderVariations, ProviderVariationsDetection>();
builder.AddTransient <IVariationStrategyServiceLocator, VariationStrategyServiceLocator>();
builder.AddTransient <IVariationStrategy, ClosureVariationStrategy>();
builder.AddTransient <IVariationStrategy, ClosureWithSuccessorVariationStrategy>();
builder.AddTransient <IVariationStrategy, ProviderMetadataVariationStrategy>();
builder.AddTransient <IVariationStrategy, PupilNumberSuccessorVariationStrategy>();
builder.AddTransient <IVariationStrategy, FundingUpdatedVariationStrategy>();
builder.AddTransient <IVariationStrategy, ProfilingUpdatedVariationStrategy>();
builder.AddTransient <IVariationStrategy, DsgTotalAllocationChangeVariationStrategy>();
builder.AddTransient <IVariationStrategy, ReProfilingVariationStrategy>();
builder.AddSingleton <IReProfilingResponseMapper, ReProfilingResponseMapper>();
builder.AddScoped <IApproveService, ApproveService>();
builder.AddSingleton <IJobTracker, JobTracker>();
builder.AddScoped <IPublishService, PublishService>();
builder.AddSingleton <IJobManagement, JobManagement>();
builder.AddSingleton <ISpecificationFundingStatusService, SpecificationFundingStatusService>();
builder.AddScoped <ICsvUtils, CsvUtils>();
builder.AddSingleton <IFileSystemAccess, FileSystemAccess>();
builder.AddSingleton <IFileSystemCacheSettings, FileSystemCacheSettings>();
builder.AddScoped <IReApplyCustomProfiles, ReApplyCustomProfiles>();
builder.AddScoped <IPublishedProviderErrorDetection, PublishedProviderErrorDetection>();
builder.AddTransient <IErrorDetectionStrategyLocator, ErrorDetectionStrategyLocator>();
builder.AddTransient <IDetectPublishedProviderErrors, FundingLineValueProfileMismatchErrorDetector>();
builder.AddTransient <IDetectPublishedProviderErrors, TrustIdMismatchErrorDetector>();
builder.AddScoped <IGeneratePublishedFundingCsvJobsCreationLocator, GeneratePublishedFundingCsvJobsCreationLocator>();
builder.AddScoped <IGeneratePublishedFundingCsvJobsCreation, GenerateRefreshPublishedFundingCsvJobsCreation>();
builder.AddScoped <IGeneratePublishedFundingCsvJobsCreation, GenerateApprovePublishedFundingCsvJobsCreation>();
builder.AddScoped <IGeneratePublishedFundingCsvJobsCreation, GenerateReleasePublishedFundingCsvJobsCreation>();
builder.AddScoped <IFundingLineCsvGenerator, FundingLineCsvGenerator>();
builder.AddScoped <IFundingLineCsvTransform, PublishedProviderFundingLineCsvTransform>();
builder.AddScoped <IFundingLineCsvTransform, PublishedProviderVersionFundingLineCsvTransform>();
builder.AddScoped <IFundingLineCsvTransform, PublishedProviderDeliveryProfileFundingLineCsvTransform>();
builder.AddScoped <IFundingLineCsvTransform, PublishedProviderVersionFundingLineProfileValuesCsvTransform>();
builder.AddScoped <IFundingLineCsvTransform, PublishedFundingFundingLineGroupingCsvTransform>();
builder.AddScoped <IFundingLineCsvTransform, PublishedFundingVersionFundingLineGroupingCsvTransform>();
builder.AddScoped <IFundingLineCsvTransform, PublishedGroupsFundingLineCsvTransform>();
builder.AddScoped <IFundingLineCsvTransformServiceLocator, FundingLineCsvTransformServiceLocator>();
builder.AddScoped <IPublishedFundingPredicateBuilder, PublishedFundingPredicateBuilder>();
builder.AddScoped <IFundingLineCsvBatchProcessorServiceLocator, FundingLineCsvBatchProcessorServiceLocator>();
builder.AddScoped <IFundingLineCsvBatchProcessor, PublishedProviderCsvBatchProcessor>();
builder.AddScoped <IFundingLineCsvBatchProcessor, PublishedProviderVersionCsvBatchProcessor>();
builder.AddScoped <IFundingLineCsvBatchProcessor, PublishedFundingOrganisationGroupCsvBatchProcessor>();
builder.AddScoped <IFundingLineCsvBatchProcessor, PublishedFundingVersionOrganisationGroupCsvBatchProcessor>();
builder.AddScoped <IFundingLineCsvBatchProcessor, PublishedGroupsCsvBatchProcessor>();
builder.AddTransient <ICreateGeneratePublishedFundingCsvJobs, GeneratePublishedFundingCsvJobCreation>();
builder.AddScoped <IPublishedProviderEstateCsvGenerator, PublishedProviderEstateCsvGenerator>()
.AddSingleton <IHealthChecker, PublishedProviderEstateCsvGenerator>();
builder.AddScoped <IPublishedProviderCsvTransformServiceLocator, PublishedProviderCsvTransformServiceLocator>();
builder.AddScoped <IPublishedProviderCsvTransform, PublishedProviderEstateCsvTransform>();
builder.AddScoped <ICreateGeneratePublishedProviderEstateCsvJobs, CreateGeneratePublishedProviderEstateCsvJobs>();
builder
.AddSingleton <IPublishedProviderVersioningService, PublishedProviderVersioningService>()
.AddSingleton <IHealthChecker, PublishedProviderVersioningService>();
builder
.AddSingleton <IPublishedProviderStatusUpdateService, PublishedProviderStatusUpdateService>()
.AddSingleton <IHealthChecker, PublishedProviderStatusUpdateService>();
builder
.AddSingleton <IPublishedProviderVersionService, PublishedProviderVersionService>()
.AddSingleton <IHealthChecker, PublishedProviderVersionService>();
builder
.AddSingleton <IPublishedSearchService, PublishedSearchService>()
.AddSingleton <IHealthChecker, PublishedSearchService>();
builder
.AddSingleton <IPublishedProviderStatusUpdateSettings>(_ =>
{
PublishedProviderStatusUpdateSettings settings = new PublishedProviderStatusUpdateSettings();
config.Bind("PublishedProviderStatusUpdateSettings", settings);
return(settings);
}
);
builder
.AddSingleton <Common.Storage.IBlobClient, CommonBlobClient>((ctx) =>
{
BlobStorageOptions storageSettings = new BlobStorageOptions();
config.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "publishedproviderversions";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(storageSettings);
return(new CommonBlobClient(blobContainerRepository));
});
builder
.AddSingleton <IBlobClient, BlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
config.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "publishedproviderversions";
return(new BlobClient(storageSettings));
});
builder.AddSingleton <IVersionRepository <PublishedProviderVersion>, VersionRepository <PublishedProviderVersion> >((ctx) =>
{
CosmosDbSettings publishedProviderVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", publishedProviderVersioningDbSettings);
publishedProviderVersioningDbSettings.ContainerName = "publishedfunding";
CosmosRepository resultsRepostory = new CosmosRepository(publishedProviderVersioningDbSettings);
return(new VersionRepository <PublishedProviderVersion>(resultsRepostory, new NewVersionBuilderFactory <PublishedProviderVersion>()));
});
builder.AddSingleton <IVersionBulkRepository <PublishedProviderVersion>, VersionBulkRepository <PublishedProviderVersion> >((ctx) =>
{
CosmosDbSettings PublishedProviderVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", PublishedProviderVersioningDbSettings);
PublishedProviderVersioningDbSettings.ContainerName = "publishedfunding";
IPublishingEngineOptions publishingEngineOptions = ctx.GetService <IPublishingEngineOptions>();
CosmosRepository cosmosRepository = new CosmosRepository(PublishedProviderVersioningDbSettings, publishingEngineOptions.AllowBatching ? new CosmosClientOptions
{
ConnectionMode = ConnectionMode.Direct,
RequestTimeout = new TimeSpan(0, 0, 15),
MaxRequestsPerTcpConnection = publishingEngineOptions.MaxRequestsPerTcpConnectionPublishedFundingCosmosBulkOptions,
MaxTcpConnectionsPerEndpoint = publishingEngineOptions.MaxTcpConnectionsPerEndpointPublishedFundingCosmosBulkOptions,
ConsistencyLevel = ConsistencyLevel.Eventual,
AllowBulkExecution = true
} : null);
return(new VersionBulkRepository <PublishedProviderVersion>(cosmosRepository, new NewVersionBuilderFactory <PublishedProviderVersion>()));
});
builder.AddSingleton <IVersionRepository <PublishedFundingVersion>, VersionRepository <PublishedFundingVersion> >((ctx) =>
{
CosmosDbSettings ProviderSourceDatasetVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", ProviderSourceDatasetVersioningDbSettings);
ProviderSourceDatasetVersioningDbSettings.ContainerName = "publishedfunding";
CosmosRepository cosmosRepository = new CosmosRepository(ProviderSourceDatasetVersioningDbSettings);
return(new VersionRepository <PublishedFundingVersion>(cosmosRepository, new NewVersionBuilderFactory <PublishedFundingVersion>()));
});
builder.AddSingleton <IVersionBulkRepository <PublishedFundingVersion>, VersionBulkRepository <PublishedFundingVersion> >((ctx) =>
{
CosmosDbSettings PublishedFundingVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", PublishedFundingVersioningDbSettings);
PublishedFundingVersioningDbSettings.ContainerName = "publishedfunding";
IPublishingEngineOptions publishingEngineOptions = ctx.GetService <IPublishingEngineOptions>();
CosmosRepository cosmosRepository = new CosmosRepository(PublishedFundingVersioningDbSettings, publishingEngineOptions.AllowBatching ? new CosmosClientOptions
{
ConnectionMode = ConnectionMode.Direct,
RequestTimeout = new TimeSpan(0, 0, 15),
MaxRequestsPerTcpConnection = publishingEngineOptions.MaxRequestsPerTcpConnectionPublishedFundingCosmosBulkOptions,
MaxTcpConnectionsPerEndpoint = publishingEngineOptions.MaxTcpConnectionsPerEndpointPublishedFundingCosmosBulkOptions,
ConsistencyLevel = ConsistencyLevel.Eventual,
AllowBulkExecution = true
} : null);
return(new VersionBulkRepository <PublishedFundingVersion>(cosmosRepository, new NewVersionBuilderFactory <PublishedFundingVersion>()));
});
builder.AddSingleton <ICalculationResultsRepository, CalculationResultsRepository>((ctx) =>
{
CosmosDbSettings calssDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calssDbSettings);
calssDbSettings.ContainerName = "calculationresults";
IPublishingEngineOptions publishingEngineOptions = ctx.GetService <IPublishingEngineOptions>();
CosmosRepository calcsCosmosRepository = new CosmosRepository(calssDbSettings, new CosmosClientOptions
{
ConnectionMode = ConnectionMode.Direct,
RequestTimeout = new TimeSpan(0, 0, 15),
MaxRequestsPerTcpConnection = publishingEngineOptions.MaxRequestsPerTcpConnectionCalculationsCosmosBulkOptions,
MaxTcpConnectionsPerEndpoint = publishingEngineOptions.MaxTcpConnectionsPerEndpointCalculationsCosmosBulkOptions,
ConsistencyLevel = ConsistencyLevel.Eventual,
AllowBulkExecution = true
});
return(new CalculationResultsRepository(calcsCosmosRepository));
});
builder.AddSingleton <ICalculationResultsService, CalculationResultsService>();
builder.AddSingleton <IPublishedProviderDataGenerator, PublishedProviderDataGenerator>();
builder.AddSingleton <IFundingLineTotalAggregator, FundingLineTotalAggregator>();
builder
.AddSingleton <IProfilingService, ProfilingService>()
.AddSingleton <IHealthChecker, ProfilingService>();
builder.AddSingleton(new MapperConfiguration(_ =>
{
_.AddProfile <PublishingServiceMappingProfile>();
}).CreateMapper());
builder.AddSingleton <IPublishedProviderDataPopulator, PublishedProviderDataPopulator>();
builder.AddSingleton <IPublishIntegrityCheckService, PublishIntegrityCheckService>();
builder.AddSingleton <IPublishedProviderContentsGeneratorResolver>(ctx =>
{
PublishedProviderContentsGeneratorResolver resolver = new PublishedProviderContentsGeneratorResolver();
resolver.Register("1.0", new Generators.Schema10.PublishedProviderContentsGenerator());
resolver.Register("1.1", new Generators.Schema11.PublishedProviderContentsGenerator());
return(resolver);
});
builder.AddSingleton <IPublishedFundingContentsGeneratorResolver>(ctx =>
{
PublishedFundingContentsGeneratorResolver resolver = new PublishedFundingContentsGeneratorResolver();
resolver.Register("1.0", new Generators.Schema10.PublishedFundingContentsGenerator());
resolver.Register("1.1", new Generators.Schema11.PublishedFundingContentsGenerator());
return(resolver);
});
builder.AddSingleton <IPublishedFundingIdGeneratorResolver>(ctx =>
{
PublishedFundingIdGeneratorResolver resolver = new PublishedFundingIdGeneratorResolver();
IPublishedFundingIdGenerator v10Generator = new Generators.Schema10.PublishedFundingIdGenerator();
resolver.Register("1.0", v10Generator);
resolver.Register("1.1", v10Generator);
return(resolver);
});
builder.AddSingleton <IDeadletterService, DeadletterService>();
builder.AddSingleton <IPublishedProviderReIndexerService, PublishedProviderReIndexerService>();
builder.AddApplicationInsightsServiceName(config, "CalculateFunding.Functions.Publishing");
builder.AddLogging("CalculateFunding.Functions.Publishing", config);
builder.AddTelemetry();
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(config);
ResiliencePolicies publishingResiliencePolicies = CreateResiliencePolicies(policySettings);
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) =>
{
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new JobManagementResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddServiceBus(config, "publishing");
builder.AddPublishingServices(config);
builder.AddSingleton <IPublishingResiliencePolicies>(publishingResiliencePolicies);
builder.AddSpecificationsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddProvidersInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddJobsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddCalculationsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddPoliciesInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddFundingDataServiceInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddSingleton <ITransactionResiliencePolicies>((ctx) => new TransactionResiliencePolicies()
{
TransactionPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings)
});
builder.AddSingleton <ITransactionFactory, TransactionFactory>();
builder
.AddProfilingInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddScoped <IPublishedFundingUndoJobService, PublishedFundingUndoJobService>();
builder.AddScoped <IPublishedFundingUndoJobCreation, PublishedFundingUndoJobCreation>();
builder.AddScoped <IPublishedFundingUndoTaskFactoryLocator, PublishedFundingUndoTaskFactoryLocator>();
builder.AddSingleton <IPublishedFundingUndoTaskFactory, SoftDeletePublishedFundingUndoTaskFactory>();
builder.AddSingleton <IPublishedFundingUndoTaskFactory, HardDeletePublishedFundingUndoTaskFactory>();
builder.AddSingleton <IPublishedFundingUndoCosmosRepository>(ctx =>
{
CosmosDbSettings settings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", settings);
settings.ContainerName = "publishedfunding";
return(new PublishedFundingUndoCosmosRepository(ctx.GetService <IPublishingResiliencePolicies>(),
new CosmosRepository(settings)));
});
builder.AddSingleton <IPublishedFundingUndoBlobStoreRepository>(ctx =>
{
BlobStorageOptions settings = new BlobStorageOptions();
config.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 <IProducerConsumerFactory, ProducerConsumerFactory>();
builder.AddScoped <IUserProfileProvider, UserProfileProvider>();
return(builder.BuildServiceProvider());
}
private IModel CreateConsumerChannel(string eventName)
{
if (!_connection.IsConnected)
{
_connection.TryConnect(ResiliencePolicies.ConnectionPolicyFactory);
}
var channel = _connection.CreateModel();
var args = ResolveQueueArgs(channel, eventName);
channel.ExchangeDeclare(ExchangeName, _queueConfiguration.ExchangeType.ToString().ToLower(), _queueConfiguration.DurableExchange);
channel.QueueDeclare(_queueConfiguration.QueueName, _queueConfiguration.DurableQueue, false, false, args);
channel.BasicQos(0, _queueConfiguration.PrefetchCount, false);
var consumer = new EventingBasicConsumer(channel);
var token = _eventCancellationTokenPool.GetCancellationToken(eventName);
consumer.Received += (model, ea) =>
{
Task.Run(async() =>
{
string message = string.Empty;
try
{
var localEventName = ea.RoutingKey;
using (var stream = new MemoryStream(ea.Body))
using (var reader = new StreamReader(stream))
{
message = reader.ReadToEnd();
}
if (token.IsCancellationRequested)
{
ResiliencePolicies.GeneralRetryPolicyFactory(_eventBusConfiguration.Logger)
.Execute(() => channel.BasicNack(ea.DeliveryTag, false, true));
return;
}
await HandleEvent(localEventName, message);
ResiliencePolicies.GeneralRetryPolicyFactory(_eventBusConfiguration.Logger)
.Execute(() => channel.BasicAck(ea.DeliveryTag, false));
}
catch (Exception ex)
{
HandleAckException(ex, message, ea.DeliveryTag, channel, new MessageHeaders(ea.BasicProperties.Headers));
}
}, token);
};
channel.QueueBind(
queue: _queueConfiguration.QueueName,
exchange: ExchangeName,
routingKey: eventName
);
channel.BasicConsume(queue: _queueConfiguration.QueueName,
autoAck: false,
consumer: consumer);
channel.CallbackException += (sender, ea) =>
{
if (ea.Exception != null)
{
_eventBusConfiguration.Logger.LogWarning(ea.Exception.ToString());
}
_consumerChannel.Dispose();
_consumerChannel = CreateConsumerChannel(eventName);
};
return(channel);
}
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 <IFundingLineRoundingSettings, FundingLineRoundingSettings>();
builder.AddScoped <ICodeContextCache, CodeContextCache>()
.AddScoped <ICodeContextBuilder, CodeContextBuilder>();
builder.AddSingleton <ICalculationFundingLineQueryService, CalculationFundingLineQueryService>();
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddSingleton(Configuration);
builder
.AddScoped <IHealthChecker, ControllerResolverHealthCheck>();
builder
.AddSingleton <ICalculationsRepository, CalculationsRepository>((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.ContainerName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new CalculationsRepository(resultsRepostory));
});
builder
.AddScoped <ICalculationService, CalculationService>()
.AddSingleton <ICalculationNameInUseCheck, CalculationNameInUseCheck>()
.AddScoped <IInstructionAllocationJobCreation, InstructionAllocationJobCreation>()
.AddScoped <IHealthChecker, CalculationService>()
.AddScoped <ICreateCalculationService, CreateCalculationService>();
builder
.AddScoped <IQueueReIndexSpecificationCalculationRelationships, QueueReIndexSpecificationCalculationRelationships>();
builder
.AddSingleton <ICalculationCodeReferenceUpdate, CalculationCodeReferenceUpdate>();
builder
.AddSingleton <ICalculationsSearchService, CalculationSearchService>()
.AddSingleton <IHealthChecker, CalculationSearchService>();
builder
.AddSingleton <IValidator <Calculation>, CalculationModelValidator>();
builder
.AddScoped <IValidator <CalculationCreateModel>, CalculationCreateModelValidator>();
builder
.AddScoped <IValidator <CalculationEditModel>, CalculationEditModelValidator>();
builder
.AddScoped <IPreviewService, PreviewService>()
.AddScoped <IHealthChecker, PreviewService>();
builder
.AddSingleton <ICompilerFactory, CompilerFactory>();
builder
.AddSingleton <CSharpCompiler>()
.AddSingleton <VisualBasicCompiler>()
.AddSingleton <VisualBasicSourceFileGenerator>();
builder
.AddSingleton <ISourceFileGeneratorProvider, SourceFileGeneratorProvider>();
builder
.AddSingleton <IValidator <PreviewRequest>, PreviewRequestModelValidator>();
builder
.AddScoped <IBuildProjectsService, BuildProjectsService>()
.AddScoped <IHealthChecker, BuildProjectsService>();
builder
.AddScoped <IDatasetReferenceService, DatasetReferenceService>();
builder
.AddSingleton <IBuildProjectsRepository, BuildProjectsRepository>((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.ContainerName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new BuildProjectsRepository(resultsRepostory));
});
builder
.AddSingleton <ICodeMetadataGeneratorService, ReflectionCodeMetadataGenerator>();
builder.AddSingleton <ISourceCodeService, SourceCodeService>();
builder
.AddSingleton <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddScoped <ICalculationEngineRunningChecker, CalculationEngineRunningChecker>();
builder
.AddScoped <IApproveAllCalculationsJobAction, ApproveAllCalculationsJobAction>();
builder.AddSingleton <ISourceFileRepository, SourceFileRepository>((ctx) =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "source";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(blobStorageOptions);
return(new SourceFileRepository(blobContainerRepository));
});
builder
.AddSingleton <IVersionRepository <CalculationVersion>, VersionRepository <CalculationVersion> >((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.ContainerName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new VersionRepository <CalculationVersion>(resultsRepostory, new NewVersionBuilderFactory <CalculationVersion>()));
});
builder
.AddSingleton <ICancellationTokenProvider, HttpContextCancellationProvider>();
MapperConfiguration calcConfig = new MapperConfiguration(c =>
{
c.AddProfile <CalculationsMappingProfile>();
});
builder
.AddSingleton(calcConfig.CreateMapper());
builder.AddSearch(Configuration);
builder
.AddSingleton <ISearchRepository <CalculationIndex>, SearchRepository <CalculationIndex> >();
builder
.AddSingleton <ISearchRepository <ProviderCalculationResultsIndex>, SearchRepository <ProviderCalculationResultsIndex> >();
builder.AddServiceBus(Configuration);
builder.AddScoped <IJobManagement, JobManagement>();
builder.AddScoped <ICalculationsFeatureFlag, CalculationsFeatureFlag>();
builder.AddScoped <IGraphRepository, GraphRepository>();
builder.AddProvidersInterServiceClient(Configuration);
builder.AddSpecificationsInterServiceClient(Configuration);
builder.AddDatasetsInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddGraphInterServiceClient(Configuration);
builder.AddPoliciesInterServiceClient(Configuration);
builder.AddResultsInterServiceClient(Configuration);
builder.AddCalcEngineInterServiceClient(Configuration);
builder.AddCaching(Configuration);
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.Calcs");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.Calcs");
builder.AddLogging("CalculateFunding.Api.Calcs");
builder.AddTelemetry();
builder.AddEngineSettings(Configuration);
builder.AddFeatureToggling(Configuration);
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(Configuration);
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
ResiliencePolicies resiliencePolicies = CreateResiliencePolicies(totalNetworkRequestsPolicy);
builder.AddSingleton <ICalcsResiliencePolicies>(resiliencePolicies);
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) =>
{
return(new JobManagementResiliencePolicies()
{
JobsApiClient = resiliencePolicies.JobsApiClient,
});
});
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "Calcs Microservice API", version: "v1");
}
}
