private void CompletedReadingPossibleStream(
ClientMessage.ReadStreamEventsBackwardCompleted completed,
ProjectionManagementMessage.Command.Post message,
IEnvelope replyEnvelope)
{
long version = -1;
if (completed.Result == ReadStreamResult.Success)
{
version = completed.LastEventNumber + 1;
}
if (message.Mode >= ProjectionMode.OneTime)
{
BeginWriteProjectionRegistration(
message.Name,
projectionId =>
{
InitializeNewProjection(projectionId, message, version, replyEnvelope);
}, replyEnvelope, ProjectionCreationRetryCount);
}
else
{
InitializeNewProjection(ProjectionQueryId, message, version, replyEnvelope);
}
}
protected override IEnumerable <WhenStep> When()
{
ProjectionManagementMessage.Command.Post message = new ProjectionManagementMessage.Command.Post(
Envelope, ProjectionMode.OneTime, _projectionName, ProjectionManagementMessage.RunAs.System,
typeof(FakeForeachStreamProjection), "", true, false, false, false);
_managedProjection.InitializeNew(
new ManagedProjection.PersistedState {
Enabled = message.Enabled,
HandlerType = message.HandlerType,
Query = message.Query,
Mode = message.Mode,
EmitEnabled = message.EmitEnabled,
CheckpointsDisabled = !message.CheckpointsEnabled,
Epoch = -1,
Version = -1,
RunAs = message.EnableRunAs ? SerializedRunAs.SerializePrincipal(message.RunAs) : null,
},
null);
var sourceDefinition = new FakeForeachStreamProjection("", Console.WriteLine).GetSourceDefinition();
var projectionSourceDefinition = ProjectionSourceDefinition.From(sourceDefinition);
_managedProjection.Handle(
new CoreProjectionStatusMessage.Prepared(
_coreProjectionId, projectionSourceDefinition));
_originalPersistedStateEventId = _consumer.HandledMessages.OfType <ClientMessage.WriteEvents>()
.Where(x => x.EventStreamId == _projectionDefinitionStreamId).First().Events[0].EventId;
CompleteWriteWithResult(_failureCondition);
_consumer.HandledMessages.Clear();
yield break;
}
protected override IEnumerable <WhenStep> When()
{
ProjectionManagementMessage.Command.Post message = new ProjectionManagementMessage.Command.Post(
Envelope, ProjectionMode.Transient, _projectionName, ProjectionManagementMessage.RunAs.System,
typeof(FakeForeachStreamProjection), "", true, false, false, false);
_mp.InitializeNew(
new ManagedProjection.PersistedState
{
Enabled = message.Enabled,
HandlerType = message.HandlerType,
Query = message.Query,
Mode = message.Mode,
EmitEnabled = message.EmitEnabled,
CheckpointsDisabled = !message.CheckpointsEnabled,
Epoch = -1,
Version = -1,
RunAs = message.EnableRunAs ? SerializedRunAs.SerializePrincipal(message.RunAs) : null,
},
null);
var sourceDefinition = new FakeForeachStreamProjection("", Console.WriteLine).GetSourceDefinition();
var projectionSourceDefinition = ProjectionSourceDefinition.From(sourceDefinition);
_mp.Handle(
new CoreProjectionStatusMessage.Prepared(
_coreProjectionId, projectionSourceDefinition));
yield break;
}
private void CompletedReadingPossibleStream(
ClientMessage.ReadStreamEventsBackwardCompleted completed,
ProjectionManagementMessage.Command.Post message,
IEnvelope replyEnvelope)
{
int version = -1;
if (completed.Result == ReadStreamResult.Success)
{
version = completed.LastEventNumber + 1;
}
if (message.Mode >= ProjectionMode.OneTime)
{
BeginWriteProjectionRegistration(
message.Name,
projectionId =>
{
var initializer = new NewProjectionInitializer(
projectionId,
message.Name,
message.Mode,
message.HandlerType,
message.Query,
message.Enabled,
message.EmitEnabled,
message.CheckpointsEnabled,
message.EnableRunAs,
message.RunAs,
replyEnvelope);
int queueIndex = GetNextWorkerIndex();
initializer.CreateAndInitializeNewProjection(
this,
Guid.NewGuid(),
_workers[queueIndex],
version: version);
});
}
else
{
var initializer = new NewProjectionInitializer(
ProjectionQueryId,
message.Name,
message.Mode,
message.HandlerType,
message.Query,
message.Enabled,
message.EmitEnabled,
message.CheckpointsEnabled,
message.EnableRunAs,
message.RunAs,
replyEnvelope);
int queueIndex = GetNextWorkerIndex();
initializer.CreateAndInitializeNewProjection(this, Guid.NewGuid(), _workers[queueIndex], version: version);
}
}
private void ProjectionsPost(HttpEntityManager http, UriTemplateMatch match, ProjectionMode mode, string name)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
var envelope = new SendToHttpEnvelope <ProjectionManagementMessage.Updated>(
_networkSendQueue, http, DefaultFormatter, (codec, message) => {
var localPath = string.Format("/projection/{0}", message.Name);
var url = MakeUrl(http, localPath);
return(new ResponseConfiguration(
201, "Created", codec.ContentType, codec.Encoding,
new KeyValuePair <string, string>("Location", url)));
}, ErrorsEnvelope(http));
http.ReadTextRequestAsync(
(o, s) => {
ProjectionManagementMessage.Command.Post postMessage;
string handlerType = match.BoundVariables["type"] ?? "JS";
bool emitEnabled = IsOn(match, "emit", false);
bool checkpointsEnabled = mode >= ProjectionMode.Continuous || IsOn(match, "checkpoints", false);
bool enabled = IsOn(match, "enabled", def: true);
bool trackEmittedStreams = IsOn(match, "trackemittedstreams", def: false);
if (!emitEnabled)
{
trackEmittedStreams = false;
}
var runAs = GetRunAs(http, match);
if (mode <= ProjectionMode.OneTime && string.IsNullOrEmpty(name))
{
postMessage = new ProjectionManagementMessage.Command.Post(
envelope, mode, Guid.NewGuid().ToString("D"), runAs, handlerType, s, enabled: enabled,
checkpointsEnabled: checkpointsEnabled, emitEnabled: emitEnabled,
trackEmittedStreams: trackEmittedStreams, enableRunAs: true);
}
else
{
postMessage = new ProjectionManagementMessage.Command.Post(
envelope, mode, name, runAs, handlerType, s, enabled: enabled,
checkpointsEnabled: checkpointsEnabled, emitEnabled: emitEnabled,
trackEmittedStreams: trackEmittedStreams, enableRunAs: true);
}
Publish(postMessage);
}, x => Log.DebugException(x, "Reply Text Body Failed."));
}
private void PostNewProjection(ProjectionManagementMessage.Command.Post message, IEnvelope replyEnvelope)
{
if (message.Mode >= ProjectionMode.OneTime)
{
BeginWriteProjectionRegistration(
message.Name,
projectionId =>
{
var initializer = new NewProjectionInitializer(
projectionId,
message.Name,
message.Mode,
message.HandlerType,
message.Query,
message.Enabled,
message.EmitEnabled,
message.CheckpointsEnabled,
message.EnableRunAs,
message.RunAs,
replyEnvelope);
int queueIndex = GetNextWorkerIndex();
initializer.CreateAndInitializeNewProjection(
this,
Guid.NewGuid(),
_workers[queueIndex]);
});
}
else
{
var initializer = new NewProjectionInitializer(
ProjectionQueryId,
message.Name,
message.Mode,
message.HandlerType,
message.Query,
message.Enabled,
message.EmitEnabled,
message.CheckpointsEnabled,
message.EnableRunAs,
message.RunAs,
replyEnvelope);
int queueIndex = GetNextWorkerIndex();
initializer.CreateAndInitializeNewProjection(this, Guid.NewGuid(), _workers[queueIndex]);
}
}
public void Handle(ProjectionManagementMessage.Command.Post message)
{
var command = new PostCommand {
Name = message.Name,
RunAs = message.RunAs,
CheckpointsEnabled = message.CheckpointsEnabled,
TrackEmittedStreams = message.TrackEmittedStreams,
EmitEnabled = message.EmitEnabled,
EnableRunAs = message.EnableRunAs,
Enabled = message.Enabled,
HandlerType = message.HandlerType,
Mode = message.Mode,
Query = message.Query,
};
_writer.PublishCommand("$post", command);
}
private void PostNewProjection(ProjectionManagementMessage.Command.Post message, IEnvelope replyEnvelope)
{
var corrId = Guid.NewGuid();
_readDispatcher.Publish(
new ClientMessage.ReadStreamEventsBackward(
corrId,
corrId,
_readDispatcher.Envelope,
"$projections-" + message.Name,
0,
_readEventsBatchSize,
resolveLinkTos: false,
requireMaster: false,
validationStreamVersion: null,
user: SystemAccount.Principal),
m => CompletedReadingPossibleStream(m, message, replyEnvelope));
}
private void CreateSystemProjection(string name, Type handlerType, string config)
{
IEnvelope envelope = new NoopEnvelope();
var postMessage = new ProjectionManagementMessage.Command.Post(
envelope,
ProjectionMode.Continuous,
name,
ProjectionManagementMessage.RunAs.System,
"native:" + handlerType.Namespace + "." + handlerType.Name,
config,
enabled: false,
checkpointsEnabled: true,
emitEnabled: true,
enableRunAs: true);
_publisher.Publish(postMessage);
}
public void null_query_throws_argument_null_exception()
{
ProjectionManagementMessage.Command.Post message = new ProjectionManagementMessage.Command.Post(
new NoopEnvelope(), ProjectionMode.OneTime, "name", ProjectionManagementMessage.RunAs.Anonymous,
"JS", query: null, enabled: true, checkpointsEnabled: false, emitEnabled: false);
_mp.InitializeNew(
new ManagedProjection.PersistedState
{
Enabled = message.Enabled,
HandlerType = message.HandlerType,
Query = message.Query,
Mode = message.Mode,
EmitEnabled = message.EmitEnabled,
CheckpointsDisabled = !message.CheckpointsEnabled,
Epoch = -1,
Version = -1,
RunAs = message.EnableRunAs ? SerializedRunAs.SerializePrincipal(message.RunAs) : null,
},
null);
}
public void empty_handler_type_throws_argument_null_exception()
{
Assert.Throws <ArgumentException>(() => {
ProjectionManagementMessage.Command.Post message = new ProjectionManagementMessage.Command.Post(
new NoopEnvelope(), ProjectionMode.OneTime, "name", ProjectionManagementMessage.RunAs.Anonymous, "",
@"log(1);", enabled: true, checkpointsEnabled: false, emitEnabled: false,
trackEmittedStreams: false);
_mp.InitializeNew(
new ManagedProjection.PersistedState {
Enabled = message.Enabled,
HandlerType = message.HandlerType,
Query = message.Query,
Mode = message.Mode,
EmitEnabled = message.EmitEnabled,
CheckpointsDisabled = !message.CheckpointsEnabled,
Epoch = -1,
Version = -1,
RunAs = message.EnableRunAs ? SerializedRunAs.SerializePrincipal(message.RunAs) : null,
},
null);
});
}
private void InitializeNewProjection(long projectionId, ProjectionManagementMessage.Command.Post message, long version, IEnvelope replyEnvelope)
{
try{
var initializer = new NewProjectionInitializer(
projectionId,
message.Name,
message.Mode,
message.HandlerType,
message.Query,
message.Enabled,
message.EmitEnabled,
message.CheckpointsEnabled,
message.EnableRunAs,
message.TrackEmittedStreams,
message.RunAs,
replyEnvelope);
int queueIndex = GetNextWorkerIndex();
initializer.CreateAndInitializeNewProjection(this, Guid.NewGuid(), _workers[queueIndex], version: version);
}catch (Exception ex) {
message.Envelope.ReplyWith(new ProjectionManagementMessage.OperationFailed(ex.Message));
}
}
public void Handle(ProjectionManagementMessage.Command.Post message)
{
if (!_started)
{
return;
}
if (
!ProjectionManagementMessage.RunAs.ValidateRunAs(
message.Mode,
ReadWrite.Write,
null,
message,
replace: message.EnableRunAs))
{
return;
}
if (message.Name == null)
{
message.Envelope.ReplyWith(
new ProjectionManagementMessage.OperationFailed("Projection name is required"));
}
else
{
if (_projections.ContainsKey(message.Name))
{
message.Envelope.ReplyWith(
new ProjectionManagementMessage.Conflict("Duplicate projection name: " + message.Name));
}
else
{
PostNewProjection(message, message.Envelope);
}
}
}
