private void OnPostShutdown(HttpEntity entity, UriTemplateMatch match) { Publish(new ClientMessage.RequestShutdown()); entity.Manager.Reply(HttpStatusCode.OK, "OK", e => Log.ErrorException(e, "Error while closing http connection (admin controller)")); }
public static ResponseConfiguration ReadEventCompleted(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(ClientMessage.ReadEventCompleted)); var completed = message as ClientMessage.ReadEventCompleted; if (completed == null) return InternalServerEror(entity, message); switch (completed.Result) { case SingleReadResult.Success: return new ResponseConfiguration(HttpStatusCode.OK, "OK", entity.ResponseCodec.ContentType, new KeyValuePair<string, string>( "Cache-Control", string.Format("max-age={0}", MaxPossibleAge))); case SingleReadResult.NotFound: case SingleReadResult.NoStream: return NotFound(entity, completed); case SingleReadResult.StreamDeleted: return Gone(entity, completed); default: throw new ArgumentOutOfRangeException(); } }
private void OnGetFreshStats(HttpEntity entity, UriTemplateMatch match) { var envelope = new SendToHttpEnvelope(_networkSendQueue, entity, Format.GetFreshStatsCompleted, Configure.GetFreshStatsCompleted); var statPath = match.BoundVariables["statPath"]; var statSelector = GetStatSelector(statPath); bool useMetadata; if (!bool.TryParse(match.QueryParameters["metadata"], out useMetadata)) useMetadata = false; bool useGrouping; if (!bool.TryParse(match.QueryParameters["group"], out useGrouping)) useGrouping = true; if (!useGrouping && !string.IsNullOrEmpty(statPath)) { SendBadRequest(entity, "Dynamic stats selection works only with grouping enabled"); return; } Publish(new MonitoringMessage.GetFreshStats(envelope, statSelector, useMetadata, useGrouping)); }
internal HttpEntityManager( HttpEntity httpEntity, string[] allowedMethods, Action <HttpEntity> onRequestSatisfied, ICodec requestCodec, ICodec responseCodec, bool logHttpRequests) { Ensure.NotNull(httpEntity, "httpEntity"); Ensure.NotNull(allowedMethods, "allowedMethods"); Ensure.NotNull(onRequestSatisfied, "onRequestSatisfied"); HttpEntity = httpEntity; TimeStamp = DateTime.UtcNow; _allowedMethods = allowedMethods; _onRequestSatisfied = onRequestSatisfied; _requestCodec = requestCodec; _responseCodec = responseCodec; _responseUrl = httpEntity.ResponseUrl; _requestedUrl = httpEntity.RequestedUrl; _responseContentEncoding = GetRequestedContentEncoding(httpEntity); _logHttpRequests = logHttpRequests; if (HttpEntity.Request != null && HttpEntity.Request.ContentLength64 == 0) { LogRequest(new byte[0]); } }
public static ResponseConfiguration CreateStreamCompleted(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(ClientMessage.CreateStreamCompleted)); var completed = message as ClientMessage.CreateStreamCompleted; if (completed == null) return InternalServerEror(entity, message); switch (completed.ErrorCode) { case OperationErrorCode.Success: return new ResponseConfiguration(HttpStatusCode.Created, "Stream created", null, new KeyValuePair<string, string>("Location", HostName.Combine(entity.UserHostName, "/streams/{0}", completed.EventStreamId))); case OperationErrorCode.PrepareTimeout: case OperationErrorCode.CommitTimeout: case OperationErrorCode.ForwardTimeout: return new ResponseConfiguration(HttpStatusCode.InternalServerError, "Create timeout", null); case OperationErrorCode.WrongExpectedVersion: case OperationErrorCode.StreamDeleted: case OperationErrorCode.InvalidTransaction: return new ResponseConfiguration(HttpStatusCode.BadRequest, string.Format("Error code : {0}. Reason : {1}", completed.ErrorCode, completed.Error), null); default: throw new ArgumentOutOfRangeException(); } }
public static string TextMessage(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(HttpMessage.TextMessage)); var textMessage = message as HttpMessage.TextMessage; return textMessage != null ? entity.ResponseCodec.To(textMessage) : string.Empty; }
private string GetRequestedContentEncoding(HttpEntity httpEntity) { if (httpEntity == null || httpEntity.Request == null) { return(null); } var httpEntityRequest = httpEntity.Request; string contentEncoding = null; var values = httpEntityRequest.Headers.GetValues("Accept-Encoding"); if (values != null) { foreach (string value in values) { if (SupportedCompressionAlgorithms.Contains(value)) { contentEncoding = value; break; } } } return(contentEncoding); }
public static string ReadEventsBackwardsCompletedFeed(HttpEntity entity, Message message, int start, int count) { Debug.Assert(message.GetType() == typeof(ClientMessage.ReadEventsBackwardsCompleted)); var completed = message as ClientMessage.ReadEventsBackwardsCompleted; if (completed != null) { switch (completed.Result) { case RangeReadResult.Success: var updateTime = completed.Events.Length != 0 ? completed.Events[0].TimeStamp : DateTime.MinValue.ToUniversalTime(); return entity.ResponseCodec.To(Convert.ToFeed(completed.EventStreamId, start, count, updateTime, completed.Events, Convert.ToEntry, entity.ServerHttpEndPoint)); case RangeReadResult.NoStream: case RangeReadResult.StreamDeleted: return string.Empty; default: throw new ArgumentOutOfRangeException(); } } return string.Empty; }
private HttpEntity(HttpEntity httpEntity, IPrincipal user) { RequestedUrl = httpEntity.RequestedUrl; Request = httpEntity.Request; Response = httpEntity.Response; User = user; }
private void OnPostShutdown(HttpEntity entity, UriTemplateMatch match) { Log.Info("Request shut down of node because shutdown command has been received."); Publish(new ClientMessage.RequestShutdown(exitProcessOnShutdown: true)); entity.Manager.ReplyStatus(HttpStatusCode.OK, "OK", e => Log.ErrorException(e, "Error while closing http connection (admin controller)")); }
private HttpEntity(HttpEntity httpEntity, IPrincipal user, bool logHttpRequests) { RequestedUrl = httpEntity.RequestedUrl; Request = httpEntity.Request; Response = httpEntity.Response; User = user; _logHttpRequests = logHttpRequests; }
public ManagerOperationState(HttpEntity entity, Action<HttpEntityManager, string> onSuccess, Action<Exception> onError) { Ensure.NotNull(entity, "entity"); Ensure.NotNull(onSuccess, "onSuccess"); Ensure.NotNull(onError, "onError"); Entity = entity; OnSuccess = onSuccess; OnError = onError; }
private void OnGetPing(HttpEntity entity, UriTemplateMatch match) { var response = new HttpMessage.TextMessage("Ping request successfully handled"); entity.Manager.Reply(Format.TextMessage(entity, response), HttpStatusCode.OK, "OK", entity.ResponseCodec.ContentType, null, e => Log.ErrorException(e, "Error while writing http response (ping)")); }
public static string GetFreshStatsCompleted(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(MonitoringMessage.GetFreshStatsCompleted)); var completed = message as MonitoringMessage.GetFreshStatsCompleted; if (completed == null || !completed.Success) return string.Empty; return entity.ResponseCodec.To(completed.Stats); }
public ManagerOperationState(HttpEntity entity, Action <HttpEntityManager, byte[]> onSuccess, Action <Exception> onError) { Ensure.NotNull(entity, "entity"); Ensure.NotNull(onSuccess, "onSuccess"); Ensure.NotNull(onError, "onError"); Entity = entity; OnSuccess = onSuccess; OnError = onError; }
internal HttpEntityManager(HttpEntity httpEntity, string[] allowedMethods, Action <HttpEntity> onRequestSatisfied) { Ensure.NotNull(httpEntity, "httpEntity"); Ensure.NotNull(allowedMethods, "allowedMethods"); Ensure.NotNull(onRequestSatisfied, "onRequestSatisfied"); HttpEntity = httpEntity; _allowedMethods = allowedMethods; _onRequestSatisfied = onRequestSatisfied; }
private HttpEntity(HttpEntity httpEntity, ClaimsPrincipal user, bool logHttpRequests) { RequestedUrl = httpEntity.RequestedUrl; ResponseUrl = httpEntity.ResponseUrl; Request = httpEntity.Request; Response = httpEntity.Response; User = user; _logHttpRequests = logHttpRequests; OnComplete = httpEntity.OnComplete; }
internal HttpEntityManager(HttpEntity httpEntity, string[] allowedMethods, Action<HttpEntity> onRequestSatisfied) { Ensure.NotNull(httpEntity, "httpEntity"); Ensure.NotNull(allowedMethods, "allowedMethods"); Ensure.NotNull(onRequestSatisfied, "onRequestSatisfied"); HttpEntity = httpEntity; _allowedMethods = allowedMethods; _onRequestSatisfied = onRequestSatisfied; }
public static string ListStreamsCompletedServiceDoc(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(ClientMessage.ListStreamsCompleted)); var streams = message as ClientMessage.ListStreamsCompleted; return streams != null ? entity.ResponseCodec.To(Convert.ToServiceDocument(streams.Streams, new string[0], entity.ServerHttpEndPoint)) : string.Empty; }
private void ReplyWithContent(HttpEntity http, string contentLocalPath) { //NOTE: this is fix for Mono incompatibility in UriTemplate behavior for /a/b{*C} if (("/" + contentLocalPath).StartsWith(_localWebRootPath)) { contentLocalPath = contentLocalPath.Substring(_localWebRootPath.Length); } //_logger.Trace("{0} requested from mini web", contentLocalPath); try { var extensionToContentType = new Dictionary<string, string> { { ".png", "image/png"} , { ".jpg", "image/jpeg"} , { ".jpeg", "image/jpeg"} , { ".css", "text/css"} , { ".htm", "text/html"} , { ".html", "text/html"} , { ".js", "application/javascript"} , { ".ico", "image/vnd.microsoft.icon"} }; var extension = Path.GetExtension(contentLocalPath); var fullPath = Path.Combine(_fileSystemRoot, contentLocalPath); string contentType; if (string.IsNullOrEmpty(extension) || !extensionToContentType.TryGetValue(extension, out contentType) || !File.Exists(fullPath)) { _logger.Info("Replying 404 for {0} ==> {1}", contentLocalPath, fullPath); http.Manager.ReplyTextContent( "Not Found", 404, "Not Found", "text/plain", null, ex => _logger.InfoException(ex, "Error while replying from MiniWeb")); } else { var config = GetWebPageConfig(contentType); var content = File.ReadAllBytes(fullPath); http.Manager.Reply(content, config.Code, config.Description, config.ContentType, config.Headers, ex => _logger.InfoException(ex, "Error while replying from MiniWeb")); } } catch (Exception ex) { http.Manager.ReplyTextContent(ex.ToString(), 500, "Internal Server Error", "text/plain", null, Console.WriteLine); } }
public void GetAllBefore(HttpEntity entity, TFPos position, int count) { var envelope = new SendToHttpEnvelope(entity, Format.Atom.ReadAllEventsBackwardCompleted, Configure.ReadAllEventsBackwardCompleted); Publish(new ClientMessage.ReadAllEventsBackward(Guid.NewGuid(), envelope, position.CommitPosition, position.PreparePosition, count, true)); }
private void OnGetFreshStats(HttpEntity entity, UriTemplateMatch match) { var envelope = new SendToHttpEnvelope( entity, Format.GetFreshStatsCompleted, Configure.GetFreshStatsCompleted); var statPath = match.BoundVariables["statPath"]; var statSelector = GetStatSelector(statPath); Publish(new MonitoringMessage.GetFreshStats(envelope, statSelector)); }
internal HttpEntityManager( HttpEntity httpEntity, string[] allowedMethods, Action <HttpEntity> onRequestSatisfied, ICodec requestCodec, ICodec responseCodec) { Ensure.NotNull(httpEntity, "httpEntity"); Ensure.NotNull(allowedMethods, "allowedMethods"); Ensure.NotNull(onRequestSatisfied, "onRequestSatisfied"); HttpEntity = httpEntity; TimeStamp = DateTime.UtcNow; _allowedMethods = allowedMethods; _onRequestSatisfied = onRequestSatisfied; _requestCodec = requestCodec; _responseCodec = responseCodec; _requestedUrl = httpEntity.RequestedUrl; }
internal HttpEntityManager( HttpEntity httpEntity, string[] allowedMethods, Action<HttpEntity> onRequestSatisfied, ICodec requestCodec, ICodec responseCodec) { Ensure.NotNull(httpEntity, "httpEntity"); Ensure.NotNull(allowedMethods, "allowedMethods"); Ensure.NotNull(onRequestSatisfied, "onRequestSatisfied"); HttpEntity = httpEntity; TimeStamp = DateTime.UtcNow; _allowedMethods = allowedMethods; _onRequestSatisfied = onRequestSatisfied; _requestCodec = requestCodec; _responseCodec = responseCodec; _requestedUrl = httpEntity.RequestedUrl; }
private void OnGetRead(HttpEntity entity, UriTemplateMatch match) { var stream = match.BoundVariables["stream"]; var versionString = match.BoundVariables["version"]; var resolve = match.BoundVariables["resolve"] ?? "yes"; //TODO: reply invalid ??? if neither NO nor YES int version; if (string.IsNullOrEmpty(stream) || !Int32.TryParse(versionString, out version)) { SendBadRequest(entity, "Stream must bu non-empty string and id must be integer value"); return; } var envelope = new SendToHttpEnvelope(entity, Format.ReadEventCompleted, Configure.ReadEventCompleted); Publish( new ClientMessage.ReadEvent( Guid.NewGuid(), envelope, stream, version, resolve.Equals("yes", StringComparison.OrdinalIgnoreCase))); }
public static string ReadEventCompletedEntry(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(ClientMessage.ReadEventCompleted)); var completed = message as ClientMessage.ReadEventCompleted; if (completed != null) { switch (completed.Result) { case SingleReadResult.Success: return entity.ResponseCodec.To(Convert.ToEntry(completed.Record, entity.ServerHttpEndPoint)); case SingleReadResult.NotFound: case SingleReadResult.NoStream: case SingleReadResult.StreamDeleted: return string.Empty; default: throw new ArgumentOutOfRangeException(); } } return string.Empty; }
internal HttpEntityManager( HttpEntity httpEntity, string[] allowedMethods, Action<HttpEntity> onRequestSatisfied, ICodec requestCodec, ICodec responseCodec, bool logHttpRequests) { Ensure.NotNull(httpEntity, "httpEntity"); Ensure.NotNull(allowedMethods, "allowedMethods"); Ensure.NotNull(onRequestSatisfied, "onRequestSatisfied"); HttpEntity = httpEntity; TimeStamp = DateTime.UtcNow; _allowedMethods = allowedMethods; _onRequestSatisfied = onRequestSatisfied; _requestCodec = requestCodec; _responseCodec = responseCodec; _requestedUrl = httpEntity.RequestedUrl; _logHttpRequests = logHttpRequests; if (HttpEntity.Request != null && HttpEntity.Request.ContentLength64 == 0) { LogRequest(new byte[0]); } }
public static string WriteEventsCompleted(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(ClientMessage.WriteEventsCompleted)); return string.Empty; }
public static string DeleteStreamCompleted(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(ClientMessage.DeleteStreamCompleted)); return string.Empty; }
public static void ReplyNotYetAvailable(HttpEntity entity) { var manager = entity.CreateManager(); manager.ReplyStatus(HttpStatusCode.ServiceUnavailable, "Not yet ready.", exception => { }, new [] {new KeyValuePair<string, string>("Retry-After", "5") }); }
public AuthenticatedHttpRequestMessage(HttpService httpService, HttpEntity entity) { HttpService = httpService; Entity = entity; }
public IncomingHttpRequestMessage(HttpService httpService, HttpEntity entity, IPublisher nextStagePublisher) { HttpService = httpService; Entity = entity; NextStagePublisher = nextStagePublisher; }
public static ResponseConfiguration Ok(HttpEntity entity, Message message) { return new ResponseConfiguration(HttpStatusCode.OK, "OK", entity.ResponseCodec.ContentType); }
public static ResponseConfiguration ReadEventsFromEndCompleted(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(ClientMessage.ReadEventsBackwardsCompleted)); var completed = message as ClientMessage.ReadEventsBackwardsCompleted; if (completed == null) return InternalServerEror(entity, message); var startIdx = (int)entity.Manager.AsyncState; var age = startIdx < AtomSpecs.FeedPageSize ? MinPossibleAge : MaxPossibleAge; switch (completed.Result) { case RangeReadResult.Success: return new ResponseConfiguration(HttpStatusCode.OK, "OK", entity.ResponseCodec.ContentType, new KeyValuePair<string, string>( "Cache-Control", string.Format("max-age={0}", age))); case RangeReadResult.NoStream: return NotFound(entity, completed); case RangeReadResult.StreamDeleted: return Gone(entity, completed); default: throw new ArgumentOutOfRangeException(); } }
internal static HttpEntityManager Create(HttpEntity httpEntity, string[] allowedMethods, Action <HttpEntity> onRequestSatisfied) { return(new HttpEntityManager(httpEntity, allowedMethods, onRequestSatisfied)); }
public static void ReplyUnauthorized(HttpEntity entity) { var manager = entity.CreateManager(); manager.ReplyStatus(HttpStatusCode.Unauthorized, "Unauthorized", exception => { }); }
public static void ReplyInternalServerError(HttpEntity entity) { var manager = entity.CreateManager(); manager.ReplyStatus(HttpStatusCode.InternalServerError, "Internal Server Error", exception => { }); }
private void OnStaticContent(HttpEntity http, UriTemplateMatch match) { var contentLocalPath = match.BoundVariables["remaining_path"]; ReplyWithContent(http, contentLocalPath); }