private async Task <CasHash> AddPathSet(ICacheSession session, params string[] thePaths)
{
var pathTable = new PathTable();
ObservedPathEntry[] paths = new ObservedPathEntry[thePaths.Length];
for (int i = 0; i < thePaths.Length; i++)
{
AbsolutePath absPath = AbsolutePath.Create(pathTable, thePaths[i]);
paths[i] = new ObservedPathEntry(absPath, false, false, false, null, false);
}
var emptyObservedAccessFileNames = SortedReadOnlyArray <StringId, CaseInsensitiveStringIdComparer> .FromSortedArrayUnsafe(
ReadOnlyArray <StringId> .Empty,
new CaseInsensitiveStringIdComparer(pathTable.StringTable));
ObservedPathSet pathSet = new ObservedPathSet(
SortedReadOnlyArray <ObservedPathEntry, ObservedPathEntryExpandedPathComparer> .FromSortedArrayUnsafe(
ReadOnlyArray <ObservedPathEntry> .FromWithoutCopy(paths),
new ObservedPathEntryExpandedPathComparer(pathTable.ExpandedPathComparer)),
emptyObservedAccessFileNames,
null);
using (var pathSetBuffer = new MemoryStream())
{
using (var writer = new BuildXLWriter(stream: pathSetBuffer, debug: false, leaveOpen: true, logStats: false))
{
pathSet.Serialize(pathTable, writer, preserveCasing: false);
}
pathSetBuffer.Seek(0, SeekOrigin.Begin);
// Must await such that the dispose of the MemoryStream is only after the write completes
return(await session.AddToCasAsync(pathSetBuffer).SuccessAsync());
}
}
/// <summary>
/// Serializes a path set to the given buffer.
/// </summary>
protected async Task <ContentHash> SerializePathSet(ObservedPathSet pathSet, MemoryStream pathSetBuffer, ContentHash?pathSetHash = null)
{
using (var writer = new BuildXLWriter(stream: pathSetBuffer, debug: false, leaveOpen: true, logStats: false))
{
pathSet.Serialize(PathTable, writer, m_pathExpander);
if (pathSetHash == null)
{
pathSetBuffer.Position = 0;
pathSetHash = await ContentHashingUtilities.HashContentStreamAsync(pathSetBuffer);
}
pathSetBuffer.Position = 0;
return(pathSetHash.Value);
}
}
private static void AssertCompressedSizeExpected(PathTable pathTable, ObservedPathSet pathSet, params string[] uncompressedStrings)
{
long compressedSize = GetSizeOfSerializedContent(writer => pathSet.Serialize(pathTable, writer));
int numberOfUniquePaths = ObservedPathSetTestUtilities.RemoveDuplicates(pathSet).Count;
// This is correct assuming the following:
// - Each string can be represented with a one byte length prefix, and a one byte reuse-count.
// - The number of strings can be represented in one byte.
// - Each character takes one byte when UTF8 encoded.
long expectedCompressedSize =
GetSizeOfSerializedContent(writer => pathSet.UnsafeOptions.Serialize(writer)) +
1 + // The number of observed accesses file names (0)
1 + // String count
(3 * numberOfUniquePaths) + // Length isSearchPath, isDirectoryPath, and reuse
uncompressedStrings.Sum(s => s.Length);
XAssert.AreEqual(expectedCompressedSize, compressedSize, "Wrong size for compressed path-set");
}
private static ObservedPathSet SerializeRoundTripAndAssertEquivalent(PathTable pathTable, ObservedPathSet original, PathExpander pathExpander = null)
{
using (var mem = new MemoryStream())
{
using (var writer = new BuildXLWriter(stream: mem, debug: true, leaveOpen: true, logStats: true))
{
original.Serialize(pathTable, writer, pathExpander);
}
mem.Position = 0;
ObservedPathSet roundtrip;
using (var reader = new BuildXLReader(stream: mem, debug: true, leaveOpen: true))
{
var maybeRoundtrip = ObservedPathSet.TryDeserialize(pathTable, reader, pathExpander);
XAssert.IsTrue(maybeRoundtrip.Succeeded, "Failed to deserialize a path set unexpectedly");
roundtrip = maybeRoundtrip.Result;
}
ObservedPathSetTestUtilities.AssertPathSetsEquivalent(original, roundtrip);
return(roundtrip);
}
}
