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();
}
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 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;
}
public RabbitMQConsumerWorker(IConnection connection, string queueName,
IMessageProcessingWorker <T> messageProcessingWorker, IMessageRejectionHandler messageRejectionHandler,
ISerializer serializer, Func <bool> scaleCallbackFunc)
{
_model = connection.CreateModel();
_model.BasicQos(0, 1, false);
_subscription = new Subscription(_model, queueName, false);
_messageProcessingWorker = messageProcessingWorker;
_messageRejectionHandler = messageRejectionHandler;
_serializer = serializer;
_scaleCallbackFunc = scaleCallbackFunc;
CheckAliveFrequency = new TimeSpan(0, 0, 10);
}
public static async Task <SimpleProcessingWorker <T> > CreateAndStartAsync(IQueueClient queueClient,
string queueName,
Action <T, RabbitMQConsumerContext> callbackAction, CancellationToken cancellationToken,
IConsumerCountManager consumerCountManager = null,
IMessageRejectionHandler messageRejectionHandler = null, ILogger logger = null, ushort prefetchCount = 1)
{
var instance = new SimpleProcessingWorker <T>(queueClient, queueName, callbackAction,
consumerCountManager, messageRejectionHandler, logger, prefetchCount);
await instance.StartAsync(cancellationToken).ConfigureAwait(false);
return(instance);
}
public RabbitMQBatchConsumerWorker(ILogger logger, RabbitMQConnection connection, string queueName, IModel model,
IBatchProcessingWorker <T> batchProcessingWorker, IMessageRejectionHandler messageRejectionHandler,
ISerializer serializer)
{
_logger = logger;
_model = model;
_model.BasicQos(0, batchProcessingWorker.GetBatchSize(), false);
_queueName = queueName;
_batchProcessingWorker = batchProcessingWorker;
_messageRejectionHandler = messageRejectionHandler;
_serializer = serializer;
CheckAliveFrequency = new TimeSpan(0, 0, 10);
}
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();
}
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 RabbitMQConsumerWorker(ILogger logger, IQueueClient queueClient, IModel modelConsumer, IModel modelPublisher, string queueName,
IMessageProcessingWorker <T> messageProcessingWorker, IMessageRejectionHandler messageRejectionHandler,
ISerializer serializer, ushort prefetchCount = 1)
{
_logger = logger;
_queueClient = queueClient;
_modelConsumer = modelConsumer;
_modelPublisher = modelPublisher;
_queueName = queueName;
_prefetchCount = prefetchCount;
_messageProcessingWorker = messageProcessingWorker;
_messageRejectionHandler = messageRejectionHandler;
_serializer = serializer;
CheckAliveFrequency = new TimeSpan(0, 0, 10);
SubscribeModelEvents();
}
public RabbitMQConsumerWorker(IConnection connection, string queueName, IMessageProcessingWorker messageProcessingWorker, IMessageRejectionHandler messageRejectionHandler, Func <int> scaleCallbackFunc, Type expectedType, CancellationToken parentToken)
{
Contract.Requires(connection != null, "connection is required");
Contract.Requires(string.IsNullOrWhiteSpace(queueName) == false, "queueName is required");
Contract.Requires(messageProcessingWorker != null, "messageProcessingWorker is required");
Contract.Requires(scaleCallbackFunc != null, "scaleCallbackFunc is required");
this._model = connection.CreateModel();
this._model.BasicQos(0, 1, false);
this._subscription = new Subscription(this._model, queueName, false);
this._messageProcessingWorker = messageProcessingWorker;
this._messageRejectionHandler = messageRejectionHandler;
this._cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(parentToken);
this._scaleCallbackFunc = scaleCallbackFunc;
this._expectedType = expectedType;
this.CheckAliveFrequency = new TimeSpan(0, 0, 10);
}
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 RabbitMQConsumerWorker(IConnection connection, string queueName, IMessageProcessingWorker messageProcessingWorker, IMessageRejectionHandler messageRejectionHandler, Func <int> scaleCallbackFunc, Type expectedType, CancellationToken parentToken)
{
Contract.Requires(connection != null, "connection is required");
Contract.Requires(string.IsNullOrWhiteSpace(queueName) == false, "queueName is required");
Contract.Requires(messageProcessingWorker != null, "messageProcessingWorker is required");
Contract.Requires(scaleCallbackFunc != null, "scaleCallbackFunc is required");
this.queueName = queueName;
this.model = connection.CreateModel();
this.model.BasicQos(0, 1, false);
this.consumer = new EventingBasicConsumer(this.model);
this.messageProcessingWorker = messageProcessingWorker;
this.messageRejectionHandler = messageRejectionHandler;
this.cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(parentToken);
this.scaleCallbackFunc = scaleCallbackFunc;
this.expectedType = expectedType;
this.CheckAliveFrequency = new TimeSpan(0, 0, 10);
this.consumer.Received += this.OnMessage;
this.consumer.Registered += this.Consumer_Registered;
this.consumer.Shutdown += this.Consumer_Shutdown;
this.consumer.Unregistered += this.Consumer_Unregistered;
}
public AdvancedMessageProcessingWorker(IQueueClient queueClient, string queueName, Action <T> callbackAction,
ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
ConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
: base(queueClient, queueName, exceptionHandlingStrategy, invokeRetryCount, invokeRetryWaitMilliseconds,
consumerCountManager, messageRejectionHandler)
{
_callbackAction = callbackAction;
}
public AdvancedAsyncMessageProcessingWorker(IQueueClient queueClient, string queueName,
Func <T, CancellationToken, Task> callbackFunc, TimeSpan processingTimeout,
ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
ConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
: base(queueClient, queueName, exceptionHandlingStrategy, invokeRetryCount, invokeRetryWaitMilliseconds,
consumerCountManager, messageRejectionHandler)
{
_callbackFunc = callbackFunc;
_processingTimeout = processingTimeout;
}
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 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;
}
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 SimpleMessageProcessingWorker(IQueueClient queueClient, string queueName, Action <T> callbackAction,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
: base(queueClient, queueName, consumerCountManager, messageRejectionHandler)
{
CallbackAction = callbackAction;
}
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 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));
}
protected AbstractAdvancedMessageProcessingWorker(IQueueClient queueClient, string queueName,
ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
ConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
: base(queueClient, queueName, consumerCountManager, messageRejectionHandler)
{
InvokeRetryCount = invokeRetryCount;
InvokeRetryWaitMilliseconds = invokeRetryWaitMilliseconds;
ExceptionHandlingStrategy = exceptionHandlingStrategy;
}
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 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 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 async static Task <AdvancedMessageProcessingWorker <T> > CreateAndStartAsync(IQueueClient queueClient,
string queueName, Action <T> callbackAction, CancellationToken cancellationToken,
ExceptionHandlingStrategy exceptionHandlingStrategy = ExceptionHandlingStrategy.Requeue,
int invokeRetryCount = 1, int invokeRetryWaitMilliseconds = 0,
ConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null)
{
var instance = new AdvancedMessageProcessingWorker <T>(queueClient, queueName, callbackAction,
exceptionHandlingStrategy, invokeRetryCount, invokeRetryWaitMilliseconds, consumerCountManager,
messageRejectionHandler);
await instance.StartAsync(cancellationToken).ConfigureAwait(false);
return(instance);
}
public RabbitMQConsumer(RabbitMQConnectionPool connectionPool, string queueName, Type expectedType, IMessageProcessingWorker messageProcessingWorker, ConsumerCountManager 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 AdvancedAsyncProcessingWorker(IQueueClient queueClient, string queueName,
Func <IEnumerable <T>, CancellationToken, Task> batchCallbackFunc, ushort batchSize,
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)
{
_batchCallbackFunc = batchCallbackFunc;
_processingTimeout = processingTimeout;
_batchSize = batchSize;
}
public static async Task <SimpleAsyncProcessingWorker <T> > CreateAndStartAsync(IQueueClient queueClient,
string queueName,
Func <IEnumerable <T>, CancellationToken, Task> batchCallbackFunc, ushort batchSize,
TimeSpan processingTimeout, CancellationToken cancellationToken,
IConsumerCountManager consumerCountManager = null, IMessageRejectionHandler messageRejectionHandler = null,
ILogger logger = null, ushort prefetchCount = 1)
{
var instance = new SimpleAsyncProcessingWorker <T>(queueClient, queueName, batchCallbackFunc, batchSize,
processingTimeout,
consumerCountManager, messageRejectionHandler, logger, prefetchCount);
await instance.StartAsync(cancellationToken).ConfigureAwait(false);
return(instance);
}
public static async Task <AdvancedAsyncProcessingWorker <T> > CreateAndStartAsync(IQueueClient queueClient,
string queueName, Func <T, RabbitMQConsumerContext, CancellationToken, Task> callbackFunc, 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, callbackFunc,
processingTimeout, exceptionHandlingStrategy, invokeRetryCount, invokeRetryWaitMilliseconds,
consumerCountManager, messageRejectionHandler, logger, prefetchCount);
await instance.StartAsync(cancellationToken).ConfigureAwait(false);
return(instance);
}
