private void onEvent(string stream, long position, IFullEvent e)
{
_metrics.Increment("Delayed Queued", Unit.Event);
WaitingEvents.AddOrUpdate(stream, (key) => new LinkedList <Tuple <long, IFullEvent> >(new[] { new Tuple <long, IFullEvent>(position, e) }.AsEnumerable()), (key, existing) =>
{
existing.AddLast(new Tuple <long, IFullEvent>(position, e));
return(existing);
});
}
// create the test stream with no events so its "found" by event reader but not hydrated
public void Exists <TEntity>(string bucket, Id streamId, Id[] parents) where TEntity : IEntity
{
var key = $"{typeof(TEntity).FullName}.{bucket}.{streamId}.{parents.BuildParentsString()}";
if (_events.ContainsKey(key))
{
return;
}
_events[key] = new IFullEvent[] { };
}
private void onEvent(string stream, long position, IFullEvent e)
{
DelayedQueued.Increment();
WaitingEvents.AddOrUpdate(stream, (key) => new List <IFullEvent> {
e
}, (key, existing) =>
{
existing.Add(e);
return(existing);
});
}
public Task Acknowledge(string stream, long position, IFullEvent @event)
{
var eventId = $"{@event.EventId.Value}:{stream}:{position}";
if ([email protected] || !_outstandingEvents.TryRemove(eventId, out var outstanding))
{
Logger.WarnEvent("ACK", "Unknown ack {EventId}", @event.EventId);
return(Task.CompletedTask);
}
outstanding.Item1.Acknowledge(outstanding.Item2);
return(Task.CompletedTask);
}
public Task Acknowledge(string stream, long position, IFullEvent @event)
{
var eventId = $"{@event.EventId.Value}:{stream}:{position}";
Tuple <EventStorePersistentSubscriptionBase, Guid> outstanding;
if ([email protected] || !_outstandingEvents.TryRemove(eventId, out outstanding))
{
Logger.Warn($"Tried to ACK unknown event {@event.EventId}");
return(Task.CompletedTask);
}
_metrics.Decrement("Outstanding Events", Unit.Event);
outstanding.Item1.Acknowledge(outstanding.Item2);
return(Task.CompletedTask);
}
public Task <long> WriteSnapshot(string stream, IFullEvent snapshot,
IDictionary <string, string> commitHeaders)
{
Logger.Write(LogLevel.Debug, () => $"Writing snapshot to stream id [{stream}]");
var settings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto,
SerializationBinder = new EventSerializationBinder(_mapper),
//ContractResolver = new EventContractResolver(_mapper)
Converters = new[] { new Newtonsoft.Json.Converters.StringEnumConverter() }
};
var descriptor = snapshot.Descriptor;
descriptor.EventId = snapshot.EventId ?? Guid.NewGuid();
descriptor.CommitHeaders = commitHeaders ?? new Dictionary <string, string>();
var mappedType = snapshot.Event.GetType();
if (!mappedType.IsInterface)
{
mappedType = _mapper.GetMappedTypeFor(mappedType) ?? mappedType;
}
var @event = snapshot.Event.Serialize(settings).AsByteArray();
if (_compress.HasFlag(Compression.Snapshots))
{
descriptor.Compressed = true;
@event = @event.Compress();
}
var metadata = descriptor.Serialize(settings).AsByteArray();
var data = new EventData(
descriptor.EventId,
mappedType.AssemblyQualifiedName,
!descriptor.Compressed,
@event,
metadata
);
return(DoWrite(stream, new[] { data }));
}
private void onEvent(string stream, long position, IFullEvent e)
{
var snapshot = new Snapshot
{
EntityType = e.Descriptor.EntityType,
Bucket = e.Descriptor.Bucket,
StreamId = e.Descriptor.StreamId,
Timestamp = e.Descriptor.Timestamp,
Version = e.Descriptor.Version,
Payload = e.Event as IState
};
Logger.Write(LogLevel.Debug, () => $"Got snapshot of stream id [{snapshot.StreamId}] bucket [{snapshot.Bucket}] entity [{snapshot.EntityType}] version {snapshot.Version}");
Snapshots.AddOrUpdate(stream, (key) =>
{
_metrics.Increment("Snapshots Stored", Unit.Items);
return(new Tuple <DateTime, ISnapshot>(DateTime.UtcNow, snapshot));
}, (key, existing) =>
{
TruncateBefore[key] = position;
return(new Tuple <DateTime, ISnapshot>(DateTime.UtcNow, snapshot));
});
}
private Task onEvent(string stream, long position, IFullEvent e)
{
var snapshot = new Snapshot
{
EntityType = e.Descriptor.EntityType,
Bucket = e.Descriptor.Bucket,
StreamId = e.Descriptor.StreamId,
Timestamp = e.Descriptor.Timestamp,
Version = e.Descriptor.Version,
Payload = e.Event
};
Logger.DebugEvent("GotSnapshot", "[{Stream:l}] bucket [{Bucket:l}] entity [{EntityType:l}] version {Version}", snapshot.StreamId, snapshot.Bucket, snapshot.EntityType, snapshot.Version);
Snapshots.AddOrUpdate(stream, (key) =>
{
_metrics.Increment("Snapshots Stored", Unit.Items);
return(new Tuple <DateTime, string>(DateTime.UtcNow, _serializer.Serialize(snapshot).AsString()));
}, (key, existing) =>
{
TruncateBefore[key] = position;
return(new Tuple <DateTime, string>(DateTime.UtcNow, _serializer.Serialize(snapshot).AsString()));
});
return(Task.CompletedTask);
}
public Task Acknowledge(IFullEvent @event)
{
return(Acknowledge(new[] { @event }));
}
private static async Task ProcessEvent(IMessaging messaging, string stream, long position, IFullEvent @event, CancellationToken token)
{
Logger.Write(LogLevel.Debug, () => $"Processing event from stream [{@event.Descriptor.StreamId}] bucket [{@event.Descriptor.Bucket}] entity [{@event.Descriptor.EntityType}] event id {@event.EventId}");
var contextBag = new ContextBag();
// Hack to get all the events to invoker without NSB deserializing
contextBag.Set(Defaults.EventHeader, @event.Event);
using (var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(token))
{
var processed = false;
var numberOfDeliveryAttempts = 0;
var messageId = Guid.NewGuid().ToString();
var corrId = "";
if (@event.Descriptor?.Headers?.ContainsKey(Headers.CorrelationId) ?? false)
{
corrId = @event.Descriptor.Headers[Headers.CorrelationId];
}
while (!processed)
{
var transportTransaction = new TransportTransaction();
var headers = new Dictionary <string, string>(@event.Descriptor.Headers ?? new Dictionary <string, string>())
{
[Headers.MessageIntent] = MessageIntentEnum.Send.ToString(),
[Headers.EnclosedMessageTypes] = SerializeEnclosedMessageTypes(messaging, @event.Event.GetType()),
[Headers.MessageId] = messageId,
[Headers.CorrelationId] = corrId,
[Defaults.EventHeader] = "",
[$"{Defaults.EventPrefixHeader}.EventId"] = @event.EventId.ToString(),
[$"{Defaults.EventPrefixHeader}.EventStream"] = stream,
[$"{Defaults.EventPrefixHeader}.EventPosition"] = position.ToString()
};
using (var ctx = EventExecution.NewContext())
{
try
{
// If canceled, this will throw the number of time immediate retry requires to send the message to the error queue
token.ThrowIfCancellationRequested();
// Don't re-use the event id for the message id
var messageContext = new MessageContext(messageId,
headers,
Marker, transportTransaction, tokenSource,
contextBag);
await Bus.OnMessage(messageContext).ConfigureAwait(false);
EventsHandled.Increment();
processed = true;
}
catch (ObjectDisposedException)
{
// NSB transport has been disconnected
throw new OperationCanceledException();
}
catch (Exception ex)
{
EventErrors.Mark($"{ex.GetType().Name} {ex.Message}");
++numberOfDeliveryAttempts;
// Don't retry a cancelation
if (tokenSource.IsCancellationRequested)
{
numberOfDeliveryAttempts = Int32.MaxValue;
}
var errorContext = new ErrorContext(ex, headers,
messageId,
Marker, transportTransaction,
numberOfDeliveryAttempts);
if (await Bus.OnError(errorContext).ConfigureAwait(false) ==
ErrorHandleResult.Handled || tokenSource.IsCancellationRequested)
{
break;
}
}
}
}
}
}
private void onEvent(string stream, long position, IFullEvent e)
{
EventsQueued.Increment();
WaitingEvents.Add(new Tuple <string, long, IFullEvent>(stream, position, e));
}
