private void LiveConsume()
{
Receive <DataResponse>(c =>
{
for (var i = 0; i < c.Data.Count; i++)
{
var msgData = c.Data.ElementAt(i);
var msg = msgData["__message_id__"].ToString().Trim('(', ')').Split(',').Select(int.Parse).ToArray();
var messageId = MessageIdUtils.GetOffset(new MessageId(msg[0], msg[1], msg[2]));
var eventMessage = new EventEnvelope(msgData, messageId, _topicName.ToString());
_buffer.Post(eventMessage);
_currentOffset = messageId;
}
_buffer.Post(new EventStats(new StatsResponse(c.StatementStats)));
});
Receive <StatsResponse>(s =>
{
var stats = new EventStats(s);
_buffer.Post(stats);
});
Receive <ErrorResponse>(s =>
{
var error = new EventError(s);
_buffer.Post(error);
});
_queryCancelable = _scheduler.ScheduleOnceCancelable(TimeSpan.FromSeconds(60), Query);
}
private void OnReadEvent(EventMetadata m, TEvent e)
{
EventEnvelope <TEvent> envelope = new EventEnvelope <TEvent>(e, m);
_logger.Information("Received event {eventName} from SignalR hub.", envelope.Event.GetType().Name);
_uiEventBus.GetEvent <EventEnvelope <TEvent> >().Publish(envelope);
}
public async static void OnOrderSendCommandPizza(
[ServiceBusTrigger("events", "pizza")] EventEnvelope <OrderCreated> envelope,
TextWriter log)
{
try
{
var repository = Container.Resolve <IRepository <QueryingOrder, Guid> >();
var e = envelope.Event as OrderCreated;
var order = repository.GetById(e.EventId);
var pizzas = order.PizzasToDo();
if (pizzas.Any())
{
var append = Container.Resolve <IDataSourceAppend <PizzaToDoDTO> >();
await append.AppendAsync(pizzas);
var client = Container.Resolve <ITotem>();
await client.NewPizzasToPrepareAsync(e.EventId);
}
}
catch (Exception ex)
{
// log...
}
}
private Task On(RawEvent rawEvent, Position?position, DateTime eventCreationTime)
{
var @event = _deserializer.Deserialize(rawEvent);
_log.Debug("Projecting event {event}", rawEvent.Body.ToString());
try
{
// return Measure(() =>// Should be moved to a messenger decorator
// {
var envelopedEvent = new EventEnvelope(
new MessageChainInfo(@event.Id.ToString()
, @event.Metadata.CorrelationId
, @event.Metadata.CausationId)
, @event.Body);
_messenger.Dispatch(envelopedEvent);
return(_checkpointStore.StoreCheckpoint(position));
// }, rawEvent.EventType
// , eventCreationTime
// , _subscriptionName);
}
catch (Exception exception)
{
_log.Error(exception
, "Error occured when projecting the event {event} from {subscriptionName}"
, @event
, _subscriptionName);
throw;
}
}
private void Consume()
{
Receive<DataResponse>(c =>
{
for (var i = 0; i < c.Data.Count; i++)
{
var msgData = c.Data.ElementAt(i);
var msg = msgData["__message_id__"].ToString().Trim('(', ')').Split(',').Select(int.Parse).ToArray();
var messageId = MessageIdUtils.GetOffset(new MessageId(msg[0], msg[1], msg[2]));
if (messageId <= _toMessageId)
{
var eventMessage = new EventEnvelope(msgData, messageId, _topicName.ToString());
_buffer.Post(eventMessage);
_currentOffset = messageId;
}
else Self.GracefulStop(TimeSpan.FromSeconds(5));
}
_buffer.Post(new EventStats(new StatsResponse(c.StatementStats)));
});
Receive<StatsResponse>(s =>
{
var stats = new EventStats(s);
_buffer.Post(stats);
});
Receive<ErrorResponse>(s =>
{
var error = new EventError(s);
_buffer.Post(error);
});
Receive<ReceiveTimeout>(t => { Self.GracefulStop(TimeSpan.FromSeconds(5)); });
//to track last sequence id for lagging player
Context.SetReceiveTimeout(TimeSpan.FromSeconds(30));
}
/// <inheritdoc/>
public IEnumerable <EventAndEnvelope> GetFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId)
{
var eventSourceIdentifier = _applicationResourceIdentifierConverter.AsString(eventSource);
var eventPath = GetPathFor(eventSourceIdentifier, eventSourceId);
var files = _files.GetFilesIn(eventPath).OrderBy(f => f);
var eventFiles = files.Where(f => f.EndsWith(".event")).ToArray();
var envelopeFiles = files.Where(f => f.EndsWith(".envelope")).ToArray();
if (eventFiles.Length != envelopeFiles.Length)
{
throw new Exception($"There is a problem with event files for {eventSourceIdentifier} with Id {eventSourceId}");
}
var events = new List <EventAndEnvelope>();
for (var eventIndex = 0; eventIndex < eventFiles.Length; eventIndex++)
{
var envelopeFile = envelopeFiles[eventIndex];
var eventFile = eventFiles[eventIndex];
var envelopeAsJson = _files.ReadString(Path.GetDirectoryName(envelopeFile), Path.GetFileName(envelopeFile));
var eventAsJson = _files.ReadString(Path.GetDirectoryName(eventFile), Path.GetFileName(eventFile));
var envelopeValues = _serializer.GetKeyValuesFromJson(envelopeAsJson);
var _correllationId = Guid.Parse((string)envelopeValues["CorrelationId"]);
var _eventId = Guid.Parse((string)envelopeValues["EventId"]);
var _sequenceNumber = (long)envelopeValues["SequenceNumber"];
var _sequenceNumberForEventType = (long)envelopeValues["SequenceNumberForEventType"];
var _generation = (long)envelopeValues["Generation"];
var _event = _applicationResourceIdentifierConverter.FromString((string)envelopeValues["Event"]);
var _eventSourceId = Guid.Parse((string)envelopeValues["EventSourceId"]);
var _eventSource = _applicationResourceIdentifierConverter.FromString((string)envelopeValues["EventSource"]);
var _eventSourceVersion = EventSourceVersion.FromCombined(double.Parse(envelopeValues["Version"].ToString()));
var _causedBy = (string)envelopeValues["CausedBy"];
var _occurred = (DateTime)envelopeValues["Occurred"];
var envelope = new EventEnvelope(
_correllationId,
_eventId,
_sequenceNumber,
_sequenceNumberForEventType,
(int)_generation,
_event,
_eventSourceId,
_eventSource,
_eventSourceVersion,
_causedBy,
_occurred
);
var eventType = _applicationResourceResolver.Resolve(envelope.Event);
var @event = Activator.CreateInstance(eventType, eventSourceId) as IEvent;
_serializer.FromJson(@event, eventAsJson);
events.Add(new EventAndEnvelope(envelope, @event));
}
return(events);
}
void On(EventEnvelope <AddedEmailToDomain> e)
{
if (!state.Domains.ContainsKey(e.StreamId))
{
state.Domains.Add(e.StreamId, 0);
}
state.Domains[e.StreamId]++;
}
public void On(EventEnvelope <TestSuiteFinishedEvent> evnt)
{
var rc = evnt.Session.Load <ReleaseCandidate>(evnt.Payload.BuildId);
var testCases = evnt.Payload.TestOutputs.Select(x => new TestCase(x.Name, x.Result));
rc.TestSuites.Add(new TestSuite(evnt.Payload.SuiteType, evnt.Payload.Result, testCases));
}
CommittedEvent ToCommittedEvent(CommitSequenceNumber commitSequenceNumber, EventEnvelope @event)
{
var eventType = _artifactTypeMap.GetTypeFor(@event.Metadata.Artifact);
var eventInstance = _objectFactory.Build(eventType, @event.Event) as IEvent;
var committedEventVersion = new CommittedEventVersion(commitSequenceNumber, @event.Metadata.VersionedEventSource.Version.Commit, @event.Metadata.VersionedEventSource.Version.Sequence);
return(new CommittedEvent(committedEventVersion, @event.Metadata, eventInstance));
}
public static IEvent ToEvent(this global::CosmoStore.EventRead <JToken, long> eventRead, Func <string, Type> typeResolver)
=> typeResolver(eventRead.Name)
.Pipe(t => ((EventRecord)eventRead.Data.ToObject(t))
.Pipe(e => EventEnvelope.Create(eventRead.Id.ToString(), e))
.Tap(e => e.Meta = eventRead.Metadata.Value.ToObject <Dictionary <string, string> >())
.Tap(e => e.Meta.AddStoreMetaData(new EventStoreMetaData {
EventPosition = eventRead.Version, EventVersion = eventRead.Version
})));
public Task Append(EventMetadata m, IEvent e)
{
var eventEnvelope = new EventEnvelope(e, m);
_rootStream.Enqueue(eventEnvelope);
_publisher.Publish(eventEnvelope);
return(Task.CompletedTask);
}
private void GivenTheCurrentEventWillTakeAWhileToBeHandled()
{
_eventHandler.Block();
while (_eventBeingHandleAtTimeOfSutdownd == null)
{
_eventBeingHandleAtTimeOfSutdownd = _eventHandler.CurrentEvent;
}
}
private Event ConvertEventEnvelopeToEvent(EventEnvelope envelope)
{
return(new Event(
id: envelope.Id,
occurred: envelope.Occurred,
type: envelope.EventType,
payload: envelope.Payload
));
}
Task Receive(Message message, CancellationToken token)
{
var dynamicEventsAndEnvelopes = new List <dynamic>();
var json = System.Text.Encoding.UTF8.GetString(message.Body);
_serializer.FromJson(dynamicEventsAndEnvelopes, json);
var eventsAndEnvelopes = new List <EventAndEnvelope>();
foreach (var dynamicEventAndEnvelope in dynamicEventsAndEnvelopes)
{
var env = dynamicEventAndEnvelope.Envelope;
var correlationId = (TransactionCorrelationId)Guid.Parse(env.CorrelationId.ToString());
var eventId = (EventId)Guid.Parse(env.EventId.ToString());
var sequenceNumber = (EventSequenceNumber)long.Parse(env.SequenceNumber.ToString());
var sequenceNumberForEventType = (EventSequenceNumber)long.Parse(env.SequenceNumberForEventType.ToString());
var generation = (EventGeneration)long.Parse(env.Generation.ToString());
var @event = _applicationResourceIdentifierConverter.FromString(env.Event.ToString());
var eventSourceId = (EventSourceId)Guid.Parse(env.EventSourceId.ToString());
var eventSource = _applicationResourceIdentifierConverter.FromString(env.EventSource.ToString());
var version = (EventSourceVersion)EventSourceVersion.FromCombined(double.Parse(env.Version.ToString()));
var causedBy = (CausedBy)env.CausedBy.ToString();
var occurred = DateTimeOffset.Parse(env.Occurred.ToString());
var envelope = new EventEnvelope(
correlationId,
eventId,
sequenceNumber,
sequenceNumberForEventType,
generation,
@event,
eventSourceId,
eventSource,
version,
causedBy,
occurred
);
var eventType = _applicationResourceResolver.Resolve(@event);
var eventInstance = Activator.CreateInstance(eventType, new object[] { eventSourceId }) as IEvent;
var e = dynamicEventAndEnvelope.Event.ToString();
_serializer.FromJson(eventInstance, e);
eventsAndEnvelopes.Add(new EventAndEnvelope(envelope, eventInstance));
}
var stream = new CommittedEventStream(eventsAndEnvelopes.First().Envelope.EventSourceId, eventsAndEnvelopes);
Received(stream);
_queueClient.CompleteAsync(message.SystemProperties.LockToken);
return(Task.CompletedTask);
}
public void CanSerializeToBson()
{
var version = new EventVersion(3, 2, 1);
var aggregateId = Guid.Parse("512fe943-c9bd-49c3-8116-20c186c755af");
var correlationId = Guid.Parse("4fabd791-ef41-4d6b-9579-fcd9189d492b");
var envelope = new EventEnvelope(correlationId, aggregateId, version, new FakeEvent("My Event"));
var bson = WriteBson(envelope);
Validate(bson, "7AAAAAVhABAAAAAEQ+kvUb3Jw0mBFiDBhsdVrwN2ABoAAAAQdgADAAAAEGMAAgAAABBpAAEAAAAAA2UAlwAAAAIkdHlwZQBwAAAAVGVzdC5TcGFyay5TZXJpYWxpemF0aW9uLkNvbnZlcnRlcnMuVXNpbmdFdmVudEVudmVsb3BlQ29udmVydGVyLkZha2VFdmVudCwgU3BhcmsuU2VyaWFsaXphdGlvbi5OZXd0b25zb2Z0LlRlc3RzAAJQcm9wZXJ0eQAJAAAATXkgRXZlbnQAAAVjABAAAAAEkderT0Hva02VefzZGJ1JKwA=");
}
public void GetStronglyTypedContentTest()
{
TestEvent testEvent = new TestEvent("some event");
EventEnvelope envelope = new EventEnvelope("Test", type => testEvent);
TestEvent content = envelope.GetContent <TestEvent>();
content.Should().NotBeNull();
content.ShouldBeEquivalentTo(testEvent);
}
private void AddItem <T>(EventEnvelope <T> evnt, string message, HistoryItemType type = HistoryItemType.Success)
where T : class
{
Items.Add(new HistoryItem()
{
Date = FormatDate(evnt.OccurenceDateUtc),
Message = message,
Type = type
});
}
private void WhenAnEventIsAddedToTheEventStream()
{
var @event = new EventEnvelope(
_dataFixture.Create <long>(),
new SomeEvent());
_eventStream.Enqueue(@event);
_eventsAddedToStream.Add(@event);
}
private Task OnEventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent @event)
{
_logger.LogInformation("Received event on subscription {@subscriptionName}: {@event}", subscription.SubscriptionName, @event);
// TODO: what should we do if this fails?
var evelynEvent = _eventMapper.MapEvent(@event);
var eventEnvelope = new EventEnvelope(@event.OriginalEventNumber, evelynEvent);
_eventStream.Enqueue(eventEnvelope);
return(Task.CompletedTask);
}
public Task AppendPartition(Guid key, EventMetadata m, IEvent e)
{
var queue = _partitionStreams.GetOrAdd(key, (x) => new ConcurrentQueue <EventEnvelope>());
var eventEnvelope = new EventEnvelope(e, m);
queue.Enqueue(eventEnvelope);
_publisher.Publish(eventEnvelope, key);
return(Task.CompletedTask);
}
public void On(EventEnvelope <StageFailedEvent> evnt)
{
var candidate = evnt.Session.QueryOver <ReleaseCandidate>()
.Where(x => x.PipelineId == evnt.Payload.StageId.PipelineId)
.List()
.Single();
var project = GetLatestProjectVersion(evnt.Session, candidate.ProjectName);
project.StageFailed(evnt.Payload.StageId.StageId, candidate, evnt.OccurenceDateUtc);
}
async private Task<ICommandHandler> Handle(OrderCreated e)
{
var envelope = new EventEnvelope<OrderCreated>
{
Timestamp = DateTime.UtcNow
,
Event = e
,
Username = "******"
};
return await ((ICommandHandler)this).Handle(envelope);
}
public void CanTolerateTransientExceptions()
{
var execution = 0;
var e = new FakeEvent();
var eventHandler = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { if (++execution == 1) { throw new ConcurrencyException(); } }, () => new Object());
var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler });
Processor.Process(message);
}
public static EventEnvelope FromEnvelope(EventEnvelope eventEnvelope)
{
var domainEvent = FromCommittedEvent(eventEnvelope.Event);
var newEventEnvelope = new EventEnvelope(
eventEnvelope.Offset,
eventEnvelope.PersistenceId,
eventEnvelope.SequenceNr,
domainEvent);
return(newEventEnvelope);
}
private static EventEnvelope Map(ResolvedEvent resolvedEvent)
{
var bytesAsString = Encoding.UTF8.GetString(resolvedEvent.Event.Data);
var a = JsonConvert.DeserializeObject(bytesAsString) as IEvent;
var jsonMetadata = Encoding.UTF8.GetString(resolvedEvent.Event.Metadata);
var metadata = JsonConvert.DeserializeObject <EventMetadata>(jsonMetadata);
var typeName = Type.GetType(metadata.Type);
var @event = (IEvent)JsonConvert.DeserializeObject(bytesAsString, typeName);
var envelope = new EventEnvelope(@event, metadata);
return(envelope);
}
public async Task HandleEvent(EventEnvelope eventEnvelope, CancellationToken stoppingToken)
{
try
{
bool initialEvent = false;
var storeKey = Projections.EventHandlerState.Projection.StoreKey(typeof(TEventStream));
Projections.EventHandlerState.Projection state;
try
{
state = await _eventHandlerStateStore.Get(storeKey).ConfigureAwait(false);
if (eventEnvelope.StreamPosition <= state.Audit.StreamPosition)
{
_logger.LogInformation("Ignoring event with stream position {@eventStreamPosition} because we have already processed to {@currentStreamPosition}", eventEnvelope.StreamPosition, state.Audit.StreamPosition);
return;
}
}
catch (ProjectionNotFoundException)
{
_logger.LogInformation("No state found");
initialEvent = true;
}
if (_projectionBuildersByEventType.TryGetValue(eventEnvelope.Event.GetType(), out var projectionBuilders))
{
var tasks = new Task[projectionBuilders.Count];
for (var index = 0; index < projectionBuilders.Count; index++)
{
tasks[index] = projectionBuilders[index](eventEnvelope.StreamPosition, eventEnvelope.Event, stoppingToken);
}
await Task.WhenAll(tasks);
}
var eventAudit = EventAudit.Create(DateTime.UtcNow, Constants.SystemUser, eventEnvelope.Event.Version, eventEnvelope.StreamPosition);
state = Projections.EventHandlerState.Projection.Create(eventAudit);
if (initialEvent)
{
await _eventHandlerStateStore.Create(storeKey, state).ConfigureAwait(false);
}
else
{
await _eventHandlerStateStore.Update(storeKey, state).ConfigureAwait(false);
}
}
catch (Exception ex)
{
_logger.LogWarning("Failed to build projection for {@event}. Exception: {@exception}", eventEnvelope.Event, ex);
throw;
}
}
public void On(EventEnvelope <ReleaseCandidateDeploymentFailedEvent> evnt)
{
var rc = evnt.Session.Load <ReleaseCandidate>(evnt.Payload.BuildId);
rc.Deployments.Add(new Deployment()
{
Date = evnt.OccurenceDateUtc,
UniqueId = evnt.Payload.UniqueDeploymentId,
Environment = evnt.Payload.Environment,
Success = false
});
}
public IActionResult PostAsync(EventEnvelope envelope)
{
if (config.EventSink)
{
// Authorization in this controller is entirely static, as this is the only mode Docker Registry supports
if (!string.IsNullOrEmpty(config.EventAuthorization))
{
if (!Request.Headers.ContainsKey("Authorization") ||
Request.Headers["Authorization"] != config.EventAuthorization)
{
return(Unauthorized());
}
}
if (envelope != null)
{
foreach (var e in envelope.Events)
{
switch (e.Action.ToLowerInvariant())
{
case "push":
if (LocalDockerClient.SupportedManifestTypes.Contains(e.Target.MediaType))
{
if (config.Documents?.Count > 0)
{
RequestIndex(e);
}
if (config.Vulnerabilities)
{
RequestScan(e);
}
}
break;
default:
logger.LogInformation($"Ignoring event {e.Id} - {e.Action} {e.Target?.MediaType} {e.Target?.Digest}");
break;
}
}
return(Ok());
}
else
{
return(BadRequest());
}
}
else
{
return(StatusCode(503, "Event sink service is not enabled"));
}
}
public void GetDynamicContentFromJsonTest()
{
TestEvent testEvent = new TestEvent("some event");
string json = JsonConvert.SerializeObject(testEvent);
EventEnvelope envelope = new EventEnvelope("Test", type => this.FromJson(type, json));
dynamic content = envelope.GetContent();
((DateTime)content.EventDate).ShouldBeEquivalentTo(testEvent.EventDate);
Assert.AreEqual(testEvent.EventId, Guid.Parse(content.EventId));
((string)content.Name).ShouldBeEquivalentTo(testEvent.Name);
((string)content.Value).ShouldBeEquivalentTo(testEvent.Value);
}
async private Task <ICommandHandler> Handle(OrderCreated e)
{
var envelope = new EventEnvelope <OrderCreated>
{
Timestamp = DateTime.UtcNow
,
Event = e
,
Username = "******"
};
return(await((ICommandHandler)this).Handle(envelope));
}
public void WillTimeoutEventuallyIfCannotExecuteHandler()
{
var e = new FakeEvent();
var eventHandler = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { throw new ConcurrencyException(); }, () => new Object());
var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
SystemTime.ClearOverride();
HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler });
Assert.Throws <TimeoutException>(() => Processor.Process(message));
}
public void Handle(
IUntypedActorContext actorContext,
IActorRef repository,
TProjectionContext projectionContext,
IActorRef manager,
EventEnvelope eventEnvelope)
{
var projector = FindOrCreate(eventEnvelope.PersistenceId, actorContext);
projector.Tell(new ProjectEvent <TProjectionContext> {
Context = projectionContext, Event = eventEnvelope
});
actorContext.GetLogger().Info("{0} - {1} - {2}", eventEnvelope.Event.GetType(), eventEnvelope.PersistenceId, eventEnvelope.SequenceNr);
}
public void RetrieveEventHandlersBasedOnEventType()
{
var e = new FakeEvent();
var eventHandler1 = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { }, () => new Object());
var eventHandler2 = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { }, () => new Object());
var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler1, eventHandler2 });
Processor.Process(message);
Assert.True(eventHandler1.Handled);
Assert.True(eventHandler2.Handled);
}
private async Task<ICommandHandler> Handle(EventEnvelope<OrderCreated> e)
{
// Create the queue if it does not exist already
string connectionString =
CloudConfigurationManager.GetSetting("EventsServiceBus");
try
{
var client =
TopicClient.CreateFromConnectionString(connectionString, "Events");
await client.SendAsync(new BrokeredMessage(e));
}
catch (Exception ex)
{
throw ex;
}
return this;
}
public void CanSerializeToJson()
{
var version = new EventVersion(3, 2, 1);
var aggregateId = Guid.Parse("512fe943-c9bd-49c3-8116-20c186c755af");
var correlationId = Guid.Parse("4fabd791-ef41-4d6b-9579-fcd9189d492b");
var envelope = new EventEnvelope(correlationId, aggregateId, version, new FakeEvent("My Event"));
var json = WriteJson(envelope);
Validate(json, @"
{
""a"": ""512fe943-c9bd-49c3-8116-20c186c755af"",
""v"": {
""v"": 3,
""c"": 2,
""i"": 1
},
""e"": {
""$type"": ""Test.Spark.Serialization.Converters.UsingEventEnvelopeConverter.FakeEvent, Spark.Serialization.Newtonsoft.Tests"",
""Property"": ""My Event""
},
""c"": ""4fabd791-ef41-4d6b-9579-fcd9189d492b""
}");
}
public void CanSerializeToBson()
{
var version = new EventVersion(3, 2, 1);
var aggregateId = Guid.Parse("512fe943-c9bd-49c3-8116-20c186c755af");
var correlationId = Guid.Parse("4fabd791-ef41-4d6b-9579-fcd9189d492b");
var envelope = new EventEnvelope(correlationId, aggregateId, version, new FakeEvent("My Event"));
var bson = WriteBson(envelope);
Validate(bson, "7AAAAAVhABAAAAAEQ+kvUb3Jw0mBFiDBhsdVrwN2ABoAAAAQdgADAAAAEGMAAgAAABBpAAEAAAAAA2UAlwAAAAIkdHlwZQBwAAAAVGVzdC5TcGFyay5TZXJpYWxpemF0aW9uLkNvbnZlcnRlcnMuVXNpbmdFdmVudEVudmVsb3BlQ29udmVydGVyLkZha2VFdmVudCwgU3BhcmsuU2VyaWFsaXphdGlvbi5OZXd0b25zb2Z0LlRlc3RzAAJQcm9wZXJ0eQAJAAAATXkgRXZlbnQAAAVjABAAAAAEkderT0Hva02VefzZGJ1JKwA=");
}
public void WillTimeoutEventuallyIfCannotExecuteHandler()
{
var e = new FakeEvent();
var eventHandler = new FakeEventHandler(typeof(Object), typeof(FakeEvent), (a, b) => { throw new ConcurrencyException(); }, () => new Object());
var envelope = new EventEnvelope(GuidStrategy.NewGuid(), GuidStrategy.NewGuid(), new EventVersion(1, 1, 1), e);
var message = Message.Create(GuidStrategy.NewGuid(), HeaderCollection.Empty, envelope);
SystemTime.ClearOverride();
HandlerRegistry.Setup(mock => mock.GetHandlersFor(e)).Returns(new EventHandler[] { eventHandler });
Assert.Throws<TimeoutException>(() => Processor.Process(message));
}
void On(EventEnvelope<InventoryItemRenamed> e) => items[e.Stream].Name = e.Event.NewName;
void On(EventEnvelope<InventoryItemDeactivated> e) => items[e.Stream].Active = false;
void On(EventEnvelope<InventoryItemCheckedOut> e) => items[e.Stream].Total -= e.Event.Quantity;
void On(EventEnvelope<InventoryItemCreated> e) => items[e.Stream] = new InventoryItemDetails(e.Event.Name, 0, true);
