/// <summary> /// Adds the specified <see cref="IEventSubscription"/> to the subscribers' collection. /// </summary> /// <param name="eventSubscription">The subscriber.</param> /// <returns>The <see cref="SubscriptionToken"/> that uniquely identifies every subscriber.</returns> /// <remarks> /// Adds the subscription to the internal list and assigns it a new <see cref="SubscriptionToken"/>. /// </remarks> protected virtual SubscriptionToken InternalSubscribe(IEventSubscription eventSubscription) { eventSubscription.SubscriptionToken = new SubscriptionToken(); lock (Subscriptions) { Subscriptions.Add(eventSubscription); } return eventSubscription.SubscriptionToken; }
/// <summary> /// Adds the specified <see cref="IEventSubscription"/> to the subscribers' collection. /// </summary> /// <param name="eventSubscription">The subscriber.</param> /// <returns>The <see cref="SubscriptionToken"/> that uniquely identifies every subscriber.</returns> /// <remarks> /// Adds the subscription to the internal list and assigns it a new <see cref="SubscriptionToken"/>. /// </remarks> protected virtual SubscriptionToken InternalSubscribe(IEventSubscription eventSubscription) { if (eventSubscription == null) throw new System.ArgumentNullException("eventSubscription"); eventSubscription.SubscriptionToken = new SubscriptionToken(); lock (Subscriptions) { Subscriptions.Add(eventSubscription); } return eventSubscription.SubscriptionToken; }
protected virtual SubscriptionToken Subscribe(IEventSubscription eventSubscription) { eventSubscription.SubscriptionToken = new SubscriptionToken(); lock (this._subscriptions) { this._subscriptions.Add(eventSubscription); } return eventSubscription.SubscriptionToken; }
/// <summary> /// Adds the specified <see cref="IEventSubscription"/> to the subscribers' collection. /// </summary> /// <param name="eventSubscription">The subscriber.</param> /// <returns>The <see cref="SubscriptionToken"/> that uniquely identifies every subscriber.</returns> /// <remarks> /// Adds the subscription to the internal list and assigns it a new <see cref="SubscriptionToken"/>. /// </remarks> protected virtual SubscriptionToken InternalSubscribe(IEventSubscription eventSubscription) { if (eventSubscription == null) throw new ArgumentNullException(nameof(eventSubscription)); eventSubscription.SubscriptionToken = new SubscriptionToken(Unsubscribe); lock (Subscriptions) { Subscriptions.Add(eventSubscription); } return eventSubscription.SubscriptionToken; }
public void AddSubscription(IEventSubscription sub) { // if the subscription is a wiretap, add it to a different list if (sub.IsWiretap()) { _wiretaps.Add(sub); return; } lock (_subscriptions) { if (false == _subscriptions.ContainsKey(sub.Topic)) { _subscriptions.Add(sub.Topic, new List<IEventSubscription>()); } _subscriptions[sub.Topic].Add(sub); } }
public void AddSubscription(IEventSubscription subscription) { List<IExchange> exchanges = new List<IExchange>(); if (subscription.IsWiretap()) { exchanges.AddRange(_exchangeLocator.GetAllExchanges()); } else { // find out which exchange we need to bind to exchanges.Add(_exchangeLocator.GetExchange(subscription.Topic)); } exchanges.ForEach(ex => { // now, get or declare the queue for this exchange IQueue queue = this.GetQueue(ex); // create a binding AmqpBinding binding = new AmqpBinding(ex, subscription.Topic); // add the binding to the queue if it doesn't already exist if (false == queue.ContainsBinding(binding)) { queue.AddBinding(binding); } // ensure an entry for this binding exists if (false == _bindingCount.ContainsKey(binding)) { _bindingCount.Add(binding, 0); } // finally, increment the count of subscriptions for this binding _bindingCount[binding]++; }); }
public async Task OnEventAsync(IEventSubscription subscription, StoredEvent storedEvent) { await eventSubscriber.OnEventAsync(subscription, storedEvent); }
void HandleOnJoin(IEventSubscription sub) { NotifyChannels(sub.Channels, "cmd.onJoin", sub.Meta); }
void HandleOnHeartbeat(IEventSubscription sub) { NotifyChannel(sub.Channel, "cmd.onHeartbeat", sub.Meta); }
public Task OnErrorAsync(IEventSubscription subscription, Exception exception) { throw exception; }
Task IEventSubscriber.OnEventAsync(IEventSubscription subscription, StoredEvent storedEvent) { return(dispatcher.DispatchAsync(() => HandleEventAsync(subscription, storedEvent))); }
public Task OnEventAsync(IEventSubscription subscription, StoredEvent storedEvent) { return(currentSubscriber !.OnEventAsync(subscription, storedEvent)); }
private void Unsubscribe() { currentSubscription?.StopAsync().Forget(); currentSubscription = null; }
private Task OnEventAsync(IEventSubscription subscriber, StoredEvent ev) { return(sutSubscriber.OnEventAsync(subscriber, ev)); }
public BatchSubscriber( EventConsumerGrain grain, IEventDataFormatter eventDataFormatter, IEventConsumer eventConsumer, Func <IEventSubscriber, IEventSubscription> factory, TaskScheduler scheduler) { var batchSize = Math.Max(1, eventConsumer !.BatchSize); var batchDelay = Math.Max(100, eventConsumer.BatchDelay); var parse = new TransformBlock <Job, Job>(job => { if (job.StoredEvent != null) { job.ShouldHandle = eventConsumer.Handles(job.StoredEvent); } if (job.ShouldHandle) { try { job.Event = eventDataFormatter.ParseIfKnown(job.StoredEvent !); } catch (Exception ex) { job.Exception = ex; } } return(job); }, new ExecutionDataflowBlockOptions { BoundedCapacity = batchSize, MaxDegreeOfParallelism = 1, MaxMessagesPerTask = 1 }); var buffer = AsyncHelper.CreateBatchBlock <Job>(batchSize, batchDelay, new GroupingDataflowBlockOptions { BoundedCapacity = batchSize * 2 }); var handle = new ActionBlock <IList <Job> >(async jobs => { var sender = eventSubscription?.Sender; foreach (var jobsBySender in jobs.GroupBy(x => x.Sender)) { if (sender != null && ReferenceEquals(jobsBySender.Key, sender)) { var exception = jobs.FirstOrDefault(x => x.Exception != null)?.Exception; if (exception != null) { await grain.OnErrorAsync(sender, exception); } else { await grain.OnEventsAsync(sender, GetEvents(jobsBySender), GetPosition(jobsBySender)); } } } }, new ExecutionDataflowBlockOptions { BoundedCapacity = 2, MaxDegreeOfParallelism = 1, MaxMessagesPerTask = 1, TaskScheduler = scheduler }); parse.LinkTo(buffer, new DataflowLinkOptions { PropagateCompletion = true }); buffer.LinkTo(handle, new DataflowLinkOptions { PropagateCompletion = true }); pipelineStart = parse; pipelineEnd = handle; eventSubscription = factory(this); }
private Task OnErrorAsync(IEventSubscription subscriber, Exception ex) { return(sutSubscriber.OnErrorAsync(subscriber, ex)); }
public SubscriptionToken Subscribe(IEventSubscription subscription) { return(base.InternalSubscribe(subscription)); }
protected EventHandlerBase(IEventSubscription subscription, long id) { Subscription = subscription; Id = id; }
void HandleOnHeartbeat(IEventSubscription sub) { NotifySubscription(sub.SubscriptionId, "cmd.onHeartbeat", sub.Meta); }
public new SubscriptionToken Subscribe(IEventSubscription eventSubscription) { return(base.Subscribe(eventSubscription)); }
public Task OnErrorAsync(IEventSubscription subscription, Exception exception) { throw new NotSupportedException(); }
public static bool HasChannel(this IEventSubscription sub, string channel) { return(sub != null && (channel == null || Array.IndexOf(sub.Channels, channel) >= 0)); }
public GetTransactionEventHandler(IEventSubscription subscription, long id, IEthGetTransactionByHash proxy) : base(subscription, id) { GetTransactionProxy = proxy; }
Task IEventSubscriber.OnErrorAsync(IEventSubscription subscription, Exception exception) { return(dispatcher.DispatchAsync(() => HandleErrorAsync(subscription, exception))); }
public EventRegistration(Type handlerType, IEventSubscription eventSubscription) { HandlerType = handlerType; EventSubscription = eventSubscription; }
public Task OnErrorAsync(IEventSubscription subscription, Exception exception) { return(currentSubscriber !.OnErrorAsync(subscription, exception)); }
public void RemoveSubscription(IEventSubscription subscription) { // the exchange to which this subscription refers IExchange exchange = _exchangeLocator.GetExchange(subscription.Topic); // get the queue that is bound to the exchange IQueue queue = this.GetQueue(exchange); // create a binding AmqpBinding binding = new AmqpBinding(exchange, subscription.Topic); // don't assume that a binding exists if (_bindingCount.ContainsKey(binding)) { // decrement the count of bindings _bindingCount[binding]--; if (0 == _bindingCount[binding]) { // since there are no more subscriptions for this binding, // we should actually remove the binding from the queue. queue.RemoveBinding(binding); } } }
public void RemoveSubscription(IEventSubscription sub) { // if the subscription is a wiretap, remove it from a different list if (sub.IsWiretap()) { _wiretaps.Remove(sub); return; } lock (_subscriptions) { if (_subscriptions.ContainsKey(sub.Topic)) { if (_subscriptions[sub.Topic].Contains(sub)) { _subscriptions[sub.Topic].Remove(sub); } } } }
private Task OnErrorAsync(IEventSubscription subscription, Exception exception) { return(sut.OnErrorAsync(subscription, exception)); }
public void when() { subscription = EventBus.Subscribe<EventMessage>(new SimpleSubscriber()); }
private void SetStateValues(IEventSubscription subscription, DecodedEvent decodedEvent) { subscription.State.Increment("EventsHandled"); decodedEvent.State["SubscriberId"] = subscription.SubscriberId; decodedEvent.State["EventSubscriptionId"] = subscription.Id; }
void HandleOnUpdate(IEventSubscription sub) { using (var redis = clientsManager.GetClient()) { StoreSubscriptionInfo(redis, sub.GetInfo()); } NotifyChannels(sub.Channels, "cmd.onUpdate", sub.Meta); }
public void given() { subscription = EventBus.Subscribe<EventMessage>(_ => notified = true); }
public new SubscriptionToken Subscribe(IEventSubscription eventSubscription) { return base.Subscribe(eventSubscription); }
public void given() { subscription = EventBus.Subscribe<EventMessage>(subscriber); }
public void when() { subscription = EventBus.Subscribe<EventMessage>(_ => { }); }
/// <summary> /// Unsubscribes from a specific event. /// </summary> /// <param name="domainRelationshipInfo">DomainRelationshipInfo specifying from what to unsubscribe.</param> /// <param name="parentElementId">Parent element Id specifying from what to unsubscribe.</param> /// <param name="action">Action identifying what to unsubscribe.</param> public void Unsubscribe(DomainRelationshipInfo domainRelationshipInfo, bool bSourceRole, Guid parentElementId, Action <ElementAddedEventArgs> action) { #region dictionarySource if (bSourceRole) { lock (dictionarySource) { Guid domainClassId = domainRelationshipInfo.Id; if (dictionarySource.Keys.Contains(domainClassId)) { if (dictionarySource[domainClassId].Keys.Contains(parentElementId)) { IEventSubscription eventSubscription = dictionarySource[domainClassId][parentElementId].Cast <EventSubscription <ElementAddedEventArgs> >().FirstOrDefault(evt => evt.Action == action); if (eventSubscription != null) { dictionarySource[domainClassId][parentElementId].Remove(eventSubscription); if (dictionarySource[domainClassId][parentElementId].Count == 0) { dictionarySource[domainClassId].Remove(parentElementId); } } if (dictionarySource[domainClassId].Count == 0) { dictionarySource.Remove(domainClassId); } } } // process descendants foreach (DomainRelationshipInfo info in domainRelationshipInfo.AllDescendants) { domainClassId = info.Id; if (dictionarySource.Keys.Contains(domainClassId)) { if (dictionarySource[domainClassId].Keys.Contains(parentElementId)) { IEventSubscription eventSubscription = dictionarySource[domainClassId][parentElementId].Cast <EventSubscription <ElementAddedEventArgs> >().FirstOrDefault(evt => evt.Action == action); if (eventSubscription != null) { dictionarySource[domainClassId][parentElementId].Remove(eventSubscription); if (dictionarySource[domainClassId][parentElementId].Count == 0) { dictionarySource[domainClassId].Remove(parentElementId); } } if (dictionarySource[domainClassId].Count == 0) { dictionarySource.Remove(domainClassId); } } } } } } #endregion #region dictionaryTarget if (!bSourceRole) { lock (dictionaryTarget) { Guid domainClassId = domainRelationshipInfo.Id; if (dictionaryTarget.Keys.Contains(domainClassId)) { if (dictionaryTarget[domainClassId].Keys.Contains(parentElementId)) { IEventSubscription eventSubscription = dictionaryTarget[domainClassId][parentElementId].Cast <EventSubscription <ElementAddedEventArgs> >().FirstOrDefault(evt => evt.Action == action); if (eventSubscription != null) { dictionaryTarget[domainClassId][parentElementId].Remove(eventSubscription); if (dictionaryTarget[domainClassId][parentElementId].Count == 0) { dictionaryTarget[domainClassId].Remove(parentElementId); } } if (dictionaryTarget[domainClassId].Count == 0) { dictionaryTarget.Remove(domainClassId); } } } // process descendants foreach (DomainRelationshipInfo info in domainRelationshipInfo.AllDescendants) { domainClassId = info.Id; if (dictionaryTarget.Keys.Contains(domainClassId)) { if (dictionaryTarget[domainClassId].Keys.Contains(parentElementId)) { IEventSubscription eventSubscription = dictionaryTarget[domainClassId][parentElementId].Cast <EventSubscription <ElementAddedEventArgs> >().FirstOrDefault(evt => evt.Action == action); if (eventSubscription != null) { dictionaryTarget[domainClassId][parentElementId].Remove(eventSubscription); if (dictionaryTarget[domainClassId][parentElementId].Count == 0) { dictionaryTarget[domainClassId].Remove(parentElementId); } } if (dictionaryTarget[domainClassId].Count == 0) { dictionaryTarget.Remove(domainClassId); } } } } } } #endregion }
public SubscriptionToken Subscribe(IEventSubscription subscription) { return base.InternalSubscribe(subscription); }
private Task OnErrorAsync(IEventSubscription subscriber, Exception ex) { return(sut.OnErrorAsync(subscriber.AsImmutable(), ex.AsImmutable())); }
void HandleOnLeave(IEventSubscription sub) { var info = sub.GetInfo(); RemoveSubscriptionFromRedis(info); NotifyChannels(sub.Channels, "cmd.onLeave", sub.Meta); }
private Task OnEventAsync(IEventSubscription subscriber, StoredEvent ev) { return(sut.OnEventAsync(subscriber.AsImmutable(), ev.AsImmutable())); }
public void Register(IEventSubscription sub, Dictionary<string, string> connectArgs = null) { if (sub == null) throw new ArgumentNullException("subscription"); var info = sub.GetInfo(); using (var redis = clientsManager.GetClient()) { StoreSubscriptionInfo(redis, info); } if (connectArgs != null) sub.Publish("cmd.onConnect", connectArgs.ToJson()); local.Register(sub); }
private static async Task WaitAndStopAsync(IEventSubscription sut) { await Task.Delay(200); await sut.StopAsync(); }