public ProjectionsStatisticsHttpFormatted( ProjectionManagementMessage.Statistics source, Func<string, string> makeAbsouteUrl) { _projections = source.Projections.Select(v => new ProjectionStatisticsHttpFormatted(v, makeAbsouteUrl)).ToArray(); _transactionFileHeadPosition = source.TransactionFileHeadPosition; }
public Definition( string name, string handlerType, string query, SlaveProjectionRequestedNumber requestedNumber, ProjectionMode mode, bool emitEnabled, bool checkpointsEnabled, bool enableRunAs, ProjectionManagementMessage.RunAs runAs) { _name = name; _handlerType = handlerType; _query = query; _requestedNumber = requestedNumber; _runAs = runAs; _enableRunAs = enableRunAs; _checkpointsEnabled = checkpointsEnabled; _emitEnabled = emitEnabled; _mode = mode; }
public void Handle(ProjectionManagementMessage.Command.Abort message) { _lastAccessed = _timeProvider.Now; UpdateProjectionVersion(); SetLastReplyEnvelope(message.Envelope); Disable(); Abort(); }
private void DoDisable(ProjectionManagementMessage.Disable message) { if (!Enabled) { message.Envelope.ReplyWith(new ProjectionManagementMessage.OperationFailed("Not enabled")); return; } Disable(); PrepareAndBeginWrite( forcePrepare: false, completed: () => message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name))); }
public void InitializeNew(ProjectionManagementMessage.Post message, Action completed) { LoadPersistedState( new PersistedState { Enabled = message.Enabled, HandlerType = message.HandlerType, Query = message.Query, Mode = message.Mode }); PrepareAndBeginWrite(forcePrepare: true, completed: () => StartNew(completed)); }
public void Handle(ProjectionManagementMessage.Enable message) { if (Enabled) { message.Envelope.ReplyWith(new ProjectionManagementMessage.OperationFailed("Not disabled")); return; } Enable(); PrepareAndBeginWrite( forcePrepare: true, completed: () => Start( () => message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name)))); }
public void Handle(ProjectionManagementMessage.GetState message) { if (_state == ManagedProjectionState.Running) { var needRequest = false; if (_stateRequests == null) { _stateRequests = new Dictionary<string, List<IEnvelope>>(); } List<IEnvelope> partitionRequests; if (!_stateRequests.TryGetValue(message.Partition, out partitionRequests)) { partitionRequests = new List<IEnvelope>(); _stateRequests.Add(message.Partition, partitionRequests); needRequest = true; } partitionRequests.Add(message.Envelope); if (needRequest) _coreQueue.Publish( new CoreProjectionManagementMessage.GetState( new PublishEnvelope(_inputQueue), _id, message.Partition)); } else { //TODO: report right state here message.Envelope.ReplyWith( new ProjectionManagementMessage.ProjectionState(message.Name, "*** UNKNOWN ***")); } }
public void Handle(ProjectionManagementMessage.GetQuery message) { message.Envelope.ReplyWith(new ProjectionManagementMessage.ProjectionQuery(_name, Query)); }
private void DoDelete(ProjectionManagementMessage.Delete message) { if (Enabled) Disable(); Delete(); Action completed = () => { message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(_name)); DisposeCoreProjection(); _output.Publish(new ProjectionManagementMessage.Internal.Deleted(_name, Id)); }; UpdateProjectionVersion(); if (Enabled) Prepare(() => BeginWrite(completed)); else BeginWrite(completed); }
private void UpdateQuery(ProjectionManagementMessage.Command.UpdateQuery message) { PersistedProjectionState.HandlerType = message.HandlerType ?? HandlerType; PersistedProjectionState.Query = message.Query; PersistedProjectionState.EmitEnabled = message.EmitEnabled ?? PersistedProjectionState.EmitEnabled; _pendingWritePersistedState = true; if (_state == ManagedProjectionState.Completed) { Reset(); } }
private void SetRunAs(ProjectionManagementMessage.Command.SetRunAs message) { PersistedProjectionState.RunAs = message.Action == ProjectionManagementMessage.Command.SetRunAs.SetRemove.Set ? SerializedRunAs.SerializePrincipal(message.RunAs) : null; _runAs = SerializedRunAs.DeserializePrincipal(PersistedProjectionState.RunAs); _pendingWritePersistedState = true; }
public void Handle(ProjectionManagementMessage.Command.Reset message) { _lastAccessed = _timeProvider.Now; Prepared = false; _pendingWritePersistedState = true; Reset(); UpdateProjectionVersion(); SetLastReplyEnvelope(message.Envelope); StopUnlessPreparedOrLoaded(); }
public void Handle(ProjectionManagementMessage.Command.Delete message) { if ((_state != ManagedProjectionState.Stopped && _state != ManagedProjectionState.Faulted) && Mode != ProjectionMode.Transient) throw new InvalidOperationException("Cannot delete a projection that hasn't been stopped or faulted."); _lastAccessed = _timeProvider.Now; PersistedProjectionState.DeleteCheckpointStream = message.DeleteCheckpointStream; PersistedProjectionState.DeleteStateStream = message.DeleteStateStream; PersistedProjectionState.DeleteEmittedStreams = message.DeleteEmittedStreams; if (PersistedProjectionState.DeleteCheckpointStream) { PersistedProjectionState.NumberOfPrequisitesMetForDeletion++; } if ((PersistedProjectionState.EmitEnabled ?? false) && ((PersistedProjectionState.TrackEmittedStreams ?? false) && PersistedProjectionState.DeleteEmittedStreams)) { PersistedProjectionState.NumberOfPrequisitesMetForDeletion++; } Delete(); UpdateProjectionVersion(); SetLastReplyEnvelope(message.Envelope); SetState(ManagedProjectionState.Deleting); StopUnlessPreparedOrLoaded(); }
public void Handle(ProjectionManagementMessage.Command.SetRunAs message) { _lastAccessed = _timeProvider.Now; Prepared = false; SetRunAs(message); UpdateProjectionVersion(); SetLastReplyEnvelope(message.Envelope); StopUnlessPreparedOrLoaded(); }
public void Handle(ProjectionManagementMessage.Command.Enable message) { _lastAccessed = _timeProvider.Now; if (Enabled && !(_state == ManagedProjectionState.Completed || _state == ManagedProjectionState.Faulted || _state == ManagedProjectionState.Aborted || _state == ManagedProjectionState.Loaded || _state == ManagedProjectionState.Prepared || _state == ManagedProjectionState.Stopped)) { //Projection is probably Running message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name)); return; } Enable(); _pendingWritePersistedState = true; UpdateProjectionVersion(); SetLastReplyEnvelope(message.Envelope); StopUnlessPreparedOrLoaded(); }
public static SerializedRunAs SerializePrincipal(ProjectionManagementMessage.RunAs runAs) { if (runAs.Principal == null) return null; // anonymous if (runAs.Principal == SystemAccount.Principal) return new SerializedRunAs {Name = "$system"}; var genericPrincipal = runAs.Principal as OpenGenericPrincipal; if (genericPrincipal == null) throw new ArgumentException( "OpenGenericPrincipal is the only supported principal type in projections", "runAs"); return new SerializedRunAs {Name = runAs.Principal.Identity.Name, Roles = genericPrincipal.Roles}; }
private void DoUpdateQuery(ProjectionManagementMessage.UpdateQuery message) { _persistedState.HandlerType = message.HandlerType ?? HandlerType; _persistedState.Query = message.Query; _persistedState.EmitEnabled = message.EmitEnabled ?? _persistedState.EmitEnabled; if (_state == ManagedProjectionState.Completed) { ResetProjection(); } Action completed = () => { StartOrLoadStopped(() => { }); message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name)); }; UpdateProjectionVersion(); Prepare(() => BeginWrite(completed)); }
public void Handle(ProjectionManagementMessage.GetQuery message) { _lastAccessed = _timeProvider.Now; if (!ProjectionManagementMessage.RunAs.ValidateRunAs(Mode, ReadWrite.Read, _runAs, message)) return; var emitEnabled = _persistedState.EmitEnabled ?? false; message.Envelope.ReplyWith( new ProjectionManagementMessage.ProjectionQuery(_name, Query, emitEnabled, _persistedState.SourceDefinition)); }
public void Handle(ProjectionManagementMessage.GetState message) { _lastAccessed = _timeProvider.Now; if (_state >= ManagedProjectionState.Stopped) { _getStateDispatcher.Publish( new CoreProjectionManagementMessage.GetState( new PublishEnvelope(_inputQueue), Guid.NewGuid(), Id, message.Partition), m => message.Envelope.ReplyWith( new ProjectionManagementMessage.ProjectionState(_name, m.Partition, m.State, m.Position))); } else { message.Envelope.ReplyWith( new ProjectionManagementMessage.ProjectionState( message.Name, message.Partition, "*** UNKNOWN ***", position: null)); } }
public void Handle(ProjectionManagementMessage.Abort message) { _lastAccessed = _timeProvider.Now; if (!ProjectionManagementMessage.RunAs.ValidateRunAs(Mode, ReadWrite.Write, _runAs, message)) return; Abort(() => DoDisable(message.Envelope, message.Name)); }
public void Handle(ProjectionManagementMessage.UpdateQuery message) { Stop(() => DoUpdateQuery(message)); }
public void Handle(ProjectionManagementMessage.Enable message) { _lastAccessed = _timeProvider.Now; if (!ProjectionManagementMessage.RunAs.ValidateRunAs(Mode, ReadWrite.Write, _runAs, message)) return; if (Enabled && !(_state == ManagedProjectionState.Completed || _state == ManagedProjectionState.Faulted || _state == ManagedProjectionState.Loaded || _state == ManagedProjectionState.Prepared || _state == ManagedProjectionState.Stopped)) { message.Envelope.ReplyWith( new ProjectionManagementMessage.OperationFailed("Invalid state")); return; } if (!Enabled) Enable(); Action completed = () => { if (_state == ManagedProjectionState.Prepared) StartOrLoadStopped(() => message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name))); else message.Envelope.ReplyWith( new ProjectionManagementMessage.Updated(message.Name)); }; UpdateProjectionVersion(); Prepare(() => BeginWrite(completed)); }
public void Handle(ProjectionManagementMessage.Disable message) { Stop(() => DoDisable(message)); }
public void Handle(ProjectionManagementMessage.SetRunAs message) { _lastAccessed = _timeProvider.Now; if ( !ProjectionManagementMessage.RunAs.ValidateRunAs( Mode, ReadWrite.Write, _runAs, message, message.Action == ProjectionManagementMessage.SetRunAs.SetRemove.Set)) return; Stop( () => { UpdateProjectionVersion(); _persistedState.RunAs = message.Action == ProjectionManagementMessage.SetRunAs.SetRemove.Set ? SerializePrincipal(message.RunAs) : null; _runAs = DeserializePrincipal(_persistedState.RunAs); Prepare( () => BeginWrite( () => { StartOrLoadStopped(() => { }); message.Envelope.ReplyWith( new ProjectionManagementMessage.Updated(message.Name)); })); }); }
public void Handle(ProjectionManagementMessage.Delete message) { Stop(() => DoDelete(message)); }
public void Handle(ProjectionManagementMessage.Reset message) { _lastAccessed = _timeProvider.Now; if (!ProjectionManagementMessage.RunAs.ValidateRunAs(Mode, ReadWrite.Write, _runAs, message)) return; Stop( () => { ResetProjection(); Prepare( () => BeginWrite( () => StartOrLoadStopped( () => message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name))))); }); }
private void DoDelete(ProjectionManagementMessage.Delete message) { if (Enabled) Disable(); Delete(); PrepareAndBeginWrite( forcePrepare: false, completed: () => message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name))); }
public void Handle(ProjectionManagementMessage.Delete message) { _lastAccessed = _timeProvider.Now; if (!ProjectionManagementMessage.RunAs.ValidateRunAs(Mode, ReadWrite.Write, _runAs, message)) return; Stop(() => DoDelete(message)); }
private void DoUpdateQuery(ProjectionManagementMessage.UpdateQuery message) { UpdateQuery(message.HandlerType ?? HandlerType, message.Query); PrepareAndBeginWrite( forcePrepare: true, completed: () => { if (Enabled) Start(() => { }); message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name)); }); }
public void Handle(ProjectionManagementMessage.Internal.CleanupExpired message) { //TODO: configurable expiration if (IsExpiredProjection()) { if (_state == ManagedProjectionState.Creating) { // NOTE: workaround for stop not working on creating state (just ignore them) return; } Stop( () => Handle( new ProjectionManagementMessage.Delete( new NoopEnvelope(), _name, ProjectionManagementMessage.RunAs.System, false, false))); } }