/// <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); }