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");
}
}
}
