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