/// <summary>
/// Gets all the MEF exports of the specified type with the specified metadata.
/// </summary>
public IEnumerable <Lazy <TExtension, TMetadata> > GetExports <TExtension, TMetadata>()
{
IEnumerable exports;
var key = new ExportKey(typeof(TExtension).AssemblyQualifiedName, typeof(TMetadata).AssemblyQualifiedName);
if (!this.exportsMap.TryGetValue(key, out exports))
{
var count = 0;
exports = ImmutableInterlocked.GetOrAdd(ref this.exportsMap, key, _ =>
{
var result = this.exportProvider.GetExports <TExtension, TMetadata>().ToImmutableArray();
count++;
CrashIfSyntaxTreeFactoryServiceDoesntExistForCSharpOrVB(result);
return(result);
});
}
var final = (IEnumerable <Lazy <TExtension, TMetadata> >)exports;
CrashIfSyntaxTreeFactoryServiceDoesntExistForCSharpOrVB(final);
return(final);
}
public void TestMethod2()
{
KeyStoreDB keyStoreDb = new KeyStoreDB();
ExportKey expKey = new ExportKey(keyStoreDb);
expKey.ExportPublicKeyFromDbSecret(keyStoreDb.KeyStores.Where(k => k.KeyStoreID != null).First().KeyStoreID, "ExportKey_Test2.asc");
Assert.IsTrue(File.Exists("ExportKey_Test2.asc"));
}
public IEnumerable <Lazy <TExtension> > GetExports <TExtension>()
{
var key = new ExportKey(typeof(TExtension).AssemblyQualifiedName, "");
if (!_exportsMap.TryGetValue(key, out var exports))
{
exports = ImmutableInterlocked.GetOrAdd(ref _exportsMap, key, _ =>
_exportProvider.GetExports <TExtension>().ToImmutableArray());
}
return((IEnumerable <Lazy <TExtension> >)exports);
}
/// <summary>
/// Gets all the MEF exports of the specified type with the specified metadata.
/// </summary>
public IEnumerable <Lazy <TExtension, TMetadata> > GetExports <TExtension, TMetadata>()
{
IEnumerable exports;
var key = new ExportKey(typeof(TExtension).AssemblyQualifiedName, typeof(TMetadata).AssemblyQualifiedName);
if (!this.exportsMap.TryGetValue(key, out exports))
{
exports = ImmutableInterlocked.GetOrAdd(ref this.exportsMap, key, _ =>
this.exportProvider.GetExports <TExtension, TMetadata>().ToImmutableList());
}
return((IEnumerable <Lazy <TExtension, TMetadata> >)exports);
}
private void btnExportKey_Click(object sender, EventArgs e)
{
ExportKey expKey = new ExportKey(Global.keyDb);
if (m_caller == "Public")
{
expKey.ExportDbKey(m_keyId, txtFileForExport.Text);
}
else
{
expKey.ExportDbKey(m_keyId, txtFileForExport.Text);
}
label1.Text = "Key Exported successfully.";
label1.Visible = true;
}
public async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "bulk/providers")] HttpRequest req, ILogger log, CancellationToken ct)
{
try
{
var requestDateTime = _nowUtc();
log.LogInformation($"{nameof(GetApprenticeshipsAsProvider)} requested at {{{nameof(requestDateTime)}}}.", requestDateTime);
for (int i = 0; i <= 1; i++)
{
var exportKey = new ExportKey(requestDateTime.AddDays(-i));
var blobClient = _blobStorageClient.GetBlobClient(exportKey);
try
{
var result = await blobClient.DownloadAsync(ct);
log.LogInformation($"{nameof(GetApprenticeshipsAsProvider)} returned {{{nameof(exportKey)}}}.", exportKey);
return(new FileStreamResult(result.Value.Content, "application/json"));
}
catch (RequestFailedException ex)
when(ex.Status == StatusCodes.Status404NotFound)
{
log.LogInformation($"{nameof(GetApprenticeshipsAsProvider)} failed to find {{{nameof(exportKey)}}}.", exportKey);
continue;
}
}
log.LogInformation($"{nameof(GetApprenticeshipsAsProvider)} failed to find an export for {{{nameof(requestDateTime)}}}.", requestDateTime);
return(new NotFoundResult());
}
catch (Exception ex)
{
log.LogError(ex, $"{nameof(GetApprenticeshipsAsProvider)} failed with exception.");
return(new InternalServerErrorResult());
}
}
public async Task Run_WithExportAvailableForToday_ReturnsTodaysExport()
{
var now = DateTimeOffset.UtcNow.Date;
_nowUtc.Setup(s => s.Invoke())
.Returns(now);
var todaysBlob = "{\"id\":\"TodaysBlob\"}";
var todaysExportKey = new ExportKey(now);
var todaysBlobClient = new Mock <BlobClient>();
todaysBlobClient.Setup(s => s.DownloadAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(ReturnBlob(todaysBlob));
_blobStorageClient.Setup(s => s.GetBlobClient(It.Is <string>(blobName => blobName == todaysExportKey)))
.Returns(todaysBlobClient.Object);
var yesterdaysBlob = "{\"id\":\"YesterdaysBlob\"}";
var yesterdayExportKey = new ExportKey(now.AddDays(-1));
var yesterdaysBlobClient = new Mock <BlobClient>();
yesterdaysBlobClient.Setup(s => s.DownloadAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(ReturnBlob(yesterdaysBlob));
_blobStorageClient.Setup(s => s.GetBlobClient(It.Is <string>(blobName => blobName == yesterdayExportKey)))
.Returns(yesterdaysBlobClient.Object);
var result = await _function.Run(new Mock <HttpRequest>().Object, NullLogger.Instance, CancellationToken.None) as FileStreamResult;
result.Should().NotBeNull();
result.ContentType.Should().Be("application/json");
using var sr = new StreamReader(result.FileStream);
var contentResult = await sr.ReadToEndAsync();
contentResult.Should().Be(todaysBlob);
}
private async Task <GenerateProviderExportResult> GenerateProviderExport(ILogger log, CancellationToken ct)
{
var exportKey = ExportKey.FromUtcNow();
try
{
var blobClient = _blobStorageClient.GetBlobClient(exportKey);
if (!await blobClient.ExistsAsync(ct))
{
await blobClient.UploadAsync(new MemoryStream(), true, ct);
}
var leaseClient = _blobStorageClient.GetBlobLeaseClient(blobClient);
Response <BlobLease> lease;
try
{
lease = await leaseClient.AcquireAsync(TimeSpan.FromSeconds(60), cancellationToken : ct);
log.LogInformation($"Acquired lease for {{{nameof(exportKey)}}}.", exportKey);
}
catch (RequestFailedException ex)
when(ex.Status == 409 && ex.ErrorCode == BlobErrorCode.LeaseAlreadyPresent)
{
log.LogWarning($"Failed to acquire lease for {{{nameof(exportKey)}}}.", exportKey);
return(GenerateProviderExportResult.FailedInProgress(exportKey));
}
var leaseRenewalTimer = new Timer(async _ =>
{
await leaseClient.RenewAsync();
log.LogInformation($"Renewed lease for {{{nameof(exportKey)}}}.", exportKey);
}, null, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(30));
try
{
log.LogInformation($"Started generation of {{{nameof(exportKey)}}}.", exportKey);
var results = default(IEnumerable <DasProviderResult>);
try
{
var generateStopwatch = Stopwatch.StartNew();
var apprenticeships = (List <Apprenticeship>) await _apprenticeshipService.GetLiveApprenticeships();
results = await _apprenticeshipService.ApprenticeshipsToDasProviders(apprenticeships);
generateStopwatch.Stop();
log.LogInformation($"Completed generation of {{{nameof(exportKey)}}} in {generateStopwatch.Elapsed}.", exportKey);
}
catch (Exception ex)
{
log.LogError(ex, $"Failed to generate {{{nameof(exportKey)}}}.", exportKey);
return(GenerateProviderExportResult.FailedGeneratation(exportKey));
}
try
{
log.LogInformation($"Started upload of {{{nameof(exportKey)}}}.", exportKey);
var uploadStopwatch = Stopwatch.StartNew();
var export = JsonConvert.SerializeObject(
results.Where(r => r.Success).Select(r => r.Result),
new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(export)))
{
await blobClient.UploadAsync(stream, conditions : new BlobRequestConditions
{
LeaseId = lease.Value.LeaseId
}, cancellationToken : ct);
}
uploadStopwatch.Stop();
log.LogInformation($"Completed upload of {{{nameof(exportKey)}}} in {uploadStopwatch.Elapsed}.", exportKey);
}
catch (RequestFailedException ex)
{
log.LogError(ex, $"Failed to upload {{{nameof(exportKey)}}}.", exportKey);
return(GenerateProviderExportResult.FailedUpload(exportKey));
}
return(GenerateProviderExportResult.Succeeded(exportKey, results.Count(r => r.Success)));
}
finally
{
leaseRenewalTimer.Dispose();
await leaseClient.ReleaseAsync();
log.LogInformation($"Released lease for {{{nameof(exportKey)}}}.", exportKey);
}
}
catch (Exception ex)
{
log.LogError(ex, $"{nameof(GenerateProviderExport)} failed with unhandled exception.");
return(GenerateProviderExportResult.FailedUnhandledException(exportKey));
}
}
