public static async Task <T> SyncronizedExecute <T>(this T command, Func <Task <WebSocket> > transport, JsonSerializer serializer, long queueKey = 0) where T : INetworkCommand
{
string key = $"SyncronizedExecute_{queueKey}";
bool retry = true, manualUnlock = false;
while (true)
{
try {
RequestLockManager.LockAndWait(key);
bool tmpManualUnlock = command.RequestManualUnlock(() => RequestLockManager.Unlock(key));
await command.ExecuteClientSyncronizedCommand(serializer, transport);
manualUnlock = tmpManualUnlock;
retry = false;
return(command);
} catch {
} finally {
if (!manualUnlock)
{
RequestLockManager.Unlock(key);
}
if (retry)
{
await Task.Yield();
}
}
}
}
public async Task <(bool success, DeleteResult result)> TryDeleteAsync(IDocument entry, CancellationToken ct)
{
string name = entry.FullPath();
await Store.Remove(name);
await Allocator.Removed(name);
RequestLockManager.RemoveStatus(name, RequestStatus.Cached);
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 (!RequestLockManager.GetStatus(name).Is(RequestStatus.IgnoreCache))
{
await Predictor.Request(name);
}
return(v);
}
public async Task TryOpenReadAsync_Bubbleup(IDocument entry, Stream result, CancellationToken ct)
{
string name = entry.FullPath();
if (!RequestLockManager.GetStatus(name).Is(RequestStatus.IgnoreCache))
{
int key = rand.Next();
activePredicitveFillKey = key;
await Predictor.Request_Bubbleup(name);
ThreadPool.QueueUserWorkItem(async(x) => await PredicitiveFillCache(key, ct));
}
}
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 DocumentPredictor(IDocumentStore store, IDocumentPredictor predictor, ICacheAllocator allocator, ChainedFileSystem predictOnFileSystem)
{
Store = store;
Predictor = predictor;
Allocator = allocator;
Allocator.OnDeallocate.Add(async(x) => {
await Store.Remove(x);
});
ThreadPool.QueueUserWorkItem(async(x) => {
try {
RequestLockManager.LockAndWait("DocumentPredictor_ctor");
while (FileSystem == null)
{
await Task.Delay(10);
}
await PredicitiveFillCache(0, CancellationToken.None);
}finally{
RequestLockManager.Unlock("DocumentPredictor_ctor");
}
});
}
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);
}
