public QueueingConsumerFactory(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy)
{
this.logger = logger;
this.consumerErrorStrategy = consumerErrorStrategy;
// start the subscription callback thread
// all subscription actions registered with Subscribe or Request
// run here.
subscriptionCallbackThread = new Thread(_ =>
{
try
{
while (true)
{
if (disposed)
{
break;
}
HandleMessageDelivery(queue.Take());
}
}
catch (InvalidOperationException ex)
{
// InvalidOperationException is thrown when Take is called after
// queue.CompleteAdding(), this is signals that this class is being
// disposed, so we allow the thread to complete.
}
});
subscriptionCallbackThread.Start();
}
public QueueingConsumerFactory(IConsumerErrorStrategy consumerErrorStrategy)
{
this.logger = Application.Current.LoggerProvider.GetLogger(RabbitMessageBus.MessageBusLoggerName);
this.consumerErrorStrategy = consumerErrorStrategy;
// start the subscription callback thread
// all subscription actions registered with Subscribe or Request
// run here.
subscriptionCallbackThread = new Thread(_ =>
{
try
{
while (true)
{
if (disposed) break;
HandleMessageDelivery(queue.Take());
}
}
catch (InvalidOperationException)
{
// InvalidOperationException is thrown when Take is called after
// queue.CompleteAdding(), this is signals that this class is being
// disposed, so we allow the thread to complete.
}
});
subscriptionCallbackThread.Start();
}
public void SetUp()
{
consumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
queueingConsumerFactory = new QueueingConsumerFactory(new ConsoleLogger(), consumerErrorStrategy);
autoResetEvent = new AutoResetEvent(false);
queueingConsumerFactory.SynchronisationAction = () => autoResetEvent.Set();
}
public LimitedHandlerRunner(
IConsumerErrorStrategy consumerErrorStrategy,
RabbitMqClientOptions rabbitMqClientOptions)
: base(consumerErrorStrategy)
{
_rabbitMqClientOptions = rabbitMqClientOptions;
}
public void SetUp()
{
consumerErrorStrategy = MockRepository.GenerateStub <IConsumerErrorStrategy>();
queueingConsumerFactory = new QueueingConsumerFactory(new ConsoleLogger(), consumerErrorStrategy);
autoResetEvent = new AutoResetEvent(false);
queueingConsumerFactory.SynchronisationAction = () => autoResetEvent.Set();
}
public When_a_user_handler_is_failed()
{
consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>();
consumerErrorStrategy.HandleConsumerError(null, null).ReturnsForAnyArgs(AckStrategies.Ack);
var handlerRunner = new HandlerRunner(consumerErrorStrategy);
var consumer = Substitute.For <IBasicConsumer>();
channel = Substitute.For <IModel>();
consumer.Model.Returns(channel);
context = new ConsumerExecutionContext(
async(body, properties, info) => throw new Exception(),
messageInfo,
messageProperties,
messageBody
);
var handlerTask = handlerRunner.InvokeUserMessageHandlerAsync(context)
.ContinueWith(async x =>
{
var ackStrategy = await x.ConfigureAwait(false);
return(ackStrategy(channel, 42));
}, TaskContinuationOptions.ExecuteSynchronously)
.Unwrap();
if (!handlerTask.Wait(5000))
{
throw new TimeoutException();
}
}
public When_a_user_handler_is_failed()
{
consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>();
var eventBus = new EventBus();
var handlerRunner = new HandlerRunner(consumerErrorStrategy, eventBus);
Func <byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Run(() => throw new Exception());
var consumer = Substitute.For <IBasicConsumer>();
var channel = Substitute.For <IModel>();
consumer.Model.Returns(channel);
context = new ConsumerExecutionContext(userHandler, messageInfo, messageProperties, messageBody, consumer);
var autoResetEvent = new AutoResetEvent(false);
eventBus.Subscribe <AckEvent>(x => autoResetEvent.Set());
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy)
{
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(consumerErrorStrategy, "consumerErrorStrategy");
this.logger = logger;
this.consumerErrorStrategy = consumerErrorStrategy;
}
public HandlerRunner(IConsumerErrorStrategy consumerErrorStrategy, IEventBus eventBus)
{
Preconditions.CheckNotNull(consumerErrorStrategy, "consumerErrorStrategy");
Preconditions.CheckNotNull(eventBus, "eventBus");
this.consumerErrorStrategy = consumerErrorStrategy;
this.eventBus = eventBus;
}
public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy)
{
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(consumerErrorStrategy, "consumerErrorStrategy");
this.logger = logger;
this.consumerErrorStrategy = consumerErrorStrategy;
}
public void SetUp()
{
var conventions = new Conventions
{
ConsumerTagConvention = () => consumerTag
};
consumerErrorStrategy = MockRepository.GenerateStub <IConsumerErrorStrategy>();
consumerErrorStrategy.Stub(x => x.HandleConsumerError(null, null))
.IgnoreArguments()
.WhenCalled(i =>
{
basicDeliverEventArgs = (ConsumerExecutionContext)i.Arguments[0];
raisedException = (Exception)i.Arguments[1];
});
consumerErrorStrategy.Stub(x => x.PostExceptionAckStrategy()).Return(PostExceptionAckStrategy.ShouldAck);
mockBuilder = new MockBuilder(x => x
.Register <IConventions>(_ => conventions)
.Register(_ => consumerErrorStrategy)
//.Register<IEasyNetQLogger>(_ => new ConsoleLogger())
);
mockBuilder.Bus.Subscribe <MyMessage>(subscriptionId, message =>
{
throw originalException;
});
const string text = "Hello there, I am the text!";
originalMessage = new MyMessage {
Text = text
};
var body = new JsonSerializer().MessageToBytes(originalMessage);
// deliver a message
mockBuilder.Consumers[0].HandleBasicDeliver(
consumerTag,
deliveryTag,
false, // redelivered
typeName,
"#",
new BasicProperties
{
Type = typeName,
CorrelationId = correlationId
},
body);
// wait for the subscription thread to handle the message ...
var autoResetEvent = new AutoResetEvent(false);
var handlerExecutionContext = (HandlerRunner)mockBuilder.ServiceProvider.Resolve <IHandlerRunner>();
handlerExecutionContext.SynchronisationAction = () => autoResetEvent.Set();
autoResetEvent.WaitOne(1000);
}
public When_the_handler_throws_an_exception()
{
var conventions = new Conventions(new DefaultTypeNameSerializer())
{
ConsumerTagConvention = () => consumerTag
};
consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>();
consumerErrorStrategy.HandleConsumerError(default, null)
public When_the_handler_throws_an_exception()
{
var conventions = new Conventions(new TypeNameSerializer())
{
ConsumerTagConvention = () => consumerTag
};
consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>();
consumerErrorStrategy.HandleConsumerError(null, null)
.ReturnsForAnyArgs(i =>
{
basicDeliverEventArgs = (ConsumerExecutionContext)i[0];
raisedException = (Exception)i[1];
return(AckStrategies.Ack);
});
mockBuilder = new MockBuilder(x => x
.Register <IConventions>(_ => conventions)
.Register(_ => consumerErrorStrategy)
//.Register<IEasyNetQLogger>(_ => new ConsoleLogger())
);
mockBuilder.Bus.Subscribe <MyMessage>(subscriptionId, message =>
{
throw originalException;
});
const string text = "Hello there, I am the text!";
originalMessage = new MyMessage {
Text = text
};
var body = new JsonSerializer(new TypeNameSerializer()).MessageToBytes(originalMessage);
// deliver a message
mockBuilder.Consumers[0].HandleBasicDeliver(
consumerTag,
deliveryTag,
false, // redelivered
typeName,
"#",
new BasicProperties
{
Type = typeName,
CorrelationId = correlationId
},
body);
// wait for the subscription thread to handle the message ...
var autoResetEvent = new AutoResetEvent(false);
mockBuilder.EventBus.Subscribe <AckEvent>(x => autoResetEvent.Set());
autoResetEvent.WaitOne(1000);
}
public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy, IEventBus eventBus)
{
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(consumerErrorStrategy, "consumerErrorStrategy");
Preconditions.CheckNotNull(eventBus, "eventBus");
this.logger = logger;
this.consumerErrorStrategy = consumerErrorStrategy;
this.eventBus = eventBus;
}
public HandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy, IEventBus eventBus)
{
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(consumerErrorStrategy, "consumerErrorStrategy");
Preconditions.CheckNotNull(eventBus, "eventBus");
this.logger = logger;
this.consumerErrorStrategy = consumerErrorStrategy;
this.eventBus = eventBus;
}
protected void SetUp()
{
ConsumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
IConventions conventions = new Conventions(new TypeNameSerializer())
{
ConsumerTagConvention = () => ConsumerTag
};
MockBuilder = new MockBuilder(x => x
.Register(_ => conventions)
.Register(_ => ConsumerErrorStrategy)
//.Register<IEasyNetQLogger>(_ => new ConsoleLogger())
);
AdditionalSetUp();
}
protected void SetUp()
{
ConsumerErrorStrategy = MockRepository.GenerateStub <IConsumerErrorStrategy>();
IConventions conventions = new Conventions(new TypeNameSerializer())
{
ConsumerTagConvention = () => ConsumerTag
};
MockBuilder = new MockBuilder(x => x
.Register(_ => conventions)
.Register(_ => ConsumerErrorStrategy)
//.Register<IEasyNetQLogger>(_ => new ConsoleLogger())
);
AdditionalSetUp();
}
protected void SetUp()
{
ConsumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
ConsumerErrorStrategy.Stub(x => x.PostExceptionAckStrategy()).Return(PostExceptionAckStrategy.ShouldAck);
IConventions conventions = new Conventions
{
ConsumerTagConvention = () => ConsumerTag
};
MockBuilder = new MockBuilder(x => x
.Register(_ => conventions)
.Register(_ => ConsumerErrorStrategy)
//.Register<IEasyNetQLogger>(_ => new ConsoleLogger())
);
AdditionalSetUp();
}
protected void SetUp()
{
ConsumerErrorStrategy = MockRepository.GenerateStub <IConsumerErrorStrategy>();
ConsumerErrorStrategy.Stub(x => x.PostExceptionAckStrategy()).Return(PostExceptionAckStrategy.ShouldAck);
IConventions conventions = new Conventions
{
ConsumerTagConvention = () => ConsumerTag
};
MockBuilder = new MockBuilder(x => x
.Register(_ => conventions)
.Register(_ => ConsumerErrorStrategy)
//.Register<IEasyNetQLogger>(_ => new ConsoleLogger())
);
AdditionalSetUp();
}
public ConsumerTestBase()
{
Cancellation = new CancellationTokenSource();
ConsumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>();
IConventions conventions = new Conventions(new DefaultTypeNameSerializer())
{
ConsumerTagConvention = () => ConsumerTag
};
MockBuilder = new MockBuilder(x => x
.Register(conventions)
.Register(ConsumerErrorStrategy)
);
AdditionalSetUp();
}
public QueueingConsumerFactory(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy)
{
this.logger = logger;
this.consumerErrorStrategy = consumerErrorStrategy;
// start the subscription callback thread
// all subscription actions registered with Subscribe or Request
// run here.
subscriptionCallbackThread = new Thread(_ =>
{
while(true)
{
if (disposed) break;
HandleMessageDelivery(queue.Take());
}
});
subscriptionCallbackThread.Start();
}
public ConsumerTestBase()
{
Cancellation = new CancellationTokenSource();
ConsumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>();
IConventions conventions = new Conventions(new TypeNameSerializer())
{
ConsumerTagConvention = () => ConsumerTag
};
MockBuilder = new MockBuilder(x => x
.Register(_ => conventions)
.Register(_ => ConsumerErrorStrategy)
//.Register<IEasyNetQLogger>(_ => new ConsoleLogger())
);
AdditionalSetUp();
}
public QueueingConsumerFactory(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy)
{
this.logger = logger;
this.consumerErrorStrategy = consumerErrorStrategy;
// start the subscription callback thread
// all subscription actions registered with Subscribe or Request
// run here.
subscriptionCallbackThread = new Thread(_ =>
{
while (true)
{
if (disposed)
{
break;
}
try
{
BasicDeliverEventArgs deliverEventArgs;
lock (sharedQueueLock)
{
deliverEventArgs = (BasicDeliverEventArgs)sharedQueue.Dequeue();
}
if (deliverEventArgs != null)
{
HandleMessageDelivery(deliverEventArgs);
}
}
catch (EndOfStreamException)
{
// do nothing here, EOS fired when queue is closed
// Looks like the connection has gone away, so wait a little while
// before continuing to poll the queue
Thread.Sleep(10);
}
}
});
subscriptionCallbackThread.Start();
}
public QueueingConsumerFactory(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy)
{
this.logger = logger;
this.consumerErrorStrategy = consumerErrorStrategy;
// start the subscription callback thread
// all subscription actions registered with Subscribe or Request
// run here.
subscriptionCallbackThread = new Thread(_ =>
{
while(true)
{
if (disposed) break;
try
{
BasicDeliverEventArgs deliverEventArgs;
lock (sharedQueueLock)
{
deliverEventArgs = (BasicDeliverEventArgs)sharedQueue.Dequeue();
}
if(deliverEventArgs != null)
{
HandleMessageDelivery(deliverEventArgs);
}
}
catch (EndOfStreamException)
{
// do nothing here, EOS fired when queue is closed
// Looks like the connection has gone away, so wait a little while
// before continuing to poll the queue
Thread.Sleep(10);
}
}
});
subscriptionCallbackThread.Start();
}
IBus IBusBuilder.CreateBus()
{
_logger.DebugWrite("Creating bus.");
if (_connectionFactory == null)
{
_logger.DebugWrite("Using default connection factory.");
_connectionFactory = CreateDefaultConnectionFactory();
}
if (_consumerErrorStrategy == null)
{
_logger.DebugWrite("Using default consumer error strategy.");
_consumerErrorStrategy = CreateDefaultConsumerErrorStrategy();
}
return new RabbitBus(
TypeNameSerializer.Serialize,
_serializer,
new QueueingConsumerFactory(_logger, _consumerErrorStrategy),
_connectionFactory,
_logger,
CorrelationIdGenerator.GetCorrelationId);
}
public void SetUp()
{
var conventions = new Conventions(new TypeNameSerializer())
{
ConsumerTagConvention = () => consumerTag
};
consumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
consumerErrorStrategy.Stub(x => x.HandleConsumerError(null, null))
.IgnoreArguments()
.WhenCalled(i =>
{
basicDeliverEventArgs = (ConsumerExecutionContext)i.Arguments[0];
raisedException = (Exception) i.Arguments[1];
}).Return(AckStrategies.Ack);
mockBuilder = new MockBuilder(x => x
.Register<IConventions>(_ => conventions)
.Register(_ => consumerErrorStrategy)
//.Register<IEasyNetQLogger>(_ => new ConsoleLogger())
);
mockBuilder.Bus.Subscribe<MyMessage>(subscriptionId, message =>
{
throw originalException;
});
const string text = "Hello there, I am the text!";
originalMessage = new MyMessage { Text = text };
var body = new JsonSerializer(new TypeNameSerializer()).MessageToBytes(originalMessage);
// deliver a message
mockBuilder.Consumers[0].HandleBasicDeliver(
consumerTag,
deliveryTag,
false, // redelivered
typeName,
"#",
new BasicProperties
{
Type = typeName,
CorrelationId = correlationId
},
body);
// wait for the subscription thread to handle the message ...
var autoResetEvent = new AutoResetEvent(false);
mockBuilder.EventBus.Subscribe<AckEvent>(x => autoResetEvent.Set());
autoResetEvent.WaitOne(1000);
}
/// <summary>
/// Initializes a new instance of the <see cref="PollyHandlerRunner"/> class.
/// </summary>
/// <param name="logger">A reference to an EasyNetQ logger implementation.</param>
/// <param name="consumerErrorStrategy">A reference to a consumer error strategy.</param>
/// <param name="eventBus">A reference to an event bus.</param>
/// <param name="policy">A reference to the policy within which message consumers will be executed.</param>
public PollyHandlerRunner(IEasyNetQLogger logger, IConsumerErrorStrategy consumerErrorStrategy, IEventBus eventBus, Policy policy)
: base(logger, consumerErrorStrategy, eventBus)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_policy = policy ?? throw new ArgumentNullException(nameof(policy));
}
public void SetUp()
{
_model = MockRepository.GenerateMock<IModel>();
_model.Stub(x => x.CreateBasicProperties())
.Return(new BasicProperties());
_model.Stub(x => x.BasicPublish(null, null, null, null))
.IgnoreArguments();
_model.Replay();
_connection = MockRepository.GenerateMock<IConnection>();
_connection.Stub(x => x.CreateModel()).Return(_model);
_connection.Replay();
_connectionFactory = MockRepository.GenerateMock<IConnectionFactory>();
_connectionFactory.Stub(x => x.CreateConnection()).Return(_connection);
_connectionFactory.Replay();
_logger = MockRepository.GenerateMock<IEasyNetQLogger>();
_logger.Replay();
_fallbackStrategy = MockRepository.GenerateMock<IConsumerErrorStrategy>();
_fallbackStrategy.Stub(x => x.HandleConsumerError(null, null))
.IgnoreArguments();
_fallbackStrategy.Replay();
_sut = new RetryConsumerErrorStrategy(
_connectionFactory,
_fallbackStrategy,
_logger);
}
public When_a_user_handler_is_cancelled()
{
consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>();
consumerErrorStrategy.HandleConsumerCancelled(default).ReturnsForAnyArgs(AckStrategies.Ack);
/// <summary>
/// Initializes a new instance of the <see cref="PollyHandlerRunner"/> class.
/// </summary>
/// <param name="logger">A reference to an EasyNetQ logger implementation.</param>
/// <param name="consumerErrorStrategy">A reference to a consumer error strategy.</param>
/// <param name="policy">A reference to the policy within which message consumers will be executed.</param>
public PollyHandlerRunner(ILog logger, IConsumerErrorStrategy consumerErrorStrategy, Policy policy)
: base(consumerErrorStrategy)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_policy = policy ?? throw new ArgumentNullException(nameof(policy));
}
public HandlerRunner(IConsumerErrorStrategy consumerErrorStrategy)
{
Preconditions.CheckNotNull(consumerErrorStrategy, "consumerErrorStrategy");
this.consumerErrorStrategy = consumerErrorStrategy;
}
public HandlerRunner(IConsumerErrorStrategy consumerErrorStrategy)
{
this.consumerErrorStrategy = consumerErrorStrategy;
}
public RetryConsumerErrorStrategy(
IConnectionFactory connectionFactory,
IConsumerErrorStrategy fallbackStrategy,
IEasyNetQLogger logger
)
{
_connectionFactory = connectionFactory;
_fallbackStrategy = fallbackStrategy;
_logger = logger;
MaxNumberOfRetries = 3;
}
