public EventHandlerGroup <T> CreateEventProcessors(
ISequence[] barrierSequences,
IEventHandler <T>[] eventHandlers)
{
CheckNotStarted();
var processorSequences = new ISequence[eventHandlers.Length];
var barrier = _ringBuffer.NewBarrier(barrierSequences);
for (var i = 0; i < eventHandlers.Length; i++)
{
var eventHandler = eventHandlers[i];
var batchEventProcessor = new BatchEventProcessor <T>(_ringBuffer, barrier, eventHandler);
if (_exceptionHandler != null)
{
batchEventProcessor.SetExceptionHandler(_exceptionHandler);
}
_consumerRepository.Add(batchEventProcessor, eventHandler, barrier);
processorSequences[i] = batchEventProcessor.GetSequence();
}
UpdateGatingSequencesForNextInChain(barrierSequences, processorSequences);
return(new EventHandlerGroup <T>(this, _consumerRepository, processorSequences));
}
internal EventHandlerGroup <T> CreateEventProcessors(ISequence[] barrierSequences, IEventHandler <T>[] eventHandlers)
{
CheckNotStarted();
var processorSequences = new List <ISequence>(eventHandlers.Length);
var barrier = _ringBuffer.NewBarrier(barrierSequences);
foreach (var eventHandler in eventHandlers)
{
var batchEventProcessor = new BatchEventProcessor <T>(_ringBuffer, barrier, eventHandler);
if (_exceptionHandler != null)
{
batchEventProcessor.SetExceptionHandler(_exceptionHandler);
}
_consumerRepository.Add(batchEventProcessor, eventHandler, barrier);
processorSequences.Add(batchEventProcessor.Sequence);
}
if (processorSequences.Count > 0)
{
_consumerRepository.UnMarkEventProcessorsAsEndOfChain(barrierSequences);
}
return(new EventHandlerGroup <T>(this, _consumerRepository, processorSequences));
}
internal EventHandlerGroup <T> CreateEventProcessors(IEventProcessor[] barrierEventProcessors,
IEventHandler <T>[] eventHandlers, long startSequence = Sequencer.InitialCursorValue)
{
CheckNotStarted();
var createdEventProcessors = new IEventProcessor[eventHandlers.Length];
ISequenceBarrier barrier = _ringBuffer.NewBarrier(Util.GetSequencesFor(barrierEventProcessors));
for (int i = 0; i < eventHandlers.Length; i++)
{
var eventHandler = eventHandlers[i];
var batchEventProcessor = new BatchEventProcessor <T>(_ringBuffer, barrier, eventHandler, startSequence);
if (_exceptionHandler != null)
{
batchEventProcessor.SetExceptionHandler(_exceptionHandler);
}
_eventProcessorRepository.Add(batchEventProcessor, eventHandler, barrier);
createdEventProcessors[i] = batchEventProcessor;
}
if (createdEventProcessors.Length > 0)
{
_eventProcessorRepository.UnmarkEventProcessorsAsEndOfChain(barrierEventProcessors);
}
return(new EventHandlerGroup <T>(this, _eventProcessorRepository, createdEventProcessors));
}
public void ShouldThrowExceptionOnSettingNullExceptionHandler()
{
var eventHandler = new ActionEventHandler <StubEvent>(x => throw new NullReferenceException());
var batchEventProcessor = new BatchEventProcessor <StubEvent>(_ringBuffer, _sequenceBarrier, eventHandler);
Assert.Throws <ArgumentNullException>(() => batchEventProcessor.SetExceptionHandler(null));
}
public EventHandlerGroup <T> CreateEventProcessors(Sequence[] barrierSequences,
IEventHandler <T>[] eventHandlers)
{
CheckNotStarted();
var processorSequences = new Sequence[eventHandlers.Length];
var barrier = ringBuffer.NewBarrier(barrierSequences);
for (int i = 0, eventHandlersLength = eventHandlers.Length; i < eventHandlersLength; i++)
{
IEventHandler <T> eventHandler = eventHandlers[i];
BatchEventProcessor <T> batchEventProcessor = new BatchEventProcessor <T>(ringBuffer, barrier, eventHandler);
if (exceptionHandler != null)
{
batchEventProcessor.SetExceptionHandler(exceptionHandler);
}
consumerRepository.Add(batchEventProcessor, eventHandler, barrier);
processorSequences[i] = batchEventProcessor.Sequence;
}
if (processorSequences.Length > 0)
{
consumerRepository.UnMarkEventProcessorsAsEndOfChain(barrierSequences);
}
return(new EventHandlerGroup <T>(this, consumerRepository, processorSequences));
}
public void ShouldCallExceptionHandlerOnUncaughtException()
{
var exceptionSignal = new CountdownEvent(1);
var exceptionHandler = new ActionExceptionHandler <StubEvent>(x => exceptionSignal.Signal());
var eventHandler = new ActionEventHandler <StubEvent>(x => throw new NullReferenceException());
var batchEventProcessor = new BatchEventProcessor <StubEvent>(_ringBuffer, _sequenceBarrier, eventHandler);
_ringBuffer.AddGatingSequences(batchEventProcessor.Sequence);
batchEventProcessor.SetExceptionHandler(exceptionHandler);
var task = Task.Run(() => batchEventProcessor.Run());
_ringBuffer.Publish(_ringBuffer.Next());
Assert.IsTrue(exceptionSignal.Wait(TimeSpan.FromSeconds(2)));
batchEventProcessor.Halt();
Assert.IsTrue(task.Wait(500));
}
public void ShouldThrowExceptionOnSettingNullExceptionHandler()
{
_batchEventProcessor.SetExceptionHandler(null);
}
public void Should_Throw_Exception_On_Setting_Null_Exception_Handler()
{
var processor = new BatchEventProcessor <StubEvent>(_ringBuffer, _barrier, null, _exceptionHandler);
Assert.Throws <ArgumentNullException>(() => { processor.SetExceptionHandler(null); });
}
