public async Task <(bool success, IDocument result)> TryMoveToAsync(IDocument entry, ICollection collection, string name, CancellationToken ct)
{
string from = entry.FullPath();
string to = collection.FullPath() + "/" + name;
RequestLockManager.RemoveStatus(from, RequestStatus.Cached);
RequestLockManager.AddStatus(to, RequestStatus.Cached);
await Store.Move(from, to);
await Allocator.Moved(from, to);
return(false, null);
}
public async Task <(bool success, Stream result)> TryOpenReadAsync(IDocument entry, CancellationToken ct)
{
string name = entry.FullPath();
var v = await Store.TryGet(name);
if (v.success)
{
await Allocator.Refresh(name, () => Task.FromResult(entry), () => Task.FromResult(v.data));
await CacheManager.Ignore_OpenReadAsync(entry);
RequestLockManager.AddStatus(name, RequestStatus.Cached);
}
return(v);
}
public async Task TryOpenReadAsync_Bubbleup(IDocument entry, Stream result, CancellationToken ct)
{
string name = entry.FullPath();
if (!IgnoreIgnoreCache && RequestLockManager.GetStatus(name).Is(RequestStatus.IgnoreCache))
{
return;
}
if (result.CanSeek)
{
if (result is IDelayedDisposable)
{
(result as IDelayedDisposable).OnDisposeAsync.Add(async() => {
result.Position = 0;
await Store.TryPut(name, result);
});
}
else
{
await Store.TryPut(name, result);
result.Position = 0;
}
RequestLockManager.AddStatus(name, RequestStatus.Cached);
}
else if (result is PushReadStream &&
!RequestLockManager.GetStatus(name).Is(RequestStatus.IgnoreCache) &&
await Allocator.TryAllocate(name, () => Task.FromResult(entry), () => Task.FromResult(result))
)
{
PushReadStream prs = result as PushReadStream;
prs.AddListener(new DocumentCacheStreamListener(prs, this, name));
RequestLockManager.AddStatus(name, RequestStatus.Cached);
}
}
private async Task PredicitiveFillCache(int predicitveFillKey, CancellationToken ct)
{
IEnumerable <string> predictedFiles = await Predictor.GetLikelyhoodSortedDocuments();
predictedFiles = predictedFiles.ToArray();
IEnumerator <string> predictedFilesEnumerator = predictedFiles.GetEnumerator();
string currentDocKey = null;
IDocument currentDoc = null;
string currentStreamKey = null;
Stream currentStream = null;
Func <Task <IDocument> > CurrentDoc = async() => {
if (predictedFilesEnumerator.Current != currentDocKey)
{
SelectionResult selectionResult = await FileSystem.SelectAsync(predictedFilesEnumerator.Current, ct, false);
currentDoc = selectionResult.Document;
currentDocKey = predictedFilesEnumerator.Current;
}
return(currentDoc);
};
Func <Task <Stream> > CurrentStream = async() => {
if (predictedFilesEnumerator.Current != currentStreamKey)
{
IDocument doc = await CurrentDoc();
currentStream = await doc.OpenReadAsync(ct);
currentStreamKey = predictedFilesEnumerator.Current;
}
return(currentStream);
};
//List<string> Cached = new List<string>();
while (predicitveFillKey == activePredicitveFillKey && predictedFilesEnumerator.MoveNext())
{
if (RequestLockManager.GetStatus_Chainable(predictedFilesEnumerator.Current).Is(RequestStatus.IgnoreCache))
{
continue;
}
RequestLockManager.AddStatus(predictedFilesEnumerator.Current, RequestStatus.PredicitiveRequest);
try {
if (!(await Store.TryGet(predictedFilesEnumerator.Current, true)).success)
{
if (!await Allocator.TryAllocate(predictedFilesEnumerator.Current, CurrentDoc, CurrentStream))
{
break;
}
if (!await Store.TryPut(predictedFilesEnumerator.Current, await CurrentStream()))
{
break;
}
}
else
{
await Allocator.TryAllocate(predictedFilesEnumerator.Current, CurrentDoc, CurrentStream);
}
RequestLockManager.AddStatus(predictedFilesEnumerator.Current, RequestStatus.Cached);
} finally{
RequestLockManager.RemoveStatus(predictedFilesEnumerator.Current, RequestStatus.PredicitiveRequest);
}
}
//string log = $"Predicted and Cached:\n {(Cached.Any() ? (Cached.Count == 1 ? Cached.First() : Cached.Aggregate((x, y) => $"{x}\n {y}")) : "None")}";
//Console.WriteLine(log);
}
