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); }