private void Dropped(EventStoreCatchUpSubscription sub,SubscriptionDropReason reason,Exception ex) { //Reconnect if we drop //TODO: check the reason and handle it appropriately _view.ErrorMsg = "Subscription Dropped, press Enter to reconnect"; Subscribe(); }
void EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent evnt) { if (evnt.OriginalStreamId.StartsWith("$")) return; dynamic ev = _adapter.TryGetDomainEvent(evnt); if (ev == null) return; try { lock (this) { Dispatch(ev); _succeded++; _checkPoint = evnt.OriginalPosition.GetValueOrDefault(); _lastEventNumber = evnt.OriginalEventNumber; if(ev.Timestamp > LastUpdate) LastUpdate = ev.Timestamp; } } catch (Exception) { Debugger.Break(); } }
private void GotEvent(EventStoreCatchUpSubscription sub, ResolvedEvent evt) { try { //create local copies of state variables var total = _total; var checkpoint = evt.Event.EventNumber; var amount = (string)JObject.Parse(Encoding.UTF8.GetString(evt.Event.Data))["amount"]; switch (evt.Event.EventType.ToUpperInvariant()) { case "CREDIT": total += int.Parse(amount); break; case "DEBIT": total -= int.Parse(amount); break; default: throw new Exception("Unknown Event Type"); } File.WriteAllText(_localFile, checkpoint + "," + total); //Update the common state after commit to disk _total = total; Checkpoint = checkpoint; } catch (Exception ex) { _view.ErrorMsg = "Event Exception: " + ex.Message; } //repaint screen _view.Total = _total; }
private void ProcessEvent(EventStoreCatchUpSubscription subscribtion, ResolvedEvent resolvedEvent) { var alarm = resolvedEvent.ParseJson<IrresponsibleGamblerDetected>(); Publish(alarm); StoreCheckpoint(resolvedEvent); }
private void HandleNewEvent(EventStoreCatchUpSubscription subscription, ResolvedEvent @event) { // make sure the event fits the ones this handler cares about if (!_eventFilter(@event)) { return; } var _event = ProcessRawEvent(@event); // filter for null event ( didn't have metadata or data ) if (_event == null) { return; } HandleEvent(_event); }
public void Stop() { HasLoaded = false; try { _subscription.Stop(TimeSpan.MaxValue); _subscription = null; _connection.Dispose(); } catch { } }
private static void Appeared(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent) { if (resolvedEvent.Event.EventType.Contains("Question") || resolvedEvent.Event.EventType.Contains("Answer")) { Console.WriteLine("Read event {0} with data: {1}", resolvedEvent.Event.EventType, Encoding.UTF8.GetString(resolvedEvent.Event.Data)); var @event = EventDeserializer.Deserialize(resolvedEvent.Event.EventType, Encoding.UTF8.GetString(resolvedEvent.Event.Data)); _eventPublisher.Publish(@event); } }
public void Start() { HasLoaded = false; _connection = EventStore.ClientAPI.EventStoreConnection.Create(_endpoint); var ct = _connection.ConnectAsync(); ct.Wait(); _checkPoint = Position.Start; if (string.IsNullOrEmpty(_streamName)) _subscription = _connection.SubscribeToAllFrom(_checkPoint, false, EventAppeared, Live, SubscriptionDropped, _credentials); else _subscription = _connection.SubscribeToStreamFrom(_streamName, _lastEventNumber, true, EventAppeared, Live, SubscriptionDropped, _credentials); }
private void EventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent re) { if (re.OriginalEvent.EventType.StartsWith("$")) return; //skip internal events if (re.OriginalEvent.Metadata == null || re.OriginalEvent.Metadata.Any() == false) return; try { var e = re.DeserializeEvent(); Dispatch(e).Wait(); } catch (Exception exception) { _log.Error(string.Format("Could not deserialize event {0}", re.OriginalEvent.EventType), exception); } }
public void OnEventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent, Action<object,DateTime> callback) { var type = _typeLocator.Locate(resolvedEvent.Event.EventType); if (null == type) { _logger.LogDebug("[{0}] unknown type", _streamName); return; } callback( JsonConvert.DeserializeObject( Encoding.UTF8.GetString(resolvedEvent.Event.Data), type ), resolvedEvent.Event.Created ); }
private static void Live(EventStoreCatchUpSubscription obj) { mre.Set(); }
private static void Dropped(EventStoreCatchUpSubscription arg1, SubscriptionDropReason arg2, Exception arg3) { }
private void OnSubscriptionDropped(EventStoreCatchUpSubscription subscription, SubscriptionDropReason reason, Exception exception) { _log.Error(string.Format("Event subscription stopped. Reason: {0}", reason), exception); }
private void SubscriptionDropped(EventStoreCatchUpSubscription eventStoreCatchUpSubscription, SubscriptionDropReason subscriptionDropReason, Exception ex) { if (ex != null) { _logger.Info(ex, "Event Store subscription dropped {0}", subscriptionDropReason.ToString()); } else { _logger.Info("Event Store subscription dropped {0}", subscriptionDropReason.ToString()); } _viewModelIsReady = false; lock (_liveProcessingTimer) { if(!_liveProcessingTimer.Enabled) _liveProcessingTimer.Start(); } }
private void EventAppeared(EventStoreCatchUpSubscription _, ResolvedEvent resolvedEvent) { if(resolvedEvent.OriginalEvent.EventType.StartsWith("$") || resolvedEvent.OriginalStreamId.StartsWith("$")) { return; } _queue.Enqueue(resolvedEvent); }
private void OnLiveProcessingStarted(EventStoreCatchUpSubscription subscription) { _log.Debug("Live processing of events started"); }
public void Dispose() { if (_isDisposed.EnsureCalledOnce()) { return; } _disposed.Cancel(); _projectedEvents.Dispose(); if(_subscription != null) { _subscription.Stop(); _subscription = null; } }
private static void Dropped(EventStoreCatchUpSubscription subscription, SubscriptionDropReason subscriptionDropReason, Exception exception) { }
private void HandleSubscriptionDropped(EventStoreCatchUpSubscription subscription, SubscriptionDropReason reason, Exception ex) { }
private async Task RecoverSubscription() { var checkpointToken = await _checkpoints.Get(); _subscription = _streamId == null ? SubscribeToAllFrom(checkpointToken.ParsePosition()) : SubscribeToStreamFrom(checkpointToken == null ? default(int?) : int.Parse(checkpointToken)); }
/// <inheritdoc /> protected override async Task LiveProcessingStarted(EventStoreCatchUpSubscription eventStoreCatchUpSubscription, Position lastPosition) { await CheckpointReachedAction(lastPosition).ConfigureAwait(false); }
/// <summary> /// The callback invoked when the subscription switches to push notifications. /// </summary> /// <param name="eventStoreCatchUpSubscription"></param> /// <param name="lastPosition"></param> /// <returns></returns> protected abstract Task LiveProcessingStarted(EventStoreCatchUpSubscription eventStoreCatchUpSubscription, Position lastPosition);
/// <inheritdoc /> protected override Task LiveProcessingStarted(EventStoreCatchUpSubscription eventStoreCatchUpSubscription, Position lastPosition) { return(TaskEx.CompletedTask); }
private static void Appeared(EventStoreCatchUpSubscription arg1, ResolvedEvent evnt) { _adapter.TryGetDomainEvent(evnt); count++; if(count % 1000 == 0) Console.WriteLine("{0}", count); //events.Add(arg2); }
private void EventAppeared(EventStoreCatchUpSubscription eventStoreCatchUpSubscription, ResolvedEvent resolvedEvent) { _queue.Add(resolvedEvent); }
private void LiveProcessingStarted(EventStoreCatchUpSubscription eventStoreCatchUpSubscription) { lock (_liveProcessingTimer) { _liveProcessingTimer.Stop(); } _logger.Info("Live event processing started"); _viewModelIsReady = true; }
public void Start() { _subscription = _connection.SubscribeToStreamFrom(_streamName, _startingPosition.HasValue ? (int?)_startingPosition.Value : null, true, EventAppeared, LiveProcessingStarted, SubscriptionDropped, readBatchSize: _catchupPageSize); Thread processor = new Thread(ProcessEvents); processor.Start(); }
private void HandleEvent(EventStoreCatchUpSubscription sub, ResolvedEvent evt) { if (evt.Event.EventType.StartsWith("$")) return; Debug.WriteLine("Handling event: {1} {0}", evt.Event.EventStreamId, evt.Event.EventNumber); var deserializedEvent = _serializer.Deserialize(evt.Event); var orderStatusbuilder = new RavenViewModelBuilder<OrderStatusModel>(_store, new OrderStatusModelHandler(), _updateNotifier); orderStatusbuilder.Build(evt.Event.EventStreamId, new[] { deserializedEvent }); var orderItemsBuilder = new RavenViewModelBuilder<OrderItemsModel>(_store, new OrderItemsModelHandler(), _updateNotifier); orderItemsBuilder.Build(evt.Event.EventStreamId, new[] { deserializedEvent }); using (var session = _store.OpenSession()) { StoreViewBuilderData(evt, session); StoreCommandData(evt, deserializedEvent, session); session.SaveChanges(); } }
private void SubscriptionDropped(EventStoreCatchUpSubscription _, SubscriptionDropReason reason, Exception ex) { if(reason == SubscriptionDropReason.UserInitiated) { return; } RecoverSubscription().Wait(TimeSpan.FromSeconds(2)); }
//ActorRef GetRef(string id) //{ // return new ActorRef(id); //} void EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent evnt) { //evnt.Event.Data Message msg = null; var worker = FindWorker(msg.ActorId); worker.Dispatch(msg); }
public void OnLiveProcessingStarted(EventStoreCatchUpSubscription subscription) { _logger.LogDebug("[{0}] in sync", _streamName); }
private void HandleEvent(EventStoreCatchUpSubscription arg1, ResolvedEvent arg2) { var @event = EventSerialization.DeserializeEvent(arg2.OriginalEvent); if (@event != null) { var eventType = @event.GetType(); if (_eventHandlerMapping.ContainsKey(eventType)) { _eventHandlerMapping[eventType](@event); } } _latestPosition = arg2.OriginalPosition; }
public void OnSubscriptionDropped(EventStoreCatchUpSubscription subscription, SubscriptionDropReason reason, Exception error) { _logger.LogCritical("Catch up on {0} failure: {1}", _streamName, error.ToString()); }