public async Task <TaskSession> OpenSession(SessionKey sessionKey, MazeTask mazeTask, string description)
{
using (await _readerWriterLock.ReaderLockAsync())
{
var file = _fileSystem.FileInfo.FromFileName(GetTaskDbFilename(mazeTask));
if (file.Exists)
{
using (var dbStream = file.OpenRead())
using (var db = new LiteDatabase(dbStream))
{
var collection = db.GetCollection <TaskSession>(nameof(TaskSession));
collection.EnsureIndex(x => x.TaskSessionId, true);
var taskSession = collection.IncludeAll().FindById(sessionKey.Hash);
if (taskSession != null)
{
return(taskSession);
}
}
}
}
return(new TaskSession
{
TaskSessionId = sessionKey.Hash,
Description = description,
CreatedOn = DateTimeOffset.UtcNow,
TaskReference = new TaskReference {
TaskId = mazeTask.Id
},
TaskReferenceId = mazeTask.Id,
Executions = ImmutableList <TaskExecution> .Empty
});
}
public async Task <DataPage <UserMessage> > GetUserMessages(string userLogin, int pageNumber, int pageSize)
{
ValidatePagination(pageNumber, pageSize);
using (await _docLock.ReaderLockAsync().ConfigureAwait(false))
{
var doc = await GetStorage();
var usr = GetUserNode(doc, userLogin);
if (usr == null)
{
return(new DataPage <UserMessage>(pageNumber, pageSize, 0, null)); //not found
}
var totalCount = usr.Elements("message") == null ? 0 : usr.Elements("message").Count();
IEnumerable <XElement> items = from m in usr.Elements("message")
orderby m.Attribute("created").Value
select m;
if (pageSize != -1)
{
items = items.Skip((pageNumber - 1) * pageSize).Take(pageSize);
}
return(new DataPage <UserMessage>(pageNumber, pageSize, totalCount, items.Select(i => Mapper.Map <UserMessage>(i)).ToList()));
}
}
/// <summary>
/// Calling this routine acknowledges an individual alarm
/// </summary>
/// <param name="myEventID"></param>
/// <returns></returns>
async public Task BeginAlarmAcknowledge(int myEventId)
{
// Find the event we are acknowledging.
IEnumerable <IEventItem> query = null;
using (var releaser = await _lock.ReaderLockAsync())
{
query = from item in this
where item.EventId == myEventId
select item;
}
// If we have found the trigger event, then build the acknowledge event
if (query.Count <IEventItem>() > 0)
{
IEventItem triggerEvent = query.First <IEventItem>();
IEventItem acknowledgedEvent = new EventItem(triggerEvent.SensorId);
acknowledgedEvent.EventPriority = 0;
acknowledgedEvent.EventCode = EventCode.AlarmAcknowledged;
acknowledgedEvent.Value = 0;
await this.BeginAddEvent(acknowledgedEvent, true);
// if this event has triggered an alarm, cancel that alarm.
AlarmAudio.CancelAlarm(triggerEvent.EventId);
}
}
public async Task Unlocked_PermitsMultipleReaderLocks()
{
AsyncReaderWriterLock rwl = new AsyncReaderWriterLock();
await rwl.ReaderLockAsync();
await rwl.ReaderLockAsync();
}
public void Unlocked_PermitsMultipleReaderLocks()
{
AsyncContext.Run(async() =>
{
var rwl = new AsyncReaderWriterLock();
await rwl.ReaderLockAsync();
await rwl.ReaderLockAsync();
});
}
public void ReaderKey_MultiDispose_DoesNothing()
{
AsyncContext.Run(async() =>
{
var rwl = new AsyncReaderWriterLock();
var key = await rwl.ReaderLockAsync();
key.Dispose();
key.Dispose();
await rwl.ReaderLockAsync();
});
}
/// <summary>
/// Find a device item by its serial number.
/// </summary>
/// <param name="serialNumber"></param>
/// <returns></returns>
async public Task <IDeviceItem> BeginFindBySerialNumber(string serialNumber)
{
IDeviceItem deviceItem = null;
using (var releaser = await _lock.ReaderLockAsync())
{
deviceItem = (IDeviceItem)_hashBySerialNumber[serialNumber];
}
return(deviceItem);
}
public async Task UsingYoutubeDL(Func <YoutubeDL, Task> action)
{
using var @lock = await ytdlLock.ReaderLockAsync();
if (ytdl == null)
{
throw new Exception("YoutubeDL not yet downloaded!");
}
await action.Invoke(ytdl);
}
async public Task <IGaugePageItem> BeginFindByPageId(Int64 myPageId)
{
IGaugePageItem result = null;
using (var releaser = await _lock.ReaderLockAsync())
{
result = this.FirstOrDefault <IGaugePageItem>(item => item.PageId == myPageId);
}
return(result);
}
public void UpgradeableReadLocked_AllowsMultipleReaderLocks()
{
AsyncContext.Run(async() =>
{
var rwl = new AsyncReaderWriterLock();
var key = await rwl.UpgradeableReaderLockAsync();
Assert.IsFalse(key.Upgraded);
await rwl.ReaderLockAsync();
await rwl.ReaderLockAsync();
});
}
public async Task WriteLocked_ReaderLockCancelled_DoesNotTakeLockWhenUnlocked()
{
var rwl = new AsyncReaderWriterLock();
using (await rwl.WriterLockAsync())
{
var cts = new CancellationTokenSource();
var task = rwl.ReaderLockAsync(cts.Token).AsTask();
cts.Cancel();
await AsyncAssert.ThrowsAsync <OperationCanceledException>(task);
}
await rwl.ReaderLockAsync();
}
public async Task WriteLocked_ReaderLockCancelled_DoesNotTakeLockWhenUnlocked()
{
AsyncReaderWriterLock rwl = new AsyncReaderWriterLock();
using (await rwl.WriterLockAsync())
{
CancellationTokenSource cts = new CancellationTokenSource();
Task <IDisposable> task = rwl.ReaderLockAsync(cts.Token).AsTask();
cts.Cancel();
await AsyncAssert.ThrowsAsync <OperationCanceledException>(task).ConfigureAwait(false);
}
await rwl.ReaderLockAsync();
}
/// <summary>
/// Try to get the value with the specified name.
/// </summary>
/// <param name="name">
/// The unique name of the entity.
/// </param>
/// <param name="cancel">
/// Is used to stop the task. When cancelled, the <see cref="TaskCanceledException" /> is raised.
/// </param>
/// <returns>
/// A task that represents the asynchronous operation. The task's result is
/// a <typeparamref name="TValue" /> or <b>null</b> if the <paramref name="name" />
/// does not exist.
/// </returns>
public async Task <TValue> TryGetAsync(TName name, CancellationToken cancel = default)
{
var path = GetPath(name);
using (await _storeLock.ReaderLockAsync().ConfigureAwait(false))
{
if (!File.Exists(path))
{
return(null);
}
await using var content = File.OpenRead(path);
return(await Deserialize(content, name, cancel).ConfigureAwait(false));
}
}
public async Task ReaderLocked_ReaderReleased_ReaderAndWriterWaiting_DoesNotReleaseReaderOrWriter()
{
AsyncReaderWriterLock rwl = new AsyncReaderWriterLock();
Task readLock, writeLock;
await rwl.ReaderLockAsync();
using (await rwl.ReaderLockAsync())
{
writeLock = rwl.WriterLockAsync().AsTask();
readLock = rwl.ReaderLockAsync().AsTask();
}
await Task.WhenAll(AsyncAssert.NeverCompletesAsync(writeLock),
AsyncAssert.NeverCompletesAsync(readLock)).ConfigureAwait(false);
}
public async Task <string> FetchJsonWebKeysAsJsonString()
{
logger.LogDebug("Middleware is now going to acquire Google's public keys from either a cached value, or over the internet:");
// Acquire the read lock in order to check the cache time validity.
// If we notice that it is expired, attempt to acquire the write lock, and fetch the newest data.
// If we cannot acquire the write lock, that means another thread is already fetching the data; in which case, we should just wait
// on the read lock!
// Using the async lock library, we can 'await' the lock aquisition. The lock will automatically be released when the
// lock resource is disposed, I.e., after the 'using' block.
using (await cacheLock.ReaderLockAsync()) {
// If the cache is not expired, then just return the cached value.
if (CacheIsValid())
{
return(cachedKeyString);
}
}
// If we got here, we need to try and fetch new keys since the cache is invalid. Note we must release the read lock first since we
// do not have an upgradable-read-write-lock that is async.
using (await cacheLock.WriterLockAsync()) {
// Double check that no one has literally just fetched stuff (avoid a 'double fetch' when two threads read the invalid cache at
// at the same time, and both queue up to the write lock)
if (CacheIsValid())
{
return(cachedKeyString);
}
else
{
long reqTimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
UpdateCache(reqTimestamp, await ExplicitFetch());
return(cachedKeyString);
}
}
}
/// <summary>
/// Runs <paramref name="funcAsync"/> with read lock.
/// </summary>
public static async Task WithReadLockAsync(this AsyncReaderWriterLock locker, Func <Task> funcAsync)
{
using (await locker.ReaderLockAsync())
{
await funcAsync();
}
}
/// <summary>
/// Runs <paramref name="funcAsync"/> with read lock.
/// </summary>
public static async Task <T> WithReadLockAsync <T>(this AsyncReaderWriterLock locker, Func <Task <T> > funcAsync)
{
using (await locker.ReaderLockAsync())
{
return(await funcAsync());
}
}
/// <summary>
/// Runs <paramref name="func"/> with read lock.
/// </summary>
public static T WithWriteLock <T>(this AsyncReaderWriterLock locker, Func <T> func)
{
using (locker.ReaderLockAsync().Result)
{
return(func());
}
}
public async Task ReadLock_WriteLockCanceled_TakesLock()
{
var rwl = new AsyncReaderWriterLock();
var readKey = rwl.ReaderLock();
var cts = new CancellationTokenSource();
var writerLockReady = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var writerLockTask = Task.Run(async() =>
{
var writeKeyTask = rwl.WriterLockAsync(cts.Token);
writerLockReady.SetResult(null);
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => writeKeyTask);
});
await writerLockReady.Task;
var readerLockReady = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var readerLockTask = Task.Run(async() =>
{
var readKeyTask = rwl.ReaderLockAsync();
readerLockReady.SetResult(null);
await readKeyTask;
});
await readerLockReady.Task;
cts.Cancel();
await readerLockTask;
}
public void UpgradeableReadAndReadLocked_UpgradeAborted_CompletesAsCanceled()
{
AsyncContext.Run(async() =>
{
var rwl = new AsyncReaderWriterLock();
var readLockTaken = new TaskCompletionSource();
var task = Task.Run(async() =>
{
using (await rwl.ReaderLockAsync())
{
readLockTaken.SetResult();
await TaskConstants.Never;
}
});
await readLockTaken.Task;
Task upgradeTask;
using (var key = await rwl.UpgradeableReaderLockAsync())
{
upgradeTask = key.UpgradeAsync();
Assert.IsFalse(key.Upgraded);
}
await AssertEx.ThrowsExceptionAsync <OperationCanceledException>(upgradeTask);
});
}
public void UpgradeableReadAndReadLocked_Upgrade_WaitsForReaderLockToUnlock()
{
AsyncContext.Run(async() =>
{
var rwl = new AsyncReaderWriterLock();
var readLockTaken = new TaskCompletionSource();
var releaseReadLock = new TaskCompletionSource();
var task = Task.Run(async() =>
{
using (await rwl.ReaderLockAsync())
{
readLockTaken.SetResult();
await releaseReadLock.Task;
}
});
await readLockTaken.Task;
using (var key = await rwl.UpgradeableReaderLockAsync())
{
Assert.IsFalse(key.Upgraded);
var lockTask = key.UpgradeAsync();
Assert.IsFalse(lockTask.IsCompleted);
releaseReadLock.SetResult();
await lockTask;
Assert.IsTrue(key.Upgraded);
}
});
}
/// <summary>
/// Copy path to new reference
/// </summary>
/// <returns></returns>
public async Task <Path <T> > Clone()
{
using (await _rwLock.ReaderLockAsync())
{
return(new Path <T>(_steps.Select(x => x)));
}
}
public async Task <RHost> ConnectAsync(string name, IRCallbacks callbacks, string rCommandLineArguments = null, int timeout = 3000,
CancellationToken cancellationToken = default(CancellationToken), ReentrancyToken reentrancyToken = default(ReentrancyToken))
{
using (await _connectArwl.ReaderLockAsync(cancellationToken, reentrancyToken)) {
return(await _broker.ConnectAsync(name, callbacks, rCommandLineArguments, timeout, cancellationToken));
}
}
internal static async Task <bool> ContainsWithLockAsync <T>(this ICollection <T> collection, T item, AsyncReaderWriterLock rwLock)
{
using (await rwLock.ReaderLockAsync())
{
return(collection.Contains(item));
}
}
/// <summary>
/// check a request for rate limit
/// </summary>
/// <param name="request">a request</param>
/// <returns>the stream of check result</returns>
public async Task <AlgorithmCheckResult> CheckAsync(object request)
{
if (_updatable)
{
using (var l = await _mutex.ReaderLockAsync())
{
var originalRuleChecks = CheckAllRulesAsync(request);
var ruleCheckResults = new List <RuleCheckResult>();
await foreach (var result in originalRuleChecks)
{
ruleCheckResults.Add(result);
}
return(new AlgorithmCheckResult(ruleCheckResults));
}
}
else
{
var originalRuleChecks = CheckAllRulesAsync(request);
var ruleCheckResults = new List <RuleCheckResult>();
await foreach (var result in originalRuleChecks)
{
ruleCheckResults.Add(result);
}
return(new AlgorithmCheckResult(ruleCheckResults));
}
}
public void WriteLocked_ReaderLockCancelled_DoesNotTakeLockWhenUnlocked()
{
AsyncContext.Run(async() =>
{
var rwl = new AsyncReaderWriterLock();
using (await rwl.WriterLockAsync())
{
var cts = new CancellationTokenSource();
var task = rwl.ReaderLockAsync(cts.Token);
cts.Cancel();
await AssertEx.ThrowsExceptionAsync <OperationCanceledException>(() => task);
}
await rwl.ReaderLockAsync();
});
}
private async void OnTick(long l)
{
if (Interlocked.CompareExchange(ref _isSending, 1, 0) == 1)
{
LogSkipped();
return;
}
IDisposable dispose = null;
try
{
dispose = await _dataLock.ReaderLockAsync();
((IPacketV2 <IPayload>)_packet).Sequence = _seq.GetNextSequenceNumber();
await _connection.Send((IPacketV2 <IPayload>) _packet, _disposeCancellation.Token);
LogSuccess();
}
catch (Exception e)
{
LogError(e);
}
finally
{
dispose?.Dispose();
Interlocked.Exchange(ref _isSending, 0);
}
}
public void LockReleased_AllowsUpgradeableReadAndMultipleReaders()
{
AsyncContext.Run(async() =>
{
var rwl = new AsyncReaderWriterLock();
Task upgradeableReadLock, readLock1, readLock2;
using (await rwl.WriterLockAsync())
{
upgradeableReadLock = rwl.UpgradeableReaderLockAsync();
readLock1 = rwl.ReaderLockAsync();
readLock2 = rwl.ReaderLockAsync();
}
await Task.WhenAll(upgradeableReadLock, readLock1, readLock2);
});
}
/// <summary>
/// Sends a single message.
/// </summary>
/// <param name="message">The message we want to send.</param>
internal async Task Send([NotNull] T message)
{
var qMessage = new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)))
{
ContentType = "application/json",
Label = message.GetType().GetEntityName()
};
await SendPolicy.ExecuteAsync(
async() =>
{
try
{
using (await SenderLock.ReaderLockAsync())
{
await Sender.SendAsync(qMessage).ConfigureAwait(false);
}
}
catch
{
await RebuildSender().ConfigureAwait(false);
throw;
}
}).ConfigureAwait(false);
}
/// <summary>
/// Sends a single message.
/// </summary>
/// <param name="message">The message we want to send.</param>
internal async Task Send([NotNull] T message)
{
var qMessage = new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)))
{
ContentType = "application/json",
Label = message.GetType().GetEntityName()
};
await SendPolicy.ExecuteAsync(
async() =>
{
try
{
using (await SenderLock.ReaderLockAsync())
{
await Sender.SendAsync(qMessage).ConfigureAwait(false);
}
}
/**
* we want to minimize the client rebuild frequency and ideally to reverse the approach
* rebuild only when there is valid reason to do so
* this list will need to be compiled/maintained
*/
catch (QuotaExceededException) //let the polly deal with this - retry if allowed
{
throw;
}
catch
{
await RebuildSender().ConfigureAwait(false);
throw;
}
}).ConfigureAwait(false);
}
