private void PostEventsIdempotent(HttpEntityManager manager, UriTemplateMatch match)
{
var stream = match.BoundVariables["stream"];
var guid = match.BoundVariables["guid"];
Guid id;
if (!Guid.TryParse(guid, out id))
{
SendBadRequest(manager, string.Format("Invalid request. Unable to parse guid"));
return;
}
if (stream.IsEmptyString())
{
SendBadRequest(manager, string.Format("Invalid request. Stream must be non-empty string"));
return;
}
string includedType;
if (!GetIncludedType(manager, out includedType))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.EventType));
return;
}
long expectedVersion;
if (!GetExpectedVersion(manager, out expectedVersion))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.ExpectedVersion));
return;
}
bool requireMaster;
if (!GetRequireMaster(manager, out requireMaster))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.RequireMaster));
return;
}
if (!requireMaster && _httpForwarder.ForwardRequest(manager))
{
return;
}
PostEntry(manager, expectedVersion, requireMaster, stream, id, includedType);
}
private void GetCurrentUser(HttpEntityManager http, UriTemplateMatch match)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
var envelope = CreateReplyEnvelope <UserManagementMessage.UserDetailsResult>(http);
if (http.User == null)
{
envelope.ReplyWith(
new UserManagementMessage.UserDetailsResult(UserManagementMessage.Error.Unauthorized));
return;
}
var message = new UserManagementMessage.Get(envelope, http.User, http.User.Identity.Name);
Publish(message);
}
private void GetSubscriptionInfo(HttpEntityManager http, UriTemplateMatch match)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
var stream = match.BoundVariables["stream"];
var groupName = match.BoundVariables["subscription"];
var envelope = new SendToHttpEnvelope(
_networkSendQueue, http,
(args, message) =>
http.ResponseCodec.To(
ToDto(http, message as MonitoringMessage.GetPersistentSubscriptionStatsCompleted)
.FirstOrDefault()),
(args, message) => StatsConfiguration(http, message));
var cmd = new MonitoringMessage.GetPersistentSubscriptionStats(envelope, stream, groupName);
Publish(cmd);
}
// METASTREAMS
private void PostMetastreamEvent(HttpEntityManager manager, UriTemplateMatch match)
{
var stream = match.BoundVariables["stream"];
if (stream.IsEmptyString() || SystemStreams.IsMetastream(stream))
{
SendBadRequest(manager, string.Format("Invalid request. Stream must be non-empty string and should not be metastream"));
return;
}
Guid includedId;
if (!GetIncludedId(manager, out includedId))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.EventId));
return;
}
string includedType;
if (!GetIncludedType(manager, out includedType))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.EventType));
return;
}
int expectedVersion;
if (!GetExpectedVersion(manager, out expectedVersion))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.ExpectedVersion));
return;
}
bool requireMaster;
if (!GetRequireMaster(manager, out requireMaster))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.RequireMaster));
return;
}
if (!requireMaster && _httpForwarder.ForwardRequest(manager))
{
return;
}
PostEntry(manager, expectedVersion, requireMaster, SystemStreams.MetastreamOf(stream), includedId, includedType);
}
private void ForwardResponse(HttpEntityManager manager, HttpRequestMessage request)
{
_forwardClient.SendAsync(request)
.ContinueWith(t => {
HttpResponseMessage response;
try {
response = t.Result;
} catch (Exception ex) {
Log.Debug("Error in SendAsync for forwarded request for '{requestedUrl}': {e}.",
manager.RequestedUrl, ex.InnerException.Message);
ForwardReplyFailed(manager);
return;
}
manager.ForwardReply(response,
exc => Log.Debug("Error forwarding response for '{requestedUrl}': {e}.", manager.RequestedUrl,
exc.Message));
});
}
private void PostCommandChangePassword(HttpEntityManager http, UriTemplateMatch match)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
var envelope = CreateReplyEnvelope <UserManagementMessage.UpdateResult>(http);
http.ReadTextRequestAsync(
(o, s) =>
{
var login = match.BoundVariables["login"];
var data = http.RequestCodec.From <ChangePasswordData>(s);
var message = new UserManagementMessage.ChangePassword(
envelope, http.User, login, data.CurrentPassword, data.NewPassword);
Publish(message);
},
x => Log.DebugException(x, "Reply Text Content Failed."));
}
private RequestParams GetAllEventsForward(HttpEntityManager manager, UriTemplateMatch match)
{
var pos = match.BoundVariables["position"];
var cnt = match.BoundVariables["count"];
TFPos position;
int count;
var embed = GetEmbedLevel(manager, match);
if (!TFPos.TryParse(pos, out position) || position.PreparePosition < 0 || position.CommitPosition < 0)
{
return(SendBadRequest(manager, string.Format("Invalid position argument: {0}", pos)));
}
if (!int.TryParse(cnt, out count) || count <= 0)
{
return(SendBadRequest(manager, string.Format("Invalid count argument: {0}", cnt)));
}
bool requireMaster;
if (!GetRequireMaster(manager, out requireMaster))
{
return(SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.RequireMaster)));
}
TimeSpan?longPollTimeout;
if (!GetLongPoll(manager, out longPollTimeout))
{
return(SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.LongPoll)));
}
var envelope = new SendToHttpEnvelope(_networkSendQueue,
manager,
(args, msg) => Format.ReadAllEventsForwardCompleted(args, msg, embed),
(args, msg) => Configure.ReadAllEventsForwardCompleted(args, msg, headOfTf: false));
var corrId = Guid.NewGuid();
Publish(new ClientMessage.ReadAllEventsForward(corrId, corrId, envelope,
position.CommitPosition, position.PreparePosition, count,
requireMaster, true, GetETagTFPosition(manager), manager.User,
longPollTimeout));
return(new RequestParams((longPollTimeout ?? TimeSpan.Zero) + ESConsts.HttpTimeout));
}
private void GetMetastreamEventsForward(HttpEntityManager manager, UriTemplateMatch match)
{
var stream = match.BoundVariables["stream"];
var evNum = match.BoundVariables["event"];
var cnt = match.BoundVariables["count"];
int eventNumber;
int count;
var embed = GetEmbedLevel(manager, match);
if (stream.IsEmptyString() || SystemStreams.IsMetastream(stream))
{
SendBadRequest(manager, string.Format("Invalid stream name '{0}'", stream));
return;
}
if (evNum.IsEmptyString() || !int.TryParse(evNum, out eventNumber) || eventNumber < 0)
{
SendBadRequest(manager, string.Format("'{0}' is not valid event number", evNum));
return;
}
if (cnt.IsEmptyString() || !int.TryParse(cnt, out count) || count <= 0)
{
SendBadRequest(manager, string.Format("'{0}' is not valid count. Should be positive integer", cnt));
return;
}
bool resolveLinkTos;
if (!GetResolveLinkTos(manager, out resolveLinkTos))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.ResolveLinkTos));
return;
}
bool requireMaster;
if (!GetRequireMaster(manager, out requireMaster))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.RequireMaster));
return;
}
GetStreamEventsForward(manager, SystemStreams.MetastreamOf(stream), eventNumber, count, resolveLinkTos, requireMaster, embed);
}
private void OnPostGossipRequestRead(HttpEntityManager manager, string body)
{
var clusterInfoDto = manager.RequestCodec.From <ClusterInfoDto>(body);
if (clusterInfoDto == null)
{
var msg = string.Format("Received as POST invalid ClusterInfo from [{0}]. Content-Type: {1}, Body:\n{2}.",
manager.RequestedUrl, manager.RequestCodec.ContentType, body);
Log.Error(msg);
SendBadRequest(manager, msg);
return;
}
var sendToHttpEnvelope = new SendToHttpEnvelope(_networkSendQueue,
manager,
Format.SendGossip,
(e, m) => Configure.Ok(e.ResponseCodec.ContentType));
var serverEndPoint = TryGetServerEndPoint(clusterInfoDto);
Publish(new GossipMessage.GossipReceived(sendToHttpEnvelope, new ClusterInfo(clusterInfoDto), serverEndPoint));
}
private IEnvelope ErrorsEnvelope(HttpEntityManager http)
{
return(new SendToHttpEnvelope <ProjectionManagementMessage.NotFound>(
_networkSendQueue,
http,
NotFoundFormatter,
NotFoundConfigurator,
new SendToHttpEnvelope <ProjectionManagementMessage.NotAuthorized>(
_networkSendQueue,
http,
NotAuthorizedFormatter,
NotAuthorizedConfigurator,
new SendToHttpEnvelope <ProjectionManagementMessage.Conflict>(
_networkSendQueue,
http,
ConflictFormatter,
ConflictConfigurator,
new SendToHttpEnvelope <ProjectionManagementMessage.OperationFailed>(
_networkSendQueue, http, OperationFailedFormatter, OperationFailedConfigurator, null)))));
}
private void OnPostEntryRequestRead(HttpEntityManager manager, string body)
{
var entity = manager.HttpEntity;
var stream = (string)manager.AsyncState;
var parsed = AutoEventConverter.SmartParse(body, entity.RequestCodec);
var expectedVersion = parsed.Item1;
var events = parsed.Item2;
if (events == null || events.Length == 0)
{
SendBadRequest(entity, "Write request body invalid");
return;
}
var envelope = new SendToHttpEnvelope(entity, Format.WriteEventsCompleted, Configure.WriteEventsCompleted);
var msg = new ClientMessage.WriteEvents(Guid.NewGuid(), envelope, true, stream, expectedVersion, events);
Publish(msg);
}
private bool GetHardDelete(HttpEntityManager manager, out bool hardDelete)
{
hardDelete = false;
var hardDel = manager.HttpEntity.Request.Headers[SystemHeaders.HardDelete];
if (hardDel == null)
{
return(true);
}
if (string.Equals(hardDel, "True", StringComparison.OrdinalIgnoreCase))
{
hardDelete = true;
return(true);
}
if (string.Equals(hardDel, "False", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(false);
}
private bool GetResolveLinkTos(HttpEntityManager manager, out bool resolveLinkTos)
{
resolveLinkTos = true;
var onlyMaster = manager.HttpEntity.Request.Headers[SystemHeaders.ResolveLinkTos];
if (onlyMaster == null)
{
return(true);
}
if (string.Equals(onlyMaster, "False", StringComparison.OrdinalIgnoreCase))
{
resolveLinkTos = false;
return(true);
}
if (string.Equals(onlyMaster, "True", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(false);
}
// $ALL
private void GetAllEventsBackward(HttpEntityManager manager, UriTemplateMatch match)
{
var pos = match.BoundVariables["position"];
var cnt = match.BoundVariables["count"];
TFPos position = TFPos.HeadOfTf;
int count = AtomSpecs.FeedPageSize;
var embed = GetEmbedLevel(manager, match);
if (pos != null && pos != "head" &&
(!TFPos.TryParse(pos, out position) || position.PreparePosition < 0 ||
position.CommitPosition < 0))
{
SendBadRequest(manager, string.Format("Invalid position argument: {0}", pos));
return;
}
if (cnt.IsNotEmptyString() && (!int.TryParse(cnt, out count) || count <= 0))
{
SendBadRequest(manager, string.Format("Invalid count argument: {0}", cnt));
return;
}
bool requireMaster;
if (!GetRequireMaster(manager, out requireMaster))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.RequireMaster));
return;
}
var envelope = new SendToHttpEnvelope(_networkSendQueue,
manager,
(args, msg) => Format.ReadAllEventsBackwardCompleted(args, msg, embed),
(args, msg) => Configure.ReadAllEventsBackwardCompleted(args, msg, position == TFPos.HeadOfTf));
var corrId = Guid.NewGuid();
Publish(new ClientMessage.ReadAllEventsBackward(corrId, corrId, envelope,
position.CommitPosition, position.PreparePosition, count,
requireMaster, true, GetETagTFPosition(manager), manager.User));
}
private static long?GetETagTFPosition(HttpEntityManager manager)
{
var etag = manager.HttpEntity.Request.Headers["If-None-Match"];
if (etag.IsNotEmptyString())
{
// etag format is version;contenttypehash
var splitted = etag.Trim('\"').Split(ETagSeparatorArray);
if (splitted.Length == 2)
{
var typeHash = manager.ResponseCodec.ContentType.GetHashCode()
.ToString(CultureInfo.InvariantCulture);
long tfEofPosition;
return(splitted[1] == typeHash && long.TryParse(splitted[0], out tfEofPosition)
? (long?)tfEofPosition
: null);
}
}
return(null);
}
private long?GetETagStreamVersion(HttpEntityManager manager)
{
var etag = manager.HttpEntity.Request.GetHeaderValues("If-None-Match");
if (!StringValues.IsNullOrEmpty(etag))
{
// etag format is version;contenttypehash
var splitted = etag.ToString().Trim('\"').Split(ETagSeparatorArray);
if (splitted.Length == 2)
{
var typeHash = manager.ResponseCodec.ContentType.GetHashCode()
.ToString(CultureInfo.InvariantCulture);
var res = splitted[1] == typeHash && long.TryParse(splitted[0], out var streamVersion)
? (long?)streamVersion
: null;
return(res);
}
}
return(null);
}
private void PostUser(HttpEntityManager http, string s)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
var envelope = CreateReplyEnvelope <UserManagementMessage.UpdateResult>(
http, configurator: (codec, result) =>
{
var configuration = AutoConfigurator(codec, result);
return(configuration.Code == HttpStatusCode.OK
? configuration.SetCreated(
MakeUrl(http, "/users/" + Uri.EscapeDataString(result.LoginName)))
: configuration);
});
var data = http.RequestCodec.From <PostUserData>(s);
var message = new UserManagementMessage.Create(
envelope, http.User, data.LoginName, data.FullName, data.Groups, data.Password);
Publish(message);
}
private bool ValidateConfig(SubscriptionConfigData config, HttpEntityManager http)
{
if (config.BufferSize <= 0)
{
SendBadRequest(
http,
string.Format(
"Buffer Size ({0}) must be positive",
config.BufferSize));
return(false);
}
if (config.LiveBufferSize <= 0)
{
SendBadRequest(
http,
string.Format(
"Live Buffer Size ({0}) must be positive",
config.LiveBufferSize));
return(false);
}
if (config.ReadBatchSize <= 0)
{
SendBadRequest(
http,
string.Format(
"Read Batch Size ({0}) must be positive",
config.ReadBatchSize));
return(false);
}
if (!(config.BufferSize > config.ReadBatchSize))
{
SendBadRequest(
http,
string.Format(
"BufferSize ({0}) must be larger than ReadBatchSize ({1})",
config.BufferSize, config.ReadBatchSize));
return(false);
}
return(true);
}
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);
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, enableRunAs: true);
}
else
{
postMessage = new ProjectionManagementMessage.Command.Post(
envelope, mode, name, runAs, handlerType, s, enabled: enabled,
checkpointsEnabled: checkpointsEnabled, emitEnabled: emitEnabled, enableRunAs: true);
}
Publish(postMessage);
}, x => Log.DebugException(x, "Reply Text Body Failed."));
}
private void OnProjectionQueryGet(HttpEntityManager http, UriTemplateMatch match)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
SendToHttpEnvelope <ProjectionManagementMessage.ProjectionQuery> envelope;
var withConfig = IsOn(match, "config", false);
if (withConfig)
{
envelope = new SendToHttpEnvelope <ProjectionManagementMessage.ProjectionQuery>(
_networkSendQueue, http, QueryConfigFormatter, QueryConfigConfigurator, ErrorsEnvelope(http));
}
else
{
envelope = new SendToHttpEnvelope <ProjectionManagementMessage.ProjectionQuery>(
_networkSendQueue, http, QueryFormatter, QueryConfigurator, ErrorsEnvelope(http));
}
Publish(new ProjectionManagementMessage.Command.GetQuery(envelope, match.BoundVariables["name"], GetRunAs(http, match)));
}
private void CreateStreamBodyRead(HttpEntityManager manager, string body)
{
var entity = manager.HttpEntity;
var create = entity.RequestCodec.From <ClientMessageDto.CreateStreamText>(body);
if (create == null)
{
SendBadRequest(entity, "Create stream request body cannot be deserialized");
return;
}
var envelope = new SendToHttpEnvelope(entity,
Format.Atom.CreateStreamCompleted,
Configure.CreateStreamCompleted);
var msg = new ClientMessage.CreateStream(create.CorrelationId == Guid.Empty ? Guid.NewGuid() : create.CorrelationId,
envelope,
create.EventStreamId,
Encoding.UTF8.GetBytes(create.Metadata ?? string.Empty));
Publish(msg);
}
private void NackMessages(HttpEntityManager http, UriTemplateMatch match)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
var envelope = new NoopEnvelope();
var groupname = match.BoundVariables["subscription"];
var stream = match.BoundVariables["stream"];
var messageIds = match.BoundVariables["messageIds"];
var nakAction = GetNackAction(http, match);
var ids = new List <Guid>();
foreach (var messageId in messageIds.Split(new[] { ',' }))
{
Guid id;
if (!Guid.TryParse(messageId, out id))
{
http.ReplyStatus(HttpStatusCode.BadRequest, "messageid should be a properly formed guid",
exception => { });
return;
}
ids.Add(id);
}
var cmd = new ClientMessage.PersistentSubscriptionNackEvents(
Guid.NewGuid(),
Guid.NewGuid(),
envelope,
BuildSubscriptionGroupKey(stream, groupname),
"Nacked from HTTP",
nakAction,
ids.ToArray(),
http.User);
Publish(cmd);
http.ReplyStatus(HttpStatusCode.Accepted, "", exception => { });
}
private void OnPostMergeIndexes(HttpEntityManager entity, UriTemplateMatch match)
{
Log.Info("Request merge indexes because /admin/mergeindexes request has been received.");
var correlationId = Guid.NewGuid();
var envelope = new SendToHttpEnvelope(_networkSendQueue, entity,
(e, message) => { return(e.ResponseCodec.To(new MergeIndexesResultDto(correlationId.ToString()))); },
(e, message) => {
var completed = message as ClientMessage.MergeIndexesResponse;
switch (completed?.Result)
{
case ClientMessage.MergeIndexesResponse.MergeIndexesResult.Started:
return(Configure.Ok(e.ResponseCodec.ContentType));
default:
return(Configure.InternalServerError());
}
}
);
Publish(new ClientMessage.MergeIndexes(envelope, correlationId, entity.User));
}
private void GetMetastreamEvent(HttpEntityManager manager, UriTemplateMatch match)
{
var stream = match.BoundVariables["stream"];
var evNum = match.BoundVariables["event"];
long eventNumber = -1;
var embed = GetEmbedLevel(manager, match, EmbedLevel.TryHarder);
if (stream.IsEmptyString() || SystemStreams.IsMetastream(stream))
{
SendBadRequest(manager, "Stream must be non-empty string and should not be metastream");
return;
}
if (evNum != null && evNum != "head" && (!long.TryParse(evNum, out eventNumber) || eventNumber < 0))
{
SendBadRequest(manager, string.Format("'{0}' is not valid event number", evNum));
return;
}
bool resolveLinkTos;
if (!GetResolveLinkTos(manager, out resolveLinkTos))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.ResolveLinkTos));
return;
}
bool requireMaster;
if (!GetRequireMaster(manager, out requireMaster))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.RequireMaster));
return;
}
GetStreamEvent(manager, SystemStreams.MetastreamOf(stream), eventNumber, resolveLinkTos, requireMaster,
embed);
}
private IEnumerable <SubscriptionSummary> ToSummaryDto(HttpEntityManager manager, MonitoringMessage.GetPersistentSubscriptionStatsCompleted message)
{
if (message == null)
{
yield break;
}
if (message.SubscriptionStats == null)
{
yield break;
}
foreach (var stat in message.SubscriptionStats)
{
string escapedStreamId = Uri.EscapeDataString(stat.EventStreamId);
string escapedGroupName = Uri.EscapeDataString(stat.GroupName);
var info = new SubscriptionSummary
{
Links = new List <RelLink>()
{
new RelLink(MakeUrl(manager, string.Format("/subscriptions/{0}/{1}/info", escapedStreamId, escapedGroupName)), "detail"),
},
EventStreamId = stat.EventStreamId,
GroupName = stat.GroupName,
Status = stat.Status,
AverageItemsPerSecond = stat.AveragePerSecond,
TotalItemsProcessed = stat.TotalItems,
LastKnownEventNumber = stat.LastKnownMessage,
LastProcessedEventNumber = stat.LastProcessedEventNumber,
ParkedMessageUri = MakeUrl(manager, string.Format(parkedMessageUriTemplate, escapedStreamId, escapedGroupName)),
GetMessagesUri = MakeUrl(manager, string.Format("/subscriptions/{0}/{1}/{2}", escapedStreamId, escapedGroupName, DefaultNumberOfMessagesToGet)),
TotalInFlightMessages = stat.TotalInFlightMessages,
};
if (stat.Connections != null)
{
info.ConnectionCount = stat.Connections.Count;
}
yield return(info);
}
}
public void PostEntry(HttpEntityManager manager, int expectedVersion, bool requireMaster, string stream, Guid idIncluded, string typeIncluded)
{
//TODO GFY SHOULD WE MAKE THIS READ BYTE[] FOR RAW THEN CONVERT? AS OF NOW ITS ALL NO BOM UTF8
manager.ReadTextRequestAsync(
(man, body) =>
{
var events = new Event[0];
try
{
events = AutoEventConverter.SmartParse(body, manager.RequestCodec, idIncluded, typeIncluded);
}
catch (Exception ex)
{
SendBadRequest(manager, ex.Message);
return;
}
if (events.IsEmpty())
{
SendBadRequest(manager, "Write request body invalid.");
return;
}
foreach (var e in events)
{
if (e.Data.Length + e.Metadata.Length > 4 * 1024 * 1024)
{
SendTooBig(manager);
}
}
var envelope = new SendToHttpEnvelope(_networkSendQueue,
manager,
Format.WriteEventsCompleted,
(a, m) => Configure.WriteEventsCompleted(a, m, stream));
var corrId = Guid.NewGuid();
var msg = new ClientMessage.WriteEvents(corrId, corrId, envelope, requireMaster,
stream, expectedVersion, events, manager.User);
Publish(msg);
},
e => Log.Debug("Error while reading request (POST entry): {0}.", e.Message));
}
private bool GetRequireLeader(HttpEntityManager manager, out bool requireLeader)
{
requireLeader = false;
var onlyLeader = manager.HttpEntity.Request.GetHeaderValues(SystemHeaders.RequireLeader);
var onlyMaster = manager.HttpEntity.Request.GetHeaderValues(SystemHeaders.RequireMaster);
if (StringValues.IsNullOrEmpty(onlyLeader) && StringValues.IsNullOrEmpty(onlyMaster))
{
return(true);
}
if (string.Equals(onlyLeader, "True", StringComparison.OrdinalIgnoreCase) ||
string.Equals(onlyMaster, "True", StringComparison.OrdinalIgnoreCase))
{
requireLeader = true;
return(true);
}
return(string.Equals(onlyLeader, "False", StringComparison.OrdinalIgnoreCase) ||
string.Equals(onlyMaster, "False", StringComparison.OrdinalIgnoreCase));
}
private bool GetResolveLinkTos(HttpEntityManager manager, out bool resolveLinkTos, bool defaultOption = false)
{
resolveLinkTos = defaultOption;
var linkToHeader = manager.HttpEntity.Request.GetHeaderValues(SystemHeaders.ResolveLinkTos);
if (StringValues.IsNullOrEmpty(linkToHeader))
{
return(true);
}
if (string.Equals(linkToHeader, "False", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
if (string.Equals(linkToHeader, "True", StringComparison.OrdinalIgnoreCase))
{
resolveLinkTos = true;
return(true);
}
return(false);
}
private void DeleteStream(HttpEntityManager manager, UriTemplateMatch match)
{
var stream = match.BoundVariables["stream"];
if (stream.IsEmptyString())
{
SendBadRequest(manager, string.Format("Invalid stream name '{0}'", stream));
return;
}
int expectedVersion;
if (!GetExpectedVersion(manager, out expectedVersion))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.ExpectedVersion));
return;
}
bool requireMaster;
if (!GetRequireMaster(manager, out requireMaster))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.RequireMaster));
return;
}
bool hardDelete;
if (!GetHardDelete(manager, out hardDelete))
{
SendBadRequest(manager, string.Format("{0} header in wrong format.", SystemHeaders.HardDelete));
return;
}
if (!requireMaster && _httpForwarder.ForwardRequest(manager))
{
return;
}
var envelope = new SendToHttpEnvelope(_networkSendQueue, manager, Format.DeleteStreamCompleted, Configure.DeleteStreamCompleted);
var corrId = Guid.NewGuid();
Publish(new ClientMessage.DeleteStream(corrId, corrId, envelope, requireMaster, stream, expectedVersion, hardDelete, manager.User));
}
private void OnPostEntryRequestRead(HttpEntityManager manager, string body)
{
var entity = manager.HttpEntity;
var stream = (string)manager.AsyncState;
var write = entity.RequestCodec.From <ClientMessageDto.WriteEventText>(body);
if (write == null || write.Events == null || write.Events.Length == 0)
{
SendBadRequest(entity, "Write request body invalid");
return;
}
var envelope = new SendToHttpEnvelope(entity, Format.WriteEventsCompleted, Configure.WriteEventsCompleted);
var msg = new ClientMessage.WriteEvents(
write.CorrelationId == Guid.Empty ? Guid.NewGuid() : write.CorrelationId,
envelope,
stream,
write.ExpectedVersion,
write.Events.Select(EventConvertion.ConvertOnWrite).ToArray());
Publish(msg);
}