// Can't really infer the topic from the subscription, since subscriptions of the same
// name can exist across different topics (i.e. "all" currently)
public EventProcessor CreateEventProcessor(string subscription, IEventHandler handler, ITextSerializer serializer)
{
if (!this.initialized)
throw new InvalidOperationException("Service bus configuration has not been initialized.");
var topicSettings = this.settings.Topics.Find(x => x.IsEventBus);
if (topicSettings == null)
throw new ArgumentOutOfRangeException("No topic has been marked with the IsEventBus attribute. Cannot create event processor.");
var subscriptionSettings = topicSettings.Subscriptions.Find(x => x.Name == subscription);
if (subscriptionSettings == null)
throw new ArgumentOutOfRangeException(string.Format(
CultureInfo.CurrentCulture,
"Subscription '{0}' for topic '{1}' has not been registered in the service bus configuration.",
subscription, topicSettings.Path));
var receiver = subscriptionSettings.RequiresSession ?
(IMessageReceiver)new SessionSubscriptionReceiver(this.settings, topicSettings.Path, subscription) :
(IMessageReceiver)new SubscriptionReceiver(this.settings, topicSettings.Path, subscription);
var processor = new EventProcessor(receiver, serializer);
processor.Register(handler);
return processor;
}
private IEnumerable<Tuple<Type, Action<IEvent>>> BuildHandlerInvocations(IEventHandler handler)
{
return handler.GetType().GetInterfaces()
.Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEventHandler<>))
.Select(i => new { HandlerInterface = i, EventType = i.GetGenericArguments()[0] })
.Select(e => new Tuple<Type, Action<IEvent>>(e.EventType, this.BuildHandlerInvocation(handler, e.HandlerInterface, e.EventType)));
}
private static void RegisterEventHandler(IEventHandler eventHandler)
{
object instance = eventHandler.Model;
_modelMap.Add(instance.GetType(), instance);
RegisterMessageHandler("SubscribeEventHandler", eventHandler);
}
/// <summary>Constructs a timer stage</summary>
/// <param name="handler">an event handler</param>
/// <param name="initialDelay">an initial delay</param>
/// <param name="period">a period in milli-seconds</param>
public TimerStage(IEventHandler<PeriodicEvent> handler, long initialDelay, long period)
{
_handler = handler;
_timer = new Timer(period);
_timer.Elapsed += (sender, e) => OnTimedEvent(sender, e, _handler, _value);
_timer.Enabled = true;
}
/// <summary>
/// Detaches a handler
/// </summary>
/// <param name="handler">A event handler/subscriber</param>
public void DetachHandler(IEventHandler handler)
{
if (!_handlers.Remove(handler))
{
throw new ArgumentException("Referenced handler is not attached to this emmiter!");
}
}
private static MethodInfo GetMatchingMethod(IEventHandler eventHandler, Type interfaceType, string methodName, IDictionary<string, object> arguments)
{
var allMethods = new List<MethodInfo>(interfaceType.GetMethods());
var candidates = new List<MethodInfo>(allMethods);
foreach (var method in allMethods) {
if (string.Equals(method.Name, methodName, StringComparison.OrdinalIgnoreCase)) {
ParameterInfo[] parameterInfos = method.GetParameters();
foreach (var parameter in parameterInfos) {
if (!arguments.ContainsKey(parameter.Name)) {
candidates.Remove(method);
break;
}
}
}
else {
candidates.Remove(method);
}
}
// treating common case separately
if (candidates.Count == 1) {
return candidates[0];
}
if (candidates.Count != 0) {
return candidates.OrderBy(x => x.GetParameters().Length).Last();
}
return null;
}
void IEventHelpers.RegisterSocketRead(IEvent e, BufferedSocket socket, IEventHandler protocol,
ReadFunction callback)
{
//Contract.Requires(socket != null);
Contract.Requires(protocol != null);
Contract.Requires(callback != null);
}
private static void _ProcessEvent(object obj)
{
IEvent evnt = (IEvent)obj;
lock(_rand){
Thread.CurrentThread.Name = "EventProcessor{" + evnt.Name + "}["+_rand.Next().ToString()+"]";
}
Thread.CurrentThread.IsBackground = true;
IEventHandler[] handlers = new IEventHandler[0];
Monitor.Enter(_lock);
handlers = new IEventHandler[_handlers.Count];
_handlers.CopyTo(handlers);
Monitor.Exit(_lock);
foreach (IEventHandler handler in handlers)
{
Log.Trace("Checking if " + handler.GetType().FullName + " handles event " + evnt.Name);
if (handler.HandlesEvent(evnt))
{
Thread delThread = null;
Log.Trace("Handling event " + evnt.Name + " with handler " + handler.GetType().FullName);
IAsyncResult res = _eventHandle.BeginInvoke(handler, evnt,ref delThread, null, null);
if (res.AsyncWaitHandle.WaitOne(_EVENT_HANDLING_TIMEOUT))
_eventHandle.EndInvoke(ref delThread,res);
else
{
Log.Error("Handle " + handler.GetType().FullName + " timed out handling event " + evnt.Name);
try
{
delThread.Abort();
}
catch (Exception e) { }
_eventHandle.EndInvoke(ref delThread,res);
}
}
}
}
public static void RegisterEventHandler(IEventHandler handler)
{
Monitor.Enter(_lock);
if (!_handlers.Contains(handler))
_handlers.Add(handler);
Monitor.Exit(_lock);
}
/// <summary>
/// Registers a listener for a specific event
/// </summary>
/// <param name="eventType">Event the listener is listening for</param>
/// <param name="listener">Listener receiving messages for the specified event</param>
public void RegisterListener(EventType eventType, IEventHandler listener)
{
List<IEventHandler> listeners = RegisterEvent(eventType);
if (listeners.Contains(listener))
throw new Exception(string.Format("Listener {0} already listen to event {1}", listener, eventType.EventName));
listeners.Add(listener);
}
public virtual void Invoke(IEventHandler handler, IEvent @event)
{
Ensure.That(handler, "handler").IsNotNull();
Ensure.That(@event, "event").IsNotNull();
var container = ContainerFactory.Invoke(handler.ContainerType);
handler.Handler.Invoke(container, new object[] { @event });
}
private static IEventBus InitializeEventBus(IEventHandler<NewNoteAdded> handler, TextChangedHandler textChangedHandler)
{
var bus = new InProcessEventBus();
bus.RegisterHandler(handler);
bus.RegisterHandler(textChangedHandler);
return bus;
}
public string RegisterHandler(IEventHandler handler)
{
_mut.WaitOne();
string ret = _rand.NextString(_ID_LENGTH);
_handlers.Add(new sEventHandler(handler, ret));
_mut.ReleaseMutex();
return ret;
}
private static bool TryInvoke(IEventHandler eventHandler, string interfaceName, string methodName, IDictionary<string, object> arguments, out IEnumerable returnValue) {
Type type = eventHandler.GetType();
foreach (var interfaceType in type.GetInterfaces()) {
if (String.Equals(interfaceType.Name, interfaceName, StringComparison.OrdinalIgnoreCase)) {
return TryInvokeMethod(eventHandler, interfaceType, methodName, arguments, out returnValue);
}
}
returnValue = null;
return false;
}
/// <summary>Constructs a timer stage</summary>
/// <param name="handler">an event handler</param>
/// <param name="initialDelay">an initial delay in the interval [0,MaxTimeValue]</param>
/// <param name="period">a period in milli-seconds in the interval [0,MaxTimeValue]</param>
public TimerStage(IEventHandler<PeriodicEvent> handler, long initialDelay, long period)
{
// Core .NET only supports 32 bit timers.
Validate("initialDelay", initialDelay);
Validate("period", period);
_handler = handler;
_timer = new Timer(
(object state) => { OnTimedEvent(_handler, _value); }, this, (int)initialDelay, (int)period);
}
public void addHandler(GameEventType gameEventType, int listeningToEntityId, IEventHandler handler)
{
if (!_handlers.ContainsKey(gameEventType))
_handlers.Add(gameEventType, new Dictionary<int,List<IEventHandler>>());
if (!_handlers[gameEventType].ContainsKey(listeningToEntityId))
_handlers[gameEventType].Add(listeningToEntityId, new List<IEventHandler>());
if (!_handlers[gameEventType][listeningToEntityId].Contains(handler))
{
_handlers[gameEventType][listeningToEntityId].Add(handler);
}
}
protected override void Context()
{
_handler = MockRepository.GenerateMock<IEventHandler<EventData>>();
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.RegisterHandler(_handler);
eventPublisher.UnregisterHandler(_handler);
eventPublisher.Publish(new EventData("My Event Data"));
}
private bool TryNotifyHandler(IEventHandler eventHandler, string messageName, string interfaceName, string methodName, IDictionary<string, object> eventData, out IEnumerable returnValue) {
try {
return TryInvoke(eventHandler, messageName, interfaceName, methodName, eventData, out returnValue);
} catch (Exception exception) {
if (!_exceptionPolicy.HandleException(this, exception))
throw;
returnValue = null;
return false;
}
}
/// <summary>
/// A factory method for creating a consumer from an array of hashes.
/// </summary>
/// <param name="user">The user object that's creating this consumer.</param>
/// <param name="type">The consumer type.</param>
/// <param name="hashes">An array of stream hashes.</param>
/// <param name="event_handler">An object that implements IEventHandler which will receive the events.</param>
/// <returns>An object of a type derived from this class.</returns>
public static StreamConsumer factory(User user, string type, string[] hashes, IEventHandler event_handler)
{
switch (type)
{
case "http":
return new StreamConsumer_Http(user, hashes, event_handler);
default:
throw new InvalidDataException("Consumer type \"" + type + "\" is unknown");
}
}
public EventRegistration(
IEventHandler handler,
Func<IEventHandler, Envelope, object> interceptor)
{
this.Handler = handler;
_interceptor = interceptor;
_registrationInfo = new Dictionary<string, string>();
_registrationInfo.SetMessageTopic(handler.Topic);
_log = LogManager.GetLogger(this.GetType());
}
public static void BootUp(IEventHandler<NewNoteAdded> handler, TextChangedHandler textChangedHandler)
{
var config = new StructureMapConfiguration(cfg =>
{
cfg.For<ICommandService>().Use(InitializeCommandService);
cfg.For<IEventBus>().Use(InitializeEventBus(handler, textChangedHandler));
cfg.For<IEventStore>().Use(InitializeEventStore);
cfg.For<ISnapshotStore>().Use(InitializeSnapshotStore);
cfg.For<IUnitOfWorkFactory>().Use(() => new SnapshottingUnitOfWorkFactory());
});
NcqrsEnvironment.Configure(config);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
mySurfaceView = FindViewById<MySurfaceView>(Resource.Id.mySurfaceView);
var metrics = Resources.DisplayMetrics;
eventHandler = new MyEventHandler(metrics.WidthPixels, metrics.HeightPixels, metrics.WidthPixels / 10, metrics.WidthPixels / 5, surfaceViewRefresh);
mySurfaceView.SetEventHandler(eventHandler);
mySurfaceView.Touch += SurfaceViewOnTouch;
}
protected override void Context()
{
_handler = MockRepository.GenerateMock<IEventHandler<EventData>>();
_handler.Stub(h => h.Handle(null)).IgnoreArguments().Callback(delegate(EventData data)
{
_eventData = data.SomeData;
return true;
});
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.RegisterHandler(_handler);
eventPublisher.Publish(new EventData("My Event Data"));
}
private static void _HandleEvent(IEventHandler handler,IEvent evnt,ref Thread delThread)
{
delThread = Thread.CurrentThread;
if (delThread.Name == null)
{
lock (_rand)
{
Thread.CurrentThread.Name = "EventHandlerCall{" + handler.GetType().FullName + "}[" + _rand.Next().ToString() + "]";
}
}
Thread.CurrentThread.IsBackground = true;
handler.ProcessEvent(evnt);
}
private Action<IEvent> BuildHandlerInvocation(IEventHandler handler, Type handlerType, Type messageType)
{
var parameter = Expression.Parameter(typeof(IEvent));
var invocationExpression =
Expression.Lambda(
Expression.Block(
Expression.Call(
Expression.Convert(Expression.Constant(handler), handlerType),
handlerType.GetMethod("Handle"),
Expression.Convert(parameter, messageType))),
parameter);
return (Action<IEvent>)invocationExpression.Compile();
}
public void InstallsHandlerInstances()
{
// Arrange
var container = new UnityContainer();
container.RegisterInstance(new EmbeddableDocumentStore { RunInMemory = true }.Initialize());
// Act
var aggregateHandlers = new IEventHandler[] { new AggregateHandler(), new AnotherAggregateHandler() };
var extension = EventStoreContainerExtension.FromHandlerInstances(aggregateHandlers);
container.AddExtension(extension);
// Assert
VerifyContainer(new UnityServiceLocator(container), 2);
}
public void InstallsHandlerInstances()
{
// Arrange
var container = new WindsorContainer();
container.Register(
Component.For<IDocumentStore>()
.Instance(new EmbeddableDocumentStore { RunInMemory = true }.Initialize()));
// Act
var aggregateHandlers = new IEventHandler[] { new AggregateHandler(), new AnotherAggregateHandler() };
var installer = EventStoreInstaller.FromHandlerInstances(aggregateHandlers);
container.Install(installer);
// Assert
VerifyContainer(new WindsorServiceLocator(container), 2);
}
protected override void Context()
{
_handler = SetupHandlerToThrowException();
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.OnHandlerError(ex =>
{
handlerExecuted = true;
caughtException = ex;
});
eventPublisher.RegisterHandler(_handler);
eventPublisher.Publish(new EventData());
}
public void SetUp()
{
_testEvent = new FakeEvent();
_handler1 = MockRepository.GenerateMock<IEventHandler<FakeEvent>>();
_handler2 = MockRepository.GenerateMock<IEventHandler<SourcedEvent>>();
_handler3 = MockRepository.GenerateMock<IEventHandler<IEvent>>();
_container = new WindsorContainer();
_container.Register(
Component.For<IWindsorContainer>().Instance(_container),
Component.For<IEventHandler<FakeEvent>>().Instance(_handler1),
Component.For<IEventHandler<SourcedEvent>>().Instance(_handler2),
Component.For<IEventHandler<IEvent>>().Instance(_handler3),
Component.For<IEventBus>().ImplementedBy<WindsorInProcessEventBus>());
var svc = _container.Resolve<IEventBus>();
svc.Publish(_testEvent);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterControllers(Assembly.GetExecutingAssembly());
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Register the SignalR hubs.
builder.RegisterHubs(Assembly.GetExecutingAssembly());
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.Where(t => t.Name.EndsWith("Repository", StringComparison.Ordinal))
.AsImplementedInterfaces();
builder.RegisterType<FeatureApplicationServices>().AsImplementedInterfaces();
builder.RegisterType<CommandSender>().As<ICommandSender>();
var innerBuilder = new ContainerBuilder();
innerBuilder.RegisterTypes(ThisAssembly.GetTypes().Where(_ => typeof(IHubBroadcasterFor).IsAssignableFrom(_)).ToArray())
.As<IHubBroadcasterFor>();
innerBuilder.RegisterTypes(ThisAssembly.GetTypes().Where(_ => typeof(IDatabaseBroadcasterFor).IsAssignableFrom(_)).ToArray())
.As<IDatabaseBroadcasterFor>();
innerBuilder.RegisterTypes(ThisAssembly.GetTypes().Where(_ => typeof(IHistoryBroadcasterFor).IsAssignableFrom(_)).ToArray())
.As<IHistoryBroadcasterFor>();
IContainer innerContainer = innerBuilder.Build();
var eventHandlers = new IEventHandler[] {
new DatabaseEventHandler(innerContainer.Resolve<IEnumerable<IDatabaseBroadcasterFor>>()),
new HubEventHandler(innerContainer.Resolve<IEnumerable<IHubBroadcasterFor>>()),
new HistoryEventHandler(innerContainer.Resolve<IEnumerable<IHistoryBroadcasterFor>>())
};
var dispatcher = new NEventStoreDispatcher(eventHandlers);
var nEventStore =
Wireup.Init()
.LogToOutputWindow()
.UsingSqlPersistence("FeatureBeeContext")
.WithDialect(new MsSqlDialect())
.InitializeStorageEngine()
// .EnlistInAmbientTransaction()
.UsingJsonSerialization()
.UsingSynchronousDispatchScheduler()
.DispatchTo(new DelegateMessageDispatcher(dispatcher.DispatchCommit))
.Build();
builder.RegisterInstance(nEventStore);
}
public void ReleaseHandler(IEventHandler handler)
{
}
/// <inheritdoc/>
public IDisposable Register <TEventData>(IEventHandler <TEventData> handler) where TEventData : IEventData
{
return(Register(typeof(TEventData), handler));
}
public Processor(Dispatcher dispatcher, GameDB gameDb, SettingsModel settings, IEventHandler eventHandler)
{
_degreeOfParallelism = 4;
_dispatcher = dispatcher;
_gameDb = gameDb;
_settings = settings;
_eventHandler = eventHandler;
}
public static ContextualMenuPopulateEvent GetPooled(EventBase triggerEvent, ContextualMenu menu, IEventHandler target)
{
ContextualMenuPopulateEvent e = GetPooled();
if (triggerEvent != null)
{
IMouseEvent mouseEvent = triggerEvent as IMouseEvent;
if (mouseEvent != null)
{
e.modifiers = mouseEvent.modifiers;
e.mousePosition = mouseEvent.mousePosition;
e.localMousePosition = mouseEvent.mousePosition;
e.mouseDelta = mouseEvent.mouseDelta;
e.button = mouseEvent.button;
e.clickCount = mouseEvent.clickCount;
}
e.target = target;
e.menu = menu;
}
return(e);
}
private EventProcessorInfo <T> GetEventProcessorInfo(IEventHandler <T> handler)
{
return(eventProcessorInfoByEventHandler[handler]);
}
public ISequenceBarrier GetBarrierFor(IEventHandler <T> handler)
{
var consumerInfo = GetEventProcessorInfo(handler);
return(consumerInfo != null ? consumerInfo.GetBarrier : null);
}
/// <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.Create{T}"/> 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>
public BatchEventProcessor(IDataProvider <T> dataProvider, ISequenceBarrier sequenceBarrier, IEventHandler <T> eventHandler)
: base(dataProvider, sequenceBarrier, eventHandler, new BatchEventProcessorFactory.BatchStartAware(eventHandler))
{
}
/// <inheritdoc/>
public IDisposable Register(Type eventType, IEventHandler handler)
{
return(NullDisposable.Instance);
}
/// <inheritdoc/>
public void Unregister <TEventData>(IEventHandler <TEventData> handler) where TEventData : IEventData
{
}
/// <inheritdoc/>
public void Unregister(Type eventType, IEventHandler handler)
{
}
public IDisposable Subscribe(Type eventType, IEventHandler handler)
{
return(NullDisposable.Instance);
}
public void Unsubscribe(Type eventType, IEventHandler handler)
{
}
public void Subscribe(IEventHandler handler)
{
_handlers.Add(handler);
}
/// <summary>
///
/// </summary>
/// <param name="handler"></param>
public SingleInstanceHandlerFactory(IEventHandler handler)
{
this.HandlerInstance = handler;
}
public static IObservable <T> ObserveWith <T>(this IObservable <T> observable, IEventHandler <T> handler)
where T : IEvent
{
return(observable.SelectMany(async(message, cancellationToken) => {
await handler.HandleAsync(message, cancellationToken);
return message;
}));
}
/// <inheritdoc/>
public IDisposable Register <TEventData>(IEventHandler <TEventData> handler) where TEventData : IEventData
{
return(NullDisposable.Instance);
}
public override void ExecuteHandler(IEventHandler handler)
{
((IEventHandlerSCP914Activate)handler).OnSCP914Activate(this);
}
/// <summary>
/// Register a handler that will receive all messages that are published.
/// </summary>
/// <param name="handler">The handler to register.</param>
public ConfigNcqrs RegisterInProcessEventHandler <TEvent>(IEventHandler <TEvent> handler) where TEvent : IEvent
{
_inProcessEventBus.RegisterHandler(handler);
return(this);
}
public Sequence GetSequenceFor(IEventHandler <T> handler)
{
return(GetEventProcessorFor(handler).Sequence);
}
protected static void expect_stream_processor_state_with_failure(IEventHandler event_handler, failing_partitioned_state failing_partitioned_state)
=> expect_stream_processor_state_with_failure(
event_handler,
committed_events.Count,
failing_partitioned_state);
public void AddEventHandler(IEventHandler service)
{
_handlers.Add(service);
}
protected static void expect_stream_processor_state_without_failure(IEventHandler event_handler) => expect_stream_processor_state_with_failure(event_handler, null !);
public Task SubscribeAndConsume(string serverName, string subscriberGroup, string eventName, IEventHandler handler)
{
if (string.IsNullOrWhiteSpace(serverName))
{
throw new ArgumentNullException(nameof(serverName));
}
if (string.IsNullOrWhiteSpace(subscriberGroup))
{
throw new ArgumentNullException(nameof(subscriberGroup));
}
if (string.IsNullOrWhiteSpace(eventName))
{
throw new ArgumentNullException(nameof(eventName));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
CancellationTokenSource cts = new CancellationTokenSource();
_cancellationTokenSources.Add(cts);
return(Task.Factory.StartNew(() => {
using (Consumer <Null, string> consumer = new Consumer <Null, string>(GetConsumerConfig(serverName, subscriberGroup), null, new StringDeserializer(Encoding.UTF8)))
{
consumer.OnMessage += (sender, message) => {
handler.Handle(message.Value);
};
consumer.OnError += (sender, error) => {
_logger.LogCritical(error.Reason);
};
consumer.Subscribe(eventName);
while (true)
{
consumer.Poll(TimeSpan.FromSeconds(_options.ConsumerPollSeconds));
consumer.CommitAsync();
}
}
}, cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default));
}
protected static void expect_stream_definition(IEventHandler event_handler) => expect_stream_definition(event_handler, number_of_event_types);
/// <inheritdoc/>
public IDisposable Register(Type eventType, IEventHandler handler)
{
return(Register(eventType, new SingleInstanceHandlerFactory(handler)));
}
public void RemoveHandle(IEventHandler eventHandler)
{
_handlers.Remove(eventHandler.GetHandler());
}
/// <inheritdoc/>
public void Unregister <TEventData>(IEventHandler <TEventData> handler) where TEventData : IEventData
{
Unregister(typeof(TEventData), handler);
}
public void RegisterHandle(IEventHandler eventHandler)
{
_handlers.Add(eventHandler.GetHandler(), eventHandler);
}
/// <summary>
/// Releases handler object using Ioc container.
/// </summary>
/// <param name="handler">Handler to be released</param>
public void ReleaseHandler(IEventHandler handler)
{
iocResolver.Release(handler);
}
public EventProcessorFactory(Disruptor <TestEvent> disruptor, IEventHandler <TestEvent> eventHandler, int sequenceLength)
{
_disruptor = disruptor;
_eventHandler = eventHandler;
_sequenceLength = sequenceLength;
}
