internal void BeginStatePartitionLoad( ProjectionMessage.Projections.CommittedEventReceived @event, Action loadCompleted) { string statePartition = _checkpointStrategy.StatePartitionSelector.GetStatePartition(@event); if (statePartition == "") // root is always cached { loadCompleted(); return; } string state = _partitionStateCache.TryGetAndLockPartitionState(statePartition, @event.CheckpointTag); if (state != null) { loadCompleted(); } else { string partitionStateStreamName = MakePartitionStateStreamName(statePartition); _readRequestsInProgress++; _readDispatcher.Publish( new ClientMessage.ReadStreamEventsBackward( Guid.NewGuid(), _readDispatcher.Envelope, partitionStateStreamName, -1, 1, resolveLinks: false), m => OnLoadStatePartitionCompleted(statePartition, @event, m, loadCompleted)); } }
public Guid ReadForward( string streamId, long fromEventNumber, int maxCount, bool resolveLinks, ClaimsPrincipal principal, Action <ClientMessage.ReadStreamEventsForwardCompleted> action, Guid?corrId = null) { if (!corrId.HasValue) { corrId = Guid.NewGuid(); } AddPendingRequest(corrId.Value); return (ForwardReader.Publish( new ClientMessage.ReadStreamEventsForward( corrId.Value, corrId.Value, ForwardReader.Envelope, streamId, fromEventNumber, maxCount, resolveLinks, false, null, principal), res => { RemovePendingRequest(res.CorrelationId); action(res); })); }
public Guid ReadForward( string streamId, long fromEventNumber, int maxCount, bool resolveLinks, IPrincipal principal, Action <ClientMessage.ReadStreamEventsForwardCompleted> action, Guid?corrId = null) { if (!corrId.HasValue) { corrId = Guid.NewGuid(); } return (ForwardReader.Publish( new ClientMessage.ReadStreamEventsForward( corrId.Value, corrId.Value, ForwardReader.Envelope, streamId, fromEventNumber, maxCount, resolveLinks, false, null, principal), action)); }
public void Handle(ProjectionManagementMessage.Internal.Deleted message) { const string eventStreamId = "$projections-$all"; var corrId = Guid.NewGuid(); _writeDispatcher.Publish( new ClientMessage.WriteEvents( corrId, corrId, _writeDispatcher.Envelope, true, eventStreamId, ExpectedVersion.Any, new Event( Guid.NewGuid(), "$ProjectionDeleted", false, Helper.UTF8NoBom.GetBytes(message.Name), Empty.ByteArray), SystemAccount.Principal), m => { _awaitingSlaveProjections.Remove(message.Id); // if any disconnected in error _projections.Remove(message.Name); _projectionsMap.Remove(message.Id); }); }
public Guid WriteEvents( string streamId, long expectedVersion, Event[] events, ClaimsPrincipal principal, Action <ClientMessage.WriteEventsCompleted> action) { var corrId = Guid.NewGuid(); AddPendingRequest(corrId); return (Writer.Publish( new ClientMessage.WriteEvents( corrId, corrId, Writer.Envelope, false, streamId, expectedVersion, events, principal), res => { RemovePendingRequest(res.CorrelationId); action(res); })); }
private void PublishWriteMetaStream() { var corrId = Guid.NewGuid(); _writeDispatcher.Publish( new ClientMessage.WriteEvents( corrId, corrId, _writeDispatcher.Envelope, true, SystemStreams.MetastreamOf(_streamId), ExpectedVersion.Any, _submittedWriteMetastreamEvent, _writeAs), HandleMetadataWriteCompleted); }
public Guid WriteEvents( string streamId, int expectedVersion, Event[] events, IPrincipal principal, Action <ClientMessage.WriteEventsCompleted> action) { var corrId = Guid.NewGuid(); return(Writer.Publish( new ClientMessage.WriteEvents(corrId, corrId, Writer.Envelope, false, streamId, expectedVersion, events, principal), action)); }
protected override void RequestLoadState() { const int recordsToRequest = 10; var corrId = Guid.NewGuid(); _readRequestId = _readDispatcher.Publish( new ClientMessage.ReadStreamEventsBackward( corrId, corrId, _readDispatcher.Envelope, _projectionCheckpointStreamId, _nextStateIndexToRequest, recordsToRequest, resolveLinkTos: false, requireMaster: false, validationStreamVersion: null, user: SystemAccount.Principal), OnLoadStateReadRequestCompleted); }
private void CreateFakeProjection(Action action) { var corrId = Guid.NewGuid(); _writeDispatcher.Publish( new ClientMessage.WriteEvents( corrId, corrId, _writeDispatcher.Envelope, true, "$projections-$all", ExpectedVersion.NoStream, new Event(Guid.NewGuid(), "$ProjectionsInitialized", false, Empty.ByteArray, Empty.ByteArray), SystemAccount.Principal), completed => WriteFakeProjectionCompleted(completed, action)); }
private void BeginLoad(string name) { _readDispatcher.Publish( new ClientMessage.ReadStreamEventsBackward( Guid.NewGuid(), _readDispatcher.Envelope, "$projections-" + name, -1, 1, resolveLinks: false), LoadCompleted); }
public Guid ReadBackward( string streamId, int fromEventNumber, int maxCount, bool resolveLinks, IPrincipal principal, Action <ClientMessage.ReadStreamEventsBackwardCompleted> action) { var corrId = Guid.NewGuid(); return (BackwardReader.Publish( new ClientMessage.ReadStreamEventsBackward( corrId, corrId, BackwardReader.Envelope, streamId, fromEventNumber, maxCount, resolveLinks, false, null, principal), action)); }
public Guid DeleteStream( string streamId, long expectedVersion, bool hardDelete, ClaimsPrincipal principal, Action <ClientMessage.DeleteStreamCompleted> action) { var corrId = Guid.NewGuid(); AddPendingRequest(corrId); return(StreamDeleter.Publish( new ClientMessage.DeleteStream( corrId, corrId, Writer.Envelope, false, streamId, expectedVersion, hardDelete, principal), res => { RemovePendingRequest(res.CorrelationId); action(res); })); }
private void BeginLoadProjectionList(int from = -1) { _readDispatcher.Publish( new ClientMessage.ReadStreamEventsBackward( Guid.NewGuid(), _readDispatcher.Envelope, "$projections-$all", from, _readEventsBatchSize, resolveLinks: false), m => LoadProjectionListCompleted(m, from)); }
public void Handle(ProjectionManagementMessage.Command.Delete message) { if (!_started) { return; } var projection = GetProjection(message.Name); if (projection == null) { message.Envelope.ReplyWith(new ProjectionManagementMessage.NotFound()); } else { if (!ProjectionManagementMessage.RunAs.ValidateRunAs(projection.GetMode(), ReadWrite.Write, projection.RunAs, message)) { return; } try { projection.Handle(message); } catch (InvalidOperationException ex) { message.Envelope.ReplyWith(new ProjectionManagementMessage.OperationFailed(ex.Message)); return; } _projections.Remove(message.Name); _projectionsMap.Remove(projection.Id); const string eventStreamId = "$projections-$all"; var corrId = Guid.NewGuid(); _writeDispatcher.Publish( new ClientMessage.WriteEvents( corrId, corrId, _writeDispatcher.Envelope, true, eventStreamId, ExpectedVersion.Any, new Event( Guid.NewGuid(), "$ProjectionDeleted", false, Helper.UTF8NoBom.GetBytes(message.Name), Empty.ByteArray), SystemAccount.Principal), m => { }); } }
private void BeginWriteProjectionRegistration(string name, Action completed) { _writeDispatcher.Publish( new ClientMessage.WriteEvents( Guid.NewGuid(), _writeDispatcher.Envelope, "$projections-$all", ExpectedVersion.Any, new Event(Guid.NewGuid(), "ProjectionCreated", false, Encoding.UTF8.GetBytes(name), new byte[0])), m => WriteProjectionRegistrationCompleted(m, completed, name)); }
private void BeginLoadProjectionList(Action completedAction, int from = -1) { var corrId = Guid.NewGuid(); _readDispatcher.Publish( new ClientMessage.ReadStreamEventsBackward( corrId, corrId, _readDispatcher.Envelope, "$projections-$all", from, _readEventsBatchSize, resolveLinkTos: false, requireMaster: false, validationStreamVersion: null, user: SystemAccount.Principal), m => LoadProjectionListCompleted(m, from, completedAction)); }
public void DeleteStream( string streamId, int expectedVersion, bool hardDelete, IPrincipal principal, Action <ClientMessage.DeleteStreamCompleted> action) { var corrId = Guid.NewGuid(); StreamDeleter.Publish( new ClientMessage.DeleteStream(corrId, corrId, Writer.Envelope, false, streamId, expectedVersion, hardDelete, principal), action); }
private void BeginLoad(string name) { var corrId = Guid.NewGuid(); _readDispatcher.Publish( new ClientMessage.ReadStreamEventsBackward( corrId, corrId, _readDispatcher.Envelope, "$projections-" + name, -1, 1, resolveLinkTos: false, requireMaster: false, validationStreamVersion: null, user: SystemAccount.Principal), LoadCompleted); }
public Guid ReadAllForwardFiltered( long commitPosition, long preparePosition, int maxCount, bool resolveLinks, bool requireLeader, int maxSearchWindow, long?validationTfLastCommitPosition, IEventFilter eventFilter, ClaimsPrincipal user, TimeSpan?longPollTimeout, Action <ClientMessage.FilteredReadAllEventsForwardCompleted> action, Action timeoutAction, Guid corrId) { AddPendingRequest(corrId); _pendingReads.Register(corrId); AllForwardFilteredReader.Publish( new ClientMessage.FilteredReadAllEventsForward( corrId, corrId, AllForwardFilteredReader.Envelope, commitPosition, preparePosition, maxCount, resolveLinks, requireLeader, maxSearchWindow, validationTfLastCommitPosition, eventFilter, user, longPollTimeout ), res => { RemovePendingRequest(corrId); if (!_pendingReads.IsRegistered(corrId)) { return; } _pendingReads.Remove(corrId); action(res); }); Delay(TimeSpan.FromMilliseconds(ReadTimeoutMs), () => { RemovePendingRequest(corrId); if (!_pendingReads.IsRegistered(corrId)) { return; } _pendingReads.Remove(corrId); timeoutAction(); }, corrId); return(corrId); }
private void DeleteStream(string streamId, Action completed) { //delete checkpoint stream var correlationId = Guid.NewGuid(); _streamDispatcher.Publish(new ClientMessage.DeleteStream( correlationId, correlationId, _writeDispatcher.Envelope, true, streamId, ExpectedVersion.Any, false, SystemAccount.Principal), m => DeleteStreamCompleted(m, streamId, completed)); }
private void BeginWrite(Action completed) { if (Mode <= ProjectionMode.AdHoc) { completed(); return; } var managedProjectionSerializedState = _persistedState.ToJsonBytes(); _writeDispatcher.Publish( new ClientMessage.WriteEvents( Guid.NewGuid(), _writeDispatcher.Envelope, "$projections-" + _name, ExpectedVersion.Any, new Event(Guid.NewGuid(), "ProjectionUpdated", false, managedProjectionSerializedState, new byte[0])), m => WriteCompleted(m, completed)); }
internal void BeginStatePartitionLoad(string statePartition, CheckpointTag eventCheckpointTag, Action loadCompleted) { if (statePartition == "") // root is always cached { loadCompleted(); return; } var state = _partitionStateCache.TryGetAndLockPartitionState(statePartition, eventCheckpointTag); if (state != null) { loadCompleted(); } else { string partitionStateStreamName = MakePartitionStateStreamName(statePartition); _readRequestsInProgress++; var requestId = _readDispatcher.Publish(new ClientMessage.ReadStreamEventsBackward(Guid.NewGuid(), _readDispatcher.Envelope, partitionStateStreamName, -1, 1, resolveLinks: false), m => OnLoadStatePartitionCompleted(statePartition, m, loadCompleted, eventCheckpointTag)); if (requestId != Guid.Empty) { _loadStateRequests.Add(requestId); } } }
private void DeleteCheckpointStream() { //delete checkpoint stream var correlationId = Guid.NewGuid(); var checkpointStreamName = new ProjectionNamesBuilder(_name, _persistedState.SourceDefinition).MakeCheckpointStreamName(); _streamDispatcher.Publish(new ClientMessage.DeleteStream( correlationId, correlationId, _writeDispatcher.Envelope, true, checkpointStreamName, ExpectedVersion.Any, false, SystemAccount.Principal), m => StreamDeleted(m, checkpointStreamName)); }
private void SubmitListEvents(CheckpointTag upTo, int fromEventNumber = -1) { if (_awaitingWriteCompleted || _awaitingMetadataWriteCompleted || _awaitingListEventsCompleted) { throw new Exception(); } _awaitingListEventsCompleted = true; var corrId = Guid.NewGuid(); _readDispatcher.Publish( new ClientMessage.ReadStreamEventsBackward( //TODO: reading events history in batches of 1 event (slow?) corrId, corrId, _readDispatcher.Envelope, _streamId, fromEventNumber, 1, resolveLinkTos: false, requireMaster: false, validationStreamVersion: null, user: SystemAccount.Principal), completed => ReadStreamEventsBackwardCompleted(completed, upTo)); }
private void PublishWriteCheckpointEvent() { if (_logger != null) { _logger.Trace( "Writing checkpoint for {0} at {1} with expected version number {2}", _name, _requestedCheckpointPosition, _lastWrittenCheckpointEventNumber); } var corrId = Guid.NewGuid(); _writeRequestId = _writeDispatcher.Publish( new ClientMessage.WriteEvents( corrId, corrId, _writeDispatcher.Envelope, true, _projectionCheckpointStreamId, _lastWrittenCheckpointEventNumber, _checkpointEventToBePublished, SystemAccount.Principal), msg => WriteCheckpointEventCompleted(msg, _projectionCheckpointStreamId)); }
public void SubscribeAwake( string streamId, TFPos from, Action <IODispatcherDelayedMessage> action, Guid?correlationId = null) { var corrId = correlationId ?? Guid.NewGuid(); Awaker.Publish( new AwakeServiceMessage.SubscribeAwake( Awaker.Envelope, corrId, streamId, from, new IODispatcherDelayedMessage(corrId, null)), action); }
public Guid ReadAllBackward( long commitPosition, long preparePosition, int maxCount, bool resolveLinks, bool requireMaster, long?validationTfLastCommitPosition, IPrincipal user, TimeSpan?longPollTimeout, Action <ClientMessage.ReadAllEventsBackwardCompleted> action, Action timeoutAction, Guid corrId) { _pendingReads.Register(corrId); AllBackwardReader.Publish( new ClientMessage.ReadAllEventsBackward( corrId, corrId, AllBackwardReader.Envelope, commitPosition, preparePosition, maxCount, resolveLinks, requireMaster, validationTfLastCommitPosition, user ), res => { if (!_pendingReads.IsRegistered(corrId)) { return; } _pendingReads.Remove(corrId); action(res); }); Delay(TimeSpan.FromMilliseconds(ReadTimeoutMs), () => { if (!_pendingReads.IsRegistered(corrId)) { return; } _pendingReads.Remove(corrId); timeoutAction(); }, corrId); return(corrId); }
public Guid ReadAllBackwardFiltered( long commitPosition, long preparePosition, int maxCount, bool resolveLinks, bool requireLeader, int maxSearchWindow, long?validationTfLastCommitPosition, IEventFilter eventFilter, ClaimsPrincipal user, Action <ClientMessage.FilteredReadAllEventsBackwardCompleted> action, Action timeoutAction, Guid corrId) { _requestTracker.AddPendingRead(corrId); AllBackwardFilteredReader.Publish( new ClientMessage.FilteredReadAllEventsBackward( corrId, corrId, AllBackwardFilteredReader.Envelope, commitPosition, preparePosition, maxCount, resolveLinks, requireLeader, maxSearchWindow, validationTfLastCommitPosition, eventFilter, user ), res => { if (_requestTracker.RemovePendingRead(res.CorrelationId)) { action(res); } }); Delay(TimeSpan.FromMilliseconds(ReadTimeoutMs), () => { if (_requestTracker.RemovePendingRead(corrId)) { timeoutAction(); } }, corrId); return(corrId); }
public void Handle(ProjectionManagementMessage.Command.GetResult message) { _lastAccessed = _timeProvider.Now; if (_state >= ManagedProjectionState.Running) { _getResultDispatcher.Publish( new CoreProjectionManagementMessage.GetResult(Guid.NewGuid(), Id, message.Partition, _workerId), m => message.Envelope.ReplyWith( new ProjectionManagementMessage.ProjectionResult(_name, m.Partition, m.Result, m.Position))); } else { message.Envelope.ReplyWith( new ProjectionManagementMessage.ProjectionResult( message.Name, message.Partition, "*** UNKNOWN ***", position: null)); } }
private void BeginWrite(Action completed) { if (Mode == ProjectionMode.Transient) { completed(); return; } var managedProjectionSerializedState = _persistedState.ToJsonBytes(); var eventStreamId = "$projections-" + _name; var corrId = Guid.NewGuid(); _writeDispatcher.Publish( new ClientMessage.WriteEvents( corrId, corrId, _writeDispatcher.Envelope, true, eventStreamId, ExpectedVersion.Any, new Event(Guid.NewGuid(), "$ProjectionUpdated", true, managedProjectionSerializedState, Empty.ByteArray), SystemAccount.Principal), m => WriteCompleted(m, completed, eventStreamId)); }