/// <inheritdoc />
public async Task <Possible <CasHash, Failure> > AddToCasAsync(
string filename,
FileState fileState,
CasHash?hash,
UrgencyHint urgencyHint,
Guid activityId)
{
if (m_outOfSpace)
{
return(new CacheFailure(s_outOfSpaceError[0]));
}
PutResult result;
if (hash.HasValue)
{
result = await CacheSession.PutFileAsync(
new Context(Logger),
hash.Value.ToContentHash(),
new BuildXL.Cache.ContentStore.Interfaces.FileSystem.AbsolutePath(filename),
fileState.ToMemoization(),
CancellationToken.None,
urgencyHint.ToMemoization());
}
else
{
result = await CacheSession.PutFileAsync(
new Context(Logger),
ContentHashingUtilities.HashInfo.HashType,
new BuildXL.Cache.ContentStore.Interfaces.FileSystem.AbsolutePath(filename),
fileState.ToMemoization(),
CancellationToken.None,
urgencyHint.ToMemoization());
}
if (result.Succeeded)
{
return(result.ContentHash.FromMemoization());
}
string outOfSpaceError;
if (!m_outOfSpace && IsOutOfSpacePut(result, out outOfSpaceError))
{
m_outOfSpace = true;
}
return(new CacheFailure(result.ErrorMessage));
}
public async Task <Possible <FullCacheRecordWithDeterminism, Failure> > AddOrGetAsync(WeakFingerprintHash weak, CasHash casElement, Hash hashElement, CasEntries hashes, UrgencyHint urgencyHint, Guid activityId)
{
var addResult = await CacheSession.AddOrGetContentHashListAsync(
new Context(Logger),
new BuildXL.Cache.MemoizationStore.Interfaces.Sessions.StrongFingerprint(
weak.ToMemoization(),
new Selector(casElement.ToMemoization(), hashElement.RawHash.ToByteArray())),
hashes.ToMemoization(),
CancellationToken.None,
urgencyHint.ToMemoization());
var strong = new StrongFingerprint(weak, casElement, hashElement, CacheId);
switch (addResult.Code)
{
case AddOrGetContentHashListResult.ResultCode.Success:
SessionEntries?.TryAdd(strong, 1);
return(addResult.ContentHashListWithDeterminism.ContentHashList == null
? new FullCacheRecordWithDeterminism(addResult.ContentHashListWithDeterminism.Determinism.FromMemoization())
: new FullCacheRecordWithDeterminism(new FullCacheRecord(strong, addResult.ContentHashListWithDeterminism.FromMemoization())));
case AddOrGetContentHashListResult.ResultCode.SinglePhaseMixingError:
return(new SinglePhaseMixingFailure(CacheId));
case AddOrGetContentHashListResult.ResultCode.InvalidToolDeterminismError:
return(new NotDeterministicFailure(
CacheId,
new FullCacheRecord(strong, addResult.ContentHashListWithDeterminism.FromMemoization()),
new FullCacheRecord(strong, hashes)));
case AddOrGetContentHashListResult.ResultCode.Error:
return(new CacheFailure(addResult.ErrorMessage));
default:
return(new CacheFailure("Unrecognized AddOrGetContentHashListAsync result code: " + addResult.Code + ", error message: " + (addResult.ErrorMessage ?? string.Empty)));
}
}
/// <inheritdoc />
public async Task <Possible <CasHash, Failure> > AddToCasAsync(Stream filestream, CasHash?hash, UrgencyHint urgencyHint, Guid activityId)
{
if (m_outOfSpace)
{
return(new CacheFailure(s_outOfSpaceError[0]));
}
PutResult result;
if (hash.HasValue)
{
result = await CacheSession.PutStreamAsync(new Context(Logger), hash.Value.ToContentHash(), filestream, CancellationToken.None, urgencyHint.ToMemoization());
}
else
{
result = await CacheSession.PutStreamAsync(new Context(Logger), ContentHashingUtilities.HashInfo.HashType, filestream, CancellationToken.None, urgencyHint.ToMemoization());
}
if (result.Succeeded)
{
return(result.ContentHash.FromMemoization());
}
string outOfSpaceError;
if (!m_outOfSpace && IsOutOfSpacePut(result, out outOfSpaceError))
{
m_outOfSpace = true;
}
return(new CacheFailure(result.ErrorMessage));
}
