public async Task TestRegistrations() { try { JobContextMessage jobContextMessage = new JobContextMessage( 1, new ITopicItem[] { new TopicItem("SubscriptionName", new List <ITaskItem>()) }, 0, DateTime.UtcNow); jobContextMessage.KeyValuePairs[JobContextMessageKey.Container] = "Container"; CancellationTokenSource cts = new CancellationTokenSource(); cts.Cancel(); ContainerBuilder containerBuilder = DIComposition.BuildContainer(new TestConfigurationHelper()); IContainer c = containerBuilder.Build(); using (var lifeTime = c.BeginLifetimeScope()) { var messageHandler = lifeTime.Resolve <IMessageHandler <JobContextMessage> >(); bool ret = await messageHandler.HandleAsync(jobContextMessage, cts.Token); } } catch (Exception ex) { Console.WriteLine(ex); Assert.Null(ex); } }
private static JobContextMessage CreatePeriodEndJobContextMessage(PeriodEndTaskType taskType) { var jobContextMessage = new JobContextMessage { JobId = 1, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "PeriodEnd", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { taskType.ToString() } } } } }, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageConstants.KeyValuePairs.ReturnPeriod, 10 }, { JobContextMessageConstants.KeyValuePairs.CollectionYear, 1819 } } }; return(jobContextMessage); }
public async Task Waits_For_Job_To_Complete(string task, int numberOfTimes) { var jobContextMessage = new JobContextMessage { JobId = 1, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "PeriodEnd", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { task } } } } }, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageConstants.KeyValuePairs.ReturnPeriod, 10 }, { JobContextMessageConstants.KeyValuePairs.CollectionYear, 1819 } } }; var handler = mocker.Create <PeriodEndJobContextMessageHandler>(); var completed = await handler.HandleAsync(jobContextMessage, CancellationToken.None); mocker.Mock <IJobStatusService>() .Verify(svc => svc.WaitForJobToFinish(It.Is <long>(jobId => jobId == 1), CancellationToken.None), Times.Exactly(numberOfTimes)); }
public async Task Fails_If_No_Collection_Year() { var jobContextMessage = new JobContextMessage { JobId = 1, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "PeriodEnd", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { "Some Task" } } } } }, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageConstants.KeyValuePairs.ReturnPeriod, 10 } } }; var handler = mocker.Create <PeriodEndJobContextMessageHandler>(); Assert.ThrowsAsync <InvalidOperationException>(() => handler.HandleAsync(jobContextMessage, CancellationToken.None)); }
public async Task Records_Period_End_Started_Job_From_Period_End_Start_Task() { var jobContextMessage = new JobContextMessage { JobId = 1, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "PeriodEnd", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { "PeriodEndStart" } } } } }, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageConstants.KeyValuePairs.ReturnPeriod, 10 }, { JobContextMessageConstants.KeyValuePairs.CollectionYear, 1819 } } }; var handler = mocker.Create <PeriodEndJobContextMessageHandler>(); await handler.HandleAsync(jobContextMessage, CancellationToken.None); mocker.Mock <IPeriodEndJobClient>() .Verify(x => x.RecordPeriodEndStart(It.Is <long>(jobId => jobId == 1), It.Is <short>(collectionYear => collectionYear == 1819), It.Is <byte>(period => period == 10), It.Is <List <GeneratedMessage> >(msgs => msgs.Any(msg => msg.MessageName.Equals(typeof(PeriodEndStartedEvent).FullName)))), Times.Once); }
private async Task <bool> Callback(JobContextMessage jobContextMessage, CancellationToken cancellationToken) { try { await _auditor.AuditStartAsync(jobContextMessage); T obj = _mapper.MapTo(jobContextMessage); if (!await _callback.Invoke(obj, cancellationToken)) { await _auditor.AuditJobFailAsync(jobContextMessage); return(false); } jobContextMessage = _mapper.MapFrom(obj); jobContextMessage.TopicPointer++; await _auditor.AuditEndAsync(jobContextMessage); if (jobContextMessage.TopicPointer >= jobContextMessage.Topics.Count) { return(true); } await _queuePublishService.PublishAsync(jobContextMessage); } catch (Exception ex) { _logger.LogError("Exception thrown in JobManager callback", ex); await _auditor.AuditJobFailAsync(jobContextMessage); return(false); } return(true); }
public async Task <MessageParameters> CreateMessageParametersAsync(long jobId) { FileUploadJob job = await _fileUploadJobManager.GetJobById(jobId); List <ITopicItem> topics = (await _jobTopicTaskService.GetTopicItems(job.JobType, job.IsFirstStage)).ToList(); JobContextMessage contextMessage = new JobContextMessage( job.JobId, topics, job.Ukprn.ToString(), job.StorageReference, job.FileName, job.SubmittedBy, 0, job.DateTimeSubmittedUtc); contextMessage.KeyValuePairs.Add("CollectionName", job.CollectionName); contextMessage.KeyValuePairs.Add("ReturnPeriod", job.PeriodNumber); AddExtraKeys(contextMessage, job); MessageParameters message = new MessageParameters(job.JobType) { JobContextMessage = contextMessage, SubscriptionLabel = topics[0].SubscriptionName, TopicParameters = new Dictionary <string, object> { { "To", topics[0].SubscriptionName } } }; return(message); }
public async Task SendMessageAsync(MessageParameters messageParameters) { JobContextMessage jobContextMessage = (JobContextMessage)messageParameters.JobContextMessage; await _topicPublishServices[messageParameters.JobType].PublishAsync( _jobContextMapper.MapFrom(jobContextMessage), messageParameters.TopicParameters, messageParameters.SubscriptionLabel); }
public async Task Uses_Correct_Filename_For_In_Period_Submission() { var jobContextMessage = new JobContextMessage { JobId = 1, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "GenerateFM36Payments", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { JobContextMessageConstants.Tasks.ProcessSubmission } } } }, new TopicItem { SubscriptionName = "Other Task", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { "Something else" } } } } }, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageConstants.KeyValuePairs.ReturnPeriod, 10 }, { JobContextMessageConstants.KeyValuePairs.CollectionYear, 1819 }, { JobContextMessageConstants.KeyValuePairs.Ukprn, 2123 }, { JobContextMessageConstants.KeyValuePairs.FundingFm36Output, "valid path" }, { JobContextMessageConstants.KeyValuePairs.FundingFm36OutputPeriodEnd, "invalid path" }, { JobContextMessageConstants.KeyValuePairs.Container, "container" }, { JobContextMessageConstants.KeyValuePairs.Filename, "filename" }, } }; var handler = mocker.Create <JobContextMessageHandler>(); await handler.HandleAsync(jobContextMessage, CancellationToken.None); mocker.Mock <IFileService>().Verify(svc => svc.OpenReadStreamAsync( It.Is <string>(file => file.Equals("valid path")), It.Is <string>(containerName => containerName.Equals("container")), It.IsAny <CancellationToken>())); }
public async Task HandlesSubmissionWhenJobFailureAlsoPresent() { var jobContextMessage = new JobContextMessage { JobId = 1, TopicPointer = 1, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "GenerateFM36Payments", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { JobContextMessageConstants.Tasks.JobFailure } } } }, new TopicItem { SubscriptionName = "Other Task", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { "Something else" } } } } }, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageConstants.KeyValuePairs.ReturnPeriod, 10 }, { JobContextMessageConstants.KeyValuePairs.CollectionYear, 1819 }, { JobContextMessageConstants.KeyValuePairs.Ukprn, 2123 }, { JobContextMessageConstants.KeyValuePairs.FundingFm36Output, "invalid path" }, { JobContextMessageConstants.KeyValuePairs.FundingFm36OutputPeriodEnd, "valid path" }, { JobContextMessageConstants.KeyValuePairs.Container, "container" }, { JobContextMessageConstants.KeyValuePairs.Filename, "filename" }, } }; var handler = mocker.Create <JobContextMessageHandler>(); await handler.HandleAsync(jobContextMessage, CancellationToken.None); mocker.Mock <IEndpointInstance>().Verify(x => x.Publish(It.IsAny <object>(), It.IsAny <PublishOptions>()), Times.Once); mocker.Mock <ITelemetry>().Verify(x => x.TrackEvent("Sent All ProcessLearnerCommand Messages", It.IsAny <Dictionary <string, string> >(), It.IsAny <Dictionary <string, double> >())); }
public void TestJobContextSerialise() { DateTime dateTime = DateTime.UtcNow; var taskItems = new List <ITaskItem> { new TaskItem( new List <string> { "Task 1", "Task 2" }, true) }; IReadOnlyList <ITopicItem> topics = new List <ITopicItem> { new TopicItem( "Subscription A", "SqlFilter A", taskItems) }; var jobContextMessage = new JobContextMessage( 9999, topics, "UkPrn", "Container", "Filename", "Username", 12, dateTime); var settings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto }; var serialised = JsonConvert.SerializeObject(jobContextMessage, settings); var deserialised = JsonConvert.DeserializeObject <JobContextMessage>(serialised, settings); deserialised.JobId.Should().Be(9999); deserialised.SubmissionDateTimeUtc.Should().Be(dateTime); deserialised.TopicPointer.Should().Be(12); deserialised.Topics.Should().BeEquivalentTo(topics); deserialised.KeyValuePairs.Should().ContainKey(JobContextMessageKey.UkPrn); deserialised.KeyValuePairs[JobContextMessageKey.UkPrn].Should().Be("UkPrn"); deserialised.KeyValuePairs.Should().ContainKey(JobContextMessageKey.Filename); deserialised.KeyValuePairs[JobContextMessageKey.Filename].Should().Be("Filename"); deserialised.KeyValuePairs.Should().ContainKey(JobContextMessageKey.Container); deserialised.KeyValuePairs[JobContextMessageKey.Container].Should().Be("Container"); deserialised.KeyValuePairs.Should().ContainKey(JobContextMessageKey.Username); deserialised.KeyValuePairs[JobContextMessageKey.Username].Should().Be("Username"); }
public void AddExtraKeys_Test(bool isFirstStage) { var message = new JobContextMessage() { KeyValuePairs = new Dictionary <string, object>() }; var job = new FileUploadJob() { FileSize = 123, Ukprn = 999, JobId = 100, StorageReference = "ref", FileName = "filename.xml", SubmittedBy = "test user", DateTimeSubmittedUtc = new DateTime(2018, 10, 10), IsFirstStage = isFirstStage, }; message.KeyValuePairs.Add("Filename", job.FileName); var factory = GetFactory(isFirstStage, job); factory.AddExtraKeys(message, job); message.KeyValuePairs[JobContextMessageKey.FileSizeInBytes].Should().Be(123); if (isFirstStage) { message.KeyValuePairs[JobContextMessageKey.PauseWhenFinished].Should().Be("1"); } else { message.KeyValuePairs.ContainsKey(JobContextMessageKey.PauseWhenFinished).Should().Be(false); } message.KeyValuePairs.ContainsKey(JobContextMessageKey.InvalidLearnRefNumbers).Should().BeTrue(); message.KeyValuePairs.ContainsKey(JobContextMessageKey.ValidLearnRefNumbers).Should().BeTrue(); message.KeyValuePairs.ContainsKey(JobContextMessageKey.ValidationErrors).Should().BeTrue(); message.KeyValuePairs.ContainsKey(JobContextMessageKey.ValidationErrorLookups).Should().BeTrue(); message.KeyValuePairs.ContainsKey(JobContextMessageKey.FundingAlbOutput).Should().BeTrue(); message.KeyValuePairs.ContainsKey(JobContextMessageKey.FundingFm35Output).Should().BeTrue(); message.KeyValuePairs.ContainsKey(JobContextMessageKey.FundingFm25Output).Should().BeTrue(); }
public void TestJobContextMappingDtoToInterface() { DateTime now = DateTime.UtcNow; JobContextDto jobContextDto = new JobContextDto { SubmissionDateTimeUtc = now, JobId = 12, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageKey.UkPrn, 12345 } }, TopicPointer = 3, Topics = new List <TopicItemDto> { new TopicItemDto { Tasks = new List <TaskItemDto> { new TaskItemDto { Tasks = new List <string> { "Task A" }, SupportsParallelExecution = true } }, SubscriptionName = "Subscription A" } } }; JobContextMapper mapper = new JobContextMapper(); JobContextMessage message = mapper.MapTo(jobContextDto); message.SubmissionDateTimeUtc.Should().Be(now); message.JobId.Should().Be(12); message.KeyValuePairs.Should().BeEquivalentTo(jobContextDto.KeyValuePairs); message.Topics.Should().BeEquivalentTo(jobContextDto.Topics); message.TopicPointer.Should().Be(3); }
public void TestJobContextMappingInterfaceToDto() { DateTime now = DateTime.UtcNow; List <ITaskItem> tasks = new List <ITaskItem>() { new TaskItem { Tasks = new List <string> { "Task A" }, SupportsParallelExecution = true } }; var topicItem = new TopicItem("Topic A", "SqlFilter A", tasks); JobContextMessage jobContextMessage = new JobContextMessage { JobId = 12, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageKey.UkPrn, 12345 } }, SubmissionDateTimeUtc = now, TopicPointer = 3, Topics = new List <ITopicItem> { topicItem } }; JobContextMapper mapper = new JobContextMapper(); JobContextDto dto = mapper.MapFrom(jobContextMessage); dto.SubmissionDateTimeUtc.Should().Be(now); dto.JobId.Should().Be(12); dto.KeyValuePairs.Should().BeEquivalentTo(jobContextMessage.KeyValuePairs); dto.Topics.Should().BeEquivalentTo(jobContextMessage.Topics); dto.TopicPointer.Should().Be(3); }
public void GetIlrTasks() { var jobContextMessage = new JobContextMessage { TopicPointer = 0, Topics = new ITopicItem[] { new TopicItem { SubscriptionName = "ReferenceDataRetrieval", Tasks = new ITaskItem[] { new TaskItem { Tasks = new List <string> { "DesktopReferenceData", "IlrMessage", "LearnerReferenceData", "FrmReferenceData" }, SupportsParallelExecution = false }, } } } }; var expectedTasks = new List <TaskKeys> { TaskKeys.IlrMessage, TaskKeys.LearnerReferenceData, TaskKeys.FrmReferenceData }; var tasks = NewHandler().GetIlrTasks(jobContextMessage); tasks.Should().BeEquivalentTo(expectedTasks); }
public async Task Publishes_Period_End_Started_Event_From_Period_End_Start_Task() { var jobContextMessage = new JobContextMessage { JobId = 1, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "PeriodEnd", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { "PeriodEndStart" } } } } }, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageConstants.KeyValuePairs.ReturnPeriod, 10 }, { JobContextMessageConstants.KeyValuePairs.CollectionYear, 1819 } } }; var handler = mocker.Create <PeriodEndJobContextMessageHandler>(); await handler.HandleAsync(jobContextMessage, CancellationToken.None); mocker.Mock <IEndpointInstance>() .Verify(x => x.Publish(It.Is <PeriodEndStartedEvent>(startedEvent => startedEvent.JobId == 1 && startedEvent.CollectionPeriod.Period == 10 && startedEvent.CollectionPeriod.AcademicYear == 1819), It.IsAny <PublishOptions>()), Times.Once); }
public async Task Returns_True_Even_If_Job_Not_Completed() { var jobContextMessage = new JobContextMessage { JobId = 1, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "PeriodEnd", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { "PeriodEndStop" } } } } }, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageConstants.KeyValuePairs.ReturnPeriod, 10 }, { JobContextMessageConstants.KeyValuePairs.CollectionYear, 1819 } } }; mocker.Mock <IJobStatusService>() .Setup(svc => svc.WaitForJobToFinish(It.IsAny <long>(), It.IsAny <CancellationToken>())) .ReturnsAsync(false); var handler = mocker.Create <PeriodEndJobContextMessageHandler>(); var completed = await handler.HandleAsync(jobContextMessage, CancellationToken.None); completed.Should().BeTrue(); }
private static JobContextMessage CreateJobContextMessage(string task, bool CreateReturnPeriod = true, bool CreateCollectionYear = true) { var jobContextMessage = new JobContextMessage { JobId = 1, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "PeriodEnd", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { task } } } } }, KeyValuePairs = new Dictionary <string, object>() }; if (CreateReturnPeriod) { jobContextMessage.KeyValuePairs.Add(JobContextMessageConstants.KeyValuePairs.ReturnPeriod, 10); } if (CreateCollectionYear) { jobContextMessage.KeyValuePairs.Add(JobContextMessageConstants.KeyValuePairs.CollectionYear, 1819); } return(jobContextMessage); }
public JobContextMessageSummarisationContext(JobContextMessage jobContextMessage) { _jobContextMessage = jobContextMessage; }
public ReportServiceContext(JobContextMessage jobContextMessage) { _jobContextMessage = jobContextMessage; }
public async Task Job_Submission_Failed_Notifies_Monitoring_To_Record_Job_Status() { long ukprn = 2123; var collectionYear = 1920; var collectionPeriod = 10; var jobContextMessage = new JobContextMessage { JobId = 1, TopicPointer = 0, Topics = new List <ITopicItem> { new TopicItem { SubscriptionName = "GenerateFM36Payments", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { JobContextMessageConstants.Tasks.JobFailure } } } }, new TopicItem { SubscriptionName = "Other Task", Tasks = new List <ITaskItem> { new TaskItem { SupportsParallelExecution = false, Tasks = new List <string> { "Something else" } } } } }, KeyValuePairs = new Dictionary <string, object> { { JobContextMessageConstants.KeyValuePairs.ReturnPeriod, collectionPeriod }, { JobContextMessageConstants.KeyValuePairs.CollectionYear, collectionYear }, { JobContextMessageConstants.KeyValuePairs.Ukprn, ukprn }, { JobContextMessageConstants.KeyValuePairs.FundingFm36Output, "invalid path" }, { JobContextMessageConstants.KeyValuePairs.FundingFm36OutputPeriodEnd, "valid path" }, { JobContextMessageConstants.KeyValuePairs.Container, "container" }, { JobContextMessageConstants.KeyValuePairs.Filename, "filename" }, } }; var handler = mocker.Create <JobContextMessageHandler>(); await handler.HandleAsync(jobContextMessage, CancellationToken.None); mocker.Mock <IEarningsJobClient>() .Verify(x => x.RecordJobFailure(It.Is <long>(jobId => jobId == jobContextMessage.JobId), It.Is <long>(provider => provider == ukprn), It.Is <DateTime>(submissionTime => submissionTime == jobContextMessage.SubmissionDateTimeUtc), It.Is <short>(year => year == collectionYear), It.Is <byte>(period => period == collectionPeriod)), Times.Once); }
public FundingServiceContext(JobContextMessage jobContextMessage) { _jobContextMessage = jobContextMessage; }
public DesktopReferenceDataJobContext(JobContextMessage jobContextMessage) { _jobContextMessage = jobContextMessage; }
public FileValidationJobContextMessageContext(JobContextMessage jobContextMessage) { _jobContextMessage = jobContextMessage; }
public EasJobContext(JobContextMessage jobContextMessage) { _jobContextMessage = jobContextMessage; }
public IlrMessageJobContext(JobContextMessage jobContextMessage) { _jobContextMessage = jobContextMessage; }
public async Task TestEntryPointZipGeneration() { string csv = $"A,B,C,D{Environment.NewLine}1,2,3,4"; byte[] zipBytes = null; ITopicAndTaskSectionOptions topicsAndTasks = TestConfigurationHelper.GetTopicsAndTasks(); Mock <ILogger> logger = new Mock <ILogger>(); Mock <IStreamableKeyValuePersistenceService> streamableKeyValuePersistenceService = new Mock <IStreamableKeyValuePersistenceService>(); streamableKeyValuePersistenceService.Setup(x => x.SaveAsync(It.IsAny <string>(), It.IsAny <Stream>(), It.IsAny <CancellationToken>())) .Callback <string, Stream, CancellationToken>((s, m, c) => { zipBytes = new byte[m.Length]; m.Seek(0, SeekOrigin.Begin); m.Read(zipBytes, 0, (int)m.Length); }) .Returns(Task.CompletedTask); Mock <IReport> report = new Mock <IReport>(); report.SetupGet(x => x.ReportTaskName).Returns(topicsAndTasks.TopicReports_TaskGenerateAllbOccupancyReport); report.Setup(x => x.GenerateReport(It.IsAny <IReportServiceContext>(), It.IsAny <ZipArchive>(), It.IsAny <bool>(), It.IsAny <CancellationToken>())) .Callback <IReportServiceContext, ZipArchive, bool, CancellationToken>((j, z, b, c) => { ZipArchiveEntry archivedFile = z.CreateEntry("ExampleReport.csv", CompressionLevel.Optimal); using (var sw = new StreamWriter(archivedFile.Open())) { sw.Write(csv); } }) .Returns(Task.CompletedTask); report.Setup(x => x.IsMatch(It.IsAny <string>())).Returns(true); JobContextMessage jobContextMessage = new JobContextMessage( 1, new ITopicItem[] { new TopicItem("SubscriptionName", new List <ITaskItem> { new TaskItem(new List <string> { topicsAndTasks.TopicReports_TaskGenerateAllbOccupancyReport }, false) }) }, 0, DateTime.UtcNow); jobContextMessage.KeyValuePairs.Add(JobContextMessageKey.UkPrn, 1234); EntryPoint entryPoint = new EntryPoint( logger.Object, streamableKeyValuePersistenceService.Object, new[] { report.Object }); await entryPoint.Callback(new ReportServiceJobContextMessageContext(jobContextMessage), CancellationToken.None); string zipContents; using (MemoryStream ms = new MemoryStream(zipBytes)) { using (ZipArchive archive = new ZipArchive(ms, ZipArchiveMode.Read)) { ZipArchiveEntry entry = archive.GetEntry("ExampleReport.csv"); entry.Should().NotBeNull(); using (StreamReader reader = new StreamReader(entry.Open())) { zipContents = reader.ReadToEnd(); } } } zipContents.Should().NotBeNullOrEmpty(); zipContents.Should().Be(csv); }
public MessageParameters(JobType jobType) { JobType = jobType; JobContextMessage = new JobContextMessage(); }
public OperationsReportServiceContext(JobContextMessage jobContextMessage) { _jobContextMessage = jobContextMessage; }
public async Task <bool> Handle(JobContextMessage jobContextMessage, CancellationToken cancellationToken) { using (var childLifeTimeScope = _parentLifeTimeScope .BeginLifetimeScope(c => { var fileName = jobContextMessage.KeyValuePairs[JobContextMessageKey.Filename].ToString(); if (fileName.EndsWith(".zip", StringComparison.InvariantCultureIgnoreCase)) { c.RegisterType <AzureStorageCompressedFileContentStringProviderService>() .As <IMessageStreamProviderService>(); } else { c.RegisterType <AzureStorageFileContentStringProviderService>() .As <IMessageStreamProviderService>(); } c.RegisterInstance( new PreValidationContext { JobId = jobContextMessage.JobId.ToString(), Input = fileName, InvalidLearnRefNumbersKey = jobContextMessage .KeyValuePairs[JobContextMessageKey.InvalidLearnRefNumbers].ToString(), ValidLearnRefNumbersKey = jobContextMessage.KeyValuePairs[JobContextMessageKey.ValidLearnRefNumbers].ToString(), ValidationErrorsKey = jobContextMessage.KeyValuePairs[JobContextMessageKey.ValidationErrors] .ToString(), ValidationErrorMessageLookupKey = jobContextMessage .KeyValuePairs[JobContextMessageKey.ValidationErrorLookups].ToString() }).As <IPreValidationContext>(); })) { var executionContext = (ExecutionContext)childLifeTimeScope.Resolve <IExecutionContext>(); executionContext.JobId = jobContextMessage.JobId.ToString(); var logger = childLifeTimeScope.Resolve <ILogger>(); try { var azureStorageModel = childLifeTimeScope.Resolve <AzureStorageModel>(); azureStorageModel.AzureContainerReference = jobContextMessage.KeyValuePairs[JobContextMessageKey.Container].ToString(); logger.LogDebug("inside process message validate"); var preValidationOrchestrationService = childLifeTimeScope .Resolve <IPreValidationOrchestrationService <IValidationError> >(); var validationContext = childLifeTimeScope.Resolve <IPreValidationContext>(); await preValidationOrchestrationService.ExecuteAsync(validationContext, cancellationToken); // Update the file name, as it could have been a zip which we have extracted now so needs updating in the message jobContextMessage.KeyValuePairs[JobContextMessageKey.Filename] = validationContext.Input; // populate the keys into jobcontextmessage jobContextMessage.KeyValuePairs[JobContextMessageKey.InvalidLearnRefNumbersCount] = validationContext.InvalidLearnRefNumbersCount; jobContextMessage.KeyValuePairs[JobContextMessageKey.ValidLearnRefNumbersCount] = validationContext.ValidLearnRefNumbersCount; jobContextMessage.KeyValuePairs[JobContextMessageKey.ValidationTotalErrorCount] = validationContext.ValidationTotalErrorCount; jobContextMessage.KeyValuePairs[JobContextMessageKey.ValidationTotalWarningCount] = validationContext.ValidationTotalWarningCount; logger.LogDebug("Validation complete"); ServiceEventSource.Current.ServiceMessage(_context, "Validation complete"); return(true); } catch (Exception ex) { ServiceEventSource.Current.ServiceMessage(_context, "Exception-{0}", ex.ToString()); logger.LogError("Error while processing job", ex); throw; } } }