public async Task <HttpServerResponse> HandleRequest(IHttpServerRequest request)
{
if (request.Method != HttpMethod.GET)
{
return(GetMethodNotAllowedResponse(request.Method));
}
if (_authenticationProvider != null) // if you pass an IAuthenticationProvider, it will be used to check every request in this handler
{
var authResult = _authenticationProvider.Authorize(request);
if (authResult == HttpResponseStatus.Unauthorized)
{
return(GetUnauthorizedResponse(_authenticationProvider.Realm));
}
}
var localFilePath = GetFilePath(request.Uri);
var absoluteFilePath = GetAbsoluteFilePath(localFilePath);
// todo: add validation for invalid path characters / invalid filename characters
IFile item;
try
{
item = await _fileSystem.GetFileFromPathAsync(absoluteFilePath);
}
catch (FileNotFoundException)
{
return(GetFileNotFoundResponse(localFilePath));
}
return(await GetHttpResponse(item));
}
private string GetAcceptCharset(IHttpServerRequest httpRequest, MediaType acceptMediaType)
{
string firstAvailableEncoding = null;
foreach (var requestedCharset in httpRequest.AcceptCharsets)
{
var encoding = EncodingCache.Default.GetEncoding(requestedCharset);
firstAvailableEncoding = requestedCharset;
if (encoding != null)
break;
}
if (string.IsNullOrEmpty(firstAvailableEncoding))
{
if (acceptMediaType == MediaType.JSON)
{
firstAvailableEncoding = Configuration.Default.DefaultJSONCharset;
}
else if (acceptMediaType == MediaType.XML)
{
firstAvailableEncoding = Configuration.Default.DefaultXMLCharset;
}
else
{
throw new NotImplementedException("Accept media type is not supported.");
}
}
return firstAvailableEncoding;
}
public async Task HandleRequest(CancellationToken ct, IHttpServerRequest request, string relativePath)
{
if (!request.Method.Equals(_method, StringComparison.OrdinalIgnoreCase))
{
return; // wrong method
}
var queryParts = relativePath.Split('?').ToList();
if (queryParts[0].Equals(_path, StringComparison.OrdinalIgnoreCase))
{
try
{
var queryParameters = ParseQueryParameters(queryParts.Skip(1).FirstOrDefault());
(var result, var statusCode) = await ProcessRequest(ct, relativePath, queryParameters);
var json = JsonConvert.SerializeObject(result, Formatting.Indented);
request.SetResponse("application/json", json, statusCode);
}
catch (Exception ex)
{
this.Log().Error($"Error processing request for path {relativePath}, error={ex.Message}");
request.SetResponse("text/plain", "Error processing request", 500, "ERROR");
}
}
}
private string GetAcceptCharset(IHttpServerRequest httpRequest, MediaType acceptMediaType)
{
string firstAvailableEncoding = null;
foreach (var requestedCharset in httpRequest.AcceptCharsets)
{
var encoding = EncodingCache.Default.GetEncoding(requestedCharset);
firstAvailableEncoding = requestedCharset;
if (encoding != null)
{
break;
}
}
if (string.IsNullOrEmpty(firstAvailableEncoding))
{
if (acceptMediaType == MediaType.JSON)
{
firstAvailableEncoding = Configuration.Default.DefaultJSONCharset;
}
else if (acceptMediaType == MediaType.XML)
{
firstAvailableEncoding = Configuration.Default.DefaultXMLCharset;
}
else
{
throw new NotImplementedException("Accept media type is not supported.");
}
}
return(firstAvailableEncoding);
}
private MediaType GetContentMediaType(IHttpServerRequest httpRequest)
{
var contentMediaType = GetMediaType(httpRequest.ContentType ?? string.Empty); // guard against nulls
if (contentMediaType == MediaType.Unsupported)
return Configuration.Default.DefaultContentType;
return contentMediaType;
}
public AfterHandleRequestResult AfterHandleRequest(IHttpServerRequest request, HttpServerResponse httpResponse)
{
string origin;
if (!TryGetAllowOrigin(request.Origin, out origin))
return null;
httpResponse.AddHeader(new AccessControlAllowOriginHeader(origin));
return new AfterHandleRequestResult(httpResponse);
}
public async Task <HttpServerResponse> HandleRequest(IHttpServerRequest request)
{
var restServerRequest = _restServerRequestFactory.Create(request);
var restResponse = await _requestHandler.HandleRequestAsync(restServerRequest);
var httpResponse = _restToHttpConverter.ConvertToHttpResponse(restResponse, restServerRequest);
return(httpResponse);
}
private MediaType GetContentMediaType(IHttpServerRequest httpRequest)
{
var contentMediaType = GetMediaType(httpRequest.ContentType ?? string.Empty); // guard against nulls
if (contentMediaType == MediaType.Unsupported)
{
return(Configuration.Default.DefaultContentType);
}
return(contentMediaType);
}
private MediaType GetAcceptMediaType(IHttpServerRequest httpRequest)
{
var preferredType = httpRequest.AcceptMediaTypes
.Select(GetMediaType)
.FirstOrDefault(a => a != MediaType.Unsupported);
if (preferredType == MediaType.Unsupported)
preferredType = Configuration.Default.DefaultAcceptType;
return preferredType;
}
internal async Task <HttpServerResponse> HandleRequestAsync(IHttpServerRequest request)
{
var routeRegistration = _routes.FirstOrDefault(x => x.Match(request));
if (routeRegistration == null)
{
return(new HttpServerResponse(new Version(1, 1), HttpResponseStatus.BadRequest));
}
return(await routeRegistration.HandleAsync(request));
}
public AfterHandleRequestResult AfterHandleRequest(IHttpServerRequest request, HttpServerResponse httpResponse)
{
string origin;
if (!TryGetAllowOrigin(request.Origin, out origin))
{
return(null);
}
httpResponse.AddHeader(new AccessControlAllowOriginHeader(origin));
return(new AfterHandleRequestResult(httpResponse));
}
public async Task HandleRequest(CancellationToken ct, IHttpServerRequest request, string relativePath)
{
if (relativePath.Equals(_path, StringComparison.OrdinalIgnoreCase))
{
if (request.Method.Equals("GET", StringComparison.OrdinalIgnoreCase))
{
request.SetResponse(_responseContentType, GetStream);
return;
}
request.SetResponse("text/plain", "Method not authorized - use a GET", 405, "METHOD NOT ALLOWED");
}
}
public bool Match(IHttpServerRequest request)
{
if (request == null)
{
return(false);
}
if (request.Uri == null)
{
return(false);
}
return(request.Uri.ToString().StartsWith(_urlPrefix, StringComparison.OrdinalIgnoreCase));
}
private HttpServerResponse ApplyMessageInspectorsAfterHandleRequest(IHttpServerRequest request,
HttpServerResponse httpResponse)
{
foreach (var httpMessageInspector in _messageInspectors)
{
var result = httpMessageInspector.AfterHandleRequest(request, httpResponse);
if (result != null)
{
httpResponse = result.Response;
}
}
return(httpResponse);
}
private MediaType GetAcceptMediaType(IHttpServerRequest httpRequest)
{
var preferredType = httpRequest.AcceptMediaTypes
.Select(GetMediaType)
.FirstOrDefault(a => a != MediaType.Unsupported);
if (preferredType == MediaType.Unsupported)
{
preferredType = Configuration.Default.DefaultAcceptType;
}
return(preferredType);
}
private HttpServerResponse ApplyMessageInspectorsBeforeHandleRequest(IHttpServerRequest request)
{
foreach (var httpMessageInspector in _messageInspectors)
{
var result = httpMessageInspector.BeforeHandleRequest(request);
if (result != null)
{
return(result.Response);
}
}
return(null);
}
internal async Task <HttpServerResponse> HandleRequestAsync(IHttpServerRequest request)
{
var routeRegistration = _routes.FirstOrDefault(x => x.Match(request));
if (routeRegistration == null)
{
return(new HttpServerResponse(new Version(1, 1), HttpResponseStatus.BadRequest));
}
var httpResponse = await routeRegistration.HandleAsync(request);
return(await AddContentEncodingAsync(httpResponse, request.AcceptEncodings));
}
public async Task HandleRequest(CancellationToken ct, IHttpServerRequest request, string relativePath)
{
if (relativePath.Equals(_notifyPath, StringComparison.OrdinalIgnoreCase))
{
if (request.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
{
request.SetResponse("text/plain", "Notified");
_notifications.OnNext(request.Body);
}
else
{
request.SetResponse("text/plain", "Method not authorized - use a POST", 405, "METHOD NOT ALLOWED");
}
}
}
public BeforeHandleRequestResult BeforeHandleRequest(IHttpServerRequest request)
{
// could potentially pass this as state between the before handle request and after handle request
// but before that would need to see if the performance increase is worth it
string allowOrigin;
if (request.Method != HttpMethod.OPTIONS || !TryGetAllowOrigin(request.Origin, out allowOrigin))
return null;
var httpResponse = HttpServerResponse.Create(HttpResponseStatus.OK);
httpResponse.AddHeader(new AccessControlAllowMethodsHeader(new[] { HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE, HttpMethod.OPTIONS, }));
// max age possible by chrome https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit/Source/core/loader/CrossOriginPreflightResultCache.cpp&l=40&rcl=1399481969
httpResponse.AddHeader(new AccessControlMaxAgeHeader(10 * 60));
if (request.AccessControlRequestHeaders.Any())
httpResponse.AddHeader(new AccessControlAllowHeadersHeader(request.AccessControlRequestHeaders));
return new BeforeHandleRequestResult(httpResponse);
}
internal RestServerRequest(
IHttpServerRequest httpServerRequest,
string acceptCharset,
MediaType acceptMediaType,
Encoding acceptEncoding,
MediaType contentMediaType,
string contentCharset,
Encoding contentEncoding)
{
this.HttpServerRequest = httpServerRequest;
this.AcceptCharset = acceptCharset;
this.AcceptMediaType = acceptMediaType;
this.AcceptEncoding = acceptEncoding;
this.ContentMediaType = contentMediaType;
this.ContentCharset = contentCharset;
this.ContentEncoding = contentEncoding;
}
private static IHttpServerRequest CreateHttpRequestWithUnprefixedUrl(IHttpServerRequest request, string prefix)
{
var requestUriWithoutPrefix = request.Uri.RemovePrefix(prefix);
return(new HttpServerRequest(
request.Headers,
request.Method,
requestUriWithoutPrefix,
request.HttpVersion,
request.ContentTypeCharset,
request.AcceptCharsets,
request.ContentLength,
request.ContentType,
request.AcceptMediaTypes,
request.Content,
request.IsComplete));
}
internal RestServerRequest(
IHttpServerRequest httpServerRequest,
string acceptCharset,
MediaType acceptMediaType,
Encoding acceptEncoding,
MediaType contentMediaType,
string contentCharset,
Encoding contentEncoding)
{
this.HttpServerRequest = httpServerRequest;
this.AcceptCharset = acceptCharset;
this.AcceptMediaType = acceptMediaType;
this.AcceptEncoding = acceptEncoding;
this.ContentMediaType = contentMediaType;
this.ContentCharset = contentCharset;
this.ContentEncoding = contentEncoding;
}
public RestServerRequest Create(IHttpServerRequest httpRequest)
{
var acceptMediaType = GetAcceptMediaType(httpRequest);
var acceptCharset = GetAcceptCharset(httpRequest, acceptMediaType);
var contentMediaType = GetContentMediaType(httpRequest);
var contentCharset = GetContentCharset(httpRequest, contentMediaType);
return(new RestServerRequest(
httpRequest,
acceptCharset,
acceptMediaType,
EncodingCache.Default.GetEncoding(acceptCharset),
contentMediaType,
contentCharset,
EncodingCache.Default.GetEncoding(contentCharset)
));
}
public HttpResponseStatus Authorize(IHttpServerRequest request)
{
if (request.Headers.Any(h => h.Name == "Authorization"))
{
var authValue = request.Headers.Single(h => h.Name == "Authorization").Value;
var pair = Base64.DecodeFrom64(authValue.Split(' ')[1]).Split(':');
var user = pair[0];
var pass = pair[1];
if (!_credentialValidator.Authenticate(user, pass))
{
return(HttpResponseStatus.Unauthorized);
}
return(HttpResponseStatus.OK);
}
else // ask for authentication headers
{
return(HttpResponseStatus.Unauthorized);
}
}
public RestServerRequest Create(IHttpServerRequest httpRequest)
{
var acceptMediaType = GetAcceptMediaType(httpRequest);
var acceptCharset = GetAcceptCharset(httpRequest, acceptMediaType);
var contentMediaType = GetContentMediaType(httpRequest);
var contentCharset = GetContentCharset(httpRequest, contentMediaType);
return new RestServerRequest(
httpRequest,
acceptCharset,
acceptMediaType,
EncodingCache.Default.GetEncoding(acceptCharset),
contentMediaType,
contentCharset,
EncodingCache.Default.GetEncoding(contentCharset)
);
}
public async Task HandleRequest(CancellationToken ct, IHttpServerRequest request, string relativePath)
{
// TODO: Request body for POST requests
var nancyRequest = new Request(request.Method, request.Url, headers: GetNancyHeaders(request.Headers));
Start();
using (var nancyContext = await _engine.HandleRequest(nancyRequest, x => x, ct))
{
var response = nancyContext.Response;
string contentType = response?.ContentType ?? "text/plain";
var resultCode = (uint?)response?.StatusCode ?? 200;
var resultText = response?.ReasonPhrase ?? "OK";
IDictionary <string, ImmutableList <string> > headers = GetResponseHeaders(response);
var stream = new MemoryStream();
response.Contents(stream);
stream.Position = 0; // seek back to beginning
request.SetResponse(contentType, _ => Task.FromResult(stream as Stream), resultCode, resultText, headers);
}
}
private string GetContentCharset(IHttpServerRequest httpRequest, MediaType contentMediaType)
{
var requestContentCharset = httpRequest.ContentTypeCharset;
var encoding = EncodingCache.Default.GetEncoding(requestContentCharset);
if (encoding == null)
{
if (contentMediaType == MediaType.JSON)
{
requestContentCharset = Configuration.Default.DefaultJSONCharset;
}
else if (contentMediaType == MediaType.XML)
{
requestContentCharset = Configuration.Default.DefaultXMLCharset;
}
else
{
throw new NotImplementedException("Content media type is not supported.");
}
}
return requestContentCharset;
}
internal async Task <HttpServerResponse> HandleRequestAsync(IHttpServerRequest request)
{
var routeRegistration = _routes.FirstOrDefault(x => x.Match(request));
if (routeRegistration == null)
{
return(HttpServerResponse.Create(new Version(1, 1), HttpResponseStatus.BadRequest));
}
var httpResponse = ApplyMessageInspectorsBeforeHandleRequest(request);
if (httpResponse == null)
{
httpResponse = await routeRegistration.HandleAsync(request);
}
httpResponse = await AddContentEncodingAsync(httpResponse, request.AcceptEncodings);
httpResponse = ApplyMessageInspectorsAfterHandleRequest(request, httpResponse);
return(httpResponse);
}
public async Task<HttpServerResponse> HandleRequest(IHttpServerRequest request)
{
if (request.Method != HttpMethod.GET)
{
return GetMethodNotAllowedResponse(request.Method);
}
var localFilePath = GetFilePath(request.Uri);
var absoluteFilePath = GetAbsoluteFilePath(localFilePath);
// todo: add validation for invalid path characters / invalid filename characters
IFile item;
try
{
item = await _fileSystem.GetFileFromPathAsync(absoluteFilePath);
}
catch (FileNotFoundException)
{
return GetFileNotFoundResponse(localFilePath);
}
return await GetHttpResponse(item);
}
public BeforeHandleRequestResult BeforeHandleRequest(IHttpServerRequest request)
{
// could potentially pass this as state between the before handle request and after handle request
// but before that would need to see if the performance increase is worth it
string allowOrigin;
if (request.Method != HttpMethod.OPTIONS || !TryGetAllowOrigin(request.Origin, out allowOrigin))
{
return(null);
}
var httpResponse = HttpServerResponse.Create(HttpResponseStatus.OK);
httpResponse.AddHeader(new AccessControlAllowMethodsHeader(new[] { HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE, HttpMethod.OPTIONS, }));
// max age possible by chrome https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit/Source/core/loader/CrossOriginPreflightResultCache.cpp&l=40&rcl=1399481969
httpResponse.AddHeader(new AccessControlMaxAgeHeader(10 * 60));
if (request.AccessControlRequestHeaders.Any())
{
httpResponse.AddHeader(new AccessControlAllowHeadersHeader(request.AccessControlRequestHeaders));
}
return(new BeforeHandleRequestResult(httpResponse));
}
private string GetContentCharset(IHttpServerRequest httpRequest, MediaType contentMediaType)
{
var requestContentCharset = httpRequest.ContentTypeCharset;
var encoding = EncodingCache.Default.GetEncoding(requestContentCharset);
if (encoding == null)
{
if (contentMediaType == MediaType.JSON)
{
requestContentCharset = Configuration.Default.DefaultJSONCharset;
}
else if (contentMediaType == MediaType.XML)
{
requestContentCharset = Configuration.Default.DefaultXMLCharset;
}
else
{
throw new NotImplementedException("Content media type is not supported.");
}
}
return(requestContentCharset);
}
async Task IHttpHandler.HandleRequest(CancellationToken ct, IHttpServerRequest request, string relativePath)
{
var handlers = _handlers;
if (handlers.IsNullOrEmpty())
{
return; // nothing to do
}
if (relativePath.StartsWith(_path, StringComparison.OrdinalIgnoreCase))
{
var subPath = relativePath.Substring(_path.Length);
if (!subPath.StartsWith("/"))
{
subPath = "/" + subPath;
}
foreach (var handler in handlers)
{
await handler.HandleRequest(ct, request, subPath);
}
}
}
public async Task <HttpServerResponse> HandleRequest(IHttpServerRequest request)
{
if (request.Method != HttpMethod.GET)
{
return(GetMethodNotAllowedResponse(request.Method));
}
var localFilePath = GetFilePath(request.Uri);
var absoluteFilePath = GetAbsoluteFilePath(localFilePath);
// todo: add validation for invalid path characters / invalid filename characters
IFile item;
try
{
item = await _fileSystem.GetFileFromPathAsync(absoluteFilePath);
}
catch (FileNotFoundException)
{
return(GetFileNotFoundResponse(localFilePath));
}
return(await GetHttpResponse(item));
}
internal async Task<HttpServerResponse> HandleRequestAsync(IHttpServerRequest request)
{
var routeRegistration = _routes.FirstOrDefault(x => x.Match(request));
if (routeRegistration == null)
{
return new HttpServerResponse(new Version(1, 1), HttpResponseStatus.BadRequest);
}
return await routeRegistration.HandleAsync(request);
}
public HttpServerRequestAdapter(IHttpServerRequest serverRequest, ISpanNameProvider spanNameProvider)
{
this.serverRequest = serverRequest;
this.spanNameProvider = spanNameProvider;
}
internal async Task <HttpServerResponse> HandleRequestAsync(IHttpServerRequest request)
{
var r = await HandleRequestExAsync(request);
return(r.Item1);
}
public Task<HttpServerResponse> HandleRequest(IHttpServerRequest request)
{
_requests.Add(request);
return Task.FromResult(Utils.CreateOkHttpServerResponse());
}
public async Task <HttpServerResponse> HandleAsync(IHttpServerRequest request)
{
var unPrefixedRequest = CreateHttpRequestWithUnprefixedUrl(request, _urlPrefix);
return(await _routeHandler.HandleRequest(unPrefixedRequest));
}
internal async Task<HttpServerResponse> HandleRequestAsync(IHttpServerRequest request)
{
var routeRegistration = _routes.FirstOrDefault(x => x.Match(request));
if (routeRegistration == null)
{
return HttpServerResponse.Create(new Version(1, 1), HttpResponseStatus.BadRequest);
}
var httpResponse = ApplyMessageInspectorsBeforeHandleRequest(request);
if (httpResponse == null)
httpResponse = await routeRegistration.HandleAsync(request);
httpResponse = await AddContentEncodingAsync(httpResponse, request.AcceptEncodings);
httpResponse = ApplyMessageInspectorsAfterHandleRequest(request, httpResponse);
return httpResponse;
}
private HttpServerResponse ApplyMessageInspectorsAfterHandleRequest(IHttpServerRequest request,
HttpServerResponse httpResponse)
{
foreach (var httpMessageInspector in _messageInspectors)
{
var result = httpMessageInspector.AfterHandleRequest(request, httpResponse);
if (result != null)
httpResponse = result.Response;
}
return httpResponse;
}
internal Task <HttpServerResponse> HandleRequest(IHttpServerRequest request)
{
return(_httpServer.HandleRequestAsync(request));
}
private HttpServerResponse ApplyMessageInspectorsBeforeHandleRequest(IHttpServerRequest request)
{
foreach (var httpMessageInspector in _messageInspectors)
{
var result = httpMessageInspector.BeforeHandleRequest(request);
if (result != null)
return result.Response;
}
return null;
}
public Task <HttpServerResponse> HandleRequest(IHttpServerRequest request)
{
_requests.Add(request);
return(Task.FromResult(Utils.CreateOkHttpServerResponse(request.Content)));
}