public void CasHashRoundTrip()
{
CasHash hash = RandomHelpers.CreateRandomCasHash();
CasHash roundTrip = hash.ToMemoization().FromMemoization();
Assert.Equal(hash, roundTrip);
}
public void CasHashToMemoization()
{
CasHash hash = RandomHelpers.CreateRandomCasHash();
ContentHash contentHash = hash.ToMemoization();
Assert.Equal(hash.BaseHash.RawHash.ToByteArray(), contentHash.ToHashByteArray());
}
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)));
}
}
public async Task <Possible <string, Failure> > ProduceFileAsync(
CasHash hash,
string filename,
FileState fileState,
UrgencyHint urgencyHint,
Guid activityId,
CancellationToken cancellationToken)
{
var result = await ReadOnlyCacheSession.PlaceFileAsync(
new Context(Logger),
hash.ToMemoization(),
new BuildXL.Cache.ContentStore.Interfaces.FileSystem.AbsolutePath(filename),
fileState == FileState.ReadOnly?FileAccessMode.ReadOnly : FileAccessMode.Write,
ReplaceExistingOnPlaceFile?FileReplacementMode.ReplaceExisting : FileReplacementMode.FailIfExists,
fileState.ToMemoization(),
cancellationToken);
switch (result.Code)
{
case PlaceFileResult.ResultCode.PlacedWithHardLink:
case PlaceFileResult.ResultCode.PlacedWithCopy:
return(filename);
case PlaceFileResult.ResultCode.NotPlacedAlreadyExists:
return(new FileAlreadyExistsFailure(CacheId, hash, filename));
case PlaceFileResult.ResultCode.NotPlacedContentNotFound:
return(new NoCasEntryFailure(CacheId, hash));
case PlaceFileResult.ResultCode.Error:
case PlaceFileResult.ResultCode.Unknown:
return(new CacheFailure(result.ErrorMessage));
default:
return(new CacheFailure("Unrecognized PlaceFileAsync result code: " + result.Code + ", error message: " + (result.ErrorMessage ?? string.Empty)));
}
}
public async Task <Possible <Stream, Failure> > GetStreamAsync(CasHash hash, UrgencyHint urgencyHint, Guid activityId)
{
var result = await ReadOnlyCacheSession.OpenStreamAsync(new Context(Logger), hash.ToMemoization(), CancellationToken.None);
switch (result.Code)
{
case OpenStreamResult.ResultCode.Success:
if (result.Stream != null)
{
return(result.Stream);
}
return(new NoCasEntryFailure(CacheId, hash));
case OpenStreamResult.ResultCode.Error:
return(new CacheFailure(result.ErrorMessage));
case OpenStreamResult.ResultCode.ContentNotFound:
return(new NoCasEntryFailure(CacheId, hash));
default:
return(new CacheFailure("Unrecognized OpenStreamAsync result code: " + result.Code + ", error message: " + (result.ErrorMessage ?? string.Empty)));
}
}
/// <inheritdoc />
public async Task <Possible <string, Failure> > PinToCasAsync(CasHash hash, UrgencyHint urgencyHint, Guid activityId)
{
var result = await ReadOnlyCacheSession.PinAsync(new Context(Logger), hash.ToMemoization(), CancellationToken.None);
return(result.FromMemoization(hash, CacheId));
}
