public async Task <IEventStream> SubscribeAsync(
IEventDescription eventReference)
{
if (eventReference == null)
{
throw new ArgumentNullException(nameof(eventReference));
}
await _semaphore.WaitAsync();
try
{
if (!_streams.TryGetValue(eventReference, out var subscribers))
{
subscribers = new List <InMemoryEventStream>();
_streams[eventReference] = subscribers;
}
var eventMessage = new EventMessage(eventReference);
var stream = new InMemoryEventStream(eventMessage);
stream.Completed += (s, e) => Unsubscribe(eventMessage, stream);
subscribers.Add(stream);
return(stream);
}
finally
{
_semaphore.Release();
}
}
public void Subscribe(string objectId, IEventDescription eventDescription, ISerializer serializer,
Delegate handler, object proxy)
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(EventHandlersRepository));
}
var eventId = new EventId
{
ObjectId = objectId,
EventName = eventDescription.Name
};
lock (_events)
{
if (!_events.TryGetValue(eventId, out var subscriptionRepository))
{
var subscribeMessage = new SubscribeEventMessage(_clientHostAddress, objectId, eventDescription.Name);
_outputChannel.SendWithAck(subscribeMessage);
subscriptionRepository = new SubscriptionRepository(eventDescription, serializer, _eloquentClient);
_events.Add(eventId, subscriptionRepository);
}
subscriptionRepository.Subscribe(handler, proxy);
}
}
private async Task <IEventStream> SubscribeInternalAsync(
IEventDescription eventDescription)
{
await _semaphore.WaitAsync().ConfigureAwait(false);
try
{
if (!_streams.TryGetValue(eventDescription,
out List <InMemoryEventStream> subscribers))
{
subscribers = new List <InMemoryEventStream>();
_streams[eventDescription] = subscribers;
}
var eventMessage = new EventMessage(eventDescription);
var stream = new InMemoryEventStream();
stream.Completed += (s, e) => Unsubscribe(eventMessage, stream);
subscribers.Add(stream);
return(stream);
}
finally
{
_semaphore.Release();
}
}
public RedisEventStream(
IEventDescription eventDescription,
ChannelMessageQueue channel,
IPayloadSerializer serializer)
{
_eventDescription = eventDescription;
_channel = channel;
_serializer = serializer;
}
public static IEventObservable <TEvent, IEventContext, TModel> GetEventObservable <TEvent, TModel>(this IRouter <TModel> router, IEventHoldingStrategy <TEvent, TModel> strategy)
where TEvent : IIdentifiableEvent
where TModel : IHeldEventStore
{
return(EventObservable.Create <TEvent, IEventContext, TModel>(
o =>
{
var heldEvents = new Dictionary <Guid, HeldEventData <TEvent> >();
var releasedEvents = new HashSet <Guid>();
var disposables = new CollectionDisposable();
disposables.Add(router.GetEventObservable <TEvent>(ObservationStage.Preview).Observe((e, c, m) =>
{
// Have we already re-published this event? If so we don't want to hold it again.
if (releasedEvents.Contains(e.Id))
{
releasedEvents.Remove(e.Id);
o.OnNext(e, c, m);
}
else
{
var shouldHoldEvent = strategy.ShouldHold(e, c, m);
if (shouldHoldEvent)
{
// Cancel the event so no other observers will receive it.
c.Cancel();
// Model that we've cancelled it, other code can now reflect the newly modelled values.
// That is other code needs to determine what to do with these held events on the model.
// When it figures that out it should raise a HeldEventActionEvent so we can proceed here.
IEventDescription eventDescription = strategy.GetEventDescription(e, m);
m.AddHeldEventDescription(eventDescription);
// finally we hold the event locally
heldEvents.Add(e.Id, new HeldEventData <TEvent>(eventDescription, e));
}
}
}));
disposables.Add(router.GetEventObservable <HeldEventActionEvent>().Observe((e, c, m) =>
{
HeldEventData <TEvent> heldEventData;
// Since we're listening to a pipe of all events we need to filter out anything we don't know about.
if (heldEvents.TryGetValue(e.EventId, out heldEventData))
{
// We're received an event to clean up.
heldEvents.Remove(e.EventId);
m.RemoveHeldEventDescription(heldEventData.EventDescription);
if (e.Action == HeldEventAction.Release)
{
// Temporarily store the event we're republishing so we don't re-hold it
releasedEvents.Add(e.EventId);
router.PublishEvent(heldEventData.Event);
}
}
}));
return disposables;
}
));
}
public Task <IEventStream> SubscribeAsync(
IEventDescription eventDescription)
{
if (eventDescription == null)
{
throw new ArgumentNullException(nameof(eventDescription));
}
return(SubscribeInternalAsync(eventDescription));
}
public ValueTask <IEventStream> SubscribeAsync(
IEventDescription eventDescription,
CancellationToken cancellationToken = default)
{
if (eventDescription is null)
{
throw new ArgumentNullException(nameof(eventDescription));
}
return(SubscribeInternalAsync(eventDescription));
}
public async Task <IEventStream> SubscribeAsync(
IEventDescription eventDescription)
{
ISubscriber subscriber = _connection.GetSubscriber();
ChannelMessageQueue channel = await subscriber
.SubscribeAsync(eventDescription.ToString())
.ConfigureAwait(false);
return(new RedisEventStream(eventDescription, channel, _serializer));
}
private static Task <IEventStream> SubscribeAsync(
IServiceProvider services,
IEventDescription @event)
{
var eventRegistry = (IEventRegistry)services
.GetService(typeof(IEventRegistry));
if (eventRegistry == null)
{
throw new QueryException(new QueryError(CoreResources
.SubscriptionExecutionStrategy_NoEventRegistry));
}
return(eventRegistry.SubscribeAsync(@event));
}
private static Task <IEventStream> SubscribeAsync(
IServiceProvider services,
IEventDescription @event)
{
var eventRegistry = services.GetService <IEventRegistry>();
if (eventRegistry == null)
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage(CoreResources.SubscriptionExecutionStrategy_NoEventRegistry)
.Build());
}
return(eventRegistry.SubscribeAsync(@event));
}
public void AddEventDescription(IEventDescription ev)
{
_events.Add(ev);
}
public HeldEventData(IEventDescription eventDescription, TEvent @event)
{
EventDescription = eventDescription;
Event = @event;
}
public SubscriptionRepository(IEventDescription eventDescription, ISerializer serializer, EloquentClient eloquentClient)
{
_eventDescription = eventDescription;
_serializer = serializer;
_eloquentClient = eloquentClient;
}
public void RemoveHeldEventDescription(IEventDescription e)
{
HeldEvents.Remove(e);
}
public void AddHeldEventDescription(IEventDescription e)
{
HeldEvents.Add(e);
}
public EventMessage(IEventDescription eventDescription)
{
Event = eventDescription
?? throw new ArgumentNullException(nameof(eventDescription));
}
public EventMessage(IEventDescription eventDescription, object payload)
{
Event = eventDescription
?? throw new ArgumentNullException(nameof(eventDescription));
Payload = payload;
}
public EventMessage(IEventDescription eventDescription)
: this(eventDescription, null)
{
}
