/// <summary>
/// Shuts down the background timer
/// </summary>
public void Dispose()
{
if (_disposed)
{
return;
}
try
{
_expiredMessagesCleanupTask.Dispose();
}
finally
{
_disposed = true;
}
}
/// <summary>
/// Stops the periodic cleanup of tracked messages
/// </summary>
public void Dispose()
{
if (_disposed)
{
return;
}
try
{
_cleanupOldTrackedErrorsTask.Dispose();
}
finally
{
_disposed = true;
}
}
/// <summary>
/// Last-resort disposal of the due messages background task
/// </summary>
public void Dispose()
{
if (_disposed)
{
return;
}
try
{
_dueMessagesSenderBackgroundTask.Dispose();
}
finally
{
_disposed = true;
}
}
/// <summary>
/// disposal of reset circuit breaker reset timer
/// </summary>
public void Dispose()
{
if (_disposed)
{
return;
}
try
{
_resetCircuitBreakerTask.Dispose();
}
finally
{
_disposed = true;
}
}
public void Dispose()
{
if (_disposed)
{
return;
}
try
{
_logger.Info("Stopping auto-scaler");
_task.Dispose();
}
finally
{
_disposed = true;
}
}
/// <summary>
/// Shuts down the background timer
/// </summary>
public void Dispose()
{
if (_disposed)
{
return;
}
try
{
_expiredMessagesCleanupTask.Dispose();
if (_autoDeleteQueue)
{
EnsureTableIsDropped();
}
}
finally
{
_disposed = true;
}
}
/// <summary>
/// Receives the next message from the input queue. Returns null if no message was available
/// </summary>
public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken)
{
var receivedMessage = await ReceiveInternal().ConfigureAwait(false);
if (receivedMessage == null)
{
return(null);
}
var message = receivedMessage.Message;
var messageReceiver = receivedMessage.MessageReceiver;
if (!message.SystemProperties.IsLockTokenSet)
{
throw new RebusApplicationException($"OMG that's weird - message with ID {message.MessageId} does not have a lock token!");
}
var lockToken = message.SystemProperties.LockToken;
var messageId = message.MessageId;
CancellationTokenSource cancellationTokenSource = null;
IAsyncTask renewalTask = null;
if (AutomaticallyRenewPeekLock && !_prefetchingEnabled)
{
var now = DateTime.UtcNow;
var leaseDuration = message.SystemProperties.LockedUntilUtc - now;
var lockRenewalInterval = TimeSpan.FromMinutes(0.5 * leaseDuration.TotalMinutes);
cancellationTokenSource = new CancellationTokenSource();
renewalTask = _asyncTaskFactory
.Create(description: $"RenewPeekLock-{messageId}",
action: () => RenewPeekLock(messageReceiver, messageId, lockToken, cancellationTokenSource),
intervalSeconds: (int)lockRenewalInterval.TotalSeconds,
prettyInsignificant: true
);
cancellationTokenSource.Token.Register(renewalTask.Dispose);
renewalTask.Start();
}
context.OnCompleted(async ctx =>
{
try
{
await messageReceiver.CompleteAsync(lockToken).ConfigureAwait(false);
}
catch (Exception exception)
{
throw new RebusApplicationException(exception,
$"Could not complete message with ID {message.MessageId} and lock token {lockToken}");
}
// Dispose the renewal task after the message has been removed.
// Note that we could get a MessageLockLostException and log an error in RenewPeekLock in the off chance that renewal runs between CompleteAsync and Dispose here,
// but that's better than disposing the renewal first and potentially loosing the lock before calling complete.
renewalTask?.Dispose();
});
context.OnAborted(async ctx =>
{
// Dispose the renewal before abandoning the message, otherwise renewal could grab the lock again.
renewalTask?.Dispose();
try
{
await messageReceiver.AbandonAsync(lockToken).ConfigureAwait(false);
}
catch (Exception exception)
{
throw new RebusApplicationException(exception,
$"Could not abandon message with ID {message.MessageId} and lock token {lockToken}");
}
});
context.OnDisposed(ctx =>
{
renewalTask?.Dispose();
cancellationTokenSource?.Dispose();
});
var userProperties = message.UserProperties;
var headers = userProperties.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToString());
var body = message.Body;
return(new TransportMessage(headers, body));
}
/// <inheritdoc /> // Note: IAsyncTask can be disposed multiple times without side-effects public void Dispose() => _expiredMessagesCleanupTask?.Dispose();
public void Dispose()
{
_cleanupTask.Dispose();
}
