示例#1
0
        private async Task ZapAsync(long[] used)
        {
            await using var wfDb = _dkDbContextFactory();

            var zap = wfDb.DiagnosisKeys
                      .Where(x => used.Contains(x.Id))
                      .ToList();

            _index += used.Length;
            _logger.LogInformation("Marking as Published - Count:{Count}, Running total:{RunningTotal}.", zap.Count, _index);

            if (zap.Count == 0)
            {
                return;
            }

            foreach (var i in zap)
            {
                i.PublishedLocally = true;
            }

            var bargs = new SubsetBulkArgs
            {
                PropertiesToInclude = new[] { $"{nameof(DiagnosisKeyEntity.PublishedLocally)}" }
            };

            await wfDb.BulkUpdateAsync2(zap, bargs); //TX
        }
示例#2
0
        private async Task WriteNewEksToOutputAsync()
        {
            _Logger.WriteBuildEntry();

            var args = _Output.Select(Map).ToArray();

            var content = await _SetBuilder.BuildAsync(args);

            var e = new EksCreateJobOutputEntity
            {
                Region  = DefaultValues.Region,
                Release = _EksEngineResult.Started,
                CreatingJobQualifier = ++_EksCount,
                Content = content,
            };

            _Logger.WriteWritingCurrentEks(e.CreatingJobQualifier);


            await using (var dbc = _PublishingDbContextFac())
            {
                await using var tx = dbc.BeginTransaction();
                await dbc.AddAsync(e);

                dbc.SaveAndCommit();
            }

            _Logger.WriteMarkTekAsUsed();

            foreach (var i in _Output)
            {
                i.Used = true;
            }

            //Could be 750k in this hit
            await using (var dbc2 = _PublishingDbContextFac())
            {
                var bargs = new SubsetBulkArgs
                {
                    PropertiesToInclude = new[] { nameof(EksCreateJobInputEntity.Used) }
                };
                await dbc2.BulkUpdateAsync2(_Output, bargs); //TX
            }

            _EksEngineResult.OutputCount += _Output.Count;

            _EksResults.Add(new EksInfo {
                TekCount = _Output.Count, TotalSeconds = _BuildEksStopwatch.Elapsed.TotalSeconds
            });
            _Output.Clear();
        }
        //TODO make this a writer
        private async Task WriteNewSetToOutput()
        {
            _logger.LogDebug("Build IKS.");

            var args = _output.Select(MappingDefaults.ToInteropKeyFormatterArgs).ToArray();

            var content = _formatter.Format(args);

            var e = new IksCreateJobOutputEntity
            {
                Created = _engineResult.Started,
                CreatingJobQualifier = ++_setCount,
                Content = content
            };

            _logger.LogInformation("Write IKS - Id:{CreatingJobQualifier}.", e.CreatingJobQualifier);

            await using (var dbc = _publishingDbContextFac())
            {
                await using var tx = dbc.BeginTransaction();
                await dbc.AddAsync(e);

                dbc.SaveAndCommit();
            }

            _logger.LogInformation("Mark TEKs as used.");

            foreach (var i in _output)
            {
                i.Used = true;
            }

            //Could be 750k in this hit
            await using (var dbc2 = _publishingDbContextFac())
            {
                var bargs = new SubsetBulkArgs
                {
                    PropertiesToInclude = new[] { nameof(IksCreateJobInputEntity.Used) }
                };
                await dbc2.BulkUpdateAsync2(_output, bargs); //TX
            }

            _engineResult.OutputCount += _output.Count;

            _iksResults.Add(new IksInfo {
                ItemCount = _output.Count, TotalSeconds = _buildSetStopwatch.Elapsed.TotalSeconds
            });
            _output.Clear();
        }
示例#4
0
        private async Task MarkTeksAsPublishedAsync(long[] used)
        {
            await using var wfDb = _workflowDbContextFactory();

            var zap = wfDb.TemporaryExposureKeys
                      .Where(x => used.Contains(x.Id))
                      .ToList();

            _commitIndex += used.Length;
            _logger.LogInformation("Marking TEKs as Published - Count:{Count}, Running total:{RunningTotal}.", zap.Count, _commitIndex);

            foreach (var i in zap)
            {
                i.PublishingState = PublishingState.Published;
            }

            var bargs = new SubsetBulkArgs
            {
                PropertiesToInclude = new[] { $"{nameof(TekEntity.PublishingState)}" }
            };

            await wfDb.BulkUpdateAsync2(zap, bargs); //TX
        }