private void ReadUsersForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted result) { if (_aborted) return; switch (result.Result) { case ReadStreamResult.Success: if (!result.IsEndOfStream) BeginReadForward(result.NextEventNumber); foreach (var loginName in from eventData in result.Events let @event = eventData.Event where @event.EventType == UserEventType let stringData = Helper.UTF8NoBom.GetString(@event.Data) select stringData) BeginReadUserDetails(loginName); break; case ReadStreamResult.NoStream: Abort(UserManagementMessage.Error.NotFound); break; default: Abort(UserManagementMessage.Error.Error); break; } _activeRequests--; TryComplete(); }
public InspectionResult InspectPackage(TcpPackage package) { try { if (package.Command != TcpCommand.ReadStreamEventsForwardCompleted) { return(new InspectionResult(InspectionDecision.NotifyError, new CommandNotExpectedException(TcpCommand.ReadStreamEventsForwardCompleted.ToString(), package.Command.ToString()))); } var data = package.Data; var dto = data.Deserialize <ClientMessage.ReadStreamEventsForwardCompleted>(); _result = dto; switch ((RangeReadResult)dto.Result) { case RangeReadResult.Success: case RangeReadResult.StreamDeleted: case RangeReadResult.NoStream: return(new InspectionResult(InspectionDecision.Succeed)); default: throw new ArgumentOutOfRangeException(); } } catch (Exception e) { return(new InspectionResult(InspectionDecision.NotifyError, e)); } }
protected static long?GetLastCommitPositionFrom(ClientMessage.ReadStreamEventsForwardCompleted msg) { return((msg.IsEndOfStream || msg.Result == ReadStreamResult.NoStream || msg.Result == ReadStreamResult.StreamDeleted) ? (msg.LastCommitPosition == -1 ? (long?)null : msg.LastCommitPosition) : (long?)null); }
private static TcpPackage WrapReadStreamEventsForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg) { var dto = new TcpClientMessageDto.ReadStreamEventsCompleted( ConvertToResolvedIndexedEvents(msg.Events), (TcpClientMessageDto.ReadStreamEventsCompleted.ReadStreamResult)msg.Result, msg.NextEventNumber, msg.LastEventNumber, msg.IsEndOfStream, msg.TfLastCommitPosition, msg.Error); return(new TcpPackage(TcpCommand.ReadStreamEventsForwardCompleted, msg.CorrelationId, dto.Serialize())); }
public void Handle(ClientMessage.ReadStreamEventsForwardCompleted message) { EventDistributionPoint distributionPoint; if (_distributionPoints.TryGetValue(message.CorrelationId, out distributionPoint)) { distributionPoint.Handle(message); } }
private static TcpPackage WrapReadStreamEventsForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg) { var dto = new ClientMessageDto.ReadStreamEventsForwardCompleted(msg.EventStreamId, msg.Events, msg.Result, msg.LastCommitPosition); return(new TcpPackage(TcpCommand.ReadStreamEventsForwardCompleted, msg.CorrelationId, dto.Serialize())); }
public ClientMessage.ReadStreamEventsForwardCompleted CreateReadStreamEventsForwardCompleted(ClientMessage.ReadStreamEventsForward msg) { var lastEventNumber = msg.FromEventNumber + 1; var nextEventNumber = lastEventNumber + 1; var events = IODispatcherTestHelpers.CreateResolvedEvent(msg.EventStreamId, "event_type", "test", eventNumber: 10); var res = new ClientMessage.ReadStreamEventsForwardCompleted(msg.CorrelationId, msg.EventStreamId, msg.FromEventNumber, msg.MaxCount, ReadStreamResult.Success, events, null, false, String.Empty, nextEventNumber, lastEventNumber, false, 0); return(res); }
private void ReadCompleted(ClientMessage.ReadStreamEventsForwardCompleted onReadCompleted, Action onEmittedStreamsDeleted) { if (onReadCompleted.Result == ReadStreamResult.Success || onReadCompleted.Result == ReadStreamResult.NoStream) { if (onReadCompleted.Events.Length == 0 && !onReadCompleted.IsEndOfStream) { DeleteEmittedStreamsFrom(onReadCompleted.NextEventNumber, onEmittedStreamsDeleted); return; } if (onReadCompleted.Events.Length == 0) { _ioDispatcher.DeleteStream(_emittedStreamsCheckpointStreamId, ExpectedVersion.Any, false, SystemAccounts.System, x => { if (x.Result == OperationResult.Success || x.Result == OperationResult.StreamDeleted) { Log.Information("PROJECTIONS: Projection Stream '{stream}' deleted", _emittedStreamsCheckpointStreamId); } else { Log.Error("PROJECTIONS: Failed to delete projection stream '{stream}'. Reason: {e}", _emittedStreamsCheckpointStreamId, x.Result); } _ioDispatcher.DeleteStream(_emittedStreamsId, ExpectedVersion.Any, false, SystemAccounts.System, y => { if (y.Result == OperationResult.Success || y.Result == OperationResult.StreamDeleted) { Log.Information("PROJECTIONS: Projection Stream '{stream}' deleted", _emittedStreamsId); } else { Log.Error( "PROJECTIONS: Failed to delete projection stream '{stream}'. Reason: {e}", _emittedStreamsId, y.Result); } onEmittedStreamsDeleted(); }); }); } else { var streamId = Helper.UTF8NoBom.GetString(onReadCompleted.Events[0].Event.Data.Span); _ioDispatcher.DeleteStream(streamId, ExpectedVersion.Any, false, SystemAccounts.System, x => DeleteStreamCompleted(x, onEmittedStreamsDeleted, streamId, onReadCompleted.Events[0].OriginalEventNumber)); } } }
private void ReadDataStreamCompleted(ClientMessage.ReadStreamEventsForwardCompleted completed) { _dataReadRequestId = Guid.Empty; if (Paused) { throw new InvalidOperationException("Paused"); } switch (completed.Result) { case ReadStreamResult.AccessDenied: SendNotAuthorized(); return; case ReadStreamResult.NoStream: _dataNextSequenceNumber = int.MaxValue; if (completed.LastEventNumber >= 0) { SendPartitionDeleted(_dataStreamName, -1, null, null, null, null); } PauseOrContinueProcessing(); break; case ReadStreamResult.StreamDeleted: _dataNextSequenceNumber = int.MaxValue; SendPartitionDeleted(_dataStreamName, -1, null, null, null, null); PauseOrContinueProcessing(); break; case ReadStreamResult.Success: foreach (var e in completed.Events) { DeliverEvent(e, 17.7f); if (CheckEnough()) { return; } } if (completed.IsEndOfStream) { _dataNextSequenceNumber = int.MaxValue; } else { _dataNextSequenceNumber = completed.NextEventNumber; } PauseOrContinueProcessing(); break; default: throw new NotSupportedException(); } }
private static TcpPackage WrapReadStreamEventsForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg) { var dto = new TcpClientMessageDto.ReadStreamEventsForwardCompleted(msg.EventStreamId, ConvertToDtos(msg.Events), (int)msg.Result, msg.NextEventNumber, msg.LastEventNumber, msg.IsEndOfStream, msg.LastCommitPosition); return(new TcpPackage(TcpCommand.ReadStreamEventsForwardCompleted, msg.CorrelationId, dto.Serialize())); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); _ioDispatcher.ReadForward( _eventStreamId, _fromEventNumber, _maxCount, true, _principal, res => _result = res, () => _hasTimedOut = true, Guid.NewGuid() ); _readForward.Envelope.ReplyWith(CreateReadStreamEventsForwardCompleted(_readForward)); }
public static FeedElement ToStreamEventForwardFeed(ClientMessage.ReadStreamEventsForwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent) { Ensure.NotNull(msg, "msg"); string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId); var self = HostName.Combine(requestedUrl, "/streams/{0}", escapedStreamId); var feed = new FeedElement(); feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId)); feed.StreamId = msg.EventStreamId; feed.SetId(self); feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null ? msg.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime()); feed.SetAuthor(AtomSpecs.Author); feed.SetHeadOfStream(msg.IsEndOfStream); var prevEventNumber = Math.Min(msg.FromEventNumber + msg.MaxCount - 1, msg.LastEventNumber) + 1; var nextEventNumber = msg.FromEventNumber - 1; feed.AddLink("self", self); feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", escapedStreamId, msg.MaxCount)); if (nextEventNumber >= 0) { feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, 0, msg.MaxCount)); feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", escapedStreamId, nextEventNumber, msg.MaxCount)); } if (!msg.IsEndOfStream || msg.Events.Length > 0) { feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, prevEventNumber, msg.MaxCount)); } if (!escapedStreamId.StartsWith("$$")) { feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", escapedStreamId)); } for (int i = msg.Events.Length - 1; i >= 0; --i) { feed.AddEntry(ToEntry(msg.Events[i], requestedUrl, embedContent)); } return(feed); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); var step = _ioDispatcher.BeginReadForward( _cancellationScope, _eventStreamId, _fromEventNumber, _maxCount, true, _principal, res => _result = res, () => _hasTimedOut = true ); IODispatcherAsync.Run(step); _readForward.Envelope.ReplyWith(CreateReadStreamEventsForwardCompleted(_readForward)); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); var mre = new ManualResetEvent(false); _ioDispatcher.ReadForward( _eventStreamId, _fromEventNumber, _maxCount, true, _principal, res => { _result = res; mre.Set(); }, () => { _hasTimedOut = true; mre.Set(); }, Guid.NewGuid() ); _readForward.Envelope.ReplyWith(CreateReadStreamEventsForwardCompleted(_readForward)); mre.WaitOne(TimeSpan.FromSeconds(10)); }
when_wrapping_read_stream_events_forward_and_stream_was_deleted_should_not_downgrade_last_event_number_for_v2_clients() { var msg = new ClientMessage.ReadStreamEventsForwardCompleted(Guid.NewGuid(), "test-stream", 0, 100, ReadStreamResult.StreamDeleted, new ResolvedEvent[0], new StreamMetadata(), true, "", -1, long.MaxValue, true, 1000); var package = _dispatcher.WrapMessage(msg, (byte)ClientVersion.V2); Assert.IsNotNull(package, "Package is null"); Assert.AreEqual(TcpCommand.ReadStreamEventsForwardCompleted, package.Value.Command, "TcpCommand"); var dto = package.Value.Data.Deserialize <TcpClientMessageDto.ReadStreamEventsCompleted>(); Assert.IsNotNull(dto, "DTO is null"); Assert.AreEqual(long.MaxValue, dto.LastEventNumber, "Last Event Number"); }
public virtual void Handle(ClientMessage.ReadStreamEventsForward message) { ClientMessage.ReadStreamEventsForwardCompleted reply; if (!_hasReadForward) { _hasReadForward = true; var events = IODispatcherTestHelpers.CreateResolvedEvent(message.EventStreamId, ProjectionEventTypes.ProjectionCheckpoint, _testStreamName); reply = new ClientMessage.ReadStreamEventsForwardCompleted(message.CorrelationId, message.EventStreamId, message.FromEventNumber, message.MaxCount, ReadStreamResult.Success, events, null, false, String.Empty, message.FromEventNumber + 1, message.FromEventNumber, true, 1000); } else { reply = new ClientMessage.ReadStreamEventsForwardCompleted(message.CorrelationId, message.EventStreamId, message.FromEventNumber, message.MaxCount, ReadStreamResult.Success, new ResolvedEvent[] {}, null, false, String.Empty, message.FromEventNumber, message.FromEventNumber, true, 1000); } message.Envelope.ReplyWith(reply); }
public void FetchCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg) { switch (msg.Result) { case ReadStreamResult.Success: case ReadStreamResult.NoStream: _onFetchCompleted(_skipFirstEvent ? msg.Events.Skip(1).ToArray() : msg.Events, new PersistentSubscriptionSingleStreamPosition(msg.NextEventNumber), msg.IsEndOfStream); break; case ReadStreamResult.AccessDenied: _onError($"Read access denied for stream: {msg.EventStreamId}"); break; default: _onError(msg.Error ?? $"Error reading stream: {msg.EventStreamId} at event number: {msg.FromEventNumber}"); break; } }
private void ReadForwardCompleted(ClientMessage.ReadStreamEventsForwardCompleted completed) { if (_cancellationScope.Cancelled(completed.CorrelationId)) { return; } if (completed.CorrelationId != _correlationId) { return; } _correlationId = Guid.Empty; if (completed.Result == ReadStreamResult.Success || completed.Result == ReadStreamResult.NoStream) { _readFrom = completed.NextEventNumber == -1 ? 0 : completed.NextEventNumber; if (completed.Result == ReadStreamResult.Success) { foreach (var e in completed.Events) { PublishCommand(e); } } if (completed.IsEndOfStream) { var subscribeFrom = new TFPos( completed.TfLastCommitPosition, completed.TfLastCommitPosition); SubscribeAwake(subscribeFrom); } else { ReadForward(); } } else { Log.Error("Failed reading stream {stream}. Read result: {readResult}, Error: '{e}'", ProjectionNamesBuilder._projectionsMasterStream, completed.Result, completed.Error); ReadForward(); } }
public static ClientMessage.ReadStreamEventsForwardCompleted ReadStreamEventsForward(MiniClusterNode node, string streamId) { ClientMessage.ReadStreamEventsForwardCompleted readResult = null; var resetEvent = new ManualResetEventSlim(); var read = new ClientMessage.ReadStreamEventsForward(Guid.NewGuid(), Guid.NewGuid(), new CallbackEnvelope(msg => { readResult = (ClientMessage.ReadStreamEventsForwardCompleted)msg; resetEvent.Set(); }), streamId, 0, 10, false, false, null, SystemAccount.Principal); node.Node.MainQueue.Publish(read); if (!resetEvent.Wait(_timeout)) { Assert.Fail("Timed out waiting for the stream to be read forward"); return(null); } return(readResult); }
private void ReadCatalogCompleted(ClientMessage.ReadStreamEventsForwardCompleted completed) { _catalogReadRequestId = Guid.Empty; if (Paused) { throw new InvalidOperationException("Paused"); } switch (completed.Result) { case ReadStreamResult.AccessDenied: SendNotAuthorized(); return; case ReadStreamResult.NoStream: case ReadStreamResult.StreamDeleted: _catalogEof = true; SendEof(); return; case ReadStreamResult.Success: _limitingCommitPosition = _limitingCommitPosition ?? completed.TfLastCommitPosition; foreach (var e in completed.Events) { EnqueueStreamForProcessing(e); } if (completed.IsEndOfStream) { _catalogEof = true; } PauseOrContinueProcessing(); break; default: throw new NotSupportedException(); } }
private IEnumerable <IODispatcherAsync.Step> ControlSteps(Guid instanceCorrelationId) { long fromEventNumber = 0; Log.Debug("PROJECTIONS: Starting read {stream}", ProjectionNamesBuilder.BuildControlStreamName(instanceCorrelationId)); long subscribeFrom = 0; while (!_stopped) { ClientMessage.ReadStreamEventsForwardCompleted readResultForward = null; var success = false; while (!success) { yield return (_ioDispatcher.BeginReadForward( _cancellationScope, ProjectionNamesBuilder.BuildControlStreamName(instanceCorrelationId), fromEventNumber, 1, false, SystemAccount.Principal, completed => { readResultForward = completed; success = true; }, () => Log.Warn("Read forward of stream {stream} timed out. Retrying", ProjectionNamesBuilder.BuildControlStreamName(instanceCorrelationId)))); } if (readResultForward.Result != ReadStreamResult.Success && readResultForward.Result != ReadStreamResult.NoStream) { throw new Exception("Control reader failed. Read result: " + readResultForward.Result); } if (readResultForward.Events != null && readResultForward.Events.Length > 0) { var doWriteRegistration = readResultForward.Events.Any(v => v.Event.EventType == "$response-reader-started"); fromEventNumber = readResultForward.NextEventNumber; subscribeFrom = readResultForward.TfLastCommitPosition; if (doWriteRegistration) { var events = new[] { new Event( Guid.NewGuid(), "$projection-worker-started", true, "{\"id\":\"" + _coreServiceId + "\"}", null) }; yield return (_ioDispatcher.BeginWriteEvents( _cancellationScope, ProjectionNamesBuilder._projectionsMasterStream, ExpectedVersion.Any, SystemAccount.Principal, events, r => { })); } break; } if (readResultForward.Result == ReadStreamResult.Success) { subscribeFrom = readResultForward.TfLastCommitPosition; } yield return (_ioDispatcher.BeginSubscribeAwake( _cancellationScope, ProjectionNamesBuilder.BuildControlStreamName(instanceCorrelationId), new TFPos(subscribeFrom, subscribeFrom), message => { })); } }
private IEnumerable <IODispatcherAsync.Step> ControlSteps() { ClientMessage.ReadStreamEventsBackwardCompleted readResult = null; yield return (_ioDispatcher.BeginReadBackward( _cancellationScope, ProjectionNamesBuilder._projectionsControlStream, -1, 1, false, SystemAccount.Principal, completed => readResult = completed)); int fromEventNumber; if (readResult.Result == ReadStreamResult.NoStream) { fromEventNumber = 0; } else { if (readResult.Result != ReadStreamResult.Success) { throw new Exception("Cannot start control reader. Read result: " + readResult.Result); } fromEventNumber = readResult.LastEventNumber + 1; } DebugLogger.Log("Starting read control from: " + fromEventNumber); //TODO: handle shutdown here and in other readers long subscribeFrom = 0; var doWriteRegistration = true; while (!_stopped) { if (doWriteRegistration) { var events = new[] { new Event( Guid.NewGuid(), "$projection-worker-started", true, "{\"id\":\"" + _coreServiceId + "\"}", null) }; DebugLogger.Log("Registering worker " + _coreServiceId); // ClientMessage.WriteEventsCompleted response = null; yield return (_ioDispatcher.BeginWriteEvents( _cancellationScope, ProjectionNamesBuilder._projectionsMasterStream, ExpectedVersion.Any, SystemAccount.Principal, events, r => { })); DebugLogger.Log("Worker registered: "); } do { ClientMessage.ReadStreamEventsForwardCompleted readResultForward = null; yield return (_ioDispatcher.BeginReadForward( _cancellationScope, ProjectionNamesBuilder._projectionsControlStream, fromEventNumber, 1, false, SystemAccount.Principal, completed => readResultForward = completed)); DebugLogger.Log("Control stream read forward result: " + readResultForward.Result); if (readResultForward.Result != ReadStreamResult.Success && readResultForward.Result != ReadStreamResult.NoStream) { throw new Exception("Control reader failed. Read result: " + readResultForward.Result); } if (readResultForward.Events != null && readResultForward.Events.Length > 0) { doWriteRegistration = readResultForward.Events.Any(v => v.Event.EventType == "$response-reader-started"); fromEventNumber = readResultForward.NextEventNumber; subscribeFrom = readResultForward.TfLastCommitPosition; break; } if (readResultForward.Result == ReadStreamResult.Success) { subscribeFrom = readResultForward.TfLastCommitPosition; } DebugLogger.Log("Awaiting control stream"); yield return (_ioDispatcher.BeginSubscribeAwake( _cancellationScope, ProjectionNamesBuilder._projectionsControlStream, new TFPos(subscribeFrom, subscribeFrom), message => { })); DebugLogger.Log("Control stream await completed"); } while (!_stopped); } }
public override void Handle(ClientMessage.ReadStreamEventsForwardCompleted message) { }
public void FetchCompleted(ClientMessage.ReadStreamEventsForwardCompleted msg) { //TODO mark error? _onFetchCompleted(msg.Events, msg.NextEventNumber, msg.IsEndOfStream); }
public override void Handle(ClientMessage.ReadStreamEventsForwardCompleted message) { if (_disposed) { return; } if (!_eventsRequested) { throw new InvalidOperationException("Read events has not been requested"); } if (message.EventStreamId != _streamName) { throw new InvalidOperationException( string.Format("Invalid stream name: {0}. Expected: {1}", message.EventStreamId, _streamName)); } if (_paused) { throw new InvalidOperationException("Paused"); } _eventsRequested = false; switch (message.Result) { case RangeReadResult.NoStream: DeliverSafeJoinPosition(message.LastCommitPosition.Value); // allow joining heading distribution if (_pauseRequested) { _paused = true; } else { RequestEvents(delay: true); } break; case RangeReadResult.Success: if (message.Events.Length == 0) { // the end DeliverSafeJoinPosition(message.LastCommitPosition.Value); } else { for (int index = 0; index < message.Events.Length; index++) { var @event = message.Events[index].Event; var @link = message.Events[index].Link; DeliverEvent(@event, @link, 100.0f * (link ?? @event).EventNumber / message.LastEventNumber); } } if (_pauseRequested) { _paused = true; } else if (message.Events.Length == 0) { RequestEvents(delay: true); } else { _publisher.Publish(CreateTickMessage()); } break; default: throw new NotSupportedException( string.Format("ReadEvents result code was not recognized. Code: {0}", message.Result)); } }
public override void Handle(ClientMessage.ReadStreamEventsForwardCompleted message) { if (_disposed) { return; } if (!_streams.Contains(message.EventStreamId)) { throw new InvalidOperationException(string.Format("Invalid stream name: {0}", message.EventStreamId)); } if (!_eventsRequested.Contains(message.EventStreamId)) { throw new InvalidOperationException("Read events has not been requested"); } if (_paused) { throw new InvalidOperationException("Paused"); } _eventsRequested.Remove(message.EventStreamId); switch (message.Result) { case RangeReadResult.NoStream: UpdateSafePositionToJoin(message.EventStreamId, message.LastCommitPosition.Value); ProcessBuffers(); if (_pauseRequested) { _paused = true; } else { RequestEvents(message.EventStreamId, delay: true); } _publisher.Publish(CreateTickMessage()); break; case RangeReadResult.Success: if (message.Events.Length == 0) { // the end UpdateSafePositionToJoin(message.EventStreamId, message.LastCommitPosition.Value); } else { for (int index = 0; index < message.Events.Length; index++) { var @event = message.Events[index].Event; var @link = message.Events[index].Link; EventRecord positionEvent = (link ?? @event); UpdateSafePositionToJoin(positionEvent.EventStreamId, positionEvent.LogPosition); Queue <Tuple <EventRecord, EventRecord, float> > queue; if (!_buffers.TryGetValue(positionEvent.EventStreamId, out queue)) { queue = new Queue <Tuple <EventRecord, EventRecord, float> >(); _buffers.Add(positionEvent.EventStreamId, queue); } //TODO: progress calculation below is incorrect. sum(current)/sum(last_event) where sum by all streams queue.Enqueue(Tuple.Create(@event, positionEvent, 100.0f * (link ?? @event).EventNumber / message.LastEventNumber)); } } ProcessBuffers(); if (_pauseRequested) { _paused = true; } else if (message.Events.Length == 0) { RequestEvents(message.EventStreamId, delay: true); } _publisher.Publish(CreateTickMessage()); break; default: throw new NotSupportedException( string.Format("ReadEvents result code was not recognized. Code: {0}", message.Result)); } }