public IEnumerator<TemporaryExposureKeyExportModel> Create(
ulong startTimestamp, ulong endTimestamp, IEnumerable<TemporaryExposureKey> keys)
{
var current = keys;
var num = 1;
while (current.Any())
{
var exportKeys = current.Take(MaxKeysPerFile);
current = current.Skip(MaxKeysPerFile);
var bin = new TemporaryExposureKeyExport();
bin.Keys.AddRange(keys);
bin.BatchNum = num++;
bin.BatchSize = bin.Keys.Count;
bin.Region = Region;
bin.StartTimestamp = startTimestamp;
bin.EndTimestamp = endTimestamp;
var signature = CreateSignature(bin.BatchNum, bin.BatchSize);
bin.SignatureInfos.Add(signature.SignatureInfo);
var sig = new Covid19Radar.Protobuf.TEKSignatureList();
sig.Signatures.Add(signature);
var model = new TemporaryExposureKeyExportModel();
model.Url = WriteToBlob(bin, sig);
model.startTimestamp = startTimestamp;
model.endTimestamp = endTimestamp;
yield return model;
}
}
public async Task WriteToBlobAsync(Stream s, TemporaryExposureKeyExportModel model, TemporaryExposureKeyExport bin, TEKSignatureList sig)
{
Logger.LogInformation($"start {nameof(WriteToBlobAsync)}");
// skip if completed upload
if (model.Uploaded)
{
return;
}
// write to blob storage
var blobContainerName = $"{TekExportBlobStorageContainerPrefix}".ToLower();
var cloudBlobContainer = BlobClient.GetContainerReference(blobContainerName);
await cloudBlobContainer.CreateIfNotExistsAsync(BlobContainerPublicAccessType.Blob, new BlobRequestOptions(), new OperationContext());
var blobDirectory = cloudBlobContainer.GetDirectoryReference($"{model.Region}".ToLower());
// Filename is inferable as batch number
var exportFileName = $"{model.BatchNum}{fileNameSuffix}";
//var blockBlob = cloudBlobContainer.GetBlockBlobReference(exportFileName);
var blockBlob = blobDirectory.GetBlockBlobReference(exportFileName);
// Set the batch number and region as metadata
blockBlob.Metadata[batchNumberMetadataKey] = model.BatchNum.ToString();
blockBlob.Metadata[batchRegionMetadataKey] = model.Region;
await blockBlob.UploadFromStreamAsync(s);
Logger.LogInformation($" {nameof(WriteToBlobAsync)} upload {exportFileName}");
await blockBlob.SetMetadataAsync();
Logger.LogInformation($" {nameof(WriteToBlobAsync)} set metadata {exportFileName}");
// set upload
model.Uploaded = true;
}
public async Task <TemporaryExposureKeyExportModel> CreateAsync(TemporaryExposureKeyExportModel model)
{
_logger.LogInformation($"start {nameof(CreateAsync)}");
var pk = new PartitionKey(model.PartitionKey);
var response = await _db.TemporaryExposureKeyExport.CreateItemAsync(model, pk);
return(response.Resource);
}
public void PropertiesTest()
{
// preparation
var model = new TemporaryExposureKeyExportModel();
// model property access
Helper.ModelTestHelper.PropetiesTest(model);
}
public void CreateMethod()
{
// action
var model = new TemporaryExposureKeyExportModel();
// assert
Assert.IsNotNull(model);
}
public async Task <TemporaryExposureKeyExportModel> CreateAsync()
{
var partitionKey = PartitionKey.None;
var newItem = new TemporaryExposureKeyExportModel();
newItem.BatchNum = await _sequence.GetNextAsync(SequenceName, 1);
var pk = PartitionKey.Null;
return((await _db.TemporaryExposureKeyExport.CreateItemAsync(newItem, pk)).Resource);
}
public async Task <TemporaryExposureKeyExportModel> CreateAsync()
{
var pk = PartitionKey.None;
var newItem = new TemporaryExposureKeyExportModel();
var batchNum = await _sequence.GetNextAsync(SequenceName, 1);
newItem.id = batchNum.ToString();
newItem.BatchNum = batchNum;
await _db.TemporaryExposureKeyExport.CreateItemAsync(newItem, pk);
return(newItem);
}
public async Task DeleteAsync(TemporaryExposureKeyExportModel model)
{
Logger.LogInformation($"start {nameof(DeleteAsync)}");
var blobContainerName = $"{TekExportBlobStorageContainerPrefix}{model.Region}".ToLower();
var cloudBlobContainer = BlobClient.GetContainerReference(blobContainerName);
await cloudBlobContainer.CreateIfNotExistsAsync(BlobContainerPublicAccessType.Blob, new BlobRequestOptions(), new OperationContext());
// Filename is inferable as batch number
var exportFileName = $"{model.BatchNum}{fileNameSuffix}";
var blockBlob = cloudBlobContainer.GetBlockBlobReference(exportFileName);
await blockBlob.DeleteIfExistsAsync();
}
public async Task WriteToBlobAsync(Stream s, TemporaryExposureKeyExportModel model, TemporaryExposureKeyExport bin, TEKSignatureList sig)
{
// write to blob storage
var cloudBlobContainer = BlobClient.GetContainerReference(BlobContainerName);
await cloudBlobContainer.CreateIfNotExistsAsync(BlobContainerPublicAccessType.Blob, new BlobRequestOptions(), new OperationContext());
// Filename is inferable as batch number
var exportFileName = $"{model.BatchNum}.tekexport";
var blockBlob = cloudBlobContainer.GetBlockBlobReference(exportFileName);
// Set the batch number and region as metadata
blockBlob.Metadata[batchNumberMetadataKey] = model.BatchNum.ToString();
blockBlob.Metadata[batchRegionMetadataKey] = model.Region;
await blockBlob.UploadFromStreamAsync(s);
await blockBlob.SetMetadataAsync();
}
public async Task CreateAsync(ulong startTimestamp,
ulong endTimestamp,
string region,
int batchNum,
long batchTimestamp,
IEnumerable <TemporaryExposureKeyModel> keys)
{
Logger.LogInformation($"start {nameof(CreateAsync)}");
var current = keys;
while (current.Any())
{
var exportKeyModels = current.Take(MaxKeysPerFile).ToArray();
var exportKeys = exportKeyModels.Select(_ => _.ToKey()).ToArray();
current = current.Skip(MaxKeysPerFile);
var signatureInfo = SignatureService.Create();
await SignService.SetSignatureAsync(signatureInfo);
var exportModel = new TemporaryExposureKeyExportModel();
exportModel.id = batchNum.ToString();
exportModel.PartitionKey = region;
// TODO: not support apple
//exportModel.BatchNum = batchNum;
exportModel.BatchNum = 1;
exportModel.Region = region;
// TODO: not support apple
//exportModel.BatchSize = exportKeyModels.Length;
exportModel.BatchSize = 1;
exportModel.StartTimestamp = startTimestamp;
exportModel.EndTimestamp = endTimestamp;
exportModel.TimestampSecondsSinceEpoch = batchTimestamp;
exportModel = await TekExportRepository.CreateAsync(exportModel);
var bin = new TemporaryExposureKeyExport();
bin.Keys.AddRange(exportKeys);
bin.BatchNum = exportModel.BatchNum;
bin.BatchSize = exportModel.BatchSize;
bin.Region = exportModel.Region;
bin.StartTimestamp = exportModel.StartTimestamp;
bin.EndTimestamp = exportModel.EndTimestamp;
bin.SignatureInfos.Add(signatureInfo);
var sig = new TEKSignatureList();
using var binStream = new MemoryStream();
await binStream.WriteAsync(FixedHeader, 0, FixedHeaderWidth);
using var binStreamCoded = new CodedOutputStream(binStream, true);
bin.WriteTo(binStreamCoded);
binStreamCoded.Flush();
await binStream.FlushAsync();
var signature = await CreateSignatureAsync(binStream, bin.BatchNum, bin.BatchSize);
signature.SignatureInfo = signatureInfo;
sig.Signatures.Add(signature);
using (var s = new MemoryStream())
{
using (var z = new System.IO.Compression.ZipArchive(s, System.IO.Compression.ZipArchiveMode.Create, true))
{
var binEntry = z.CreateEntry(ExportBinFileName);
using (var binFile = binEntry.Open())
{
binStream.Seek(0, SeekOrigin.Begin);
await binStream.CopyToAsync(binFile);
await binFile.FlushAsync();
}
var sigEntry = z.CreateEntry(ExportSigFileName);
using (var sigFile = sigEntry.Open())
using (var output = new CodedOutputStream(sigFile))
{
sig.WriteTo(output);
output.Flush();
await sigFile.FlushAsync();
}
}
s.Seek(0, SeekOrigin.Begin);
await BlobService.WriteToBlobAsync(s, exportModel, bin, sig);
}
await TekExportRepository.UpdateAsync(exportModel);
}
}
public async Task UpdateAsync(TemporaryExposureKeyExportModel model)
{
_logger.LogInformation($"start {nameof(UpdateAsync)}");
await _db.TemporaryExposureKeyExport.UpsertItemAsync(model);
}
public void CreateMethod()
{
// action
var model = new TemporaryExposureKeyExportModel();
}
public async Task UpdateAsync(TemporaryExposureKeyExportModel model)
{
await _db.TemporaryExposureKeyExport.UpsertItemAsync(model);
}
