public static void Main(string[] args)
{
var disruptor = new Disruptor <DynamicEvent>(() => new DynamicEvent(), 1024, TaskScheduler.Current);
var ringBuffer = disruptor.Start();
// Construct 2 batch event processors.
var handler1 = new DynamicHandler();
var processor1 = EventProcessorFactory.Create(ringBuffer, ringBuffer.NewBarrier(), handler1);
var handler2 = new DynamicHandler();
var processor2 = EventProcessorFactory.Create(ringBuffer, ringBuffer.NewBarrier(processor1.Sequence), handler2);
// Dynamically add both sequences to the ring buffer
ringBuffer.AddGatingSequences(processor1.Sequence, processor2.Sequence);
// Start the new batch processors.
var t1 = processor1.Start();
var t2 = processor2.Start();
Thread.Sleep(5000);
// Remove a processor.
// Stop the processor
processor2.Halt();
// Wait for shutdown the complete
handler2.WaitShutdown(); // Or simply t2.Wait()
// Remove the gating sequence from the ring buffer
ringBuffer.RemoveGatingSequence(processor2.Sequence);
}
public OneToThreeDiamondSequencedThroughputTest()
{
var sequenceBarrier = _ringBuffer.NewBarrier();
var fizzHandler = new FizzBuzzEventHandler(FizzBuzzStep.Fizz);
_eventProcessorFizz = EventProcessorFactory.Create(_ringBuffer, sequenceBarrier, fizzHandler);
var buzzHandler = new FizzBuzzEventHandler(FizzBuzzStep.Buzz);
_eventProcessorBuzz = EventProcessorFactory.Create(_ringBuffer, sequenceBarrier, buzzHandler);
var sequenceBarrierFizzBuzz = _ringBuffer.NewBarrier(_eventProcessorFizz.Sequence, _eventProcessorBuzz.Sequence);
_fizzBuzzHandler = new FizzBuzzEventHandler(FizzBuzzStep.FizzBuzz);
_eventProcessorFizzBuzz = EventProcessorFactory.Create(_ringBuffer, sequenceBarrierFizzBuzz, _fizzBuzzHandler);
var temp = 0L;
for (long i = 0; i < _iterations; i++)
{
var fizz = 0 == (i % 3L);
var buzz = 0 == (i % 5L);
if (fizz && buzz)
{
++temp;
}
}
_expectedResult = temp;
_ringBuffer.AddGatingSequences(_eventProcessorFizzBuzz.Sequence);
}
public OneToOneSequencedThroughputTest_Unmanaged()
{
_eventHandler = new AdditionEventHandler();
_memory = UnmanagedRingBufferMemory.Allocate(_bufferSize, PerfValueEvent.Size);
_ringBuffer = new UnmanagedRingBuffer <PerfValueEvent>(_memory, ProducerType.Single, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_eventProcessor = EventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _eventHandler);
_ringBuffer.AddGatingSequences(_eventProcessor.Sequence);
}
public OneToOneSequencedThroughputTest_BatchPublisher_BatchHandler()
{
_ringBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handler = new AdditionBatchEventHandler();
_eventProcessor = EventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _handler);
_ringBuffer.AddGatingSequences(_eventProcessor.Sequence);
}
public OneToOneSequencedThroughputTest_LongArray()
{
_ringBuffer = RingBuffer <long[]> .CreateSingleProducer(() => new long[_arraySize], _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handler = new LongArrayEventHandler();
_eventProcessor = EventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _handler);
_ringBuffer.AddGatingSequences(_eventProcessor.Sequence);
}
public async Task Should()
{
var rb = _disruptor.GetRingBuffer();
var p1 = new BatchEventProcessor <TestEvent>(
rb, rb.NewBarrier(), new SleepingEventHandler());
var p2 = new EventProcessorFactory();
_disruptor
.HandleEventsWith(p1)
.Then(p2);
await _disruptor.StartAsync();
}
public async Task <bool> RegisterEventMessageConsumerAsync <TEventProcessor>(string name)
where TEventProcessor : EventProcessorDefault
{
ConsumerConfigurationsOptions consumerConfiguration = GetConsumerConfiguration(name);
if (EventProcessorHostList != null && EventProcessorHostList.Any(s => s.EventHubPath == consumerConfiguration.EventHubName))
{
return(false);
}
eventProcessorHost = new EventProcessorHost(
consumerConfiguration.EventHubName,
!string.IsNullOrWhiteSpace(consumerConfiguration.ConsumerGroupName) ? consumerConfiguration.ConsumerGroupName : PartitionReceiver.DefaultConsumerGroupName,
consumerConfiguration.ConnectionString,
consumerConfiguration.StorageConnectionString,
consumerConfiguration.StorageContainerName)
{
PartitionManagerOptions = new PartitionManagerOptions
{
RenewInterval = TimeSpan.FromSeconds(consumerConfiguration.RenewIntervalInSeconds),
LeaseDuration = TimeSpan.FromSeconds(consumerConfiguration.LeaseDurationInSeconds)
}
};
var eventProcessorOptions = new EventProcessorOptions()
{
MaxBatchSize = consumerConfiguration.NumberOfEventsPerRequest,
ReceiveTimeout = TimeSpan.FromSeconds(consumerConfiguration.ReceiveTimeoutInSeconds)
};
DateTime offsetStartDateTime;
if (!string.IsNullOrEmpty(consumerConfiguration.OffsetStartDateTime) && DateTime.TryParse(consumerConfiguration.OffsetStartDateTime, out offsetStartDateTime))
{
eventProcessorOptions.InitialOffsetProvider = (partitionId) => EventPosition.FromEnqueuedTime(offsetStartDateTime);
}
else
{
eventProcessorOptions.InitialOffsetProvider = (partitionId) => EventPosition.FromStart();
}
EventProcessorFactory <TEventProcessor> eventProcessorFactory = new EventProcessorFactory <TEventProcessor>(consumerConfiguration, ServiceProvider, Configuration);
await eventProcessorHost.RegisterEventProcessorFactoryAsync(eventProcessorFactory, eventProcessorOptions);
EventProcessorHostList.Add(eventProcessorHost);
EventProcessorFactoryList.Add(name, eventProcessorFactory);
return(true);
}
public void ShouldCreateValueTypeProxyForEachParameter()
{
// Arrange
var dataProvider = new RingBuffer <TestEvent>(() => new TestEvent(), 64);
var sequenceBarrier = dataProvider.NewBarrier();
// Act
var eventProcessor = EventProcessorFactory.Create(dataProvider, sequenceBarrier, new DummyEventHandler <TestEvent>());
// Assert
foreach (var genericArgument in eventProcessor.GetType().GetGenericArguments().Where(x => x != typeof(TestEvent)))
{
Assert.True(genericArgument.IsValueType, $"Generic argument {genericArgument.Name} is not a value type");
}
}
public static async Task Main(string[] args)
{
IConfigurationBuilder configBuilder = SetupConfig();
var config = configBuilder.Build();
LoggerFactory loggerFactory = SetupLoggerFactory();
_logger = loggerFactory.CreateLogger("VacancyAnalyticsWebJob");
var vacancyEventStoreConnString = config.GetConnectionString(VacancyEventStoreConnStringKey);
var vacancyEventHubConnString = config.GetConnectionString(VacancyEventHubConnStringKey);
var queueStorageConnString = config.GetConnectionString(QueueStorageConnStringKey);
var eventStoreWriter = new VacancyEventStoreWriter(vacancyEventStoreConnString, loggerFactory.CreateLogger <VacancyEventStoreWriter>());
var factory = new EventProcessorFactory(loggerFactory.CreateLogger <VacancyEventProcessor>(), eventStoreWriter);
var epHostName = IsDevelopment ? HostNamePrefix : GetUniqueEventHostProcessorName();
var eventProcessorHost = new EventProcessorHost(
EventHubName,
PartitionReceiver.DefaultConsumerGroupName,
vacancyEventHubConnString,
queueStorageConnString,
epHostName);
var opts = new EventProcessorOptions
{
PrefetchCount = 512,
MaxBatchSize = 256
};
try
{
opts.SetExceptionHandler(HandleEventProcessorException);
await eventProcessorHost.RegisterEventProcessorFactoryAsync(factory, opts);
Console.WriteLine("Receiving. Press enter key to stop worker job.");
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
Console.ReadLine();
await eventProcessorHost.UnregisterEventProcessorAsync();
}
public PingPongSequencedLatencyTest()
{
var pingBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new BlockingWaitStrategy());
var pongBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new BlockingWaitStrategy());
var pingBarrier = pingBuffer.NewBarrier();
var pongBarrier = pongBuffer.NewBarrier();
_pinger = new Pinger(pingBuffer, _iterations, _pauseNanos);
_ponger = new Ponger(pongBuffer);
_pingProcessor = EventProcessorFactory.Create(pongBuffer, pongBarrier, _pinger);
_pongProcessor = EventProcessorFactory.Create(pingBuffer, pingBarrier, _ponger);
pingBuffer.AddGatingSequences(_pongProcessor.Sequence);
pongBuffer.AddGatingSequences(_pingProcessor.Sequence);
}
public PingPongSequencedLatencyTest_AsyncBatchHandler()
{
var pingBuffer = RingBuffer <PingPongEvent> .CreateSingleProducer(() => new PingPongEvent(), _bufferSize, new AsyncWaitStrategy());
var pongBuffer = RingBuffer <PingPongEvent> .CreateSingleProducer(() => new PingPongEvent(), _bufferSize, new AsyncWaitStrategy());
var pingBarrier = pingBuffer.NewAsyncBarrier();
var pongBarrier = pongBuffer.NewAsyncBarrier();
_pinger = new Pinger(pongBuffer, _pauseNanos);
_ponger = new Ponger(pingBuffer);
_pingProcessor = EventProcessorFactory.Create(pingBuffer, pingBarrier, _pinger);
_pongProcessor = EventProcessorFactory.Create(pongBuffer, pongBarrier, _ponger);
pingBuffer.AddGatingSequences(_pingProcessor.Sequence);
pongBuffer.AddGatingSequences(_pongProcessor.Sequence);
}
private async Task Listen()
{
_host = new EventProcessorHost(_options.Host, _options.HubPath, _options.ConsumerGroup, _options.ConnString, _options.StorageConnString);
var factory = new EventProcessorFactory();
factory.OnMessageAction += _options.OnMessageAction;
factory.OnError += _options.OnError;
/*
* Use this if you want to read from beginning of your EventHub stream
* await _host.RegisterEventProcessorFactoryAsync(factory);
*/
await _host.RegisterEventProcessorFactoryAsync(factory, new EventProcessorOptions
{
InitialOffsetProvider = (partitionId) => DateTime.UtcNow,
});
}
/// <summary>
/// Opens the asynchronous.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The Task</returns>
public async Task <string> OpenAsync(CancellationToken cancellationToken)
{
try
{
this.eventHubClient = EventHubClient.CreateFromConnectionString(this.eventHubConnectionString, this.eventHubName);
this.eventHubConsumerGroup = string.IsNullOrWhiteSpace(this.consumerGroup)
? this.eventHubClient.GetDefaultConsumerGroup()
: this.eventHubClient.GetConsumerGroup(this.consumerGroup);
var runtimeInfo = await this.eventHubClient.GetRuntimeInformationAsync().ConfigureAwait(false);
this.eventProcessorFactory = new EventProcessorFactory(this.eventDataHandler);
CheckPointManager checkPointManager = new CheckPointManager();
ServiceEventSource.Current.Message("Initializing event hub listener");
foreach (string pid in runtimeInfo.PartitionIds)
{
StateManagerLease lease =
await
StateManagerLease.GetOrCreateAsync(
this.stateManager,
this.stateDictionary,
this.Namespace,
this.consumerGroup,
this.eventHubName,
pid);
await this.eventHubConsumerGroup.RegisterProcessorFactoryAsync(
lease,
checkPointManager,
this.eventProcessorFactory
);
}
}
catch (Exception exception)
{
ServiceEventSource.Current.Message(exception.ToString());
}
return(string.Concat(this.eventHubName, " @ ", this.Namespace));
}
/// <inheritdoc/>
public async Task ListenAsync(Func <IReadOnlyCollection <Message>, CancellationToken, Task> handleMessages, CancellationToken cancellationToken = default)
{
_ = handleMessages ?? throw new ArgumentNullException(nameof(handleMessages));
try
{
var factory = new EventProcessorFactory(handleMessages, _host, _logger, cancellationToken);
await _host.RegisterEventProcessorFactoryAsync(factory, _processorOptions);
await Task.Delay(Timeout.Infinite, cancellationToken);
}
catch (TaskCanceledException) { throw; }
catch (Exception e)
{
throw new MessageReceivingFailedException("Registration of the message listener failed.", e);
}
finally
{
await _host.UnregisterEventProcessorAsync();
}
}
public static void UseEventProcessor(
this IAppBuilder appBuilder,
EventProcessorHost eventProcessorHost,
IMessageHandler messageHandler,
IEventProcessingExceptionHandler exceptionHandler)
{
if (appBuilder == null)
{
throw new ArgumentNullException(nameof(appBuilder));
}
if (eventProcessorHost == null)
{
throw new ArgumentNullException(nameof(eventProcessorHost));
}
var processorFactory = new EventProcessorFactory(messageHandler, exceptionHandler, CancellationToken.None);
eventProcessorHost.RegisterEventProcessorFactoryAsync(processorFactory).Wait();
CancellationToken appDisposing = new AppProperties(appBuilder.Properties).OnAppDisposing;
appDisposing.Register(() => eventProcessorHost.UnregisterEventProcessorAsync().Wait());
}
public OneToThreeSequencedThroughputTest()
{
for (long i = 0; i < _iterations; i++)
{
_results[0] = Operation.Addition.Op(_results[0], i);
_results[1] = Operation.Subtraction.Op(_results[1], i);
_results[2] = Operation.And.Op(_results[2], i);
}
_ringBuffer = RingBuffer <PerfEvent> .CreateSingleProducer(PerfEvent.EventFactory, _bufferSize, new YieldingWaitStrategy());
var sequenceBarrier = _ringBuffer.NewBarrier();
_handlers[0] = new PerfMutationEventHandler(Operation.Addition);
_handlers[1] = new PerfMutationEventHandler(Operation.Subtraction);
_handlers[2] = new PerfMutationEventHandler(Operation.And);
for (var i = 0; i < _numEventProcessors; i++)
{
_eventProcessors[i] = EventProcessorFactory.Create(_ringBuffer, sequenceBarrier, _handlers[i]);
}
_ringBuffer.AddGatingSequences(_eventProcessors.Select(x => x.Sequence).ToArray());
}
public void ShouldReportValueEventHandlerProgressByUpdatingSequenceViaCallback()
{
var ringBuffer = ValueRingBuffer <StubValueEvent> .CreateMultiProducer(() => new StubValueEvent(-1), 16);
var sequenceBarrier = ringBuffer.NewBarrier();
var handler = new TestSequenceReportingEventHandler();
var eventProcessor = EventProcessorFactory.Create(ringBuffer, sequenceBarrier, handler);
ringBuffer.AddGatingSequences(eventProcessor.Sequence);
var task = eventProcessor.Start();
Assert.AreEqual(-1L, eventProcessor.Sequence.Value);
ringBuffer.Publish(ringBuffer.Next());
handler.CallbackSignal.WaitOne();
Assert.AreEqual(0L, eventProcessor.Sequence.Value);
handler.OnEndOfBatchSignal.Set();
Assert.AreEqual(0L, eventProcessor.Sequence.Value);
eventProcessor.Halt();
Assert.IsTrue(task.Wait(TimeSpan.FromSeconds(10)));
}
public OneToThreePipelineSequencedThroughputTest()
{
var stepOneFunctionHandler = new FunctionEventHandler(FunctionStep.One);
var stepTwoFunctionHandler = new FunctionEventHandler(FunctionStep.Two);
_stepThreeFunctionHandler = new FunctionEventHandler(FunctionStep.Three);
var stepOneSequenceBarrier = _ringBuffer.NewBarrier();
_stepOneEventProcessor = EventProcessorFactory.Create(_ringBuffer, stepOneSequenceBarrier, stepOneFunctionHandler);
var stepTwoSequenceBarrier = _ringBuffer.NewBarrier(_stepOneEventProcessor.Sequence);
_stepTwoEventProcessor = EventProcessorFactory.Create(_ringBuffer, stepTwoSequenceBarrier, stepTwoFunctionHandler);
var stepThreeSequenceBarrier = _ringBuffer.NewBarrier(_stepTwoEventProcessor.Sequence);
_stepThreeEventProcessor = EventProcessorFactory.Create(_ringBuffer, stepThreeSequenceBarrier, _stepThreeFunctionHandler);
var temp = 0L;
var operandTwo = _operandTwoInitialValue;
for (long i = 0; i < _iterations; i++)
{
var stepOneResult = i + operandTwo--;
var stepTwoResult = stepOneResult + 3;
if ((stepTwoResult & 4L) == 4L)
{
++temp;
}
}
_expectedResult = temp;
_ringBuffer.AddGatingSequences(_stepThreeEventProcessor.Sequence);
}
private static IValueEventProcessor <T> CreateEventProcessor <T>(IValueDataProvider <T> dataProvider, SequenceBarrier sequenceBarrier, IValueEventHandler <T> eventHandler)
where T : struct
{
return(EventProcessorFactory.Create(dataProvider, sequenceBarrier, eventHandler));
}
private static IAsyncEventProcessor <T> CreateEventProcessor <T>(IDataProvider <T> dataProvider, AsyncSequenceBarrier sequenceBarrier, IAsyncBatchEventHandler <T> eventHandler)
where T : class
{
return(EventProcessorFactory.Create(dataProvider, sequenceBarrier, eventHandler));
}
public void Setup()
{
_processor = EventProcessorFactory.Create(_ringBuffer, _ringBuffer.NewBarrier(), new XEventHandler(() => _processor.Halt()));
}
public void ShouldDetectExplicitImplementation()
{
Assert.True(EventProcessorFactory.HasNonDefaultImplementation(typeof(TypeWithImplicitImplementation <int>), typeof(IInterface <int>), nameof(IInterface <int> .Method)));
Assert.True(EventProcessorFactory.HasNonDefaultImplementation(typeof(TypeWithExplicitImplementation <int>), typeof(IInterface <int>), nameof(IInterface <int> .Method)));
Assert.False(EventProcessorFactory.HasNonDefaultImplementation(typeof(TypeWithNoImplementation <int>), typeof(IInterface <int>), nameof(IInterface <int> .Method)));
}
