/// <summary>
/// Dispose pattern.
/// </summary>
private void Dispose(bool disposing)
{
if (disposing)
{
_memoizationReadOnlySession?.Dispose();
_memoizationReadOnlySession = null;
_contentReadOnlySession?.Dispose();
_contentReadOnlySession = null;
}
}
/// <inheritdoc />
public static Task <PlaceFileResult> PlaceFileAsync(this IReadOnlyContentSession session, Context context, AbsolutePath path, VfsFilePlacementData placementData, CancellationToken token)
{
return(session.PlaceFileAsync(
context,
placementData.Hash,
path,
placementData.AccessMode,
FileReplacementMode.ReplaceExisting,
placementData.RealizationMode,
token));
}
/// <nodoc />
public VfsContentManager(ILogger logger, VfsCasConfiguration configuration, IReadOnlyContentSession placer)
{
Tree = new VfsTree(configuration);
_logger = logger;
_configuration = configuration;
_placer = placer;
_fileSystem = new PassThroughFileSystem();
_tempDirectory = new DisposableDirectory(_fileSystem, configuration.DataRootPath / "temp");
Provider = new VfsProvider(logger, configuration, this);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReadOnlyOneLevelCacheSession" /> class.
/// </summary>
public ReadOnlyOneLevelCacheSession(
string name, ImplicitPin implicitPin, IReadOnlyMemoizationSession memoizationSession, IReadOnlyContentSession contentSession)
{
Contract.Requires(name != null);
Contract.Requires(memoizationSession != null);
Contract.Requires(contentSession != null);
Name = name;
ImplicitPin = implicitPin;
_memoizationReadOnlySession = memoizationSession;
_contentReadOnlySession = contentSession;
}
private async Task OpenStreamAsync(
IReadOnlyContentSession session, IReadOnlyCollection <ContentHash> hashes, List <OpenStreamResult> results)
{
var tasks = hashes.Select(contentHash => Task.Run(async() =>
await session.OpenStreamAsync(_context, contentHash, Token)));
foreach (var task in tasks.ToList())
{
var result = await task;
results.Add(result);
}
}
protected async Task OpenStreamReturnsExpectedFile(
IReadOnlyContentSession session, Context context, ContentHash hash, byte[] expected)
{
OpenStreamResult openResult = await session.OpenStreamAsync(context, hash, Token);
context.Debug($"Validating stream for content hash {hash} returned result {openResult.Code} with diagnostics {openResult} with ErrorMessage {openResult.ErrorMessage} diagnostics {openResult.Diagnostics}");
Assert.Equal <OpenStreamResult.ResultCode>(OpenStreamResult.ResultCode.Success, openResult.Code);
Assert.True(openResult.Succeeded, $"OpenStream did not succeed for content hash {hash}");
Assert.NotNull(openResult.Stream);
using (openResult.Stream)
{
var actualBytes = await openResult.Stream.GetBytes(false);
actualBytes.Should().Equal(expected);
}
}
private async Task PlaceFileAsync(
IReadOnlyContentSession session, IReadOnlyCollection <Tuple <ContentHash, AbsolutePath> > args, List <PlaceFileResult> results)
{
var tasks = args.Select(t => Task.Run(async() => await session.PlaceFileAsync(
_context,
t.Item1,
t.Item2,
FileAccessMode.ReadOnly,
FileReplacementMode.FailIfExists,
FileRealizationMode.HardLink,
CancellationToken.None)));
foreach (var task in tasks.ToList())
{
var result = await task;
results.Add(result);
}
}
protected override Task <IReadOnlyList <ContentHash> > EnumerateContentHashesAsync(IReadOnlyContentSession session)
{
var testSession = (TestServiceClientContentSession)session;
return(testSession.EnumerateHashes());
}
/// <nodoc />
public ContentSessionVfsFilePlacer(IReadOnlyContentSession contentSession)
{
_contentSession = contentSession;
}
protected abstract Task <IReadOnlyList <ContentHash> > EnumerateContentHashesAsync(IReadOnlyContentSession session);
