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