public ReplyHandlerStep(ConcurrentDictionary<string, TimedMessage> messages, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, TimeSpan replyMaxAge)
{
_messages = messages;
_replyMaxAge = replyMaxAge;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_cleanupTask = asyncTaskFactory.Create("CleanupAbandonedRepliesTask", CleanupAbandonedReplies);
}
public ReplyHandlerStep(ConcurrentDictionary <string, TimedMessage> messages, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, TimeSpan replyMaxAge)
{
_messages = messages ?? throw new ArgumentNullException(nameof(messages));
_log = rebusLoggerFactory?.GetLogger <ReplyHandlerStep>() ?? throw new ArgumentNullException(nameof(rebusLoggerFactory));
_cleanupTask = asyncTaskFactory?.Create("CleanupAbandonedRepliesTask", CleanupAbandonedReplies) ?? throw new ArgumentNullException(nameof(asyncTaskFactory));
_replyMaxAge = replyMaxAge;
}
/// <summary>
/// Constructs the in-mem error tracker with the configured number of delivery attempts as the MAX
/// </summary>
public InMemErrorTracker(int maxDeliveryAttempts, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
if (rebusLoggerFactory == null) throw new ArgumentNullException(nameof(rebusLoggerFactory));
if (asyncTaskFactory == null) throw new ArgumentNullException(nameof(asyncTaskFactory));
_maxDeliveryAttempts = maxDeliveryAttempts;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_cleanupOldTrackedErrorsTask = asyncTaskFactory.Create(BackgroundTaskName, CleanupOldTrackedErrors, intervalSeconds: 60);
}
/// <summary>
/// Constructs the step, using the specified <see cref="ITimeoutManager"/> to defer relevant messages
/// and the specified <see cref="ITransport"/> to deliver messages when they're due.
/// </summary>
public HandleDeferredMessagesStep(ITimeoutManager timeoutManager, ITransport transport, Options options, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
_timeoutManager = timeoutManager;
_transport = transport;
_options = options;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_dueMessagesSenderBackgroundTask = asyncTaskFactory.Create(DueMessagesSenderTaskName, TimerElapsed, intervalSeconds: 1);
}
/// <summary>
/// Constructs the transport with the given <see cref="IDbConnectionProvider"/>, using the specified <paramref name="tableName"/> to send/receive messages,
/// querying for messages with recipient = <paramref name="inputQueueName"/>
/// </summary>
public SqlServerTransport(IDbConnectionProvider connectionProvider, string tableName, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
_connectionProvider = connectionProvider;
_tableName = tableName;
_inputQueueName = inputQueueName;
_log = rebusLoggerFactory.GetCurrentClassLogger();
ExpiredMessagesCleanupInterval = DefaultExpiredMessagesCleanupInterval;
_expiredMessagesCleanupTask = asyncTaskFactory.Create("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle, intervalSeconds: 60);
}
/// <summary>
/// Constructs the in-mem error tracker with the configured number of delivery attempts as the MAX
/// </summary>
public InMemErrorTracker(int maxDeliveryAttempts, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
_maxDeliveryAttempts = maxDeliveryAttempts;
_log = rebusLoggerFactory.GetLogger <InMemErrorTracker>();
_cleanupOldTrackedErrorsTask = asyncTaskFactory.Create(BackgroundTaskName, CleanupOldTrackedErrors, intervalSeconds: 60);
}
IAsyncTask CreateRenewalTaskForMessage(Message message, IAmazonSQS client)
{
return(_asyncTaskFactory.Create($"RenewPeekLock-{message.MessageId}",
async() =>
{
_log.Info("Renewing peek lock for message with ID {messageId}", message.MessageId);
var request = new ChangeMessageVisibilityRequest(_queueUrl, message.ReceiptHandle, (int)_peekLockDuration.TotalSeconds);
await client.ChangeMessageVisibilityAsync(request);
},
intervalSeconds: (int)_peekLockRenewalInterval.TotalSeconds,
prettyInsignificant: true));
}
/// <summary>
/// Constructs a MySql transport.
/// </summary>
public MySqlTransport(MySqlConnectionHelper connectionHelper, string tableName, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, IRebusTime rebusTime)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
_connectionHelper = connectionHelper;
_tableName = tableName;
_inputQueueName = inputQueueName;
_asyncTaskFactory = asyncTaskFactory ?? throw new ArgumentNullException(nameof(asyncTaskFactory));
_rebusTime = rebusTime ?? throw new ArgumentNullException(nameof(rebusTime));
ExpiredMessagesCleanupInterval = DefaultExpiredMessagesCleanupInterval;
_expiredMessagesCleanupTask = asyncTaskFactory.Create("ExpiredMessagesCleanup",
PerformExpiredMessagesCleanupCycle, intervalSeconds: 60);
_log = rebusLoggerFactory.GetLogger <MySqlTransport>();
}
public AutoScaler(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, int maximumNumberOfWorkers, IAsyncTaskFactory asyncTaskFactory, Func <IBus> busFactory, int adjustmentIntervalSeconds)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
_logger = rebusLoggerFactory.GetLogger <AutoScaler>();
_transport = transport ?? throw new ArgumentNullException(nameof(transport));
_maximumNumberOfWorkers = maximumNumberOfWorkers;
_busFactory = busFactory ?? throw new ArgumentNullException(nameof(busFactory));
_task = asyncTaskFactory.Create("AutoScale", Tick, intervalSeconds: adjustmentIntervalSeconds);
}
/// <summary>
/// Constructs the transport, connecting to the service bus pointed to by the connection string.
/// </summary>
public AzureServiceBusTransport(string connectionString, string queueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, INameFormatter nameFormatter, CancellationToken cancellationToken = default(CancellationToken), ITokenProvider tokenProvider = null)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
_nameFormatter = nameFormatter;
if (queueName != null)
{
// this never happens
if (queueName.StartsWith(MagicSubscriptionPrefix))
{
throw new ArgumentException($"Sorry, but the queue name '{queueName}' cannot be used because it conflicts with Rebus' internally used 'magic subscription prefix': '{MagicSubscriptionPrefix}'. ");
}
Address = _nameFormatter.FormatQueueName(queueName);
_subscriptionName = _nameFormatter.FormatSubscriptionName(queueName);
}
_connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
_cancellationToken = cancellationToken;
_log = rebusLoggerFactory.GetLogger <AzureServiceBusTransport>();
if (tokenProvider != null)
{
var connectionStringBuilder = new ServiceBusConnectionStringBuilder(connectionString);
_managementClient = new ManagementClient(connectionStringBuilder, tokenProvider);
_endpoint = connectionStringBuilder.Endpoint;
_transportType = connectionStringBuilder.TransportType;
}
else
{
_managementClient = new ManagementClient(connectionString);
}
_tokenProvider = tokenProvider;
_messageLockRenewalTask = asyncTaskFactory.Create("Peek Lock Renewal", RenewPeekLocks, prettyInsignificant: true, intervalSeconds: 10);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="connectionProvider">A <see cref="IDbConnection"/> to obtain a database connection</param>
/// <param name="inputQueueName">Name of the queue this transport is servicing</param>
/// <param name="rebusLoggerFactory">A <seealso cref="IRebusLoggerFactory"/> for building loggers</param>
/// <param name="asyncTaskFactory">A <seealso cref="IAsyncTaskFactory"/> for creating periodic tasks</param>
/// <param name="rebusTime">A <seealso cref="IRebusTime"/> to provide the current time</param>
/// <param name="options">Additional options</param>
public MySqlTransport(
IDbConnectionProvider connectionProvider,
string inputQueueName,
IRebusLoggerFactory rebusLoggerFactory,
IAsyncTaskFactory asyncTaskFactory,
IRebusTime rebusTime,
MySqlTransportOptions options)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
_rebusTime = rebusTime ?? throw new ArgumentNullException(nameof(rebusTime));
_connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
_receiveTableName = inputQueueName != null?TableName.Parse(inputQueueName) : null;
_log = rebusLoggerFactory.GetLogger <MySqlTransport>();
var cleanupInterval = options.ExpiredMessagesCleanupInterval ?? DefaultExpiredMessagesCleanupInterval;
var intervalSeconds = (int)cleanupInterval.TotalSeconds;
_expiredMessagesCleanupTask = asyncTaskFactory.Create("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle, intervalSeconds: intervalSeconds);
_autoDeleteQueue = options.AutoDeleteQueue;
_leasedByFactory = options.LeasedByFactory ?? (() => Environment.MachineName);
_leaseInterval = options.LeaseInterval ?? DefaultLeaseTime;
_leaseTolerance = options.LeaseInterval ?? DefaultLeaseTolerance;
_ensureTablesAreCreated = options.EnsureTablesAreCreated;
var automaticLeaseRenewalInterval = options.LeaseAutoRenewInterval;
if (!automaticLeaseRenewalInterval.HasValue)
{
_automaticLeaseRenewal = false;
}
else
{
_automaticLeaseRenewal = true;
_automaticLeaseRenewalInterval = automaticLeaseRenewalInterval.Value;
}
}
/// <summary>
/// Constructs the step, using the specified <see cref="ITimeoutManager"/> to defer relevant messages
/// and the specified <see cref="ITransport"/> to deliver messages when they're due.
/// </summary>
public HandleDeferredMessagesStep(ITimeoutManager timeoutManager, ITransport transport, Options options, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
if (timeoutManager == null) throw new ArgumentNullException(nameof(timeoutManager));
if (transport == null) throw new ArgumentNullException(nameof(transport));
if (options == null) throw new ArgumentNullException(nameof(options));
if (rebusLoggerFactory == null) throw new ArgumentNullException(nameof(rebusLoggerFactory));
if (asyncTaskFactory == null) throw new ArgumentNullException(nameof(asyncTaskFactory));
_timeoutManager = timeoutManager;
_transport = transport;
_options = options;
_log = rebusLoggerFactory.GetCurrentClassLogger();
var dueTimeoutsPollIntervalSeconds = (int)options.DueTimeoutsPollInterval.TotalSeconds;
var intervalToUse = dueTimeoutsPollIntervalSeconds >= 1 ? dueTimeoutsPollIntervalSeconds : 1;
_dueMessagesSenderBackgroundTask = asyncTaskFactory.Create(DueMessagesSenderTaskName, TimerElapsed, intervalSeconds: intervalToUse);
}
/// <summary>
/// Constructs the step, using the specified <see cref="ITimeoutManager"/> to defer relevant messages
/// and the specified <see cref="ITransport"/> to deliver messages when they're due.
/// </summary>
public HandleDeferredMessagesStep(ITimeoutManager timeoutManager, ITransport transport, Options options, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
_timeoutManager = timeoutManager ?? throw new ArgumentNullException(nameof(timeoutManager));
_transport = transport ?? throw new ArgumentNullException(nameof(transport));
_options = options ?? throw new ArgumentNullException(nameof(options));
_log = rebusLoggerFactory.GetLogger <HandleDeferredMessagesStep>();
_dueMessagesSenderBackgroundTask = asyncTaskFactory.Create(DueMessagesSenderTaskName, TimerElapsed, interval: options.DueTimeoutsPollInterval);
}
/// <summary>
/// Constructs the transport with the given <see cref="IDbConnectionProvider"/>
/// </summary>
public SqlServerTransport(IDbConnectionProvider connectionProvider, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
ConnectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
ReceiveTableName = inputQueueName != null?TableName.Parse(inputQueueName) : null;
_log = rebusLoggerFactory.GetLogger <SqlServerTransport>();
ExpiredMessagesCleanupInterval = DefaultExpiredMessagesCleanupInterval;
_expiredMessagesCleanupTask = asyncTaskFactory.Create("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle, intervalSeconds: 60);
}
IDisposable GetRenewalTaskOrFakeDisposable(string messageId, BrokeredMessage brokeredMessage, TimeSpan lockRenewalInterval)
{
if (AutomaticallyRenewPeekLock)
{
var renewalTask = _asyncTaskFactory.Create($"RenewPeekLock-{messageId}",
async() =>
{
_log.Info("Renewing peek lock for message with ID {0}", messageId);
await brokeredMessage.RenewLockAsync();
},
intervalSeconds: (int)lockRenewalInterval.TotalSeconds,
prettyInsignificant: true);
renewalTask.Start();
return(renewalTask);
}
return(new FakeDisposable());
}
/// <summary>
/// Constructs the in-mem error tracker with the configured number of delivery attempts as the MAX
/// </summary>
public InMemErrorTracker(SimpleRetryStrategySettings simpleRetryStrategySettings, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, ITransport transport)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
_simpleRetryStrategySettings = simpleRetryStrategySettings ?? throw new ArgumentNullException(nameof(simpleRetryStrategySettings));
_transport = transport ?? throw new ArgumentNullException(nameof(transport));
_log = rebusLoggerFactory.GetLogger <InMemErrorTracker>();
_cleanupOldTrackedErrorsTask = asyncTaskFactory.Create(
BackgroundTaskName,
CleanupOldTrackedErrors,
intervalSeconds: 10
);
}
/// <summary>
/// Constructs the transport with the given <see cref="IDbConnectionProvider"/>
/// </summary>
public MySqlTransport(IDbConnectionProvider connectionProvider, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, IRebusTime rebusTime, MySqlTransportOptions options)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
_rebusTime = rebusTime ?? throw new ArgumentNullException(nameof(rebusTime));
_connectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
_receiveTableName = inputQueueName != null?TableName.Parse(inputQueueName) : null;
_log = rebusLoggerFactory.GetLogger <MySqlTransport>();
var cleanupInterval = options.ExpiredMessagesCleanupInterval ?? DefaultExpiredMessagesCleanupInterval;
var intervalSeconds = (int)cleanupInterval.TotalSeconds;
_expiredMessagesCleanupTask = asyncTaskFactory.Create("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle, intervalSeconds: intervalSeconds);
_autoDeleteQueue = options.AutoDeleteQueue;
}
/// <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;
if (AutomaticallyRenewPeekLock && !_prefetchingEnabled)
{
var now = DateTime.UtcNow;
var leaseDuration = message.SystemProperties.LockedUntilUtc - now;
var lockRenewalInterval = TimeSpan.FromMinutes(0.5 * leaseDuration.TotalMinutes);
var cancellationTokenSource = new CancellationTokenSource();
var renewalTask = _asyncTaskFactory
.Create(description: $"RenewPeekLock-{messageId}",
action: () => RenewPeekLock(messageReceiver, messageId, lockToken, cancellationTokenSource),
intervalSeconds: (int)lockRenewalInterval.TotalSeconds,
prettyInsignificant: true
);
// be sure to stop the renewal task regardless of whether we're committing or aborting
context.OnCommitted(async() => renewalTask.Dispose());
context.OnAborted(() => renewalTask.Dispose());
context.OnDisposed(() =>
{
renewalTask.Dispose();
cancellationTokenSource.Dispose();
});
cancellationTokenSource.Token.Register(renewalTask.Dispose);
renewalTask.Start();
}
context.OnCompleted(async() =>
{
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}");
}
});
context.OnAborted(() =>
{
try
{
AsyncHelpers.RunSync(async() => 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}");
}
});
var userProperties = message.UserProperties;
var headers = userProperties.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.ToString());
var body = message.Body;
return(new TransportMessage(headers, body));
}
/// <summary>
/// Constructs the in-mem error tracker with the configured number of delivery attempts as the MAX
/// </summary>
public InMemErrorTracker(int maxDeliveryAttempts, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
_maxDeliveryAttempts = maxDeliveryAttempts;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_cleanupOldTrackedErrorsTask = asyncTaskFactory.Create(BackgroundTaskName, CleanupOldTrackedErrors, intervalSeconds: 60);
}
/// <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));
}
/// <summary>
/// Constructs the in-mem error tracker with the configured number of delivery attempts as the MAX
/// </summary>
public InMemErrorTracker(int maxDeliveryAttempts, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory)
{
_maxDeliveryAttempts = maxDeliveryAttempts;
_log = rebusLoggerFactory.GetCurrentClassLogger();
_cleanupOldTrackedErrorsTask = asyncTaskFactory.Create(BackgroundTaskName, CleanupOldTrackedErrors, intervalSeconds: 60);
}