public Task <MessageLockResponse> TryAcquireLockPermanentlyAsync(string key) { _store.AddOrUpdate(key, int.MinValue, (_, i) => int.MinValue); var response = new MessageLockResponse { DoIHaveExclusiveLock = true, IsMessagePermanentlyLocked = true, }; return(Task.FromResult(response)); }
public Task <MessageLockResponse> TryAcquireLockAsync(string key, TimeSpan howLong) { // Only the first attempt to access the value for the key can acquire the lock int newValue = _store.AddOrUpdate(key, 0, (_, i) => i + 1); var response = new MessageLockResponse { DoIHaveExclusiveLock = newValue == 0, IsMessagePermanentlyLocked = newValue == int.MinValue, }; return(Task.FromResult(response)); }
protected override async Task <bool> RunInnerAsync(HandleMessageContext context, Func <CancellationToken, Task <bool> > func, CancellationToken stoppingToken) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (func == null) { throw new ArgumentNullException(nameof(func)); } string lockKey = $"{context.Message.UniqueKey()}-{_lockSuffixKeyForHandler}"; MessageLockResponse lockResponse = await _messageLock.TryAcquireLockAsync(lockKey, _timeout).ConfigureAwait(false); if (!lockResponse.DoIHaveExclusiveLock) { if (lockResponse.IsMessagePermanentlyLocked) { _logger.LogDebug("Failed to acquire lock for message with key {MessageLockKey} as it is permanently locked.", lockKey); return(RemoveTheMessageFromTheQueue); } _logger.LogDebug("Failed to acquire lock for message with key {MessageLockKey}; returning message to queue.", lockKey); return(LeaveItInTheQueue); } try { _logger.LogDebug("Acquired lock for message with key {MessageLockKey}.", lockKey); bool successfullyHandled = await func(stoppingToken).ConfigureAwait(false); if (successfullyHandled) { await _messageLock.TryAcquireLockPermanentlyAsync(lockKey).ConfigureAwait(false); _logger.LogDebug("Acquired permanent lock for message with key {MessageLockKey}.", lockKey); } return(successfullyHandled); } catch (Exception) { await _messageLock.ReleaseLockAsync(lockKey).ConfigureAwait(false); _logger.LogDebug("Released lock for message with key {MessageLockKey}.", lockKey); throw; } }
public Task <MessageLockResponse> TryAquireLockPermanentlyAsync(string key) { var canAquire = !_store.TryGetValue(key, out int value); if (canAquire) { _store.Add(key, 1); } var response = new MessageLockResponse { DoIHaveExclusiveLock = canAquire }; return(Task.FromResult(response)); }
protected override async Task Given() { await base.Given(); var messageLockResponse = new MessageLockResponse { DoIHaveExclusiveLock = true }; MessageLock = Substitute.For <IMessageLockAsync>(); MessageLock.TryAquireLockAsync(Arg.Any <string>(), Arg.Any <TimeSpan>()) .Returns(messageLockResponse); _handler = new ExactlyOnceSignallingHandler(_tcs); Handler = _handler; }
protected override void Given() { base.Given(); _expectedtimeout = 5; var messageLockResponse = new MessageLockResponse { DoIHaveExclusiveLock = true }; MessageLock = Substitute.For <IMessageLock>(); MessageLock.TryAquireLock(Arg.Any <string>(), Arg.Any <TimeSpan>()) .Returns(messageLockResponse); _handler = new ExplicitExactlyOnceSignallingHandler(_tcs); Handler = _handler; }
protected override void Given() { _queue = CreateSuccessfulTestQueue("TestQueue", new TestMessage()); Queues.Add(_queue); var messageLockResponse = new MessageLockResponse { DoIHaveExclusiveLock = true }; MessageLock = Substitute.For <IMessageLockAsync>(); MessageLock.TryAquireLockAsync(Arg.Any <string>(), Arg.Any <TimeSpan>()) .Returns(messageLockResponse); _handler = new ExplicitExactlyOnceSignallingHandler(_tcs); Handler = _handler; }