jellyfin/Emby.Server.Implementations/Services/ServiceHandler.cs

249 lines
8.8 KiB
C#
Raw Normal View History

2017-02-13 01:07:48 +00:00
using System;
using System.Collections.Generic;
using System.Reflection;
2017-05-22 04:54:02 +00:00
using System.Threading;
2017-02-13 01:07:48 +00:00
using System.Threading.Tasks;
using Emby.Server.Implementations.HttpServer;
using Microsoft.Extensions.Logging;
2017-02-13 01:07:48 +00:00
using MediaBrowser.Model.Services;
namespace Emby.Server.Implementations.Services
{
public class ServiceHandler
{
2018-09-12 17:26:21 +00:00
protected static Task<object> CreateContentTypeRequest(HttpListenerHost host, IRequest httpReq, Type requestType, string contentType)
2017-02-13 01:07:48 +00:00
{
if (!string.IsNullOrEmpty(contentType) && httpReq.ContentLength > 0)
{
2017-02-13 02:06:54 +00:00
var deserializer = RequestHelper.GetRequestReader(host, contentType);
2017-02-13 01:07:48 +00:00
if (deserializer != null)
{
return deserializer(requestType, httpReq.InputStream);
}
}
2019-01-07 23:27:46 +00:00
return Task.FromResult(host.CreateInstance(requestType));
2017-02-13 01:07:48 +00:00
}
2018-12-14 19:17:29 +00:00
public static RestPath FindMatchingRestPath(string httpMethod, string pathInfo, out string contentType)
2017-02-13 01:07:48 +00:00
{
pathInfo = GetSanitizedPathInfo(pathInfo, out contentType);
2018-12-14 19:17:29 +00:00
return ServiceController.Instance.GetRestPathForRequest(httpMethod, pathInfo);
2017-02-13 01:07:48 +00:00
}
public static string GetSanitizedPathInfo(string pathInfo, out string contentType)
{
contentType = null;
var pos = pathInfo.LastIndexOf('.');
if (pos >= 0)
{
var format = pathInfo.Substring(pos + 1);
contentType = GetFormatContentType(format);
if (contentType != null)
{
pathInfo = pathInfo.Substring(0, pos);
}
}
return pathInfo;
}
private static string GetFormatContentType(string format)
{
//built-in formats
if (format == "json")
return "application/json";
if (format == "xml")
return "application/xml";
return null;
}
public RestPath GetRestPath(string httpMethod, string pathInfo)
{
if (this.RestPath == null)
{
string contentType;
2018-12-14 19:17:29 +00:00
this.RestPath = FindMatchingRestPath(httpMethod, pathInfo, out contentType);
2017-02-13 01:07:48 +00:00
if (contentType != null)
ResponseContentType = contentType;
}
return this.RestPath;
}
public RestPath RestPath { get; set; }
// Set from SSHHF.GetHandlerForPathInfo()
public string ResponseContentType { get; set; }
2017-05-22 04:54:02 +00:00
public async Task ProcessRequestAsync(HttpListenerHost appHost, IRequest httpReq, IResponse httpRes, ILogger logger, string operationName, CancellationToken cancellationToken)
2017-02-13 01:07:48 +00:00
{
var restPath = GetRestPath(httpReq.Verb, httpReq.PathInfo);
if (restPath == null)
{
throw new NotSupportedException("No RestPath found for: " + httpReq.Verb + " " + httpReq.PathInfo);
}
SetRoute(httpReq, restPath);
if (ResponseContentType != null)
httpReq.ResponseContentType = ResponseContentType;
2018-09-12 17:26:21 +00:00
var request = httpReq.Dto = await CreateRequest(appHost, httpReq, restPath, logger).ConfigureAwait(false);
2017-02-13 01:07:48 +00:00
appHost.ApplyRequestFilters(httpReq, httpRes, request);
2018-09-12 17:26:21 +00:00
var response = await appHost.ServiceController.Execute(appHost, request, httpReq).ConfigureAwait(false);
2017-02-13 01:07:48 +00:00
// Apply response filters
2017-02-13 02:06:54 +00:00
foreach (var responseFilter in appHost.ResponseFilters)
2017-02-13 01:07:48 +00:00
{
responseFilter(httpReq, httpRes, response);
}
2017-05-22 04:54:02 +00:00
await ResponseHelper.WriteToResponse(httpRes, httpReq, response, cancellationToken).ConfigureAwait(false);
2017-02-13 01:07:48 +00:00
}
2018-09-12 17:26:21 +00:00
public static async Task<object> CreateRequest(HttpListenerHost host, IRequest httpReq, RestPath restPath, ILogger logger)
2017-02-13 01:07:48 +00:00
{
var requestType = restPath.RequestType;
if (RequireqRequestStream(requestType))
{
// Used by IRequiresRequestStream
2018-09-12 17:26:21 +00:00
var requestParams = await GetRequestParams(httpReq).ConfigureAwait(false);
var request = ServiceHandler.CreateRequest(httpReq, restPath, requestParams, host.CreateInstance(requestType));
2017-09-03 07:28:58 +00:00
var rawReq = (IRequiresRequestStream)request;
rawReq.RequestStream = httpReq.InputStream;
return rawReq;
2017-02-13 01:07:48 +00:00
}
2018-09-12 17:26:21 +00:00
else
{
var requestParams = await GetFlattenedRequestParams(httpReq).ConfigureAwait(false);
2017-02-13 01:07:48 +00:00
2018-09-12 17:26:21 +00:00
var requestDto = await CreateContentTypeRequest(host, httpReq, restPath.RequestType, httpReq.ContentType).ConfigureAwait(false);
return CreateRequest(httpReq, restPath, requestParams, requestDto);
}
2017-02-13 01:07:48 +00:00
}
2018-09-12 17:26:21 +00:00
public static bool RequireqRequestStream(Type requestType)
2017-02-13 01:07:48 +00:00
{
var requiresRequestStreamTypeInfo = typeof(IRequiresRequestStream).GetTypeInfo();
return requiresRequestStreamTypeInfo.IsAssignableFrom(requestType.GetTypeInfo());
}
public static object CreateRequest(IRequest httpReq, RestPath restPath, Dictionary<string, string> requestParams, object requestDto)
{
string contentType;
var pathInfo = !restPath.IsWildCardPath
? GetSanitizedPathInfo(httpReq.PathInfo, out contentType)
: httpReq.PathInfo;
return restPath.CreateRequest(pathInfo, requestParams, requestDto);
}
/// <summary>
/// Duplicate Params are given a unique key by appending a #1 suffix
/// </summary>
2018-09-12 17:26:21 +00:00
private static async Task<Dictionary<string, string>> GetRequestParams(IRequest request)
2017-02-13 01:07:48 +00:00
{
var map = new Dictionary<string, string>();
foreach (var name in request.QueryString.Keys)
{
if (name == null) continue; //thank you ASP.NET
var values = request.QueryString.GetValues(name);
2017-08-24 19:52:19 +00:00
if (values.Count == 1)
2017-02-13 01:07:48 +00:00
{
map[name] = values[0];
}
else
{
2017-08-24 19:52:19 +00:00
for (var i = 0; i < values.Count; i++)
2017-02-13 01:07:48 +00:00
{
map[name + (i == 0 ? "" : "#" + i)] = values[i];
}
}
}
2017-09-03 07:28:58 +00:00
if ((IsMethod(request.Verb, "POST") || IsMethod(request.Verb, "PUT")))
2017-02-13 01:07:48 +00:00
{
2018-09-12 17:26:21 +00:00
var formData = await request.GetFormData().ConfigureAwait(false);
2017-09-03 07:28:58 +00:00
if (formData != null)
2017-02-13 01:07:48 +00:00
{
2017-09-03 07:28:58 +00:00
foreach (var name in formData.Keys)
2017-02-13 01:07:48 +00:00
{
2017-09-03 07:28:58 +00:00
if (name == null) continue; //thank you ASP.NET
var values = formData.GetValues(name);
if (values.Count == 1)
{
map[name] = values[0];
}
else
2017-02-13 01:07:48 +00:00
{
2017-09-03 07:28:58 +00:00
for (var i = 0; i < values.Count; i++)
{
map[name + (i == 0 ? "" : "#" + i)] = values[i];
}
2017-02-13 01:07:48 +00:00
}
}
}
}
return map;
}
private static bool IsMethod(string method, string expected)
{
return string.Equals(method, expected, StringComparison.OrdinalIgnoreCase);
}
/// <summary>
/// Duplicate params have their values joined together in a comma-delimited string
/// </summary>
2018-09-12 17:26:21 +00:00
private static async Task<Dictionary<string, string>> GetFlattenedRequestParams(IRequest request)
2017-02-13 01:07:48 +00:00
{
var map = new Dictionary<string, string>();
foreach (var name in request.QueryString.Keys)
{
if (name == null) continue; //thank you ASP.NET
map[name] = request.QueryString[name];
}
2017-09-03 07:28:58 +00:00
if ((IsMethod(request.Verb, "POST") || IsMethod(request.Verb, "PUT")))
2017-02-13 01:07:48 +00:00
{
2018-09-12 17:26:21 +00:00
var formData = await request.GetFormData().ConfigureAwait(false);
2017-09-03 07:28:58 +00:00
if (formData != null)
2017-02-13 01:07:48 +00:00
{
2017-09-03 07:28:58 +00:00
foreach (var name in formData.Keys)
{
if (name == null) continue; //thank you ASP.NET
map[name] = formData[name];
}
2017-02-13 01:07:48 +00:00
}
}
return map;
}
private static void SetRoute(IRequest req, RestPath route)
{
req.Items["__route"] = route;
}
private static RestPath GetRoute(IRequest req)
{
object route;
req.Items.TryGetValue("__route", out route);
return route as RestPath;
}
}
}