Esempio n. 1
0
        private IEnumerable <LearnerValidationError> DivideAndConquer(Guid correlationId, Message message, ILogger logger)
        {
            var actorTasks = new List <Task <string> >();
            //split the file

            var listOfShreddedLearners = message.Learner.ToList()
                                         .SplitList(_actorsHelper.GetLearnersPerActor(message.Learner.Count()));

            message.Learner = null; //work around until actual split logic

            foreach (var learnerShard in listOfShreddedLearners)
            {
                //get actor ref
                var actor = GetLearnerActor();
                actorTasks.Add(actor.Validate(correlationId.ToString(), message, learnerShard.ToArray()));
            }

            logger.LogInfo($"created {actorTasks.Count()} validation Actors");


            Task.WaitAll(actorTasks.ToArray());

            List <LearnerValidationError> results = new List <LearnerValidationError>();

            foreach (var actorTask in actorTasks)
            {
                results.AddRange(JsonConvert.DeserializeObject <IEnumerable <LearnerValidationError> >(actorTask.Result));
            }



            return(results);
        }
        private async Task ProcessALBRuleBase(Message message, string correlationId)
        {
            var stopWatch     = new Stopwatch();
            var startDateTime = DateTime.Now;

            stopWatch.Start();

            var learnerShards = message.Learner.ToList()
                                .SplitList(_actorsHelper.GetLearnersPerActor(message.Learner.Count()));

            message.Learner = null;

            var actorTasks = new List <Task <FundingServiceOutputs> >();

            foreach (var learnerShard in learnerShards)
            {
                var albActorProxy = GetALBActor();
                actorTasks.Add(albActorProxy.ProcessFunding(correlationId,
                                                            message, learnerShard.ToArray()));
            }
            _logger.LogInfo($"Created {actorTasks.Count} actors.");
            await Task.WhenAll(actorTasks);

            var finalResult = new FundingServiceOutputs()
            {
                LearnerPeriodAttributeOutputses          = new GlobalOutputs.LearnerPeriodAttributeOutputs[] {},
                LearnerPeriodisedValuesOutputs           = new GlobalOutputs.LearnerPeriodisedValuesOutput[] {},
                LearnerPeriodOutputs                     = new GlobalOutputs.LearnerPeriodOutput[] {},
                LearningDeliveryOutputs                  = new GlobalOutputs.LearningDeliveryOutput[] {},
                LearningDeliveryPeriodAttributeOutputses = new GlobalOutputs.LearningDeliveryPeriodAttributeOutputs[] {},
                LearningDeliveryPeriodOutputs            = new GlobalOutputs.LearningDeliveryPeriodOutput[] {},
                LearningDeliveryPeriodisedValuesOutputs  = new GlobalOutputs.LearningDeliveryPeriodisedValuesOutput[] {}
            };

            foreach (var actorTask in actorTasks)
            {
                finalResult.GlobalOutputs = actorTask.Result.GlobalOutputs;
                finalResult.LearnerPeriodAttributeOutputses?.ToList().AddRange(actorTask.Result.LearnerPeriodAttributeOutputses);
                finalResult.LearnerPeriodOutputs.ToList().AddRange(actorTask.Result.LearnerPeriodOutputs);
                finalResult.LearnerPeriodisedValuesOutputs.ToList().AddRange(actorTask.Result.LearnerPeriodisedValuesOutputs);
                finalResult.LearningDeliveryOutputs.ToList().AddRange(actorTask.Result.LearningDeliveryOutputs);
                finalResult.LearningDeliveryPeriodAttributeOutputses.ToList().AddRange(actorTask.Result.LearningDeliveryPeriodAttributeOutputses);
                finalResult.LearningDeliveryPeriodOutputs.ToList().AddRange(actorTask.Result.LearningDeliveryPeriodOutputs);
                finalResult.LearningDeliveryPeriodisedValuesOutputs.ToList()
                .AddRange(actorTask.Result.LearningDeliveryPeriodisedValuesOutputs);
            }

            var opaJobMs = stopWatch.ElapsedMilliseconds;

            var endTime = DateTime.Now;

            var processTimes = new List <string>()
            {
                $"Start Time : {startDateTime}",
                $"OPA job : {opaJobMs}",
                $"End Time : {endTime}",
                $"Total Time : {(endTime - startDateTime).TotalMilliseconds}",
            };

            stopWatch.Restart();

            //save results in DS.
            await SaveResultsToDataService(correlationId, processTimes);

            var dataSavedtime = stopWatch.ElapsedMilliseconds;

            _logger.LogInfo(
                $"Results saved in DS in {dataSavedtime} ");

            _logger.LogInfo(
                $"Completed ALB Rulebase for jobId:{correlationId} in {(DateTime.Now - startDateTime).TotalMilliseconds} ");
        }