/// <summary>
/// Construct a <see cref="WorkProcessor{T}"/>.
/// </summary>
/// <param name="ringBuffer">to which events are published.</param>
/// <param name="barrier">on which it is waiting.</param>
/// <param name="workHandler">is the delegate to which events are dispatched.</param>
/// <param name="exceptionHandler">to be called back when an error occurs.</param>
/// <param name="workSequence">from which to claim the next event to be worked on. It should always be initialised <see cref="Sequence.InitialValue"/></param>
public WorkProcessor(
RingBuffer <T> ringBuffer,
ISequenceBarrier barrier,
IWorkHandler <T> workHandler,
IExceptionHandler <T> exceptionHandler,
ISequence workSequence)
{
_ringBuffer = ringBuffer;
_barrier = barrier;
_workHandler = workHandler;
_exceptionHandler = exceptionHandler;
_workSequence = workSequence;
_sequence = new Sequence();
if (_workHandler is ITimeoutHandler timeoutHandler)
{
_timeoutHandler = timeoutHandler;
}
if (_workHandler is ILifecycleAware lifecycleAware)
{
_lifecycleAware = lifecycleAware;
}
if (_workHandler is IEventReleaseAware eventReleaseAware)
{
_eventReleaser = new EventReleaser(_sequence);
eventReleaseAware.SetEventReleaser(_eventReleaser);
}
}
/// <summary>
/// Construct a <see cref="IBatchEventProcessor{TEvent}"/> that will automatically track the progress by updating its sequence when the <see cref="IEventHandler{TEvent}.OnEvent(TEvent,long,bool)"/> method returns.
/// </summary>
/// <param name="exceptionHandler"></param>
/// <param name="dataProvider">to which events are published.</param>
/// <param name="sequenceBarrier">on which it is waiting.</param>
/// <param name="eventHandler">is the delegate to which events are dispatched.</param>
public BatchEventProcessor(
IDataProvider <TEvent> dataProvider,
ISequenceBarrier sequenceBarrier,
IEventHandler <TEvent> eventHandler,
IExceptionHandler <TEvent> exceptionHandler)
{
_exceptionHandler = exceptionHandler;
_dataProvider = dataProvider;
_sequenceBarrier = sequenceBarrier;
_eventHandler = eventHandler;
_sequence = new Sequence();
if (eventHandler is ISequenceReportingEventHandler <TEvent> reporting)
{
reporting?.SetSequenceCallback(_sequence);
}
if (eventHandler is IBatchStartAware batchStartAware)
{
_batchStartAware = batchStartAware;
}
if (eventHandler is ITimeoutHandler timeoutHandler)
{
_timeoutHandler = timeoutHandler;
}
if (eventHandler is ILifecycleAware lifecycleAware)
{
_lifecycleAware = lifecycleAware;
}
}
/// <summary>
/// Construct a <see cref="BatchEventProcessor{T}"/> that will automatically track the progress by updating its sequence when
/// the <see cref="IEventHandler{T}.OnEvent"/> method returns.
/// </summary>
/// <param name="dataProvider">dataProvider to which events are published</param>
/// <param name="sequenceBarrier">SequenceBarrier on which it is waiting.</param>
/// <param name="eventHandler">eventHandler is the delegate to which events are dispatched.</param>
public BatchEventProcessor(IDataProvider <T> dataProvider, ISequenceBarrier sequenceBarrier, IEventHandler <T> eventHandler)
{
_dataProvider = dataProvider;
_sequenceBarrier = sequenceBarrier;
_eventHandler = eventHandler;
(eventHandler as ISequenceReportingEventHandler <T>)?.SetSequenceCallback(_sequence);
_timeoutHandler = eventHandler as ITimeoutHandler;
}
/// <summary>
/// Construct a <see cref="WorkProcessor{T}"/>.
/// </summary>
/// <param name="ringBuffer">ringBuffer to which events are published.</param>
/// <param name="sequenceBarrier">sequenceBarrier on which it is waiting.</param>
/// <param name="workHandler">workHandler is the delegate to which events are dispatched.</param>
/// <param name="exceptionHandler">exceptionHandler to be called back when an error occurs</param>
/// <param name="workSequence">workSequence from which to claim the next event to be worked on. It should always be initialised
/// as <see cref="Disruptor.Sequence.InitialCursorValue"/></param>
public WorkProcessor(RingBuffer <T> ringBuffer, ISequenceBarrier sequenceBarrier, IWorkHandler <T> workHandler, IExceptionHandler <T> exceptionHandler, ISequence workSequence)
{
_ringBuffer = ringBuffer;
_sequenceBarrier = sequenceBarrier;
_workHandler = workHandler;
_exceptionHandler = exceptionHandler;
_workSequence = workSequence;
_eventReleaser = new EventReleaser(this);
(_workHandler as IEventReleaseAware)?.SetEventReleaser(_eventReleaser);
_timeoutHandler = _workHandler as ITimeoutHandler;
}
/// <summary>
/// Construct a BatchEventProcessor that will automatically track the progress by updating its sequence when
/// the <see cref="IValueEventHandler{T}.OnEvent"/> method returns.
///
/// Consider using <see cref="BatchEventProcessorFactory"/> to create your <see cref="IEventProcessor"/>.
/// </summary>
/// <param name="dataProvider">dataProvider to which events are published</param>
/// <param name="sequenceBarrier">SequenceBarrier on which it is waiting.</param>
/// <param name="eventHandler">eventHandler is the delegate to which events are dispatched.</param>
/// <param name="batchStartAware"></param>
public ValueBatchEventProcessor(TDataProvider dataProvider, TSequenceBarrier sequenceBarrier, TEventHandler eventHandler, TBatchStartAware batchStartAware)
{
_dataProvider = dataProvider;
_sequenceBarrier = sequenceBarrier;
_eventHandler = eventHandler;
_batchStartAware = batchStartAware;
if (eventHandler is ISequenceReportingEventHandler <T> sequenceReportingEventHandler)
{
sequenceReportingEventHandler.SetSequenceCallback(_sequence);
}
_timeoutHandler = eventHandler as ITimeoutHandler;
}
/// <summary>
/// Construct a <see cref="BatchEventProcessor{T}"/> that will automatically track the progress by updating its sequence when
/// the <see cref="IEventHandler{T}.OnEvent"/> method returns.
/// </summary>
/// <param name="dataProvider">dataProvider to which events are published</param>
/// <param name="sequenceBarrier">SequenceBarrier on which it is waiting.</param>
/// <param name="eventHandler">eventHandler is the delegate to which events are dispatched.</param>
public BatchEventProcessor(IDataProvider <T> dataProvider, ISequenceBarrier sequenceBarrier, IEventHandler <T> eventHandler)
{
_dataProvider = dataProvider;
_sequenceBarrier = sequenceBarrier;
_eventHandler = eventHandler;
if (eventHandler is ISequenceReportingEventHandler <T> sequenceReportingEventHandler)
{
sequenceReportingEventHandler.SetSequenceCallback(_sequence);
}
_batchStartAware = eventHandler as IBatchStartAware;
_timeoutHandler = eventHandler as ITimeoutHandler;
}
/// <summary>
/// Construct a BatchEventProcessor that will automatically track the progress by updating its sequence when
/// the <see cref="IEventHandler{T}.OnEvent"/> method returns.
///
/// Consider using <see cref="BatchEventProcessorFactory"/> to create your <see cref="IEventProcessor"/>.
/// </summary>
/// <param name="dataProvider">dataProvider to which events are published</param>
/// <param name="sequenceBarrier">SequenceBarrier on which it is waiting.</param>
/// <param name="eventHandler">eventHandler is the delegate to which events are dispatched.</param>
/// <param name="batchStartAware"></param>
public BatchEventProcessorRef(TDataProvider dataProvider, TSequenceBarrier sequenceBarrier, TEventHandler eventHandler, TBatchStartAware batchStartAware)
{
_dataProvider = dataProvider;
_sequenceBarrier = sequenceBarrier;
_eventHandler = eventHandler;
_batchStartAware = batchStartAware;
if (eventHandler is IEventProcessorSequenceAware sequenceAware)
{
sequenceAware.SetSequenceCallback(_sequence);
}
_timeoutHandler = eventHandler as ITimeoutHandler;
}
/// <summary>
/// Construct a {@link EventProcessor} that will automatically track the progress by updating its sequence when
/// the {@link EventHandler#OnEvent(Object, long, boolean)} method returns.
/// </summary>
/// <param name="dataProvider">to which events are published.</param>
/// <param name="sequenceBarrier"> on which it is waiting.</param>
/// <param name="eventHandler">is the delegate to which events are dispatched.</param>
public BatchEventProcessor(IDataProvider <T> dataProvider,
ISequenceBarrier sequenceBarrier,
IEventHandler <T> eventHandler)
{
this.dataProvider = dataProvider;
this.sequenceBarrier = sequenceBarrier;
this.eventHandler = eventHandler;
if (eventHandler is ISequenceReportingEventHandler <T> )
{
((ISequenceReportingEventHandler <T>)eventHandler).SetSequenceCallback(sequence);
}
timeoutHandler = (eventHandler is ITimeoutHandler) ? (ITimeoutHandler)eventHandler : null;
}
public TimeoutControl(ITimeoutHandler timeoutHandler)
{
_timeoutHandler = timeoutHandler;
}
public TimeoutControlConnectionInvoker(Http3InMemory http3, ITimeoutHandler inner)
{
_http3 = http3;
_inner = inner;
}
public Http3InMemory(ServiceContext serviceContext, MockSystemClock mockSystemClock, ITimeoutHandler timeoutHandler, ILoggerFactory loggerFactory)
{
_serviceContext = serviceContext;
_timeoutControl = new TimeoutControl(new TimeoutControlConnectionInvoker(this, timeoutHandler));
_timeoutControl.Debugger = new TestDebugger();
_mockSystemClock = mockSystemClock;
_serverReceivedSettings = Channel.CreateUnbounded <KeyValuePair <Http3SettingType, long> >();
Logger = loggerFactory.CreateLogger <Http3InMemory>();
}
public void AddHandler(ITimeoutHandler handler)
{
_handlers.Add(handler);
}
public ListenerBuilder <TAction> OnTimeout()
{
_timeoutHandler = null;
return(this);
}
public ListenerBuilder <TAction> OnTimeout(System.Action action)
{
_timeoutHandler = new LambdaTimeoutHandler(action);
return(this);
}
public ListenerBuilder <TAction> OnTimeout(Func <Task> action)
{
_timeoutHandler = new AsynchronousLambdaTimeoutHandler(action);
return(this);
}
public ListenerBuilder <TAction> OnTimeout(ITimeoutHandler handler)
{
_timeoutHandler = handler;
return(this);
}
