private async Task <BoolResult> PushToRemoteAsync(OperationContext context, IReadOnlyList <ContentHash> hashes)
{
Contract.Check(_publisher != null)?.Assert("Startup should be run before attempting to publish.");
var pinResults = await Task.WhenAll(await _sourceContentSession.PinAsync(context, hashes, context.Token));
var missingFromLocal = pinResults.Where(r => !r.Item.Succeeded);
if (missingFromLocal.Any())
{
return(new BoolResult($"Not all contents of the content hash list are available in the cache. Missing hashes: {string.Join(", ", missingFromLocal.Select(m => hashes[m.Index].ToShortString()))}"));
}
// TODO: concurrency?
foreach (var hash in hashes)
{
var streamResult = await _sourceContentSession.OpenStreamAsync(context, hash, context.Token).ThrowIfFailure();
var stream = streamResult.Stream;
var putStreamResult = await _publisher.PutStreamAsync(context, hash, stream, context.Token).ThrowIfFailure();
}
return(BoolResult.Success);
}
private async Task UploadContent(
Context context, ContentHash contentHash, IContentSession fromSession, IContentSession toSession)
{
var openStreamResult = await fromSession.OpenStreamAsync(context, contentHash, Token).ConfigureAwait(false);
openStreamResult.Succeeded.Should().BeTrue();
var putResult = await toSession.PutStreamAsync(context, contentHash, openStreamResult.Stream, Token).ConfigureAwait(false);
putResult.Succeeded.Should().BeTrue();
}
/// <inheritdoc />
public async Task <OpenStreamResult> OpenStreamAsync(
Context context,
ContentHash contentHash,
CancellationToken cts,
UrgencyHint urgencyHint = UrgencyHint.Nominal)
{
var openStreamResult = await _sessionForStream.OpenStreamAsync(context, contentHash, cts, urgencyHint);
if (openStreamResult.Code == OpenStreamResult.ResultCode.ContentNotFound)
{
openStreamResult = await _sessionForPath.OpenStreamAsync(context, contentHash, cts, urgencyHint);
}
return(openStreamResult);
}
private async Task <ObjectResult <ContentHashListWithCacheMetadata> > UnpackBlobContentHashListAsync(Context context, BlobContentHashListWithCacheMetadata blobCacheMetadata)
{
Contract.Assert(blobCacheMetadata != null);
if (blobCacheMetadata.ContentHashListWithDeterminism.BlobIdentifier == null)
{
return(new ObjectResult <ContentHashListWithCacheMetadata>(
new ContentHashListWithCacheMetadata(
new ContentHashListWithDeterminism(null, blobCacheMetadata.Determinism),
blobCacheMetadata.GetRawExpirationTimeUtc(),
blobCacheMetadata.ContentGuarantee,
blobCacheMetadata.HashOfExistingContentHashList)));
}
BlobIdentifier blobId = blobCacheMetadata.ContentHashListWithDeterminism.BlobIdentifier;
Func <ContentHash, CancellationToken, Task <ObjectResult <Stream> > > openStreamFunc = async(hash, cts) =>
{
OpenStreamResult openStreamResult = await _blobContentSession.OpenStreamAsync(context, hash, cts);
if (openStreamResult.Succeeded)
{
return(new ObjectResult <Stream>(openStreamResult.Stream));
}
return(new ObjectResult <Stream>(openStreamResult));
};
StructResult <ContentHashListWithDeterminism> contentHashListResult =
await BlobContentHashListExtensions.UnpackFromBlob(
openStreamFunc,
blobId);
if (contentHashListResult.Succeeded)
{
var contentHashListWithCacheMetadata = new ContentHashListWithCacheMetadata(
contentHashListResult.Data,
blobCacheMetadata.GetRawExpirationTimeUtc(),
blobCacheMetadata.ContentGuarantee,
blobCacheMetadata.HashOfExistingContentHashList);
return(new ObjectResult <ContentHashListWithCacheMetadata>(contentHashListWithCacheMetadata));
}
else
{
return(new ObjectResult <ContentHashListWithCacheMetadata>(contentHashListResult));
}
}
/// <inheritdoc />
public Task <OpenStreamResult> OpenStreamAsync(
Context context, ContentHash contentHash, CancellationToken cts, UrgencyHint urgencyHint)
{
return(OpenStreamCall <ContentSessionTracer> .RunAsync(Tracer.ContentSessionTracer, new OperationContext(context), contentHash, async() =>
{
if (WriteThroughContentSession != null)
{
var result =
await WriteThroughContentSession.OpenStreamAsync(context, contentHash, cts, urgencyHint).ConfigureAwait(false);
if (result.Succeeded || result.Code != OpenStreamResult.ResultCode.ContentNotFound)
{
return result;
}
}
return await BackingContentSession.OpenStreamAsync(context, contentHash, cts, urgencyHint).ConfigureAwait(false);
}));
}
/// <inheritdoc />
protected override Task <OpenStreamResult> OpenStreamCoreAsync(OperationContext operationContext, ContentHash contentHash, UrgencyHint urgencyHint, Counter retryCounter)
{
return(_innerSession.OpenStreamAsync(operationContext, contentHash, operationContext.Token, urgencyHint));
}
