public ConsumerPushResult PushMessageToClient(ResolvedEvent ev)
{
if (_state == null)
{
return ConsumerPushResult.NoMoreCapacity;
}
if (_state.AvailableCapacity == 0)
{
return ConsumerPushResult.NoMoreCapacity;
}
uint bucket = GetAssignmentId(ev);
if (_state.Assignments[bucket].State != BucketAssignment.BucketState.Assigned)
{
_state.AssignBucket(bucket);
}
if (!_state.Assignments[bucket].Node.Client.Push(ev))
{
return ConsumerPushResult.Skipped;
}
_state.RecordEventSent(bucket);
return ConsumerPushResult.Sent;
}
public static string SmartFormat(ResolvedEvent evnt, ICodec targetCodec)
{
var dto = CreateDataDto(evnt);
switch (targetCodec.ContentType)
{
case ContentType.Xml:
case ContentType.ApplicationXml:
{
var serializeObject = JsonConvert.SerializeObject(dto.data);
var deserializeXmlNode = JsonConvert.DeserializeXmlNode(serializeObject, "data");
return deserializeXmlNode.InnerXml;
}
case ContentType.Json:
return targetCodec.To(dto.data);
case ContentType.Atom:
case ContentType.EventXml:
{
var serializeObject = JsonConvert.SerializeObject(dto);
var deserializeXmlNode = JsonConvert.DeserializeXmlNode(serializeObject, "event");
return deserializeXmlNode.InnerXml;
}
case ContentType.EventJson:
return targetCodec.To(dto);
default:
throw new NotSupportedException();
}
}
public OutstandingMessage(Guid eventId, PersistentSubscriptionClient handlingClient, ResolvedEvent resolvedEvent, int retryCount) : this()
{
EventId = eventId;
HandlingClient = handlingClient;
ResolvedEvent = resolvedEvent;
RetryCount = retryCount;
}
public static string GetJsonEventReadResult(ResolvedEvent evnt, bool dataJson = true, bool metadataJson = true)
{
return string.Format(JsonEventReadFormat,
WrapIntoQuotes(evnt.Event.EventStreamId),
evnt.Event.EventNumber,
WrapIntoQuotes(evnt.Event.EventType),
dataJson ? JsonData : WrapIntoQuotes(AsString(evnt.Event.Data)),
metadataJson ? JsonMetadata : WrapIntoQuotes(AsString(evnt.Event.Metadata)));
}
private string GetLinkToFor(ResolvedEvent ev)
{
if (ev.Event == null) // Unresolved link so just use the bad/deleted link data.
{
return Encoding.UTF8.GetString(ev.Link.Data);
}
return string.Format("{0}@{1}", ev.Event.EventNumber, ev.Event.EventStreamId);
}
public void BeginParkMessage(ResolvedEvent ev,string reason, Action<ResolvedEvent, OperationResult> completed)
{
var metadata = new ParkedMessageMetadata {Added = DateTime.Now, Reason = reason, SubscriptionEventNumber = ev.OriginalEventNumber};
string data = GetLinkToFor(ev);
var parkedEvent = new Event(Guid.NewGuid(), SystemEventTypes.LinkTo, false, data, metadata.ToJson());
_ioDispatcher.WriteEvent(_parkedStreamId, ExpectedVersion.Any, parkedEvent, SystemAccount.Principal, x => WriteStateCompleted(completed, ev, x));
}
public ReadAllResult(ResolvedEvent[] events, int maxCount, TFPos currentPos, TFPos nextPos, TFPos prevPos, long tfEofPosition)
{
Ensure.NotNull(events, "events");
Events = events;
MaxCount = maxCount;
CurrentPos = currentPos;
NextPos = nextPos;
PrevPos = prevPos;
TfEofPosition = tfEofPosition;
}
public override ConsumerPushResult PushMessageToClient(ResolvedEvent ev)
{
for (int i = 0; i < Clients.Count; i++)
{
if (Clients.Peek().Push(ev))
{
return ConsumerPushResult.Sent;
}
var c = Clients.Dequeue();
Clients.Enqueue(c);
}
return ConsumerPushResult.NoMoreCapacity;
}
public virtual ConsumerPushResult PushMessageToClient(ResolvedEvent ev)
{
for (int i = 0; i < Clients.Count; i++)
{
var c = Clients.Dequeue();
var pushed = c.Push(ev);
Clients.Enqueue(c);
if (pushed)
{
return ConsumerPushResult.Sent;
}
}
return ConsumerPushResult.NoMoreCapacity;
}
public void can_handle_read_events_completed()
{
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
_distibutionPointCorrelationId, "a", 100, 100, ReadStreamResult.Success,
new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
1, 50, Guid.NewGuid(), Guid.NewGuid(), 50, 0, "a", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type", new byte[0], new byte[0]), 0)
}, null, false, "", 2, 4, false, 100));
}
when_wrapping_stream_event_appeared_with_deleted_event_should_not_downgrade_version_for_v2_clients()
{
var msg = new ClientMessage.StreamEventAppeared(Guid.NewGuid(),
ResolvedEvent.ForUnresolvedEvent(CreateDeletedEventRecord(), 0));
var package = _dispatcher.WrapMessage(msg, (byte)ClientVersion.V2);
Assert.IsNotNull(package, "Package is null");
Assert.AreEqual(TcpCommand.StreamEventAppeared, package.Value.Command, "TcpCommand");
var dto = package.Value.Data.Deserialize <StreamEventAppeared>();
Assert.IsNotNull(dto, "DTO is null");
Assert.AreEqual(long.MaxValue, dto.Event.Event.EventNumber, "Event Number");
}
public static HttpClientMessageDto.ReadEventCompletedText CreateDataDto(ResolvedEvent evnt)
{
var dto = new HttpClientMessageDto.ReadEventCompletedText(evnt);
if (evnt.Event.Flags.HasFlag(PrepareFlags.IsJson))
{
var deserializedData = Codec.Json.From<object>((string) dto.data);
var deserializedMetadata = Codec.Json.From<object>((string) dto.metadata);
if (deserializedData != null)
dto.data = deserializedData;
if (deserializedMetadata != null)
dto.metadata = deserializedMetadata;
}
return dto;
}
private void DeliverEvent(
EventStore.Core.Data.ResolvedEvent @event, long lastCommitPosition, TFPos currentFrom)
{
_deliveredEvents++;
EventRecord positionEvent = (@event.Link ?? @event.Event);
TFPos receivedPosition = @event.OriginalPosition.Value;
if (currentFrom > receivedPosition)
{
throw new Exception(
string.Format(
"ReadFromTF returned events in incorrect order. Last known position is: {0}. Received position is: {1}",
currentFrom, receivedPosition));
}
TFPos originalPosition;
if (@event.IsResolved)
{
if (positionEvent.Metadata != null && positionEvent.Metadata.Length > 0)
{
var parsedPosition =
positionEvent.Metadata.ParseCheckpointTagJson().Position;
originalPosition = parsedPosition != new TFPos(long.MinValue, long.MinValue)
? parsedPosition
: new TFPos(-1, @event.OriginalEvent.LogPosition);
}
else
{
originalPosition = new TFPos(-1, @event.OriginalEvent.LogPosition);
}
}
else
{
originalPosition = receivedPosition;
}
_publisher.Publish(
new ReaderSubscriptionMessage.CommittedEventDistributed(
EventReaderCorrelationId,
new ResolvedEvent(
positionEvent.EventStreamId, positionEvent.EventNumber, @event.Event.EventStreamId,
@event.Event.EventNumber, @event.Link != null, receivedPosition,
originalPosition, @event.Event.EventId, @event.Event.EventType,
(@event.Event.Flags & PrepareFlags.IsJson) != 0, @event.Event.Data, @event.Event.Metadata,
@event.Link == null ? null : @event.Link.Metadata, positionEvent.TimeStamp),
_stopOnEof ? (long?)null : receivedPosition.PreparePosition,
100.0f * positionEvent.LogPosition / lastCommitPosition, source: this.GetType()));
}
private void PublishCommand(ResolvedEvent resolvedEvent)
{
var command = resolvedEvent.Event.EventType;
Log.Debug("Response received: {command}", command);
switch (command)
{
case "$measured": {
var body = resolvedEvent.Event.Data.ParseJson <PartitionMeasuredResponse>();
_publisher.Publish(
new PartitionMeasured(
_workerId,
_masterProjectionId,
Guid.ParseExact(body.SubscriptionId, "N"),
body.Partition,
body.Size));
break;
}
case "$progress": {
var body = resolvedEvent.Event.Data.ParseJson <PartitionProcessingProgressResponse>();
_publisher.Publish(
new PartitionProcessingProgress(
_workerId,
_masterProjectionId,
Guid.ParseExact(body.SubscriptionId, "N"),
body.Progress));
break;
}
case "$result": {
var body = resolvedEvent.Event.Data.ParseJson <PartitionProcessingResultResponse>();
_publisher.Publish(
new PartitionProcessingResult(
_workerId,
_masterProjectionId,
Guid.ParseExact(body.SubscriptionId, "N"),
body.Partition,
Guid.ParseExact(body.CausedBy, "N"),
body.Position,
body.Result));
break;
}
default:
throw new Exception("Unknown response: " + command);
}
}
private void DeliverEvent(EventStore.Core.Data.ResolvedEvent pair, float progress, ref int sequenceNumber)
{
EventRecord positionEvent = pair.OriginalEvent;
if (positionEvent.EventNumber != sequenceNumber)
{
throw new InvalidOperationException(
string.Format(
"Event number {0} was expected in the stream {1}, but event number {2} was received",
sequenceNumber, _streamName, positionEvent.EventNumber));
}
sequenceNumber = positionEvent.EventNumber + 1;
var resolvedEvent = new ResolvedEvent(pair, null);
string deletedPartitionStreamId;
if (resolvedEvent.IsLinkToDeletedStream && !resolvedEvent.IsLinkToDeletedStreamTombstone)
{
return;
}
bool isDeletedStreamEvent = StreamDeletedHelper.IsStreamDeletedEventOrLinkToStreamDeletedEvent(resolvedEvent, out deletedPartitionStreamId);
if (isDeletedStreamEvent)
{
var deletedPartition = deletedPartitionStreamId;
if (_produceStreamDeletes)
{
_publisher.Publish(
//TODO: publish both link and event data
new ReaderSubscriptionMessage.EventReaderPartitionDeleted(
EventReaderCorrelationId, deletedPartition, source: this.GetType(), lastEventNumber: -1,
deleteEventOrLinkTargetPosition: null, deleteLinkOrEventPosition: resolvedEvent.EventOrLinkTargetPosition,
positionStreamId: resolvedEvent.PositionStreamId,
positionEventNumber: resolvedEvent.PositionSequenceNumber));
}
}
else if (!resolvedEvent.IsStreamDeletedEvent)
{
_publisher.Publish(
//TODO: publish both link and event data
new ReaderSubscriptionMessage.CommittedEventDistributed(
EventReaderCorrelationId, resolvedEvent, _stopOnEof ? (long?)null : positionEvent.LogPosition,
progress, source: this.GetType()));
}
}
public new void When()
{
_ab12Tag = new Dictionary <string, int> {
{ "a", 1 }, { "b", 2 }
};
_abStreams = new[] { "a", "b" };
_distibutionPointCorrelationId = Guid.NewGuid();
_fakeTimeProvider = new FakeTimeProvider();
_edp = new MultiStreamEventReader(
_ioDispatcher, _bus, _distibutionPointCorrelationId, null, 0, _abStreams, _ab12Tag, false,
_fakeTimeProvider);
_edp.Resume();
_firstEventId = Guid.NewGuid();
_secondEventId = Guid.NewGuid();
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
_distibutionPointCorrelationId, "a", 100, 100, ReadStreamResult.Success,
new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
1, 50, Guid.NewGuid(), _firstEventId, 50, 0, "a", ExpectedVersion.Any, _fakeTimeProvider.Now,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type1", new byte[] { 1 }, new byte[] { 2 })),
}, null, false, "", 2, 1, true, 200));
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
_distibutionPointCorrelationId, "b", 100, 100, ReadStreamResult.Success,
new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
2, 100, Guid.NewGuid(), _secondEventId, 100, 0, "b", ExpectedVersion.Any, _fakeTimeProvider.Now,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type1", new byte[] { 1 }, new byte[] { 2 })),
}, null, false, "", 3, 2, true, 200));
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
_distibutionPointCorrelationId, "a", 100, 100, ReadStreamResult.Success, new ResolvedEvent[] { }, null, false, "", 2, 1, true, 400));
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
_distibutionPointCorrelationId, "b", 100, 100, ReadStreamResult.Success, new ResolvedEvent[] { }, null, false, "", 3, 2, true, 400));
_fakeTimeProvider.AddTime(TimeSpan.FromMilliseconds(500));
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
_distibutionPointCorrelationId, "a", 100, 100, ReadStreamResult.Success, new ResolvedEvent[] { }, null, false, "", 2, 1, true, 600));
}
public void can_handle_following_read_events_completed()
{
var correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>().Last(x => x.EventStreamId == "a").CorrelationId;
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "a", 100, 100, ReadStreamResult.Success,
new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
3, 250, Guid.NewGuid(), Guid.NewGuid(), 250, 0, "a", ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type", new byte[0], new byte[0]))
}, null, false, "", 4, 4, false, 300));
}
protected void DeliverEvent(float progress, ResolvedEvent resolvedEvent, TFPos position,
EventStore.Core.Data.ResolvedEvent pair)
{
if (resolvedEvent.EventOrLinkTargetPosition <= _reader._lastEventPosition)
{
return;
}
_reader._lastEventPosition = resolvedEvent.EventOrLinkTargetPosition;
//TODO: this is incomplete. where reading from TF we need to handle actual deletes
string deletedPartitionStreamId;
if (resolvedEvent.IsLinkToDeletedStream && !resolvedEvent.IsLinkToDeletedStreamTombstone)
{
return;
}
bool isDeletedStreamEvent = StreamDeletedHelper.IsStreamDeletedEventOrLinkToStreamDeletedEvent(
resolvedEvent, pair.ResolveResult, out deletedPartitionStreamId);
if (isDeletedStreamEvent)
{
var deletedPartition = deletedPartitionStreamId;
if (_reader._includeDeletedStreamNotification)
{
_reader._publisher.Publish(
//TODO: publish both link and event data
new ReaderSubscriptionMessage.EventReaderPartitionDeleted(
_reader.EventReaderCorrelationId, deletedPartition, source: this.GetType(),
lastEventNumber: -1, deleteEventOrLinkTargetPosition: position,
deleteLinkOrEventPosition: resolvedEvent.EventOrLinkTargetPosition,
positionStreamId: resolvedEvent.PositionStreamId,
positionEventNumber: resolvedEvent.PositionSequenceNumber));
}
}
else
{
_reader._publisher.Publish(
//TODO: publish both link and event data
new ReaderSubscriptionMessage.CommittedEventDistributed(
_reader.EventReaderCorrelationId, resolvedEvent,
_reader._stopOnEof ? (long?)null : position.PreparePosition, progress,
source: this.GetType()));
}
}
public new void When()
{
_distributionCorrelationId = Guid.NewGuid();
_fakeTimeProvider = new FakeTimeProvider();
var fromPositions = new Dictionary <string, long>();
fromPositions.Add("$et-eventTypeOne", 0);
fromPositions.Add("$et-eventTypeTwo", 0);
_eventReader = new EventByTypeIndexEventReader(_bus, _distributionCorrelationId,
null, new [] { "eventTypeOne", "eventTypeTwo" },
false, new TFPos(0, 0),
fromPositions, true,
_fakeTimeProvider,
stopOnEof: true);
_eventReader.Resume();
_checkpointStreamCorrelationId = TimeoutRead("$et", Guid.Empty);
CompleteForwardStreamRead("$et-eventTypeOne", Guid.Empty, new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
1, 50, Guid.NewGuid(), Guid.NewGuid(), 50, 0, "$et-eventTypeOne", ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd | PrepareFlags.IsJson,
"$>", Helper.UTF8NoBom.GetBytes("0@test-stream"), Helper.UTF8NoBom.GetBytes(TFPosToMetadata(new TFPos(50, 50))))),
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
2, 150, Guid.NewGuid(), Guid.NewGuid(), 150, 0, "$et-eventTypeOne", ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"$>", Helper.UTF8NoBom.GetBytes("1@test-stream"), Helper.UTF8NoBom.GetBytes(TFPosToMetadata(new TFPos(150, 150)))))
});
CompleteForwardStreamRead("$et-eventTypeTwo", Guid.Empty, new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
1, 100, Guid.NewGuid(), Guid.NewGuid(), 100, 0, "$et-eventTypeTwo", ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd | PrepareFlags.IsJson,
"$>", Helper.UTF8NoBom.GetBytes("2@test-stream"), Helper.UTF8NoBom.GetBytes(TFPosToMetadata(new TFPos(100, 100))))),
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
2, 200, Guid.NewGuid(), Guid.NewGuid(), 200, 0, "$et-eventTypeTwo", ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"$>", Helper.UTF8NoBom.GetBytes("3@test-stream"), Helper.UTF8NoBom.GetBytes(TFPosToMetadata(new TFPos(200, 200)))))
});
}
private void DeliverEvent(
EventStore.Core.Data.ResolvedEvent @event, long lastCommitPosition, TFPos currentFrom)
{
EventRecord linkEvent = @event.Link;
EventRecord targetEvent = @event.Event ?? linkEvent;
EventRecord positionEvent = (linkEvent ?? targetEvent);
TFPos receivedPosition = @event.OriginalPosition.Value;
if (currentFrom > receivedPosition)
{
throw new Exception(
string.Format(
"ReadFromTF returned events in incorrect order. Last known position is: {0}. Received position is: {1}",
currentFrom, receivedPosition));
}
var resolvedEvent = new ResolvedEvent(@event, null);
string deletedPartitionStreamId;
if (resolvedEvent.IsLinkToDeletedStream && !resolvedEvent.IsLinkToDeletedStreamTombstone)
{
return;
}
bool isDeletedStreamEvent = StreamDeletedHelper.IsStreamDeletedEventOrLinkToStreamDeletedEvent(
resolvedEvent, out deletedPartitionStreamId);
_publisher.Publish(
new ReaderSubscriptionMessage.CommittedEventDistributed(
EventReaderCorrelationId,
resolvedEvent,
_stopOnEof ? (long?)null : receivedPosition.PreparePosition,
100.0f * positionEvent.LogPosition / lastCommitPosition,
source: this.GetType()));
if (isDeletedStreamEvent)
{
_publisher.Publish(
new ReaderSubscriptionMessage.EventReaderPartitionDeleted(
EventReaderCorrelationId, deletedPartitionStreamId, source: this.GetType(), lastEventNumber: -1,
deleteEventOrLinkTargetPosition: resolvedEvent.EventOrLinkTargetPosition,
deleteLinkOrEventPosition: resolvedEvent.LinkOrEventPosition,
positionStreamId: positionEvent.EventStreamId, positionEventNumber: positionEvent.EventNumber));
}
}
public void cannot_handle_repeated_read_events_completed()
{
Assert.Throws <InvalidOperationException>(() => {
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
_distibutionPointCorrelationId, "stream", 100, 100, ReadStreamResult.Success,
new[] {
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
10, 50, Guid.NewGuid(), Guid.NewGuid(), 50, 0, "stream", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin |
PrepareFlags.TransactionEnd,
"event_type", new byte[0], new byte[0]))
}, null, false, "", 11, 10, true, 100));
});
}
public void cannot_handle_repeated_read_events_completed()
{
var correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>().Last().CorrelationId;
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "stream", 100, 100, ReadStreamResult.Success,
new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
10, 50, Guid.NewGuid(), Guid.NewGuid(), 50, 0, "stream", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type", new byte[0], new byte[0]))
}, null, false, "", 11, 10, true, 100));
Assert.AreEqual(1, HandledMessages.OfType <ReaderSubscriptionMessage.Faulted>().Count());
}
public ClientMessage.ReadStreamEventsBackwardCompleted ReadOrderStream(
ClientMessage.ReadStreamEventsBackward message) {
ResolvedEvent[] events;
if (!_hasRead) {
var checkpoint =
CheckpointTag.FromStreamPositions(0, new Dictionary<string, long> {{"a", 5}, {"b", 5}, {"c", 5}});
events = IODispatcherTestHelpers.CreateResolvedEvent(message.EventStreamId, "$>",
"10@a", checkpoint.ToJsonString(new ProjectionVersion(3, 0, 1)));
_hasRead = true;
} else {
events = new ResolvedEvent[0] { };
}
return new ClientMessage.ReadStreamEventsBackwardCompleted(message.CorrelationId, message.EventStreamId,
message.FromEventNumber,
message.MaxCount, ReadStreamResult.Success, events, null, true, "",
message.FromEventNumber - events.Length, message.FromEventNumber, true, 10000);
}
public void cannot_handle_repeated_read_events_completed()
{
var correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>().Last(x => x.EventStreamId == "a").CorrelationId;
Assert.Throws <InvalidOperationException>(() => {
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "a", 100, 100, ReadStreamResult.Success,
new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
2, 50, Guid.NewGuid(), Guid.NewGuid(), 50, 0, "a", ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type", new byte[0], new byte[0]))
}, null, false, "", 3, 4, false, 100));
});
}
public new void When()
{
_distibutionPointCorrelationId = Guid.NewGuid();
_fakeTimeProvider = new FakeTimeProvider();
_edp = new StreamEventReader(_bus, _distibutionPointCorrelationId, null, "stream", 10, _fakeTimeProvider,
false,
produceStreamDeletes: false);
_edp.Resume();
_firstEventId = Guid.NewGuid();
_secondEventId = Guid.NewGuid();
var correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>().Last()
.CorrelationId;
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "stream", 100, 100, ReadStreamResult.Success,
new[] {
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
10, 50, Guid.NewGuid(), _firstEventId, 50, 0, "stream", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type1", new byte[] { 1 }, new byte[] { 2 })),
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
11, 100, Guid.NewGuid(), _secondEventId, 100, 0, "stream", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type2", new byte[] { 3 }, new byte[] { 4 }))
}, null, false, "", 12, 11, true, 200));
correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>().Last()
.CorrelationId;
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "stream", 100, 100, ReadStreamResult.Success,
new ResolvedEvent[] { }, null, false, "", 12, 11, true, 400));
_fakeTimeProvider.AddToUtcTime(TimeSpan.FromMilliseconds(500));
correlationId = ((ClientMessage.ReadStreamEventsForward)(_consumer.HandledMessages
.OfType <AwakeServiceMessage.SubscribeAwake>().Last().ReplyWithMessage)).CorrelationId;
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "stream", 100, 100, ReadStreamResult.Success,
new ResolvedEvent[] { }, null, false, "", 12, 11, true, 400));
}
protected void SendPrerecordedEvent(
EventStore.Core.Data.ResolvedEvent pair, CheckpointTag positionTag,
long prerecordedEventMessageSequenceNumber)
{
var position = pair.OriginalEvent;
var committedEvent = new ReaderSubscriptionMessage.CommittedEventDistributed(
Guid.Empty,
new ResolvedEvent(
position.EventStreamId, position.EventNumber, pair.Event.EventStreamId, pair.Event.EventNumber,
pair.Link != null, new TFPos(-1, position.LogPosition), new TFPos(-1, pair.Event.LogPosition),
pair.Event.EventId, pair.Event.EventType, (pair.Event.Flags & PrepareFlags.IsJson) != 0,
pair.Event.Data, pair.Event.Metadata, pair.Link == null ? null : pair.Link.Metadata,
pair.Event.TimeStamp), null, -1, source: this.GetType());
_publisher.Publish(
EventReaderSubscriptionMessage.CommittedEventReceived.FromCommittedEventDistributed(
committedEvent, positionTag, null, _projectionCorrelationId,
prerecordedEventMessageSequenceNumber));
}
public new void When()
{
_streamEventReader.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
_distibutionPointCorrelationId, _streamId, 100, 100, ReadStreamResult.Success,
new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
10, 50, Guid.NewGuid(), _firstEventId, 50, 0, _streamId, ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type1", new byte[] { 1 }, new byte[] { 2 })),
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
11, 100, Guid.NewGuid(), _secondEventId, 100, 0, _streamId, ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd | PrepareFlags.IsJson,
"event_type2", new byte[] { 3 }, new byte[] { 4 }))
}, null, false, "", 12, 11, true, 200));
}
public ReadEventCompletedText(ResolvedEvent evnt)
{
if (evnt.Event != null)
{
eventStreamId = evnt.Event.EventStreamId;
eventNumber = evnt.Event.EventNumber;
eventType = evnt.Event.EventType;
data = Helper.UTF8NoBom.GetString(evnt.Event.Data ?? Empty.ByteArray);
metadata = Helper.UTF8NoBom.GetString(evnt.Event.Metadata ?? Empty.ByteArray);
}
else
{
eventStreamId = null;
eventNumber = EventNumber.Invalid;
eventType = null;
data = null;
metadata = null;
}
}
private void HandleEvents(string stream, long[] eventNumbers)
{
string eventType = "event_type";
List <ResolvedEvent> events = new List <ResolvedEvent>();
foreach (long eventNumber in eventNumbers)
{
events.Add(
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
eventNumber, 50 * (eventNumber + 1), Guid.NewGuid(), Guid.NewGuid(), 50 * (eventNumber + 1),
0, stream, ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
eventType, new byte[] { 0 }, new byte[] { 0 }
)
)
);
}
long start, end;
if (eventNumbers.Length > 0)
{
start = eventNumbers[0];
end = eventNumbers[eventNumbers.Length - 1];
}
else
{
start = _fromSequenceNumber;
end = _fromSequenceNumber;
}
var correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>()
.Last(x => x.EventStreamId == stream).CorrelationId;
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, stream, start, 100, ReadStreamResult.Success, events.ToArray(), null, false, "",
start + 1, end, true, 200)
);
}
when_wrapping_read_all_events_forward_completed_with_deleted_event_should_not_downgrade_last_event_number_for_v2_clients()
{
var events = new ResolvedEvent[] {
ResolvedEvent.ForUnresolvedEvent(CreateDeletedEventRecord(), 0),
};
var msg = new ClientMessage.ReadAllEventsForwardCompleted(Guid.NewGuid(), ReadAllResult.Success, "", events,
new StreamMetadata(), true, 10, new TFPos(0, 0),
new TFPos(200, 200), new TFPos(0, 0), 100);
var package = _dispatcher.WrapMessage(msg, (byte)ClientVersion.V2);
Assert.IsNotNull(package, "Package is null");
Assert.AreEqual(TcpCommand.ReadAllEventsForwardCompleted, package.Value.Command, "TcpCommand");
var dto = package.Value.Data.Deserialize <ReadAllEventsCompleted>();
Assert.IsNotNull(dto, "DTO is null");
Assert.AreEqual(1, dto.Events.Count(), "Number of events");
Assert.AreEqual(long.MaxValue, dto.Events[0].Event.EventNumber, "Event Number");
}
private void DeliverEvent(EventStore.Core.Data.ResolvedEvent pair, float progress)
{
_deliveredEvents++;
var positionEvent = pair.OriginalEvent;
string streamId = positionEvent.EventStreamId;
long fromPosition = _fromPositions.Streams[streamId];
if (positionEvent.EventNumber != fromPosition)
{
throw new InvalidOperationException(
string.Format(
"Event number {0} was expected in the stream {1}, but event number {2} was received",
fromPosition, streamId, positionEvent.EventNumber));
}
_fromPositions = _fromPositions.UpdateStreamPosition(streamId, positionEvent.EventNumber + 1);
_publisher.Publish(
//TODO: publish both link and event data
new ReaderSubscriptionMessage.CommittedEventDistributed(
EventReaderCorrelationId, new ResolvedEvent(pair, null),
_stopOnEof ? (long?)null : positionEvent.LogPosition, progress, source: this.GetType()));
}
public new void When()
{
_ab12Tag = new Dictionary <string, long> {
{ "a", 1 }, { "b", 0 }
};
_abStreams = new[] { "a", "b" };
_distibutionPointCorrelationId = Guid.NewGuid();
_edp = new MultiStreamEventReader(
_ioDispatcher, _bus, _distibutionPointCorrelationId, null, 0, _abStreams, _ab12Tag, false,
new RealTimeProvider());
_edp.Resume();
_firstEventId = Guid.NewGuid();
_secondEventId = Guid.NewGuid();
var correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>()
.Last(x => x.EventStreamId == "a").CorrelationId;
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "a", 100, 100, ReadStreamResult.Success,
new[] {
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
1, 50, Guid.NewGuid(), _firstEventId, 50, 0, "a", ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type1", new byte[] { 1 }, new byte[] { 2 })),
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
2, 100, Guid.NewGuid(), _secondEventId, 100, 0, "a", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type2", new byte[] { 3 }, new byte[] { 4 }))
}, null, false, "", 3, 2, true, 200));
correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>()
.Last(x => x.EventStreamId == "b").CorrelationId;
_edp.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "b", 100, 100, ReadStreamResult.Success, new ResolvedEvent[0], null, false, "",
-1, ExpectedVersion.NoStream, true, 200));
}
public new void When()
{
_distributionCorrelationId = Guid.NewGuid();
_fakeTimeProvider = new FakeTimeProvider();
var fromPositions = new Dictionary <string, long>();
fromPositions.Add("$et-eventTypeOne", 0);
fromPositions.Add("$et-eventTypeTwo", 0);
_eventReader = new EventByTypeIndexEventReader(_bus, _distributionCorrelationId,
null, new string[] { "eventTypeOne", "eventTypeTwo" },
false, new TFPos(0, 0),
fromPositions, true,
_fakeTimeProvider,
stopOnEof: true);
_eventReader.Resume();
CompleteForwardStreamRead("$et-eventTypeOne", Guid.Empty);
CompleteForwardStreamRead("$et-eventTypeTwo", Guid.Empty);
CompleteBackwardStreamRead("$et", Guid.Empty);
_readAllEventsForwardCorrelationId = TimeoutRead("$all", Guid.Empty);
CompleteForwardAllStreamRead(_readAllEventsForwardCorrelationId, new[]
{
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
1, 50, Guid.NewGuid(), Guid.NewGuid(), 50, 0, "test_stream", ExpectedVersion.Any,
_fakeTimeProvider.Now,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"eventTypeOne", new byte[] { 1 }, new byte[] { 2 }), 100),
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
2, 150, Guid.NewGuid(), Guid.NewGuid(), 150, 0, "test_stream", ExpectedVersion.Any,
_fakeTimeProvider.Now,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"eventTypeTwo", new byte[] { 1 }, new byte[] { 2 }), 200),
});
}
public void HandleReadCompleted(ResolvedEvent[] events, int newposition, bool isEndOfStream)
{
lock (_lock)
{
if ((_state & PersistentSubscriptionState.OutstandingPageRequest) == 0) return;
_state &= ~PersistentSubscriptionState.OutstandingPageRequest;
if (_streamBuffer.Live) return;
foreach (var ev in events)
{
_streamBuffer.AddReadMessage(new OutstandingMessage(ev.OriginalEvent.EventId, null, ev, 0));
}
if (_streamBuffer.Live)
{
SetLive();
}
if (isEndOfStream)
{
SetLive();
_streamBuffer.MoveToLive();
return;
}
_lastPulledEvent = newposition;
TryReadingNewBatch();
TryPushingMessagesToClients();
}
}
private static TcpClientMessageDto.ResolvedEvent[] ConvertToResolvedEvents(ResolvedEvent[] events)
{
var result = new TcpClientMessageDto.ResolvedEvent[events.Length];
for (int i = 0; i < events.Length; ++i)
{
result[i] = new TcpClientMessageDto.ResolvedEvent(events[i]);
}
return result;
}
public new void When()
{
_ab12Tag = new Dictionary <string, long> {
{ "a", 1 }, { "b", 2 }
};
_abStreams = new[] { "a", "b" };
_distibutionPointCorrelationId = Guid.NewGuid();
_eventReader = new MultiStreamEventReader(
_ioDispatcher, _bus, _distibutionPointCorrelationId, null, 0, _abStreams, _ab12Tag, false,
new RealTimeProvider());
_eventReader.Resume();
var correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>()
.Last(x => x.EventStreamId == "a").CorrelationId;
_eventReader.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "a", 100, 100, ReadStreamResult.Success,
new[] {
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
1, 50, Guid.NewGuid(), Guid.NewGuid(), 50, 0, "a", ExpectedVersion.Any, DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd |
PrepareFlags.IsJson,
"event_type1", new byte[] { 1 }, new byte[] { 2 })),
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
2, 150, Guid.NewGuid(), Guid.NewGuid(), 150, 0, "a", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type2", new byte[] { 3 }, new byte[] { 4 }))
}, null, false, "", 3, 2, true, 200));
//timeout follows
_eventReader.Handle(
new ProjectionManagementMessage.Internal.ReadTimeout(correlationId, "a"));
correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>()
.Last(x => x.EventStreamId == "b").CorrelationId;
_eventReader.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "b", 100, 100, ReadStreamResult.Success,
new[] {
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
2, 100, Guid.NewGuid(), Guid.NewGuid(), 100, 0, "b", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type1", new byte[] { 1 }, new byte[] { 2 })),
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
3, 200, Guid.NewGuid(), Guid.NewGuid(), 200, 0, "b", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type2", new byte[] { 3 }, new byte[] { 4 }))
}, null, false, "", 4, 3, true, 200));
//timeout follows
_eventReader.Handle(
new ProjectionManagementMessage.Internal.ReadTimeout(correlationId, "b"));
correlationId = _consumer.HandledMessages.OfType <ClientMessage.ReadStreamEventsForward>()
.Last(x => x.EventStreamId == "a").CorrelationId;
_consumer.HandledMessages.Clear();
//timeout before read completes
_eventReader.Handle(
new ProjectionManagementMessage.Internal.ReadTimeout(correlationId, "a"));
_eventReader.Handle(
new ClientMessage.ReadStreamEventsForwardCompleted(
correlationId, "a", 100, 100, ReadStreamResult.Success,
new[] {
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
3, 300, Guid.NewGuid(), Guid.NewGuid(), 300, 0, "a", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd |
PrepareFlags.IsJson,
"event_type1", new byte[] { 4 }, new byte[] { 6 })),
ResolvedEvent.ForUnresolvedEvent(
new EventRecord(
4, 400, Guid.NewGuid(), Guid.NewGuid(), 400, 0, "a", ExpectedVersion.Any,
DateTime.UtcNow,
PrepareFlags.SingleWrite | PrepareFlags.TransactionBegin | PrepareFlags.TransactionEnd,
"event_type2", new byte[] { 6 }, new byte[] { 8 }))
}, null, false, "", 3, 2, true, 200));
}
public ReadAllEventsBackwardCompleted(Guid correlationId, ReadAllResult result, string error, ResolvedEvent[] events,
StreamMetadata streamMetadata, bool isCachePublic, int maxCount,
TFPos currentPos, TFPos nextPos, TFPos prevPos, long tfLastCommitPosition)
{
Ensure.NotNull(events, "events");
CorrelationId = correlationId;
Result = result;
Error = error;
Events = events;
StreamMetadata = streamMetadata;
IsCachePublic = isCachePublic;
MaxCount = maxCount;
CurrentPos = currentPos;
NextPos = nextPos;
PrevPos = prevPos;
TfLastCommitPosition = tfLastCommitPosition;
}
public ReadEventCompleted(Guid correlationId, string eventStreamId, ReadEventResult result,
ResolvedEvent record, StreamMetadata streamMetadata, bool isCachePublic, string error)
{
Ensure.NotNullOrEmpty(eventStreamId, "eventStreamId");
if (result == ReadEventResult.Success)
Ensure.NotNull(record.Event, "record.Event");
CorrelationId = correlationId;
EventStreamId = eventStreamId;
Result = result;
Record = record;
StreamMetadata = streamMetadata;
IsCachePublic = isCachePublic;
Error = error;
}
private void RetryMessage(ResolvedEvent @event, int count)
{
Log.Debug("Retrying message {0} {1}/{2}", SubscriptionId, @event.OriginalStreamId, @event.OriginalPosition);
_outstandingMessages.Remove(@event.OriginalEvent.EventId);
_pushClients.RemoveProcessingMessage(@event.OriginalEvent.EventId);
_streamBuffer.AddRetry(new OutstandingMessage(@event.OriginalEvent.EventId, null, @event, count + 1));
}
private void ParkMessage(ResolvedEvent resolvedEvent, string reason, int count)
{
_settings.MessageParker.BeginParkMessage(resolvedEvent, reason, (e, result) =>
{
if (result != OperationResult.Success)
{
if (count < 5)
{
Log.Info("Unable to park message {0}/{1} operation failed {2} retrying.", e.OriginalStreamId,
e.OriginalEventNumber, result);
ParkMessage(e, reason, count + 1);
return;
}
Log.Error("Unable to park message {0}/{1} operation failed {2} after retries. Possible message loss.", e.OriginalStreamId,
e.OriginalEventNumber, result);
}
lock (_lock)
{
_outstandingMessages.Remove(e.OriginalEvent.EventId);
_pushClients.RemoveProcessingMessage(e.OriginalEvent.EventId);
TryPushingMessagesToClients();
}
});
}
private void DeliverEventRetrievedFromTf(EventStore.Core.Data.ResolvedEvent pair, float progress, TFPos position)
{
var resolvedEvent = new ResolvedEvent(pair, null);
DeliverEvent(progress, resolvedEvent, position);
}
public PendingEvent(EventStore.Core.Data.ResolvedEvent resolvedEvent, TFPos tfPosition, float progress)
{
ResolvedEvent = resolvedEvent;
Progress = progress;
TfPosition = tfPosition;
}
private void PublishCommand(EventStore.Core.Data.ResolvedEvent resolvedEvent)
{
var command = resolvedEvent.Event.EventType;
if (!Logging.FilteredMessages.Contains(command))
{
Log.Debug("PROJECTIONS: Command received: {eventNumber}@{command}", resolvedEvent.OriginalEventNumber,
command);
}
switch (command)
{
case "$create-prepared": {
var commandBody = resolvedEvent.Event.Data.ParseJson <CreatePreparedCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.CreatePrepared(
Guid.ParseExact(commandBody.Id, "N"),
Guid.Empty,
commandBody.Name,
commandBody.Version,
commandBody.Config.ToConfig(),
commandBody.SourceDefinition,
commandBody.HandlerType,
commandBody.Query));
break;
}
case "$create-and-prepare": {
var commandBody = resolvedEvent.Event.Data.ParseJson <CreateAndPrepareCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.CreateAndPrepare(
Guid.ParseExact(commandBody.Id, "N"),
Guid.Empty,
commandBody.Name,
commandBody.Version,
commandBody.Config.ToConfig(),
commandBody.HandlerType,
commandBody.Query));
break;
}
case "$create-and-prepare-slave": {
var commandBody = resolvedEvent.Event.Data.ParseJson <CreateAndPrepareSlaveCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.CreateAndPrepareSlave(
Guid.ParseExact(commandBody.Id, "N"),
Guid.Empty,
commandBody.Name,
commandBody.Version,
commandBody.Config.ToConfig(),
Guid.ParseExact(commandBody.MasterWorkerId, "N"),
Guid.ParseExact(commandBody.MasterCoreProjectionId, "N"),
commandBody.HandlerType,
commandBody.Query));
break;
}
case "$spool-stream-reading": {
var commandBody = resolvedEvent.Event.Data.ParseJson <SpoolStreamReadingCommand>();
_publisher.Publish(
new ReaderSubscriptionManagement.SpoolStreamReadingCore(
Guid.ParseExact(commandBody.SubscriptionId, "N"),
commandBody.StreamId,
commandBody.CatalogSequenceNumber,
commandBody.LimitingCommitPosition));
break;
}
case "$load-stopped": {
var commandBody = resolvedEvent.Event.Data.ParseJson <LoadStoppedCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.LoadStopped(
Guid.ParseExact(commandBody.Id, "N"),
Guid.Empty));
break;
}
case "$start": {
var commandBody = resolvedEvent.Event.Data.ParseJson <StartCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.Start(Guid.ParseExact(commandBody.Id, "N"), Guid.Empty));
break;
}
case "$stop": {
var commandBody = resolvedEvent.Event.Data.ParseJson <StopCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.Stop(Guid.ParseExact(commandBody.Id, "N"), Guid.Empty));
break;
}
case "$kill": {
var commandBody = resolvedEvent.Event.Data.ParseJson <KillCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.Kill(Guid.ParseExact(commandBody.Id, "N"), Guid.Empty));
break;
}
case "$dispose": {
var commandBody = resolvedEvent.Event.Data.ParseJson <DisposeCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.Dispose(Guid.ParseExact(commandBody.Id, "N"), Guid.Empty));
break;
}
case "$get-state": {
var commandBody = resolvedEvent.Event.Data.ParseJson <GetStateCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.GetState(
Guid.ParseExact(commandBody.CorrelationId, "N"),
Guid.ParseExact(commandBody.Id, "N"),
commandBody.Partition,
Guid.Empty));
break;
}
case "$get-result": {
var commandBody = resolvedEvent.Event.Data.ParseJson <GetResultCommand>();
_publisher.Publish(
new CoreProjectionManagementMessage.GetResult(
Guid.ParseExact(commandBody.CorrelationId, "N"),
Guid.ParseExact(commandBody.Id, "N"),
commandBody.Partition,
Guid.Empty));
break;
}
case "$slave-projections-started": {
var commandBody = resolvedEvent.Event.Data.ParseJson <SlaveProjectionsStartedResponse>();
_publisher.Publish(
new ProjectionManagementMessage.SlaveProjectionsStarted(
Guid.ParseExact(commandBody.CorrelationId, "N"),
Guid.Empty,
commandBody.SlaveProjections));
break;
}
default:
throw new Exception("Unknown command: " + command);
}
}
public static EntryElement ToEntry(ResolvedEvent eventLinkPair, string userHostName, EmbedLevel embedContent)
{
if (eventLinkPair.Event == null || userHostName == null)
return null;
var evnt = eventLinkPair.Event;
EntryElement entry;
if (embedContent > EmbedLevel.None)
{
var richEntry = new RichEntryElement();
entry = richEntry;
richEntry.EventType = evnt.EventType;
richEntry.EventNumber = evnt.EventNumber;
richEntry.StreamId = evnt.EventStreamId;
richEntry.PositionEventNumber = (eventLinkPair.Link ?? eventLinkPair.Event).EventNumber;
richEntry.PositionStreamId = (eventLinkPair.Link ?? eventLinkPair.Event).EventStreamId;
richEntry.IsJson = (evnt.Flags & PrepareFlags.IsJson) != 0;
if (embedContent >= EmbedLevel.Body)
{
if (richEntry.IsJson)
{
if (embedContent >= EmbedLevel.PrettyBody)
try
{
richEntry.Data = Encoding.UTF8.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(Encoding.UTF8.GetString(evnt.Data));
}
catch
{
// ignore - we tried
}
else
richEntry.Data = Encoding.UTF8.GetString(evnt.Data);
}
else if (embedContent >= EmbedLevel.TryHarder)
{
try
{
richEntry.Data = Encoding.UTF8.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(richEntry.Data);
// it is json if successed
richEntry.IsJson = true;
}
catch
{
// ignore - we tried
}
}
// metadata
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.MetaData = Encoding.UTF8.GetString(evnt.Metadata);
richEntry.IsMetaData = richEntry.MetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.MetaData = FormatJson(richEntry.MetaData);
}
catch
{
// ignore - we tried
}
var lnk = eventLinkPair.Link;
if (lnk != null)
{
try
{
richEntry.LinkMetaData = Encoding.UTF8.GetString(lnk.Metadata);
richEntry.IsLinkMetaData = richEntry.LinkMetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.LinkMetaData = FormatJson(richEntry.LinkMetaData);
}
catch
{
// ignore - we tried
}
}
}
}
}
else
{
entry = new EntryElement();
}
var escapedStreamId = Uri.EscapeDataString(evnt.EventStreamId);
entry.SetTitle(evnt.EventNumber + "@" + evnt.EventStreamId);
entry.SetId(HostName.Combine(userHostName, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.SetUpdated(evnt.TimeStamp);
entry.SetAuthor(AtomSpecs.Author);
entry.SetSummary(evnt.EventType);
entry.AddLink("edit", HostName.Combine(userHostName, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.AddLink(null, HostName.Combine(userHostName, "/streams/{0}/event/{1}?format=text", escapedStreamId, evnt.EventNumber), ContentType.PlainText);
entry.AddLink("alternate", HostName.Combine(userHostName, "/streams/{0}/event/{1}?format=json", escapedStreamId, evnt.EventNumber), ContentType.Json);
entry.AddLink("alternate", HostName.Combine(userHostName, "/streams/{0}/event/{1}?format=xml", escapedStreamId, evnt.EventNumber), ContentType.Xml);
return entry;
}
private long?EventPairToPosition(EventStore.Core.Data.ResolvedEvent resolvedEvent)
{
return(resolvedEvent.OriginalEvent.LogPosition);
}
public void NotifyLiveSubscriptionMessage(ResolvedEvent resolvedEvent)
{
lock (_lock)
{
if (resolvedEvent.OriginalEvent.EventNumber < _settings.StartFrom) return;
if (_state == PersistentSubscriptionState.NotReady) return;
_statistics.SetLastKnownEventNumber(resolvedEvent.OriginalEventNumber);
var waslive = _streamBuffer.Live; //hacky
_streamBuffer.AddLiveMessage(new OutstandingMessage(resolvedEvent.OriginalEvent.EventId, null,
resolvedEvent, 0));
if (!_streamBuffer.Live)
{
SetBehind();
if (waslive) _lastPulledEvent = resolvedEvent.OriginalEventNumber;
}
TryPushingMessagesToClients();
}
}
public void AddMessageAsProcessing(ResolvedEvent ev, PersistentSubscriptionClient client)
{
lock (_lock)
{
_outstandingMessages.StartMessage(new OutstandingMessage(ev.OriginalEvent.EventId, client, ev, 0),
DateTime.Now + _settings.MessageTimeout);
}
}
private void PublishCommand(ResolvedEvent resolvedEvent)
{
var command = resolvedEvent.Event.EventType;
Log.Debug("Response received: {0}", command);
switch (command)
{
case "$measured":
{
var body = resolvedEvent.Event.Data.ParseJson<PartitionMeasuredResponse>();
_publisher.Publish(
new PartitionMeasured(
_workerId,
_masterProjectionId,
Guid.ParseExact(body.SubscriptionId, "N"),
body.Partition,
body.Size));
break;
}
case "$progress":
{
var body = resolvedEvent.Event.Data.ParseJson<PartitionProcessingProgressResponse>();
_publisher.Publish(
new PartitionProcessingProgress(
_workerId,
_masterProjectionId,
Guid.ParseExact(body.SubscriptionId, "N"),
body.Progress));
break;
}
case "$result":
{
var body = resolvedEvent.Event.Data.ParseJson<PartitionProcessingResultResponse>();
_publisher.Publish(
new PartitionProcessingResult(
_workerId,
_masterProjectionId,
Guid.ParseExact(body.SubscriptionId, "N"),
body.Partition,
Guid.ParseExact(body.CausedBy, "N"),
body.Position,
body.Result));
break;
}
default:
throw new Exception("Unknown response: " + command);
}
}
public void HandleParkedReadCompleted(ResolvedEvent[] events, int newposition, bool isEndofStrem, int stopAt)
{
lock (_lock)
{
if ((_state & PersistentSubscriptionState.ReplayingParkedMessages) == 0) return;
foreach (var ev in events)
{
if (ev.OriginalEventNumber == stopAt)
{
break;
}
Log.Debug("Retrying event {0} on subscription {1}", ev.OriginalEvent.EventId, _settings.SubscriptionId);
_streamBuffer.AddRetry(new OutstandingMessage(ev.OriginalEvent.EventId, null, ev, 0));
}
TryPushingMessagesToClients();
if (isEndofStrem || stopAt <= newposition)
{
var replayedEnd = newposition == -1 ? stopAt : Math.Min(stopAt, newposition);
_settings.MessageParker.BeginMarkParkedMessagesReprocessed(replayedEnd);
_state ^= PersistentSubscriptionState.ReplayingParkedMessages;
}
else
{
TryReadingParkedMessagesFrom(newposition, stopAt);
}
}
}
public void SetLoadedEvent(EventStore.Core.Data.ResolvedEvent eventLinkPair)
{
_result = eventLinkPair;
}
public void RetrySingleMessage(ResolvedEvent @event)
{
_streamBuffer.AddRetry(new OutstandingMessage(@event.OriginalEvent.EventId, null, @event, 0));
}
public static EntryElement ToEntry(ResolvedEvent eventLinkPair, Uri requestedUrl, EmbedLevel embedContent, bool singleEntry = false)
{
if (requestedUrl == null)
return null;
var evnt = eventLinkPair.Event;
var link = eventLinkPair.Link;
EntryElement entry;
if (embedContent > EmbedLevel.Content && evnt != null)
{
var richEntry = new RichEntryElement();
entry = richEntry;
richEntry.EventId = evnt.EventId;
richEntry.EventType = evnt.EventType;
richEntry.EventNumber = evnt.EventNumber;
richEntry.StreamId = evnt.EventStreamId;
richEntry.PositionEventNumber = eventLinkPair.OriginalEvent.EventNumber;
richEntry.PositionStreamId = eventLinkPair.OriginalEvent.EventStreamId;
richEntry.IsJson = (evnt.Flags & PrepareFlags.IsJson) != 0;
if (embedContent >= EmbedLevel.Body && eventLinkPair.Event != null)
{
if (richEntry.IsJson)
{
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(Helper.UTF8NoBom.GetString(evnt.Data));
}
catch
{
// ignore - we tried
}
}
else
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
}
else if (embedContent >= EmbedLevel.TryHarder)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(richEntry.Data);
// it is json if successed
richEntry.IsJson = true;
}
catch
{
// ignore - we tried
}
}
// metadata
if (embedContent >= EmbedLevel.Body)
{
try
{
richEntry.MetaData = Helper.UTF8NoBom.GetString(evnt.Metadata);
richEntry.IsMetaData = richEntry.MetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
if (embedContent >= EmbedLevel.PrettyBody)
{
richEntry.MetaData = FormatJson(richEntry.MetaData);
}
if (string.IsNullOrEmpty(richEntry.MetaData))
{
richEntry.MetaData = null;
}
}
catch
{
// ignore - we tried
}
var lnk = eventLinkPair.Link;
if (lnk != null)
{
try
{
richEntry.LinkMetaData = Helper.UTF8NoBom.GetString(lnk.Metadata);
richEntry.IsLinkMetaData = richEntry.LinkMetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
if (embedContent >= EmbedLevel.PrettyBody)
{
richEntry.LinkMetaData = FormatJson(richEntry.LinkMetaData);
}
}
catch
{
// ignore - we tried
}
}
}
}
}
else
{
entry = new EntryElement();
}
if (evnt != null && link == null)
{
SetEntryProperties(evnt.EventStreamId, evnt.EventNumber, evnt.TimeStamp, requestedUrl, entry);
entry.SetSummary(evnt.EventType);
if ((singleEntry || embedContent == EmbedLevel.Content) && ((evnt.Flags & PrepareFlags.IsJson) != 0))
entry.SetContent(AutoEventConverter.CreateDataDto(eventLinkPair));
}
else if (link != null)
{
var eventLoc = GetLinkData(Encoding.UTF8.GetString(link.Data));
SetEntryProperties(eventLoc.Item1, eventLoc.Item2, link.TimeStamp, requestedUrl, entry);
entry.SetSummary("$>");
}
return entry;
}
public ReadStreamEventsBackwardCompleted(Guid correlationId,
string eventStreamId,
int fromEventNumber,
int maxCount,
ReadStreamResult result,
ResolvedEvent[] events,
StreamMetadata streamMetadata,
bool isCachePublic,
string error,
int nextEventNumber,
int lastEventNumber,
bool isEndOfStream,
long tfLastCommitPosition)
{
Ensure.NotNull(events, "events");
if (result != ReadStreamResult.Success)
{
Ensure.Equal(nextEventNumber, -1, "nextEventNumber");
Ensure.Equal(isEndOfStream, true, "isEndOfStream");
}
CorrelationId = correlationId;
EventStreamId = eventStreamId;
FromEventNumber = fromEventNumber;
MaxCount = maxCount;
Result = result;
Events = events;
StreamMetadata = streamMetadata;
IsCachePublic = isCachePublic;
Error = error;
NextEventNumber = nextEventNumber;
LastEventNumber = lastEventNumber;
IsEndOfStream = isEndOfStream;
TfLastCommitPosition = tfLastCommitPosition;
}
private static bool IsV1StreamCreatedEvent(EventStore.Core.Data.ResolvedEvent e)
{
return(e.Link == null && e.OriginalEventNumber == 0 &&
(e.OriginalEvent.EventType == SystemEventTypes.V1__StreamCreatedImplicit__ ||
e.OriginalEvent.EventType == SystemEventTypes.V1__StreamCreated__));
}
public StreamEventAppeared(Guid correlationId, ResolvedEvent @event)
{
CorrelationId = correlationId;
Event = @event;
}
public void BeginParkMessage(ResolvedEvent @event, string reason, Action<ResolvedEvent, OperationResult> completed)
{
ParkedEvents.Add(@event);
_parkMessageCompleted = completed;
}
private void PublishCommand(ResolvedEvent resolvedEvent)
{
var command = resolvedEvent.Event.EventType;
//TODO: PROJECTIONS: Remove before release
if (!Logging.FilteredMessages.Contains(x => x == command))
{
Log.Debug("PROJECTIONS: Response received: {eventNumber}@{command}", resolvedEvent.OriginalEventNumber, command);
}
switch (command)
{
case "$response-reader-starting":
break;
case "$projection-worker-started":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <ProjectionWorkerStarted>();
_publisher.Publish(
new CoreProjectionStatusMessage.ProjectionWorkerStarted(Guid.ParseExact(commandBody.Id, "N")));
_numberOfStartedWorkers++;
if (_numberOfStartedWorkers == _numberOfWorkers)
{
_publisher.Publish(new ProjectionManagementMessage.ReaderReady());
}
break;
}
case "$prepared":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <Prepared>();
_publisher.Publish(
new CoreProjectionStatusMessage.Prepared(
Guid.ParseExact(commandBody.Id, "N"),
commandBody.SourceDefinition));
break;
}
case "$faulted":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <Faulted>();
_publisher.Publish(
new CoreProjectionStatusMessage.Faulted(
Guid.ParseExact(commandBody.Id, "N"),
commandBody.FaultedReason));
break;
}
case "$started":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <Started>();
_publisher.Publish(new CoreProjectionStatusMessage.Started(Guid.ParseExact(commandBody.Id, "N")));
break;
}
case "$statistics-report":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <StatisticsReport>();
_publisher.Publish(
new CoreProjectionStatusMessage.StatisticsReport(
Guid.ParseExact(commandBody.Id, "N"),
commandBody.Statistics,
-1));
break;
}
case "$stopped":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <Stopped>();
_publisher.Publish(
new CoreProjectionStatusMessage.Stopped(
Guid.ParseExact(commandBody.Id, "N"),
commandBody.Name,
commandBody.Completed));
break;
}
case "$state":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <StateReport>();
_publisher.Publish(
new CoreProjectionStatusMessage.StateReport(
Guid.ParseExact(commandBody.CorrelationId, "N"),
Guid.ParseExact(commandBody.Id, "N"),
commandBody.Partition,
commandBody.State,
commandBody.Position));
break;
}
case "$result":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <ResultReport>();
_publisher.Publish(
new CoreProjectionStatusMessage.ResultReport(
Guid.ParseExact(commandBody.CorrelationId, "N"),
Guid.ParseExact(commandBody.Id, "N"),
commandBody.Partition,
commandBody.Result,
commandBody.Position));
break;
}
case "$slave-projection-reader-assigned":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <SlaveProjectionReaderAssigned>();
_publisher.Publish(
new CoreProjectionManagementMessage.SlaveProjectionReaderAssigned(
Guid.ParseExact(commandBody.Id, "N"),
Guid.ParseExact(commandBody.SubscriptionId, "N")));
break;
}
case "$abort":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <AbortCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.Abort(
new NoopEnvelope(),
commandBody.Name,
commandBody.RunAs));
break;
}
case "$disable":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <DisableCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.Disable(
new NoopEnvelope(),
commandBody.Name,
commandBody.RunAs));
break;
}
case "$enable":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <EnableCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.Enable(
new NoopEnvelope(),
commandBody.Name,
commandBody.RunAs));
break;
}
case "$get-query":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <GetQueryCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.GetQuery(
new NoopEnvelope(),
commandBody.Name,
commandBody.RunAs));
break;
}
case "$get-result":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <GetResultCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.GetResult(
new NoopEnvelope(),
commandBody.Name,
commandBody.Partition));
break;
}
case "$get-state":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <GetStateCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.GetState(
new NoopEnvelope(),
commandBody.Name,
commandBody.Partition));
break;
}
case "$get-statistics":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <GetStatisticsCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.GetStatistics(
new NoopEnvelope(),
commandBody.Mode,
commandBody.Name,
commandBody.IncludeDeleted));
break;
}
case "$post":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <PostCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.Post(
new NoopEnvelope(),
commandBody.Mode,
commandBody.Name,
commandBody.RunAs,
commandBody.HandlerType,
commandBody.Query,
commandBody.Enabled,
commandBody.CheckpointsEnabled,
commandBody.EmitEnabled,
commandBody.TrackEmittedStreams,
commandBody.EnableRunAs));
break;
}
case "$reset":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <ResetCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.Reset(
new NoopEnvelope(),
commandBody.Name,
commandBody.RunAs));
break;
}
case "$set-runas":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <SetRunAsCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.SetRunAs(
new NoopEnvelope(),
commandBody.Name,
commandBody.RunAs,
commandBody.SetRemove));
break;
}
case "$start-slave-projections":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <StartSlaveProjectionsCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.StartSlaveProjections(
new PublishEnvelope(_publisher),
commandBody.RunAs,
commandBody.Name,
commandBody.SlaveProjections,
Guid.ParseExact(commandBody.MasterWorkerId, "N"),
Guid.ParseExact(commandBody.MasterCorrelationId, "N")));
break;
}
case "$delete":
{
var commandBody = resolvedEvent.Event.Data.ParseJson <DeleteCommand>();
_publisher.Publish(
new ProjectionManagementMessage.Command.Delete(
new NoopEnvelope(),
commandBody.Name,
commandBody.RunAs,
commandBody.DeleteCheckpointStream,
commandBody.DeleteStateStream,
commandBody.DeleteEmittedStreams));
break;
}
default:
throw new Exception("Unknown response: " + command);
}
}
public static ResolvedEvent BuildLinkEvent(Guid id, string stream, int version, ResolvedEvent ev, bool resolved = true)
{
var link = new EventRecord(version, 1234567, Guid.NewGuid(), id, 1234567, 1234, stream, version, DateTime.Now, PrepareFlags.SingleWrite, SystemEventTypes.LinkTo, Encoding.UTF8.GetBytes(string.Format("{0}@{1}", ev.OriginalEventNumber, ev.OriginalStreamId)), new byte[0]);
if (resolved)
return ResolvedEvent.ForResolvedLink(ev.Event, link);
else
return ResolvedEvent.ForUnresolvedEvent(link);
}
public void SetLoadedEvent(EventStore.Core.Data.ResolvedEvent eventLinkPair)
{
_result = eventLinkPair;
}
private void WriteStateCompleted(Action<ResolvedEvent, OperationResult> completed, ResolvedEvent ev, ClientMessage.WriteEventsCompleted msg)
{
if(completed != null)
completed(ev, msg.Result);
}
