private void ProjectionsPost(HttpEntity http, UriTemplateMatch match, ProjectionMode mode, string name)
{
var envelope = new SendToHttpEnvelope <ProjectionManagementMessage.Updated>(
http, DefaultFormatter, (codec, message) =>
{
var localPath = string.Format("/projection/{0}", message.Name);
var url = MakeUrl(match, localPath);
return(new ResponseConfiguration(
201, "Created", codec.ContentType, new KeyValuePair <string, string>("Location", url)));
}, ErrorsEnvelope(http));
http.Manager.ReadRequestAsync(
(o, s) =>
{
ProjectionManagementMessage.Post postMessage;
string handlerType = match.BoundVariables["type"] ?? "JS";
if ((mode == ProjectionMode.OneTime || mode == ProjectionMode.AdHoc) &&
string.IsNullOrEmpty(name))
{
postMessage = new ProjectionManagementMessage.Post(
envelope, mode, Guid.NewGuid().ToString("D"), handlerType, s, enabled: true);
}
else
{
postMessage = new ProjectionManagementMessage.Post(envelope, mode, name, handlerType, s, enabled: true);
}
this.Publish(postMessage);
}, Console.WriteLine);
}
public void Handle(ProjectionManagementMessage.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.OperationFailed("Duplicate projection name: " + message.Name));
}
else
{
PostNewProjection(
message,
managedProjection =>
message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name)));
}
}
}
public void InitializeNew(ProjectionManagementMessage.Post message, Action completed)
{
if (message.Mode >= ProjectionMode.Continuous && !message.CheckpointsEnabled)
{
throw new InvalidOperationException("Continuous mode requires checkpoints");
}
if (message.EmitEnabled && !message.CheckpointsEnabled)
{
throw new InvalidOperationException("Emit requires checkpoints");
}
LoadPersistedState(
new 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 ? SerializePrincipal(message.RunAs) : null,
});
UpdateProjectionVersion();
Prepare(() => BeginWrite(() => StartOrLoadStopped(completed)));
}
protected override IEnumerable <WhenStep> When()
{
ProjectionManagementMessage.Post message = new ProjectionManagementMessage.Post(
Envelope, ProjectionMode.Transient, _projectionName, ProjectionManagementMessage.RunAs.System,
typeof(FakeForeachStreamProjection), "", true, 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 ? ManagedProjection.SerializePrincipal(message.RunAs) : null,
});
var sourceDefinition = new FakeForeachStreamProjection("", Console.WriteLine).GetSourceDefinition();
var projectionSourceDefinition = ProjectionSourceDefinition.From(
_projectionName, sourceDefinition, message.HandlerType, message.Query);
_mp.Handle(
new CoreProjectionManagementMessage.Prepared(
_coreProjectionId, projectionSourceDefinition, null));
yield break;
}
public void InitializeNew(ProjectionManagementMessage.Post message, Action completed)
{
LoadPersistedState(
new PersistedState
{
Enabled = message.Enabled, HandlerType = message.HandlerType, Query = message.Query, Mode = message.Mode
});
BeginWrite(() => StartNew(completed));
}
private void CreatePredefinedProjection(string name, Type handlerType, string config)
{
IEnvelope envelope = new NoopEnvelope();
var postMessage = new ProjectionManagementMessage.Post(
envelope, ProjectionMode.Persistent, name, "native:" + handlerType.Namespace + "." + handlerType.Name,
config, enabled: false);
_publisher.Publish(postMessage);
}
private void CreateSystemProjection(string name, Type handlerType, string config)
{
IEnvelope envelope = new NoopEnvelope();
var postMessage = new ProjectionManagementMessage.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);
}
private void PostNewProjection(ProjectionManagementMessage.Post message, Action <ManagedProjection> completed)
{
if (message.Mode > ProjectionMode.AdHoc)
{
BeginWriteProjectionRegistration(
message.Name, () =>
{
var projection = CreateManagedProjectionInstance(message.Name);
projection.InitializeNew(message, () => completed(projection));
});
}
else
{
var projection = CreateManagedProjectionInstance(message.Name);
projection.InitializeNew(message, () => completed(projection));
}
}
public void null_query_throws_argument_null_exception()
{
ProjectionManagementMessage.Post message = new ProjectionManagementMessage.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 ? ManagedProjection.SerializePrincipal(message.RunAs) : null,
});
}
private void PostNewProjection(ProjectionManagementMessage.Post message, Action <ManagedProjection> completed)
{
if (message.Mode >= ProjectionMode.OneTime)
{
BeginWriteProjectionRegistration(
message.Name,
projectionId =>
new NewProjectionInitializer(
projectionId, message.Name, message.Mode, message.HandlerType, message.Query,
message.Enabled, message.EmitEnabled, message.CheckpointsEnabled, message.EnableRunAs,
message.RunAs).CreateAndInitializeNewProjection(
this, completed, Guid.NewGuid(), GetNextQueueIndex()));
}
else
{
new NewProjectionInitializer(
ProjectionQueryId, message.Name, message.Mode, message.HandlerType, message.Query, message.Enabled,
message.EmitEnabled, message.CheckpointsEnabled, message.EnableRunAs, message.RunAs)
.CreateAndInitializeNewProjection(this, completed, Guid.NewGuid(), GetNextQueueIndex());
}
}
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(match, localPath);
return(new ResponseConfiguration(
201, "Created", codec.ContentType, codec.Encoding, new KeyValuePair <string, string>("Location", url)));
}, ErrorsEnvelope(http));
http.ReadTextRequestAsync(
(o, s) =>
{
ProjectionManagementMessage.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);
var runAs = GetRunAs(http, match);
if (mode <= ProjectionMode.OneTime && string.IsNullOrEmpty(name))
{
postMessage = new ProjectionManagementMessage.Post(
envelope, mode, Guid.NewGuid().ToString("D"), runAs, handlerType, s, enabled: enabled,
checkpointsEnabled: checkpointsEnabled, emitEnabled: emitEnabled, enableRunAs: true);
}
else
{
postMessage = new ProjectionManagementMessage.Post(
envelope, mode, name, runAs, handlerType, s, enabled: enabled,
checkpointsEnabled: checkpointsEnabled, emitEnabled: emitEnabled, enableRunAs: true);
}
Publish(postMessage);
}, Console.WriteLine);
}
public void Handle(ProjectionManagementMessage.Post message)
{
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.OperationFailed("Duplicate projection name: " + message.Name));
}
else
{
PostNewProjection(
message,
managedProjection =>
message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name)));
}
}
}
