public void OnNext(LogEvent @event)
{
foreach (var e in EventConverter.Convert(@event))
{
EventQueue.Enqueue(e);
}
}
public async Task <ISubscription> Subscribe(IEventHandlerFactory factory, object[] args = null)
{
Subscription s = new Subscription(true);
var lastPosition = (StreamPosition)await _stream.LastPosition();
string[] prefixes = _events.Select(x => x.Name).ToArray();
FilterOptions filters = new FilterOptions(EventTypeFilter.Prefix(prefixes));
// be very careful. We need to subscribe after the global position.
await _eventStore.SubscribeToAllAsync(lastPosition.GlobalPosition,
async (s, r, c) =>
{
var type = _schema.EventByName(r.Event.EventType);
if (type != null && _events.Contains(type))
{
using (var scope = factory.Scope())
{
var handler = scope.CreateHandler(type);
var(m, e) = _eventConverter.Convert(type, r);
await handler.Execute(m, e);
}
}
}, true, null, filters);
return(s);
}
private async IAsyncEnumerable <EventEnvelope> ReadStream(string streamName)
{
await foreach (var e in _connection.ReadStreamAsync(Direction.Forwards, streamName, StreamRevision.Start,
100, resolveLinkTos: true))
{
var eventType = _projectionSchema.EventByName(e.Event.EventType);
var(metadata, eventInstance) = _eventConveter.Convert(eventType, e);
yield return(new EventEnvelope(eventInstance, metadata));
}
}
public async IAsyncEnumerable <IEvent> Get(Guid key)
{
var streamName = GetStreamName(key);
await foreach (var e in _connection.ReadStreamAsync(Direction.Forwards, streamName, StreamRevision.Start,
100, resolveLinkTos: true))
{
var eventType = _aggregateSchema.EventByName(e.Event.EventType);
var(m, eventInstance) = _eventConverter.Convert(eventType.EventType, e);
yield return(eventInstance);
}
}
public async Task <ISubscription> Subscribe(IEventHandlerFactory factory, object[] args = null)
{
if (!factory.SupportedEventTypes.Contains <TEvent>())
{
throw new InvalidOperationException(
$"Event Handler Factory seems not to support this Event. {typeof(TEvent).Name}");
}
// uhhh and we need to know from when...
Type checkpointRepo = typeof(ICheckpointRepository <,>).MakeGenericType(_schema.Type, typeof(TEvent));
var repo = (ICheckpointEventRepository <TEvent>)_serviceProvider.GetService(checkpointRepo);
string streamName = $"$et-{typeof(TEvent).Name}";
var lastCheckpoint = await repo.GetLastCheckpoint();
StreamRevision start = StreamRevision.Start;
if (!lastCheckpoint.HasValue)
{
// this is the first time we run this processor.
var(globalPosition, streamRevision) = await _eventStore.GetLastStreamPosition(streamName);
start = streamRevision;
await repo.SaveCheckpoint(start.ToUInt64());
}
else
{
start = new StreamRevision(lastCheckpoint.Value + 1);
}
Subscription s = new Subscription();
await _eventStore.SubscribeToStreamAsync(streamName, start,
async (s, r, c) =>
{
using (var scope = factory.Scope())
{
var handler = scope.CreateHandler <TEvent>();
var(m, e) = _eventConverter.Convert <TEvent>(r);
await handler.Execute(m, e);
await repo.SaveCheckpoint(r.Link.EventNumber.ToUInt64());
}
}, ss => s.MakeLive(), true);
return(s);
}
private async Task OnReadEvent(IStreamSubscription arg1, ResolvedEvent arg2, CancellationToken t)
{
var(m, ev) = _converter.Convert <TEvent>(arg2);
var groupName = typeof(TEvent).FullName.Replace(".", "-");
try
{
await _connection.Clients.All.SendCoreAsync(groupName, new object[] { m, ev });
Log.Information("SignalR hub send event {eventName} to it's clients.", typeof(TEvent).Name);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
public void Send(CommittedEventStream committedEventStream)
{
if (_senderConfiguration.Topics.Count() == 0)
{
return;
}
_logger.Information("Sending committed event stream");
_bridge.Send(committedEventStream);
var eventContentAndEnvelopes = _eventConverter.Convert(committedEventStream);
var json = _serializer.ToJson(eventContentAndEnvelopes);
_logger.Trace("Sending JSON : " + json);
_senderConfiguration.Topics.ForEach(topic =>
{
_logger.Information($"Send committed event stream to topic: '{topic}'");
_publisher.Publish(topic, json);
});
}
public async Task <ISubscription> Subscribe(IEventHandlerFactory factory, object[] args = null)
{
Subscription s = new Subscription();
if (!factory.SupportedEventTypes.Contains <TEvent>())
{
throw new InvalidOperationException($"Event Handler Factory seems not to support this Event. {typeof(TEvent).Name}");
}
// Projections stream type might not be the same as origin of the event.
// For instance Stream might go directly to memory, where as some events
// come from EventStore
// In such a case, we could assume to subscribe from the beginning
// or we could assume that we want to subscribe from now.
// For now we subscribe from beginning - however this is a problem.
// We don't know the nature of this subscription - if it is temporal or not.
// If it had been temporal, we would subscribe from now
// It it had not been temporal, we would subscribe from beginning
var position = await Stream.LastPosition();
StreamRevision sr = StreamRevision.Start;
if (position is StreamPosition lastPosition)
{
sr = lastPosition.IsStart ? StreamRevision.Start : new StreamRevision(lastPosition.StreamRevision + 1);
}
await _eventStore.SubscribeToStreamAsync(STREAM_NAME, sr, async (s, r, c) =>
{
using (var scope = factory.Scope())
{
var handler = scope.CreateHandler <TEvent>();
var(m, e) = _eventConverter.Convert <TEvent>(r);
await handler.Execute(m, e);
}
}, ss => s.MakeLive(), true);
return(s);
}
