private void Connect() { var position = GetLastCheckpoint(CheckpointStream); _eventStoreConnection.SubscribeToStreamFrom(AlarmStream, position, true, ProcessEvent, userCredentials: EventStoreCredentials.Default, subscriptionDropped: TryToReconnect); }
public IDisposable Subscribe(IObserver <T> observer) { _subscription = _connection.SubscribeToStreamFrom(_stream, _lastCheckpoint, _resolveLinkTos, EventAppeared, subscriptionDropped: SubscriptionDropped); _observer = observer; return(Disposable.Create(Stop)); }
public void Init() { _logger.LogDebug("--------------- SUBSCRIBE -----------------\nVersion: {0}\nStreamName: {1}\nCatchupPosition: {2}\n--------------- SUBSCRIBE -----------------", Version, GetStreamName(), GetCatchupPosition()); _eventStoreConnection.SubscribeToStreamFrom( GetStreamName(), GetCatchupPosition(), CatchUpSubscriptionSettings.Default, (subscription, @event) => { _logger.LogDebug("++++++++ NEW EVENT ++++++++\n{0}\n++++++++ NEW EVENT ++++++++", @event.Event.EventType); var methodToInvoke = GetType() .GetMethod("ApplyEvent", new[] { Type.GetType(@event.Event.EventType) }); if (methodToInvoke == null) { _logger.LogError($"The view normalizer doesnt know how to handle this event: {@event.Event.EventType}"); throw new InvalidOperationException($"The view normalizer doesnt know how to handle this event: {@event.Event.EventType}"); } Version++; // bump up read model version methodToInvoke.Invoke(this, new object[] { @event.Event.ToDomainEvent() }); }); }
private void SetupSubscription(IComponentContext c, IEventStoreConnection esConnection) { var freshContext = c.Resolve <IComponentContext>(); long? lastPosition; string stream = "nalozi"; using (var scope = freshContext.Resolve <ILifetimeScope>().BeginLifetimeScope()) { var processedRepo = scope.Resolve <IProcessedEventRepository>(); var lastEvent = processedRepo.GetLastProcessed(stream); lastPosition = lastEvent?.Checkpoint; } var options = freshContext.Resolve <IOptions <AppSettings> >(); var catchUpSettings = new CatchUpSubscriptionSettings(options.Value.EventStoreMaxQueueSize, options.Value.EventStoreReadBatchSize, true, true); esConnection.SubscribeToStreamFrom(stream, lastPosition, catchUpSettings, eventAppeared: async(s, e) => { using (var scope = freshContext.Resolve <ILifetimeScope>().BeginLifetimeScope()) { var eventHandler = scope.Resolve <Persistence.IEventHandler>(); await eventHandler.HandleAsync(e); } }, liveProcessingStarted: null, subscriptionDropped: (sub, reason, exc) => { sub.Stop(); var conn = freshContext.Resolve <IEventStoreConnection>(); SetupSubscription(freshContext, conn); }, userCredentials: new UserCredentials(options.Value.EVENTSTORE_USERNAME, options.Value.EVENTSTORE_PASSWORD)); }
public IJournalSubscription Subscribe(long from, Action <JournalRecord> handler) { long?checkPoint = null; if (from > 0) { checkPoint = from - 1; } var ready = false; var sub = _connection.SubscribeToStreamFrom( stream: _streamName, lastCheckpoint: checkPoint, settings: new CatchUpSubscriptionSettings(10000, 4096, false, false), eventAppeared: (s, re) => { _logger.Debug("eventAppeared, recordNumber {0}", re.OriginalEventNumber); handler.Invoke(re.Event.ToJournalRecord(_serializer)); }, liveProcessingStarted: s => { ready = true; _logger.Info("liveProcessingStarted"); }); return(new EventStoreSubscriptionAdapter(_settings, sub, () => ready)); }
private void SubscribeInternal(IEventStoreConnection src, UserCredentials cred) { long?lastCheckpoint = null; if (Status.LastCheckPoint.HasValue && Status.LastCheckPoint != -1) { lastCheckpoint = Status.LastCheckPoint; } // if (_useQueue) // { // _logger.LogDebug("Start Working in Queue"); // await Queue.StartWorkingAsync(HandleAsync, cancellationToken: _cancellationToken).ConfigureAwait(false); // } var sub = src.SubscribeToStreamFrom(StreamName, lastCheckpoint, CatchUpSubscriptionSettings.Default, EventAppeared, LiveProcessingStarted, SubscriptionDropped, cred); _cancellationToken.Register(sub.Stop); }
/// <summary> /// Creates the Subscription with EventStore. /// </summary> /// <param name="streamName">The name of the EventStore Stream we are subscribing to.</param> /// <param name="eventStoreStreamSequenceToken"></param> /// <returns>An EventStoreSubscription or EventStorePersistentSubscription.</returns> private object CreateEventStoreSubscription(string streamName, EventStoreStreamSequenceToken eventStoreStreamSequenceToken) { object subscription = null; if (eventStoreStreamSequenceToken == null || eventStoreStreamSequenceToken.EventNumber == int.MinValue) { var subscribeTask = m_EventStoreConnection.SubscribeToStreamAsync(streamName, true, EventAppeared, SubscriptionDropped); Task.WaitAll(subscribeTask); if (subscribeTask.IsFaulted) { throw subscribeTask.Exception; } subscription = subscribeTask.Result; } else { // If we have been provided with a StreamSequenceToken, we can call SubscribeFrom to get previous messages. subscription = m_EventStoreConnection.SubscribeToStreamFrom(streamName, eventStoreStreamSequenceToken.EventNumber, new CatchUpSubscriptionSettings(100, 20, false, true), EventAppeared); } m_Logger.Info($"Subscribed to Stream {streamName}"); return(subscription); }
public IObservable <OccuredEvent> Start(long?position) { eventSub?.Dispose(); eventSub = new Subject <OccuredEvent>(); activeSub = connection.SubscribeToStreamFrom(StreamName, position, settings, Handle); return(eventSub); }
public void SubscribeToCatchupStream(string streamName, Action <EventstoreEvent> eventHandler) { _connection.SubscribeToStreamFrom(streamName, null, new CatchUpSubscriptionSettings(1, 1, false, false), (subscription, receivedEvent) => eventHandler(MapEventstoreEvent(receivedEvent)), subscription => {}, (subscription, reason, arg3) => CatchupSubscriptionDropped(subscription, reason, arg3, streamName, eventHandler), _userCredentials); }
public EventStoreStreamCatchUpSubscription(IEventStoreConnection connection, string streamName, Action <IEvent> handler) { _handler = handler; _subscription = connection.SubscribeToStreamFrom( streamName, null, // don't use StreamPosition.Start (see https://groups.google.com/forum/#!topic/event-store/8tpXJMNEMqI), CatchUpSubscriptionSettings.Default, OnEventAppeared); }
public async Task Start(long fromCheckpoint) { Connection = EventStoreConnection.Create(ESConnectionConfig.ConnectionString); Connection.Connected += Connection_Connected; await Connection.ConnectAsync().ConfigureAwait(false); long?eventstoreCheckpoint = (fromCheckpoint == 0) ? null : (long?)(fromCheckpoint - 1); Subscription = Connection.SubscribeToStreamFrom(StreamName, eventstoreCheckpoint, CatchUpSubscriptionSettings.Default, EventAppeared, LiveProcessingStarted, SubscriptionDropped); }
private void SubscribeToStream() { eventStoreSubscription = connection.SubscribeToStreamFrom( streamId, position == 0 ? (long?)null : position, CatchUpSubscriptionSettings.Default, EventAppeared, _ => liveProcessingStarted(position) ); }
public void Run() { connection.ConnectAsync() .Wait(); connection.SubscribeToStreamFrom( "Employee", 0L, Settings, (subscription, evt) => processor.ProcessEvent(evt)); }
private void SubscribeToStream(IEventStoreConnection connection) { if (_subscription != null) { _subscription.Stop(); _subscription = null; } _subscription = connection.SubscribeToStreamFrom(_streamName, _checkpoint, CatchUpSubscriptionSettings.Default, EventAppeared, LiveProcessingStarted, SubscriptionDropped); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var settings = new CatchUpSubscriptionSettings(100, 100, false, true); var subscription = _connection.SubscribeToStreamFrom(EvelynEvents, null, settings, OnEventAppeared, OnLiveProcessingStarted, OnSubscriptionDropped); while (!stoppingToken.IsCancellationRequested) { await Task.Delay(TimeSpan.FromSeconds(1), stoppingToken); } subscription.Stop(); }
public void Start() { if (subscriber != null) { logger.LogError("Subscriber already started"); } Task convertAndPlayEvent(EventStoreCatchUpSubscription sub, ResolvedEvent storeEvent) => playEvent(ToEvent(storeEvent)); void logStart(EventStoreCatchUpSubscription sub) => LiveProcessingStarted(sub, DateTime.Now); this.subscriber = connection.SubscribeToStreamFrom(CategoryStreamName, StreamPosition.Start, CatchUpSubscriptionSettings.Default, convertAndPlayEvent, logStart, SubscriptionDropped); }
static void MeasureLines(IEventStoreConnection con, UserCredentials credentials) { var stream = "lines_of_Budgets-a208105f_d5ba_475e_bb23_e7012945d332"; var w = Stopwatch.StartNew(); var sub = con.SubscribeToStreamFrom(stream, null, true, Appeared, Live, null, userCredentials); mre.WaitOne(); w.Stop(); Console.WriteLine("read {0} events, in {1}. {2}", count, w.Elapsed, count / w.Elapsed.TotalSeconds); Console.ReadLine(); }
static void MeasureLines(IEventStoreConnection con, UserCredentials credentials) { var stream = "lines_of_Budgets-a208105f_d5ba_475e_bb23_e7012945d332"; var w = Stopwatch.StartNew(); var sub = con.SubscribeToStreamFrom(stream, null, true, Appeared, Live, null, userCredentials); mre.WaitOne(); w.Stop(); Console.WriteLine("read {0} events, in {1}. {2}", count, w.Elapsed, count / w.Elapsed.TotalSeconds); Console.ReadLine(); }
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 async Task SubscribeProjection(IEventStoreProjection currentEventStoreProjection, AppFunc chain, IDictionary <string, object> environment) { environment.Log("Subscribing projection: {0}", LogLevel.Debug, currentEventStoreProjection.ProjectionName); var bufferSettings = environment.GetSettings <ProjectionSettings>().GetBufferSettings(); while (true) { if (!running) { return; } if (_projectionSubscriptions.ContainsKey(currentEventStoreProjection.ProjectionName)) { _projectionSubscriptions[currentEventStoreProjection.ProjectionName].Close(); _projectionSubscriptions.Remove(currentEventStoreProjection.ProjectionName); } try { var eventNumberManager = environment.Resolve <IManageEventNumbersForProjections>(); var messageProcessor = new MessageProcessor(); var messageSubscription = Observable .FromEvent <DeSerializationResult>(x => messageProcessor.MessageArrived += x, x => messageProcessor.MessageArrived -= x) .Buffer(TimeSpan.FromSeconds(bufferSettings.Seconds), bufferSettings.NumberOfEvents) .Subscribe(async x => await PushEventsToProjections(chain, currentEventStoreProjection, x, environment).ConfigureAwait(false)); var eventStoreSubscription = _eventStoreConnection.SubscribeToStreamFrom(currentEventStoreProjection.ProjectionName, await eventNumberManager.GetLastEvent(currentEventStoreProjection.ProjectionName, environment).ConfigureAwait(false), CatchUpSubscriptionSettings.Default, (subscription, evnt) => messageProcessor.OnMessageArrived(_eventSerialization.DeSerialize(evnt)), subscriptionDropped: async(subscription, reason, exception) => await SubscriptionDropped(chain, currentEventStoreProjection, reason, exception, environment).ConfigureAwait(false)); _projectionSubscriptions[currentEventStoreProjection.ProjectionName] = new ProjectionSubscription(messageSubscription, eventStoreSubscription); return; } catch (Exception ex) { if (!running) { return; } environment.Log(ex, "Couldn't subscribe projection: {0}. Retrying in 5 seconds.", LogLevel.Warn, currentEventStoreProjection.ProjectionName); await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false); } } }
public void Run_PassesEventsToProcessor() { sut.Run(); A.CallTo(() => connection.ConnectAsync()).MustHaveHappened() .Then(A.CallTo(() => connection.SubscribeToStreamFrom( "Employee", 0L, sut.Settings, A <Func <EventStoreCatchUpSubscription, ResolvedEvent, Task> > ._, null, null, null)).MustHaveHappened()); }
public void Subscribe(IActorRef subscriber, string stream, long?from, int max, Func <ResolvedEvent, object> resolved) { if (!_subscriptions.TryGetValue(subscriber, out var subscriptions)) { subscriptions = new HashSet <EventStoreCatchUpSubscription>(); _subscriptions.Add(subscriber, subscriptions); _context.WatchWith(subscriber, new Unsubscribe(stream, subscriber)); } try { // need to have this since ES Catchup Subscription needs null for from when user wants to // read from begging of the stream long?nullable = null; var self = _context.Self; var subscription = _conn.SubscribeToStreamFrom( stream, from.HasValue && from.Value == 0 ? nullable : from, new CatchUpSubscriptionSettings(max * 2, 500, false, true), (sub, @event) => { var p = resolved(@event); if (p != null) { subscriber.Tell(p, self); } }, _ => subscriber.Tell(CaughtUp.Instance, self), (_, reason, exception) => { var msg = $"Subscription dropped due reason {reason.ToString()}"; subscriber.Tell(new SubscriptionDroppedException(msg, exception), self); }); subscriptions.Add(subscription); } catch (Exception) { if (subscriptions.Count == 0) { _context.Unwatch(subscriber); } throw; } }
/// <summary> /// subscribe to a stream and count the events in it /// </summary> /// <param name="connection"></param> /// <param name="configuration"></param> /// <returns></returns> private async Task <TestResult> CountEvents(IEventStoreConnection connection, EventStoreConnectionConfiguration configuration) { _output.WriteLine($"Counting all Events in Stream '{configuration.Stream}'", 1); var startTime = DateTime.Now; var stopTime = DateTime.Now; // subscribe to the stream to count the number of events contained in it connection.SubscribeToStreamFrom(configuration.Stream, StreamCheckpoint.StreamStart, new CatchUpSubscriptionSettings(128, 256, false, true, "ConfigService.CLI.ConnectionTest"), (subscription, @event) => { _countedEvents += 1; }, subscription => { _output.WriteLine($"Subscription to '{subscription.SubscriptionName}' opened", 1); stopTime = DateTime.Now; _liveProcessingEvents = true; }, (subscription, reason, exception) => { _output.WriteLine( $"Subscription to '{subscription.SubscriptionName}' dropped: " + $"{reason}; {exception.GetType().Name} {exception.Message}", 1); stopTime = DateTime.Now; _subscriptionDropped = true; }); do { await Task.Delay(TimeSpan.FromSeconds(1)); } while (!_liveProcessingEvents && !_subscriptionDropped); if (_subscriptionDropped) { _output.WriteLine($"Counted '{_countedEvents}' events in {FormatTime(stopTime - startTime)} before Subscription was dropped", 1); return(new TestResult { Result = false, Message = "Subscription was dropped" }); } _output.WriteLine($"Counted '{_countedEvents}' events in {FormatTime(stopTime - startTime)}", 1); return(new TestResult { Result = true, Message = string.Empty }); }
/// <summary> /// Initializes the in-memory names list with all names that exist in the "FullName" events category and /// sets up the service to subscribe to all future FullName events to update the names list. /// </summary> public static async Task <bool> Init(IEventStoreConnection eventStoreConnection, INameProjector nameProjector) { _connection = eventStoreConnection; _modelProjector = nameProjector; _names = new ConcurrentDictionary <string, NameDTO>(); _nameIds = new ConcurrentBag <string>(); // Subscribe to the FullName category event stream for all events now and in the future var eventStreamName = "$ce-FullName"; var catchupSettings = new CatchUpSubscriptionSettings(4096, 4096, true, true); _connection.SubscribeToStreamFrom(eventStreamName, null, catchupSettings, HandleEventFromSubscription, null, ReconnectToStreamSubscription); return(true); }
public void CatchupSubscriptionToStreamHandlesManyEventsWithSmallBatchSize() { var mre = new ManualResetEvent(false); _conn.SubscribeToStreamFrom(_streamName, null, _settings, (sub, evnt) => { if (evnt.OriginalEventNumber % 1000 == 0) { Console.WriteLine("Processed {0} events", evnt.OriginalEventNumber); } }, (sub) => { mre.Set(); }, null, new UserCredentials("admin", "changeit")); if (!mre.WaitOne(TimeSpan.FromMinutes(10))) { Assert.Fail("Timed out waiting for test to complete"); } }
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); } }
public async Task StartAsync(CancellationToken cancellationToken) { var topicsLastCheckpoint = await _checkpointRepository.GetAsync("groups"); var settings = new CatchUpSubscriptionSettings( maxLiveQueueSize: 10000, readBatchSize: 500, verboseLogging: false, resolveLinkTos: false, subscriptionName: "Events-Groups"); _subscription = _eventStore.SubscribeToStreamFrom( stream: "Groups", lastCheckpoint: topicsLastCheckpoint?.PreparePosition, settings: settings, eventAppeared: async(sub, @event) => { if (@event.OriginalEvent.EventType.StartsWith("$")) { return; } try { await _mediator.Publish(new Notification { Event = JsonSerializer.Deserialize(Encoding.UTF8.GetString(@event.OriginalEvent.Data), Type.GetType(Encoding.UTF8.GetString(@event.OriginalEvent.Metadata))) }); await _checkpointRepository.SaveAsync("groups", @event.OriginalPosition.GetValueOrDefault()); } catch (Exception exception) { _logger.LogError(exception, exception.Message); } }, liveProcessingStarted: (sub) => { _logger.LogInformation("{SubscriptionName} subscription started.", sub.SubscriptionName); }, subscriptionDropped: (sub, subDropReason, exception) => { _logger.LogWarning("{SubscriptionName} dropped. Reason: {SubDropReason}.", sub.SubscriptionName, subDropReason); }); }
void SubscribeToStream(StreamId streamId, Func <Checkpoint> checkpoint, CatchUpSubscriptionSettings settings, Func <EventStoreCatchUpSubscription, ResolvedEvent, Task> eventAppeared, Action <EventStoreCatchUpSubscription> liveProcessingStarted, Action <SubscriptionDropReason, Exception> subscriptionDropped) { _loggingAdaptor.Information("Subscribing to {0} stream starting at checkpoint {1}", streamId.ToString(), checkpoint().ToString()); _eventStoreConnection.SubscribeToStreamFrom(streamId.Id, checkpoint().ToEventNumber(), settings, OnEventAppeared(eventAppeared), OnLiveProcessingStarted(liveProcessingStarted), OnSubscriptionDropped(subscriptionDropped)); }
/// <summary> /// Subscribes to a single event stream. Existing events from /// lastCheckpoint onwards are read from the stream /// and presented to the user of <see cref="EventStoreCatchUpSubscription"/> /// as if they had been pushed. /// /// Once the end of the stream is read the subscription is /// transparently (to the user) switched to push new events as /// they are written. /// /// The action liveProcessingStarted is called when the /// <see cref="EventStoreCatchUpSubscription"/> switches from the reading /// phase to the live subscription phase. /// </summary> /// <param name="stream">The stream to subscribe to</param> /// <param name="lastCheckpoint">The event number from which to start. /// /// To receive all events in the stream, use <see cref="StreamCheckpoint.StreamStart" />. /// If events have already been received and resubscription from the same point /// is desired, use the event number of the last event processed which /// appeared on the subscription. /// /// NOTE: Using <see cref="StreamPosition.Start" /> here will result in missing /// the first event in the stream.</param> /// <param name="target">The connection to subscribe to</param> /// <param name="eventAppeared">An action invoked when a new event is received over the subscription</param> /// <param name="liveProcessingStarted">An action invoked when the subscription switches to newly-pushed events</param> /// <param name="subscriptionDropped">An action invoked if the subscription is dropped</param> /// <param name="userCredentials">User credentials to use for the operation</param> /// <param name="settings">The <see cref="CatchUpSubscriptionSettings"/> for the subscription</param> /// <returns>An <see cref="EventStoreSubscription"/> representing the subscription</returns> public static EventStoreStreamCatchUpSubscription SubscribeToStreamFrom( this IEventStoreConnection target, string stream, long?lastCheckpoint, CatchUpSubscriptionSettings settings, Action <EventStoreCatchUpSubscription, ResolvedEvent> eventAppeared, Action <EventStoreCatchUpSubscription> liveProcessingStarted = null, Action <EventStoreCatchUpSubscription, SubscriptionDropReason, Exception> subscriptionDropped = null, UserCredentials userCredentials = null) => target.SubscribeToStreamFrom( stream, lastCheckpoint, settings, ToTask(eventAppeared), liveProcessingStarted, subscriptionDropped, userCredentials );
private async Task Connect() { _connection = _connectionProvider.GetConnection(); await _connection.ConnectAsync(); Func <EventStoreCatchUpSubscription, ResolvedEvent, Task> processEvent = (subscriptionBase, resolvedEvent) => { return(HandleEvent(resolvedEvent)); }; Func <ESSubscription, ResolvedEvent, Task> processEventAlt = (subscriptionBase, resolvedEvent) => { return(HandleEvent(resolvedEvent)); }; var streamId = _streamId == null ? $"$ce-{_aggregateType.ToUpper()}" : _streamId.Id; if (_startPosition == StreamPosition.End) { _subscriptionBase = await _connection.SubscribeToStreamAsync( streamId, true, processEventAlt, subscriptionDropped : SubscriptionDropped); _connected = true; _status = SubscriptionConnectionStatus.Connected; } else { _catchUpSubscriptionBase = _connection.SubscribeToStreamFrom( streamId, 0, new CatchUpSubscriptionSettings( CatchUpSubscriptionSettings.Default.MaxLiveQueueSize, CatchUpSubscriptionSettings.Default.ReadBatchSize, false, true, CatchUpSubscriptionSettings.Default.SubscriptionName), processEvent, subscriptionDropped: SubscriptionDropped); _connected = true; _status = SubscriptionConnectionStatus.Connected; } }
private void ConnectToEventstore() { latestPosition = Position.Start; var subs = connection.SubscribeToAllFrom(latestPosition, true, HandleEvent); //subscribe to the stream of fraud alert connection.SubscribeToStreamFrom("PossiblyStolenCardClients", 0, true, (sub, e) => { var jsonString = Encoding.UTF8.GetString(e.Event.Data); JObject o = JObject.Parse(jsonString); var clientID = (string)o["ClientID"]; Bus.Publish(new ClientPossiblyStolen() { ClientID = clientID }); var ci = indexer.Get <ClientInformation>(clientID); if (ci == null) { ci = new ClientInformation() { ID = clientID } } ; ci.PossiblyStolen = true; indexer.Index(ci); } ); Console.WriteLine("Indexing service started"); }
public void LinkTo(IEventStoreConnection connection, Guid identifier) { connection.SubscribeToStreamFrom( "remote_control-" + Identifier.ToString("N"), EventNumber, CatchUpSubscriptionSettings.Default, (EventStoreCatchUpSubscription EventStoreCatchUpSubscription, ResolvedEvent ResolvedEvent) => { switch (ResolvedEvent.Event.EventType) { case nameof(Events.BrightnessChanged): var BrightnessChanged = JsonConvert.DeserializeObject( Encoding.UTF8.GetString(ResolvedEvent.Event.Data), typeof(Events.BrightnessChanged) ) as Events.BrightnessChanged; Brightness += BrightnessChanged.Change; EventNumber = ResolvedEvent.Event.EventNumber; break; case nameof(Events.ColorChanged): var ColorChanged = JsonConvert.DeserializeObject( Encoding.UTF8.GetString(ResolvedEvent.Event.Data), typeof(Events.ColorChanged) ) as Events.ColorChanged; Color += ColorChanged.Change; EventNumber = ResolvedEvent.Event.EventNumber; break; } }, (EventStoreCatchUpSubscription EventStoreCatchUpSubscription) => { }, (EventStoreCatchUpSubscription EventStoreCatchUpSubscription, SubscriptionDropReason SubscriptionDropReason, Exception Exception) => { Console.WriteLine( "The subscription was dropped because of: {0}", SubscriptionDropReason ); NotifyPropertyChanged(null); }, null ); }
//TODO: Need restore point configuration private static void Start(ProjectionGatewayConfiguration projectionGatewayConfiguration, IEventStoreConnection eventStoreConnection) { projectionGatewayConfiguration.Locator.Register(() => eventStoreConnection); eventStoreConnection.ConnectAsync().Wait(); foreach (var subscription in projectionGatewayConfiguration.Subscriptions) { var eventHandlers = subscription.Value; eventStoreConnection.SubscribeToStreamFrom( stream: subscription.Key + "View", lastCheckpoint: StreamCheckpoint.StreamStart, resolveLinkTos: true, eventAppeared: (upSubscription, @event) => { var eventType = Type.GetType(@event.Event.EventType); var deserializedEvent = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(@event.Event.Data), eventType); eventHandlers .Single(x => x.EventType == eventType) .EventHandler(deserializedEvent); }); } }