protected AbstractRabbitMQConsumer(
ConnectionFactory connectionFactory,
RabbitMQConnection connectionConsumer,
RabbitMQConnection connectionPublisher,
string queueName,
ISerializer serializer = null,
ILogger logger = null,
IConsumerCountManager consumerCountManager = null,
IMessageRejectionHandler messageRejectionHandler = null,
ushort prefetchCount = 1)
{
_connectionFactory = connectionFactory;
ConnectionConsumer = connectionConsumer;
ConnectionPublisher = connectionPublisher;
QueueName = queueName;
Serializer = serializer ?? new JsonSerializer();
_logger = logger;
ConsumerCountManager = consumerCountManager ?? new ConsumerCountManager();
MessageRejectionHandler =
messageRejectionHandler ?? new MessageDeserializationRejectionHandler(connectionFactory);
PrefetchCount = prefetchCount;
_cancellationTokenSource = new CancellationTokenSource();
}
public SimpleProcessingWorker(IQueueClient queueClient, string queueName, Action <T, RabbitMQConsumerContext> callbackAction,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
: base(queueClient, queueName, consumerCountManager, messageRejectionHandler, logger, prefetchCount)
{
_callbackAction = callbackAction;
}
public SimpleAsyncMessageProcessingWorker(IQueueClient queueClient, string queueName,
Func <T, CancellationToken, Task> callbackFunc, TimeSpan processingTimeout,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
: base(queueClient, queueName, consumerCountManager, messageRejectionHandler)
{
_callbackFunc = callbackFunc;
_processingTimeout = processingTimeout;
}
protected AbstractSimpleMessageProcessingWorker(IQueueClient queueClient, string queueName,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
{
QueueClient = queueClient;
QueueName = queueName;
ConsumerCountManager = consumerCountManager ?? new ConsumerCountManager();
MessageRejectionHandler = messageRejectionHandler ?? new MessageDeserializationRejectionHandler(QueueClient);
}
public SimpleAsyncProcessingWorker(IQueueClient queueClient, string queueName,
Func <T, RabbitMQConsumerContext, CancellationToken, Task> callbackFunc, TimeSpan processingTimeout,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
: base(queueClient, queueName, consumerCountManager, messageRejectionHandler, logger, prefetchCount)
{
_callbackFunc = callbackFunc;
_processingTimeout = processingTimeout;
}
public SimpleProcessingWorker(IQueueClient queueClient, string queueName,
Action <IEnumerable <T> > batchCallbackAction,
ushort batchSize, IConsumerCountManager consumerCountManager = null,
IMessageRejectionHandler messageRejectionHandler = null, ILogger logger = null, ushort prefetchCount = 1)
: base(queueClient, queueName, consumerCountManager, messageRejectionHandler, logger, prefetchCount)
{
_batchCallbackAction = batchCallbackAction;
_batchSize = batchSize;
}
protected AbstractAdvancedProcessingWorker(IQueueClient queueClient, string queueName,
ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null, ILogger logger = null, ushort prefetchCount = 1)
: base(queueClient, queueName, consumerCountManager, messageRejectionHandler, logger, prefetchCount)
{
InvokeRetryCount = invokeRetryCount;
InvokeRetryWaitMilliseconds = invokeRetryWaitMilliseconds;
ExceptionHandlingStrategy = exceptionHandlingStrategy;
}
public IQueueConsumer GetConsumer(string queueName, IConsumerCountManager consumerCountManager, IMessageProcessingWorker messageProcessingWorker, Type expectedType, IMessageRejectionHandler messageRejectionHandler)
{
return(new RabbitMQConsumer(
connectionPool: this.ConnectionPool,
queueName: queueName,
expectedType: expectedType,
messageProcessingWorker: messageProcessingWorker,
consumerCountManager: consumerCountManager,
messageRejectionHandler: messageRejectionHandler));
}
public AdvancedProcessingWorker(IQueueClient queueClient, string queueName, Action <T, RabbitMQConsumerContext> callbackAction,
ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
: base(queueClient, queueName, exceptionHandlingStrategy, invokeRetryCount, invokeRetryWaitMilliseconds,
consumerCountManager, messageRejectionHandler, logger, prefetchCount)
{
_callbackAction = callbackAction;
}
public SimpleAsyncProcessingWorker(IQueueClient queueClient, string queueName,
Func <IEnumerable <T>, CancellationToken, Task> batchCallbackFunc, ushort batchSize,
TimeSpan processingTimeout,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
: base(queueClient, queueName, consumerCountManager, messageRejectionHandler, logger, prefetchCount)
{
_batchCallbackFunc = batchCallbackFunc;
_processingTimeout = processingTimeout;
_batchSize = batchSize;
}
public AdvancedProcessingWorker(IQueueClient queueClient, string queueName,
Action <IEnumerable <T> > batchCallbackAction,
ushort batchSize, ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
: base(queueClient, queueName, exceptionHandlingStrategy, invokeRetryCount, invokeRetryWaitMilliseconds,
consumerCountManager, messageRejectionHandler, logger, prefetchCount)
{
_batchCallbackAction = batchCallbackAction;
_batchSize = batchSize;
}
public AdvancedAsyncProcessingWorker(IQueueClient queueClient, string queueName,
Func <T, RabbitMQConsumerContext, CancellationToken, Task> callbackFunc, TimeSpan processingTimeout,
ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
: base(queueClient, queueName, exceptionHandlingStrategy, invokeRetryCount, invokeRetryWaitMilliseconds,
consumerCountManager, messageRejectionHandler, logger, prefetchCount)
{
_callbackFunc = callbackFunc;
_processingTimeout = processingTimeout;
}
public static async Task <SimpleProcessingWorker <T> > CreateAndStartAsync(IQueueClient queueClient,
string queueName,
Action <IEnumerable <T> > batchCallbackAction, ushort batchSize, CancellationToken cancellationToken,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
{
var instance = new SimpleProcessingWorker <T>(queueClient, queueName, batchCallbackAction, batchSize,
consumerCountManager, messageRejectionHandler, logger, prefetchCount);
await instance.StartAsync(cancellationToken).ConfigureAwait(false);
return(instance);
}
public IQueueConsumer GetConsumer <T>(string queueName, IConsumerCountManager consumerCountManager,
IMessageProcessingWorker <T> messageProcessingWorker, IMessageRejectionHandler messageRejectionHandler)
where T : class
{
return(new RabbitMQConsumer <T>(
connectionPool: _connectionPool,
queueName: queueName,
serializer: _serializer,
errorLogger: _errorLogger,
messageProcessingWorker: messageProcessingWorker,
consumerCountManager: consumerCountManager,
messageRejectionHandler: messageRejectionHandler));
}
public static async Task <AdvancedProcessingWorker <T> > CreateAndStartAsync(IQueueClient queueClient,
string queueName, Action <T, RabbitMQConsumerContext> callbackAction, CancellationToken cancellationToken,
ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
{
var instance = new AdvancedProcessingWorker <T>(queueClient, queueName, callbackAction,
exceptionHandlingStrategy, invokeRetryCount, invokeRetryWaitMilliseconds, consumerCountManager,
messageRejectionHandler, logger, prefetchCount);
await instance.StartAsync(cancellationToken).ConfigureAwait(false);
return(instance);
}
protected AbstractSimpleProcessingWorker(IQueueClient queueClient, string queueName,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
{
QueueClient = queueClient;
QueueName = queueName;
ConsumerCountManager = consumerCountManager ?? new ConsumerCountManager();
MessageRejectionHandler =
messageRejectionHandler ?? new MessageDeserializationRejectionHandler(QueueClient);
Logger = logger;
PrefetchCount = prefetchCount;
}
public RabbitMQConsumer(RabbitMQConnectionPool connectionPool, string queueName,
IMessageProcessingWorker <T> messageProcessingWorker, ISerializer serializer = null, IErrorLogger errorLogger = null,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
{
_connectionPool = connectionPool;
_queueName = queueName;
_serializer = serializer ?? new JsonSerializer();
_errorLogger = errorLogger;
_messageProcessingWorker = messageProcessingWorker;
_consumerCountManager = consumerCountManager ?? new ConsumerCountManager();
_messageRejectionHandler = messageRejectionHandler ?? new MessageDeserializationRejectionHandler(connectionPool);
_consumerWorkersCount = 0;
_cancellationTokenSource = new CancellationTokenSource();
}
public RabbitMQConsumer(RabbitMQConnectionPool connectionPool, string queueName, Type expectedType, IMessageProcessingWorker messageProcessingWorker, IConsumerCountManager consumerCountManager, IMessageRejectionHandler messageRejectionHandler)
{
//Set using constructor parameters
this.ConnectionPool = connectionPool;
this.QueueName = queueName;
this.ExpectedType = expectedType;
this.MessageProcessingWorker = messageProcessingWorker;
this._consumerCountManager = consumerCountManager;
this.MessageRejectionHandler = messageRejectionHandler;
//Set using default values
this._consumerWorkersCount = 0;
this._cancellationTokenSource = new CancellationTokenSource();
this._isStopped = true;
}
public RabbitMQConsumer(
ILogger logger,
IQueueClient queueClient,
ConnectionFactory connectionFactory,
RabbitMQConnection connectionConsumer,
RabbitMQConnection connectionPublisher,
string queueName,
IMessageProcessingWorker <T> messageProcessingWorker,
ISerializer serializer = null,
IConsumerCountManager consumerCountManager = null,
IMessageRejectionHandler messageRejectionHandler = null,
ushort prefetchCount = 1)
: base(connectionFactory, connectionConsumer, connectionPublisher, queueName, serializer, logger, consumerCountManager, messageRejectionHandler, prefetchCount)
{
_queueClient = queueClient;
_logger = logger;
_messageProcessingWorker = messageProcessingWorker;
}
public IQueueConsumer CreateBatchConsumer <T>(string queueName, IConsumerCountManager consumerCountManager,
IBatchProcessingWorker <T> batchProcessingWorker, IMessageRejectionHandler messageRejectionHandler)
where T : class
{
RabbitMQConnection connectionConsumer = ConnectionPerQueue
? _rabbitMQConnectionManager.CreateConnection($"consumer: {queueName}")
: _rabbitMQConnectionManager.ConnectionByName("consumer") ?? _rabbitMQConnectionManager.CreateConnection("consumer");
var connectionPublisher = _rabbitMQConnectionManager.ConnectionByName("publisher");
return(new RabbitMQBatchConsumer <T>(
connection: connectionConsumer,
connectionPublisher: connectionPublisher,
connectionFactory: _connectionFactory,
queueName: queueName,
serializer: _serializer,
logger: _logger,
batchProcessingWorker: batchProcessingWorker,
consumerCountManager: consumerCountManager,
messageRejectionHandler: messageRejectionHandler));
}
public IQueueConsumer CreateConsumer <T>(string queueName, IConsumerCountManager consumerCountManager,
IMessageProcessingWorker <T> messageProcessingWorker, IMessageRejectionHandler messageRejectionHandler,
ushort prefetchCount = 1)
where T : class
{
RabbitMQConnection connectionConsumer = ConnectionPerQueue
? _rabbitMQConnectionManager.CreateConnection($"consumer: {queueName}")
: _rabbitMQConnectionManager.ConnectionByName("consumer") ?? _rabbitMQConnectionManager.CreateConnection("consumer");
var connectionPublisher = _rabbitMQConnectionManager.ConnectionByName("publisher");
return(new RabbitMQConsumer <T>(
queueClient: this,
connectionConsumer: connectionConsumer,
connectionPublisher: connectionPublisher,
connectionFactory: _connectionFactory,
queueName: queueName,
serializer: _serializer,
logger: _logger,
messageProcessingWorker: messageProcessingWorker,
consumerCountManager: consumerCountManager,
messageRejectionHandler: messageRejectionHandler,
prefetchCount: prefetchCount));
}
public SimpleMessageProcessingWorker(IQueueClient queueClient, string queueName, Action <T> callbackAction,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
: base(queueClient, queueName, consumerCountManager, messageRejectionHandler)
{
CallbackAction = callbackAction;
}
public RabbitMQBatchConsumer(ILogger logger, ConnectionFactory connectionFactory, RabbitMQConnection connection, RabbitMQConnection connectionPublisher, string queueName, IBatchProcessingWorker <T> batchProcessingWorker, ISerializer serializer = null, IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
: base(connectionFactory, connection, connectionPublisher, queueName, serializer, logger, consumerCountManager, messageRejectionHandler)
{
_batchProcessingWorker = batchProcessingWorker;
_logger = logger;
}
public async static Task <SimpleAsyncMessageProcessingWorker <T> > CreateAndStartAsync(IQueueClient queueClient,
string queueName, Func <T, CancellationToken, Task> callbackFunc, TimeSpan processingTimeout,
CancellationToken cancellationToken, IConsumerCountManager consumerCountManager = null,
IMessageRejectionHandler messageRejectionHandler = null)
{
var instance = new SimpleAsyncMessageProcessingWorker <T>(queueClient, queueName, callbackFunc,
processingTimeout, consumerCountManager, messageRejectionHandler);
await instance.StartAsync(cancellationToken).ConfigureAwait(false);
return(instance);
}
public static async Task <AdvancedAsyncProcessingWorker <T> > CreateAndStartAsync(IQueueClient queueClient,
string queueName, Func <IEnumerable <T>, CancellationToken, Task> batchCallbackFunc, ushort batchSize,
TimeSpan processingTimeout,
CancellationToken cancellationToken,
ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
{
var instance = new AdvancedAsyncProcessingWorker <T>(queueClient, queueName, batchCallbackFunc, batchSize,
processingTimeout,
exceptionHandlingStrategy, invokeRetryCount, invokeRetryWaitMilliseconds,
consumerCountManager, messageRejectionHandler, logger, prefetchCount);
await instance.StartAsync(cancellationToken).ConfigureAwait(false);
return(instance);
}
