public CreateSessionResult <ICacheSession> CreateSession(Context context, string name, ImplicitPin implicitPin)
{
Contract.Requires(ContentStore != null);
Contract.Requires(MemoizationStore != null);
return(Tracing.CreateSessionCall.Run(CacheTracer, context, name, () =>
{
var createContentResult = ContentStore.CreateSession(context, name, implicitPin);
if (!createContentResult)
{
return new CreateSessionResult <ICacheSession>(createContentResult, "Content session creation failed");
}
var contentSession = createContentResult.Session;
var createMemoizationResult = _passContentToMemoization
? MemoizationStore.CreateSession(context, name, contentSession)
: MemoizationStore.CreateSession(context, name);
if (!createMemoizationResult)
{
return new CreateSessionResult <ICacheSession>(createMemoizationResult, "Memoization session creation failed");
}
var memoizationSession = createMemoizationResult.Session;
var session = new OneLevelCacheSession(name, implicitPin, memoizationSession, contentSession);
return new CreateSessionResult <ICacheSession>(session);
}));
}
/// <inheritdoc />
public Task <AddOrGetContentHashListResult> AddOrGetContentHashListAsync(
Context context,
StrongFingerprint strongFingerprint,
ContentHashListWithDeterminism contentHashListWithDeterminism,
CancellationToken cts,
UrgencyHint urgencyHint)
{
return(MemoizationStore.AddOrGetContentHashListAsync(
context, strongFingerprint, contentHashListWithDeterminism, _contentSession, cts));
}
/// <inheritdoc />
protected override async Task <BoolResult> StartupCoreAsync(OperationContext context)
{
(var contentStoreResult, var memoizationStoreResult) = await CreateAndStartStoresAsync(context);
Contract.Assert(ContentStore != null, "Content store must be initialized");
Contract.Assert(MemoizationStore != null, "Memoization store must be initialized");
Contract.Assert(!ReferenceEquals(ContentStore, MemoizationStore));
BoolResult result;
if (!contentStoreResult.Succeeded || !memoizationStoreResult.Succeeded)
{
var sb = new StringBuilder();
if (contentStoreResult.Succeeded)
{
var r = await ContentStore.ShutdownAsync(context).ConfigureAwait(false);
if (!r.Succeeded)
{
sb.Append($"Content store shutdown failed, error=[{r}]");
}
}
else
{
sb.Append($"Content store startup failed, error=[{contentStoreResult}]");
}
if (memoizationStoreResult.Succeeded)
{
var r = await MemoizationStore.ShutdownAsync(context).ConfigureAwait(false);
if (!r.Succeeded)
{
sb.Append(sb.Length > 0 ? ", " : string.Empty);
sb.Append($"Memoization store shutdown failed, error=[{memoizationStoreResult}]");
}
}
else
{
sb.Append(sb.Length > 0 ? ", " : string.Empty);
sb.Append($"Memoization store startup failed, error=[{memoizationStoreResult}]");
}
result = new BoolResult(sb.ToString());
}
else
{
result = BoolResult.Success;
}
return(result);
}
/// <inheritdoc />
protected override async Task <(BoolResult contentStoreResult, BoolResult memoizationStoreResult)> CreateAndStartStoresAsync(OperationContext context)
{
ContentStore = _contentStoreFunc();
MemoizationStore = _memoizationStoreFunc();
var preStartupResult = await PreStartupAsync(context).ThrowIfFailure();
var contentStoreTask = Task.Run(() => ContentStore.StartupAsync(context));
var memoizationStoreResult = await MemoizationStore.StartupAsync(context).ConfigureAwait(false);
var contentStoreResult = await contentStoreTask.ConfigureAwait(false);
return(contentStoreResult, memoizationStoreResult);
}
/// <inheritdoc />
protected override async Task <BoolResult> ShutdownCoreAsync(OperationContext context)
{
var statsResult = await StatsAsync(context).ConfigureAwait(false);
var contentStoreTask = Task.Run(() => ContentStore.ShutdownAsync(context));
var memoizationStoreResult = await MemoizationStore.ShutdownAsync(context).ConfigureAwait(false);
var contentStoreResult = await contentStoreTask.ConfigureAwait(false);
BoolResult result;
if (contentStoreResult.Succeeded && memoizationStoreResult.Succeeded)
{
result = BoolResult.Success;
}
else
{
var sb = new StringBuilder();
if (!contentStoreResult.Succeeded)
{
sb.Append($"Content store shutdown failed, error=[{contentStoreResult}]");
}
if (!memoizationStoreResult.Succeeded)
{
sb.Append(sb.Length > 0 ? ", " : string.Empty);
sb.Append($"Memoization store shutdown failed, error=[{memoizationStoreResult}]");
}
result = new BoolResult(sb.ToString());
}
if (statsResult.Succeeded)
{
#if NET_FRAMEWORK
LocalCacheStatsEventSource.Instance.Stats(statsResult.CounterSet);
#endif
statsResult.CounterSet.LogOrderedNameValuePairs(s => Tracer.Debug(context, s));
}
return(result);
}
protected override async Task <BoolResult> StartupCoreAsync(OperationContext context)
{
var(contentStoreResult, memoizationStoreResult) = await CreateAndStartStoresAsync(context);
if (contentStoreResult.Succeeded && memoizationStoreResult.Succeeded)
{
// The properties must be initialized but only when the startup succeeded.
Contract.Assert(ContentStore != null, "Content store must be initialized");
Contract.Assert(MemoizationStore != null, "Memoization store must be initialized");
Contract.Assert(!ReferenceEquals(ContentStore, MemoizationStore), "ContentStore and MemoizationStore should not be the same.");
return(BoolResult.Success);
}
else
{
// One of the startup operations failed.
var sb = new StringBuilder();
AppendIfError(sb, "Content store startup", contentStoreResult);
if (contentStoreResult)
{
Contract.Assert(ContentStore != null, "Content store must be initialized");
var r = await ContentStore.ShutdownAsync(context).ConfigureAwait(false);
AppendIfError(sb, "Content store shutdown", r);
}
AppendIfError(sb, "Memoization store startup", memoizationStoreResult);
if (memoizationStoreResult)
{
Contract.Assert(MemoizationStore != null, "Memoization store must be initialized");
var r = await MemoizationStore.ShutdownAsync(context).ConfigureAwait(false);
AppendIfError(sb, "Memoization store shutdown", r);
}
return(new BoolResult(sb.ToString()));
}
}
/// <inheritdoc />
public CreateSessionResult <IReadOnlyCacheSession> CreateReadOnlySession(Context context, string name, ImplicitPin implicitPin)
{
return(Tracing.CreateReadOnlySessionCall.Run(CacheTracer, context, name, () =>
{
var createContentResult = ContentStore.CreateReadOnlySession(context, name, implicitPin);
if (!createContentResult.Succeeded)
{
return new CreateSessionResult <IReadOnlyCacheSession>(createContentResult, "Content session creation failed");
}
var contentReadOnlySession = createContentResult.Session;
var createMemoizationResult = MemoizationStore.CreateReadOnlySession(context, name);
if (!createMemoizationResult.Succeeded)
{
return new CreateSessionResult <IReadOnlyCacheSession>(createMemoizationResult, "Memoization session creation failed");
}
var memoizationReadOnlySession = createMemoizationResult.Session;
var session = new ReadOnlyOneLevelCacheSession(name, implicitPin, memoizationReadOnlySession, contentReadOnlySession);
return new CreateSessionResult <IReadOnlyCacheSession>(session);
}));
}
private async Task <GetStatsResult> StatsAsync(Context context)
{
var counters = new CounterSet();
var statsResult = await ContentStore.GetStatsAsync(context).ConfigureAwait(false);
if (!statsResult.Succeeded)
{
return(statsResult);
}
counters.Merge(statsResult.CounterSet);
statsResult = await MemoizationStore.GetStatsAsync(context).ConfigureAwait(false);
if (!statsResult.Succeeded)
{
return(statsResult);
}
counters.Merge(statsResult.CounterSet);
return(new GetStatsResult(counters));
}
protected override void DisposeCore()
{
MemoizationStore?.Dispose();
ContentStore?.Dispose();
}
public IAsyncEnumerable <StructResult <StrongFingerprint> > EnumerateStrongFingerprints(Context context)
{
Contract.Assert(MemoizationStore != null, "Memoization store must be initialized");
return(MemoizationStore.EnumerateStrongFingerprints(context));
}
/// <inheritdoc />
public Async::System.Collections.Generic.IAsyncEnumerable <StructResult <StrongFingerprint> > EnumerateStrongFingerprints(Context context)
{
return(MemoizationStore.EnumerateStrongFingerprints(context));
}
