public static FeedElement ToAllEventsForwardFeed(ClientMessage.ReadAllEventsForwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent)
{
var self = HostName.Combine(requestedUrl, "/streams/{0}", AllEscaped);
var feed = new FeedElement();
feed.SetTitle("All events");
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null ? msg.Events[msg.Events.Length - 1].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", AllEscaped, msg.MaxCount));
if (msg.CurrentPos.CommitPosition != 0)
{
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, new TFPos(0, 0).AsString(), msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", AllEscaped, msg.PrevPos.AsString(), msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
{
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, msg.NextPos.AsString(), msg.MaxCount));
}
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", AllEscaped));
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(
ToEntry(
new ResolvedEvent(msg.Events[i].Event, msg.Events[i].Link, msg.Events[i].ResolveResult),
requestedUrl, embedContent));
}
return(feed);
}
public static ClientMessage.ReadAllEventsForwardCompleted ReadAllEventsForward(MiniClusterNode node,
long position)
{
ClientMessage.ReadAllEventsForwardCompleted readResult = null;
var readEvent = new ManualResetEventSlim();
var done = false;
while (!done)
{
var read = new ClientMessage.ReadAllEventsForward(Guid.NewGuid(), Guid.NewGuid(), new CallbackEnvelope(
msg => {
readResult = (ClientMessage.ReadAllEventsForwardCompleted)msg;
readEvent.Set();
}),
0, 0, 100, false, false, null, SystemAccount.Principal);
node.Node.MainQueue.Publish(read);
if (!readEvent.Wait(_timeout))
{
Assert.Fail("Timed out waiting for events to be read forward");
return(null);
}
if (readResult.Result == ReadAllResult.Error)
{
Assert.Fail("Failed to read forwards. Read result error: {0}", readResult.Error);
return(null);
}
done = readResult.NextPos.CommitPosition > position;
readEvent.Reset();
}
return(readResult);
}
private static TcpPackage WrapReadAllEventsForwardCompleted(ClientMessage.ReadAllEventsForwardCompleted msg)
{
var dto = new TcpClientMessageDto.ReadAllEventsCompleted(
msg.CurrentPos.CommitPosition, msg.CurrentPos.PreparePosition, ConvertToResolvedEvents(msg.Events),
msg.NextPos.CommitPosition, msg.NextPos.PreparePosition,
(TcpClientMessageDto.ReadAllEventsCompleted.ReadAllResult)msg.Result, msg.Error);
return(new TcpPackage(TcpCommand.ReadAllEventsForwardCompleted, msg.CorrelationId, dto.Serialize()));
}
public void Handle(ClientMessage.ReadAllEventsForwardCompleted message)
{
EventDistributionPoint distributionPoint;
if (_distributionPoints.TryGetValue(message.CorrelationId, out distributionPoint))
{
distributionPoint.Handle(message);
}
}
private static TcpPackage WrapReadAllEventsForwardCompleted(ClientMessage.ReadAllEventsForwardCompleted msg)
{
var dto = new ClientMessageDto.ReadAllEventsForwardCompleted(msg.Result.CurrentPos.CommitPosition,
msg.Result.CurrentPos.PreparePosition,
msg.Result.Records.Select(x => new EventLinkPair(x.Event, x.Link)).ToArray(),
msg.Result.NextPos.CommitPosition,
msg.Result.NextPos.PreparePosition);
return(new TcpPackage(TcpCommand.ReadAllEventsForwardCompleted, msg.CorrelationId, dto.Serialize()));
}
public override void Handle(ClientMessage.ReadAllEventsForwardCompleted message)
{
if (_disposed)
{
return;
}
if (!_eventsRequested)
{
throw new InvalidOperationException("Read events has not been requested");
}
if (_paused)
{
throw new InvalidOperationException("Paused");
}
_eventsRequested = false;
if (message.Result.Records.Count == 0)
{
// the end
if (_deliverEndOfTfPosition)
{
DeliverLastCommitPosition(_from);
}
// allow joining heading distribution
}
else
{
for (int index = 0; index < message.Result.Records.Count; index++)
{
var @event = message.Result.Records[index];
DeliverEvent(@event);
}
_from = message.Result.NextPos;
}
if (_pauseRequested)
{
_paused = true;
}
else
{
//TODO: we may publish this message somewhere 10 events before the end of the chunk
_publisher.Publish(
new ProjectionMessage.CoreService.Tick(
() => { if (!_paused && !_disposed)
{
RequestEvents();
}
}));
}
}
public override void Handle(ClientMessage.ReadAllEventsForwardCompleted message)
{
if (_disposed)
{
return;
}
if (!_eventsRequested)
{
throw new InvalidOperationException("Read events has not been requested");
}
if (_paused)
{
throw new InvalidOperationException("Paused");
}
_eventsRequested = false;
if (message.Result.Records.Length == 0)
{
// the end
if (_deliverEndOfTfPosition)
{
DeliverLastCommitPosition(_from);
}
// allow joining heading distribution
}
else
{
for (int index = 0; index < message.Result.Records.Length; index++)
{
var @event = message.Result.Records[index];
DeliverEvent(@event, message.Result.TfEofPosition);
}
_from = message.Result.NextPos;
}
if (_pauseRequested)
{
_paused = true;
}
else if (message.Result.Records.Length == 0)
{
RequestEvents(delay: true);
}
else
{
_publisher.Publish(CreateTickMessage());
}
}
public void FetchAllCompleted(ClientMessage.ReadAllEventsForwardCompleted msg)
{
switch (msg.Result)
{
case ReadAllResult.Success:
_onFetchCompleted(_skipFirstEvent ? msg.Events.Skip(1).ToArray() : msg.Events, new PersistentSubscriptionAllStreamPosition(msg.NextPos.CommitPosition, msg.NextPos.PreparePosition), msg.IsEndOfStream);
break;
case ReadAllResult.AccessDenied:
_onError($"Read access denied for stream: {SystemStreams.AllStream}");
break;
default:
_onError(msg.Error ?? $"Error reading stream: {SystemStreams.AllStream} at position: {msg.CurrentPos}");
break;
}
}
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 <TcpClientMessageDto.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");
}
public InspectionResult InspectPackage(TcpPackage package)
{
try
{
if (package.Command != TcpCommand.ReadAllEventsForwardCompleted)
{
return(new InspectionResult(InspectionDecision.NotifyError,
new CommandNotExpectedException(TcpCommand.ReadAllEventsForwardCompleted.ToString(),
package.Command.ToString())));
}
var data = package.Data;
var dto = data.Deserialize <ClientMessage.ReadAllEventsForwardCompleted>();
_result = dto;
return(new InspectionResult(InspectionDecision.Succeed));
}
catch (Exception e)
{
return(new InspectionResult(InspectionDecision.NotifyError, e));
}
}
public void when_wrapping_read_all_events_forward_completed_with_link_to_deleted_event_should_downgrade_version()
{
var events = new ResolvedEvent[] {
ResolvedEvent.ForResolvedLink(CreateLinkEventRecord(), CreateDeletedEventRecord(), 100)
};
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, _version);
Assert.IsNotNull(package, "Package is null");
Assert.AreEqual(TcpCommand.ReadAllEventsForwardCompleted, package.Value.Command, "TcpCommand");
var dto = package.Value.Data.Deserialize <TcpClientMessageDto.ReadAllEventsCompleted>();
Assert.IsNotNull(dto, "DTO is null");
Assert.AreEqual(1, dto.Events.Count(), "Number of events");
Assert.AreEqual(0, dto.Events[0].Event.EventNumber, "Event Number");
Assert.AreEqual(int.MaxValue, dto.Events[0].Link.EventNumber, "Link Event Number");
}
public abstract void Handle(ClientMessage.ReadAllEventsForwardCompleted message);
public override void Handle(ClientMessage.ReadAllEventsForwardCompleted message)
{
throw new NotImplementedException();
}
