private Task HandleEvent(EventStorePersistentSubscriptionBase sub, ResolvedEvent resolvedEvent, int?retryCount) { if (retryCount > 4) { _retryCount = retryCount; sub.Acknowledge(resolvedEvent); _resetEvent.Set(); } else { sub.Fail(resolvedEvent, PersistentSubscriptionNakEventAction.Retry, "Not yet tried enough times"); } return(Task.CompletedTask); }
/// <summary> /// Persistents the subscription event appeared. /// </summary> /// <param name="subscription">The subscription.</param> /// <param name="resolvedEvent">The resolved event.</param> /// <param name="subscriptionGroupId">The subscription group identifier.</param> /// <returns></returns> private async Task PersistentSubscriptionEventAppeared(EventStorePersistentSubscriptionBase subscription, ResolvedEvent resolvedEvent, Guid subscriptionGroupId) { try { // Check the event data has been received if (this.EventAppeared != null) { // Serialise the event data //String serialisedData = this.Serialiser.Serialise(resolvedEvent); // Get the event data from the resolved Event var serialisedData = Encoding.UTF8.GetString(resolvedEvent.Event.Data); SubscriptionDataTransferObject subscriptionInformation = new SubscriptionDataTransferObject() { SerialisedData = serialisedData, EventId = (Guid)((RecordedEvent)resolvedEvent.Event).EventId, SubscriptionGroupId = subscriptionGroupId.ToString(), }; var handledSuccessfully = await this.EventAppeared(subscriptionInformation); if (!handledSuccessfully) { throw new Exception( $"Failed to Process Event {resolvedEvent.Event.EventId} on persistent subscription group {subscriptionGroupId}"); } } else { Logger.LogInformation("Unable to process event as EventAppeared Event handler is null"); } // Acknowledge the event subscription.Acknowledge(resolvedEvent); } catch (TimeoutException tex) { subscription.Fail(resolvedEvent, PersistentSubscriptionNakEventAction.Park, tex.Message); } catch (InvalidOperationException ioex) { subscription.Fail(resolvedEvent, PersistentSubscriptionNakEventAction.Skip, ioex.Message); } catch (Exception ex) { subscription.Fail(resolvedEvent, PersistentSubscriptionNakEventAction.Retry, ex.Message); } }
private void DoSomething(EventStorePersistentSubscriptionBase _, ResolvedEvent x) { var data = Encoding.ASCII.GetString(x.Event.Data); try { Console.WriteLine(data); var pictureInfo = JsonConvert.DeserializeObject <PictureInfo>(data); AddToDB(pictureInfo); _.Acknowledge(x); }catch (Exception ex) { Console.Write(ex); _.Fail(x, PersistentSubscriptionNakEventAction.Park, ex.Message); } }
private static async Task PushEventToProcessManager(AppFunc chain, IManageProcess processManager, DeSerializationResult evnt, IDictionary <string, object> environment, EventStorePersistentSubscriptionBase subscription) { if (!running) { return; } if (!evnt.Successful) { subscription.Fail(evnt.OriginalEvent, PersistentSubscriptionNakEventAction.Unknown, evnt.Error.Message); return; } try { var requestEnvironment = new Dictionary <string, object>(); foreach (var item in environment) { requestEnvironment[item.Key] = item.Value; } var request = requestEnvironment.GetEventStoreRequest(); request.ProcessManager = processManager; request.Event = evnt; var correlationId = evnt.Metadata.Get(DefaultRepository.CorrelationIdKey, Guid.NewGuid().ToString()); using (requestEnvironment.OpenCorrelationContext(correlationId)) using (requestEnvironment.OpenCausationContext(evnt.EventId.ToString())) { await chain(requestEnvironment).ConfigureAwait(false); } subscription.Acknowledge(evnt.OriginalEvent); } catch (Exception ex) { environment.Log(ex, "Couldn't push event to processmanager: {0}", LogLevel.Error, processManager.ProcessName); subscription.Fail(evnt.OriginalEvent, PersistentSubscriptionNakEventAction.Unknown, ex.Message); } }
public EventSubscriber(MessageHandlerRegistry registry, IEventStoreConnection connection, IMessageMapper mapper, MessageMetadataRegistry messageMeta) { _registry = registry; _connection = connection; _messageMeta = messageMeta; _settings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto, Binder = new EventSerializationBinder(mapper), ContractResolver = new EventContractResolver(mapper) }; _toBeAcknowledged = new ConcurrentBag <ResolvedEvent>(); _acknowledger = new Timer(_ => { if (_toBeAcknowledged.IsEmpty) { return; } var willAcknowledge = _toBeAcknowledged.ToList(); var newBag = new ConcurrentBag <ResolvedEvent>(); Interlocked.Exchange <ConcurrentBag <ResolvedEvent> >(ref _toBeAcknowledged, newBag); if (!ProcessingLive) { return; } Acknowledging.Update(willAcknowledge.Count); Logger.Write(LogLevel.Info, () => $"Acknowledging {willAcknowledge.Count} events"); var page = 0; while (page < willAcknowledge.Count) { var working = willAcknowledge.Skip(page).Take(1000); _subscription.Acknowledge(working); page += 1000; } }, null, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(5)); }
private void EventAppeared(EventStorePersistentSubscriptionBase sub, ResolvedEvent e, CancellationToken token, Action <string, long, IFullEvent> callback) { // Don't care about metadata streams if (e.Event == null || e.Event.EventStreamId[0] == '$') { sub.Acknowledge(e.OriginalEvent.EventId); return; } if (token.IsCancellationRequested) { Logger.Warn($"Token cancelation requested, stopping persistent subscription"); sub.Stop(TimeSpan.FromSeconds(5)); lock (_subLock) _persistentSubs.Remove(sub); token.ThrowIfCancellationRequested(); } _outstandingEvents[e.Event.EventId] = new Tuple <EventStorePersistentSubscriptionBase, Guid>(sub, e.OriginalEvent.EventId); EventAppeared(e, token, callback); }
private static void EventAppeared(EventStorePersistentSubscriptionBase arg1, ResolvedEvent arg2) { Console.WriteLine($"Message '{arg2.OriginalEvent.EventId}' handled"); arg1.Acknowledge(arg2); }
public override Task Acknowledge() { _eventStorePersistentSubscriptionBase?.Acknowledge(ResolvedEvent); return(Task.CompletedTask); }
private async Task EventAppeared(EventStorePersistentSubscriptionBase sub, ResolvedEvent subEvent) { //var con = await _connectionProvider.GetActiveConnection().ConfigureAwait(false); var con = _connectionProvider.GetActiveConnection(); // var origEvent = await con.ReadEventAsync(subEvent.OriginalStreamId, subEvent.OriginalEventNumber, true, _connectionProvider.OpsCredentials); var subData = subEvent.Event.Data.FromUtf8(); var xx = subData.Split('@'); if (xx.Length == 2) { var eventNumber = int.Parse(xx[0]); var stream = xx[1]; var eosEvents = await con.ReadStreamEventsBackwardAsync(stream, StreamPosition.End, 1, false, _connectionProvider.OpsCredentials).ConfigureAwait(false); ResolvedEvent? @event = null; bool isResultRemoved = false; bool eventIsRemovedEvent = false; if (eosEvents.Events.Length > 0) { var eosEvent = eosEvents.Events[0]; if (eosEvent.OriginalEventNumber == eventNumber) { _logger.LogDebug("Event From Subscription is Last Event in Stream"); if (eosEvent.Event.EventType == "ResultRemoved") { _logger.LogDebug("The current event is the removed event"); eventIsRemovedEvent = true; } } else { _logger.LogDebug("Checking Last Event if Removed"); if (eosEvent.Event.EventType == "ResultRemoved") { _logger.LogDebug("Last Event Is Removed"); isResultRemoved = true; } } } if (!eventIsRemovedEvent && (!isResultRemoved || !_skipRemoved)) { var curEvent = await con.ReadEventAsync(stream, eventNumber, false, _connectionProvider.OpsCredentials).ConfigureAwait(false); if (curEvent.Event.HasValue) { @event = curEvent.Event; } } // if (@event.HasValue) { var data = @event.Value.Event.Data.FromUtf8(); var item = JsonConvert.DeserializeObject <T>(data); await _eventAppeared(item).ConfigureAwait(false); //await _telemetryAdapter.RunDependencyAsync("PERS SUBS", "EVENTSTORE", state => _eventAppeared(item, state), parentState, _logger); sub.Acknowledge(subEvent); } else { _logger.LogDebug("Event Has no Value"); } } }