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)));
}
}