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