jellyfin-server/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs

689 lines
26 KiB
C#
Raw Normal View History

using MediaBrowser.Common.Extensions;
using MediaBrowser.Common.IO;
2013-12-07 15:52:38 +00:00
using MediaBrowser.Controller.Net;
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Serialization;
using ServiceStack;
using ServiceStack.Web;
using System;
using System.Collections.Generic;
using System.Globalization;
2013-03-08 17:25:25 +00:00
using System.IO;
using System.Net;
2013-03-25 12:46:38 +00:00
using System.Text;
using System.Threading.Tasks;
2014-12-26 17:45:06 +00:00
using MimeTypes = MediaBrowser.Model.Net.MimeTypes;
2013-03-08 17:25:25 +00:00
namespace MediaBrowser.Server.Implementations.HttpServer
{
/// <summary>
/// Class HttpResultFactory
/// </summary>
2013-03-08 17:25:25 +00:00
public class HttpResultFactory : IHttpResultFactory
{
/// <summary>
/// The _logger
/// </summary>
private readonly ILogger _logger;
private readonly IFileSystem _fileSystem;
private readonly IJsonSerializer _jsonSerializer;
/// <summary>
/// Initializes a new instance of the <see cref="HttpResultFactory" /> class.
/// </summary>
/// <param name="logManager">The log manager.</param>
/// <param name="fileSystem">The file system.</param>
/// <param name="jsonSerializer">The json serializer.</param>
public HttpResultFactory(ILogManager logManager, IFileSystem fileSystem, IJsonSerializer jsonSerializer)
{
_fileSystem = fileSystem;
_jsonSerializer = jsonSerializer;
_logger = logManager.GetLogger("HttpResultFactory");
}
/// <summary>
/// Gets the result.
/// </summary>
/// <param name="content">The content.</param>
/// <param name="contentType">Type of the content.</param>
/// <param name="responseHeaders">The response headers.</param>
/// <returns>System.Object.</returns>
public object GetResult(object content, string contentType, IDictionary<string, string> responseHeaders = null)
{
2013-03-25 02:41:27 +00:00
return GetHttpResult(content, contentType, responseHeaders);
}
/// <summary>
/// Gets the HTTP result.
/// </summary>
/// <param name="content">The content.</param>
/// <param name="contentType">Type of the content.</param>
/// <param name="responseHeaders">The response headers.</param>
/// <returns>IHasOptions.</returns>
private IHasOptions GetHttpResult(object content, string contentType, IDictionary<string, string> responseHeaders = null)
{
IHasOptions result;
var stream = content as Stream;
if (stream != null)
{
result = new StreamWriter(stream, contentType, _logger);
}
else
{
var bytes = content as byte[];
if (bytes != null)
{
result = new StreamWriter(bytes, contentType, _logger);
}
else
{
2013-03-25 12:46:38 +00:00
var text = content as string;
if (text != null)
{
result = new StreamWriter(Encoding.UTF8.GetBytes(text), contentType, _logger);
}
else
{
result = new HttpResult(content, contentType);
}
2013-03-25 02:41:27 +00:00
}
}
if (responseHeaders != null)
{
AddResponseHeaders(result, responseHeaders);
}
2013-09-15 17:34:37 +00:00
return result;
}
/// <summary>
/// Gets the optimized result.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="requestContext">The request context.</param>
/// <param name="result">The result.</param>
/// <param name="responseHeaders">The response headers.</param>
/// <returns>System.Object.</returns>
/// <exception cref="System.ArgumentNullException">result</exception>
2013-12-07 15:52:38 +00:00
public object GetOptimizedResult<T>(IRequest requestContext, T result, IDictionary<string, string> responseHeaders = null)
where T : class
{
if (result == null)
{
throw new ArgumentNullException("result");
}
2014-09-03 02:30:24 +00:00
var optimizedResult = requestContext.ToOptimizedResult(result);
if (responseHeaders != null)
{
// Apply headers
var hasOptions = optimizedResult as IHasOptions;
if (hasOptions != null)
{
AddResponseHeaders(hasOptions, responseHeaders);
}
}
return optimizedResult;
}
/// <summary>
/// Gets the optimized result using cache.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="requestContext">The request context.</param>
/// <param name="cacheKey">The cache key.</param>
/// <param name="lastDateModified">The last date modified.</param>
/// <param name="cacheDuration">Duration of the cache.</param>
/// <param name="factoryFn">The factory fn.</param>
/// <param name="responseHeaders">The response headers.</param>
/// <returns>System.Object.</returns>
/// <exception cref="System.ArgumentNullException">cacheKey
/// or
/// factoryFn</exception>
public object GetOptimizedResultUsingCache<T>(IRequest requestContext, Guid cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn, IDictionary<string, string> responseHeaders = null)
where T : class
{
if (cacheKey == Guid.Empty)
{
throw new ArgumentNullException("cacheKey");
}
if (factoryFn == null)
{
throw new ArgumentNullException("factoryFn");
}
var key = cacheKey.ToString("N");
if (responseHeaders == null)
{
responseHeaders = new Dictionary<string, string>();
}
// See if the result is already cached in the browser
var result = GetCachedResult(requestContext, responseHeaders, cacheKey, key, lastDateModified, cacheDuration, null);
if (result != null)
{
return result;
}
return GetOptimizedResult(requestContext, factoryFn(), responseHeaders);
}
/// <summary>
/// To the cached result.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="requestContext">The request context.</param>
/// <param name="cacheKey">The cache key.</param>
/// <param name="lastDateModified">The last date modified.</param>
/// <param name="cacheDuration">Duration of the cache.</param>
/// <param name="factoryFn">The factory fn.</param>
/// <param name="contentType">Type of the content.</param>
/// <param name="responseHeaders">The response headers.</param>
/// <returns>System.Object.</returns>
/// <exception cref="System.ArgumentNullException">cacheKey</exception>
public object GetCachedResult<T>(IRequest requestContext, Guid cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn, string contentType, IDictionary<string, string> responseHeaders = null)
where T : class
{
if (cacheKey == Guid.Empty)
{
throw new ArgumentNullException("cacheKey");
}
if (factoryFn == null)
{
throw new ArgumentNullException("factoryFn");
}
var key = cacheKey.ToString("N");
if (responseHeaders == null)
{
responseHeaders = new Dictionary<string, string>();
}
// See if the result is already cached in the browser
var result = GetCachedResult(requestContext, responseHeaders, cacheKey, key, lastDateModified, cacheDuration, contentType);
if (result != null)
{
return result;
}
result = factoryFn();
// Apply caching headers
var hasOptions = result as IHasOptions;
if (hasOptions != null)
{
AddResponseHeaders(hasOptions, responseHeaders);
return hasOptions;
}
2014-02-28 05:22:36 +00:00
IHasOptions httpResult;
var stream = result as Stream;
if (stream != null)
{
httpResult = new StreamWriter(stream, contentType, _logger);
}
else
{
// Otherwise wrap into an HttpResult
httpResult = new HttpResult(result, contentType ?? "text/html", HttpStatusCode.NotModified);
}
AddResponseHeaders(httpResult, responseHeaders);
return httpResult;
}
/// <summary>
/// Pres the process optimized result.
/// </summary>
/// <param name="requestContext">The request context.</param>
/// <param name="responseHeaders">The responseHeaders.</param>
/// <param name="cacheKey">The cache key.</param>
/// <param name="cacheKeyString">The cache key string.</param>
/// <param name="lastDateModified">The last date modified.</param>
/// <param name="cacheDuration">Duration of the cache.</param>
/// <param name="contentType">Type of the content.</param>
/// <returns>System.Object.</returns>
2013-12-07 15:52:38 +00:00
private object GetCachedResult(IRequest requestContext, IDictionary<string, string> responseHeaders, Guid cacheKey, string cacheKeyString, DateTime? lastDateModified, TimeSpan? cacheDuration, string contentType)
{
responseHeaders["ETag"] = cacheKeyString;
if (IsNotModified(requestContext, cacheKey, lastDateModified, cacheDuration))
{
AddAgeHeader(responseHeaders, lastDateModified);
AddExpiresHeader(responseHeaders, cacheKeyString, cacheDuration);
var result = new HttpResult(new byte[] { }, contentType ?? "text/html", HttpStatusCode.NotModified);
AddResponseHeaders(result, responseHeaders);
return result;
}
AddCachingHeaders(responseHeaders, cacheKeyString, lastDateModified, cacheDuration);
return null;
}
2014-08-29 12:14:41 +00:00
public object GetStaticFileResult(IRequest requestContext,
string path,
2014-08-30 14:26:29 +00:00
FileShare fileShare = FileShare.Read)
2013-03-08 17:25:25 +00:00
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
2014-08-30 14:26:29 +00:00
return GetStaticFileResult(requestContext, new StaticFileResultOptions
{
Path = path,
FileShare = fileShare
});
}
2014-08-29 12:14:41 +00:00
public object GetStaticFileResult(IRequest requestContext,
2014-08-30 14:26:29 +00:00
StaticFileResultOptions options)
{
2014-08-30 14:26:29 +00:00
var path = options.Path;
var fileShare = options.FileShare;
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
2013-09-15 17:34:37 +00:00
if (fileShare != FileShare.Read && fileShare != FileShare.ReadWrite)
{
throw new ArgumentException("FileShare must be either Read or ReadWrite");
}
2014-08-30 14:26:29 +00:00
if (string.IsNullOrWhiteSpace(options.ContentType))
{
options.ContentType = MimeTypes.GetMimeType(path);
}
2014-08-30 14:26:29 +00:00
options.DateLastModified = _fileSystem.GetLastWriteTimeUtc(path);
var cacheKey = path + options.DateLastModified.Value.Ticks;
2014-08-30 14:26:29 +00:00
options.CacheKey = cacheKey.GetMD5();
options.ContentFactory = () => Task.FromResult(GetFileStream(path, fileShare));
return GetStaticResult(requestContext, options);
}
/// <summary>
/// Gets the file stream.
/// </summary>
/// <param name="path">The path.</param>
2013-09-15 17:34:37 +00:00
/// <param name="fileShare">The file share.</param>
/// <returns>Stream.</returns>
2013-09-15 17:34:37 +00:00
private Stream GetFileStream(string path, FileShare fileShare)
{
return _fileSystem.GetFileStream(path, FileMode.Open, FileAccess.Read, fileShare, true);
}
2014-08-29 12:14:41 +00:00
public object GetStaticResult(IRequest requestContext,
Guid cacheKey,
DateTime? lastDateModified,
TimeSpan? cacheDuration,
string contentType,
Func<Task<Stream>> factoryFn,
IDictionary<string, string> responseHeaders = null,
bool isHeadRequest = false)
{
2014-08-30 14:26:29 +00:00
return GetStaticResult(requestContext, new StaticResultOptions
{
CacheDuration = cacheDuration,
CacheKey = cacheKey,
ContentFactory = factoryFn,
ContentType = contentType,
DateLastModified = lastDateModified,
IsHeadRequest = isHeadRequest,
ResponseHeaders = responseHeaders
});
2014-08-29 12:14:41 +00:00
}
2014-08-30 14:26:29 +00:00
public object GetStaticResult(IRequest requestContext, StaticResultOptions options)
{
2014-08-30 14:26:29 +00:00
var cacheKey = options.CacheKey;
options.ResponseHeaders = options.ResponseHeaders ?? new Dictionary<string, string>();
var contentType = options.ContentType;
if (cacheKey == Guid.Empty)
{
throw new ArgumentNullException("cacheKey");
}
2014-08-30 14:26:29 +00:00
if (options.ContentFactory == null)
{
throw new ArgumentNullException("factoryFn");
}
var key = cacheKey.ToString("N");
// See if the result is already cached in the browser
2014-08-30 14:26:29 +00:00
var result = GetCachedResult(requestContext, options.ResponseHeaders, cacheKey, key, options.DateLastModified, options.CacheDuration, contentType);
if (result != null)
{
return result;
}
var compress = ShouldCompressResponse(requestContext, contentType);
2014-08-30 14:26:29 +00:00
var hasOptions = GetStaticResult(requestContext, options, compress).Result;
AddResponseHeaders(hasOptions, options.ResponseHeaders);
2014-01-12 03:29:47 +00:00
return hasOptions;
}
/// <summary>
/// Shoulds the compress response.
/// </summary>
/// <param name="requestContext">The request context.</param>
/// <param name="contentType">Type of the content.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
2013-12-07 15:52:38 +00:00
private bool ShouldCompressResponse(IRequest requestContext, string contentType)
{
// It will take some work to support compression with byte range requests
if (!string.IsNullOrEmpty(requestContext.GetHeader("Range")))
{
return false;
}
// Don't compress media
if (contentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase) || contentType.StartsWith("video/", StringComparison.OrdinalIgnoreCase))
{
return false;
}
// Don't compress images
if (contentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
{
return false;
}
if (contentType.StartsWith("font/", StringComparison.OrdinalIgnoreCase))
{
return false;
}
if (contentType.StartsWith("application/", StringComparison.OrdinalIgnoreCase))
{
if (string.Equals(contentType, "application/x-javascript", StringComparison.OrdinalIgnoreCase))
{
return true;
}
if (string.Equals(contentType, "application/xml", StringComparison.OrdinalIgnoreCase))
{
return true;
}
return false;
}
return true;
}
/// <summary>
/// The us culture
/// </summary>
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
2014-08-30 14:26:29 +00:00
private async Task<IHasOptions> GetStaticResult(IRequest requestContext, StaticResultOptions options, bool compress)
{
2014-08-30 14:26:29 +00:00
var isHeadRequest = options.IsHeadRequest;
var factoryFn = options.ContentFactory;
var contentType = options.ContentType;
var responseHeaders = options.ResponseHeaders;
2013-12-07 15:52:38 +00:00
var requestedCompressionType = requestContext.GetCompressionType();
if (!compress || string.IsNullOrEmpty(requestedCompressionType))
{
var rangeHeader = requestContext.GetHeader("Range");
2014-02-19 05:21:03 +00:00
var stream = await factoryFn().ConfigureAwait(false);
if (!string.IsNullOrEmpty(rangeHeader))
{
2014-08-29 12:14:41 +00:00
return new RangeRequestWriter(rangeHeader, stream, contentType, isHeadRequest)
{
2014-09-03 02:30:24 +00:00
OnComplete = options.OnComplete
2014-08-29 12:14:41 +00:00
};
}
responseHeaders["Content-Length"] = stream.Length.ToString(UsCulture);
if (isHeadRequest)
{
2014-02-19 05:21:03 +00:00
stream.Dispose();
2013-03-25 02:41:27 +00:00
return GetHttpResult(new byte[] { }, contentType);
}
2014-08-29 12:14:41 +00:00
return new StreamWriter(stream, contentType, _logger)
{
2014-09-03 02:30:24 +00:00
OnComplete = options.OnComplete
2014-08-29 12:14:41 +00:00
};
}
string content;
using (var stream = await factoryFn().ConfigureAwait(false))
{
2014-09-03 02:30:24 +00:00
using (var reader = new StreamReader(stream))
2014-02-19 05:21:03 +00:00
{
2014-09-03 02:30:24 +00:00
content = await reader.ReadToEndAsync().ConfigureAwait(false);
2014-02-19 05:21:03 +00:00
}
}
2013-12-07 15:52:38 +00:00
var contents = content.Compress(requestedCompressionType);
2014-02-19 05:21:03 +00:00
responseHeaders["Content-Length"] = contents.Length.ToString(UsCulture);
if (isHeadRequest)
{
return GetHttpResult(new byte[] { }, contentType);
}
2014-02-28 05:22:36 +00:00
2013-12-07 15:52:38 +00:00
return new CompressedResult(contents, requestedCompressionType, contentType);
}
/// <summary>
/// Adds the caching responseHeaders.
/// </summary>
/// <param name="responseHeaders">The responseHeaders.</param>
/// <param name="cacheKey">The cache key.</param>
/// <param name="lastDateModified">The last date modified.</param>
/// <param name="cacheDuration">Duration of the cache.</param>
private void AddCachingHeaders(IDictionary<string, string> responseHeaders, string cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
{
// Don't specify both last modified and Etag, unless caching unconditionally. They are redundant
// https://developers.google.com/speed/docs/best-practices/caching#LeverageBrowserCaching
if (lastDateModified.HasValue && (string.IsNullOrEmpty(cacheKey) || cacheDuration.HasValue))
{
AddAgeHeader(responseHeaders, lastDateModified);
responseHeaders["LastModified"] = lastDateModified.Value.ToString("r");
}
if (cacheDuration.HasValue)
{
responseHeaders["Cache-Control"] = "public, max-age=" + Convert.ToInt32(cacheDuration.Value.TotalSeconds);
}
else if (!string.IsNullOrEmpty(cacheKey))
{
responseHeaders["Cache-Control"] = "public";
}
else
{
responseHeaders["Cache-Control"] = "no-cache, no-store, must-revalidate";
responseHeaders["pragma"] = "no-cache, no-store, must-revalidate";
}
AddExpiresHeader(responseHeaders, cacheKey, cacheDuration);
}
/// <summary>
/// Adds the expires header.
/// </summary>
/// <param name="responseHeaders">The responseHeaders.</param>
/// <param name="cacheKey">The cache key.</param>
/// <param name="cacheDuration">Duration of the cache.</param>
private void AddExpiresHeader(IDictionary<string, string> responseHeaders, string cacheKey, TimeSpan? cacheDuration)
{
if (cacheDuration.HasValue)
{
responseHeaders["Expires"] = DateTime.UtcNow.Add(cacheDuration.Value).ToString("r");
}
else if (string.IsNullOrEmpty(cacheKey))
{
responseHeaders["Expires"] = "-1";
}
}
/// <summary>
/// Adds the age header.
/// </summary>
/// <param name="responseHeaders">The responseHeaders.</param>
/// <param name="lastDateModified">The last date modified.</param>
private void AddAgeHeader(IDictionary<string, string> responseHeaders, DateTime? lastDateModified)
{
if (lastDateModified.HasValue)
{
responseHeaders["Age"] = Convert.ToInt64((DateTime.UtcNow - lastDateModified.Value).TotalSeconds).ToString(CultureInfo.InvariantCulture);
}
}
/// <summary>
/// Determines whether [is not modified] [the specified cache key].
/// </summary>
/// <param name="requestContext">The request context.</param>
/// <param name="cacheKey">The cache key.</param>
/// <param name="lastDateModified">The last date modified.</param>
/// <param name="cacheDuration">Duration of the cache.</param>
/// <returns><c>true</c> if [is not modified] [the specified cache key]; otherwise, <c>false</c>.</returns>
2013-12-07 15:52:38 +00:00
private bool IsNotModified(IRequest requestContext, Guid? cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
{
var isNotModified = true;
var ifModifiedSinceHeader = requestContext.GetHeader("If-Modified-Since");
if (!string.IsNullOrEmpty(ifModifiedSinceHeader))
{
DateTime ifModifiedSince;
if (DateTime.TryParse(ifModifiedSinceHeader, out ifModifiedSince))
{
isNotModified = IsNotModified(ifModifiedSince.ToUniversalTime(), cacheDuration, lastDateModified);
}
}
var ifNoneMatchHeader = requestContext.GetHeader("If-None-Match");
// Validate If-None-Match
if (isNotModified && (cacheKey.HasValue || !string.IsNullOrEmpty(ifNoneMatchHeader)))
{
Guid ifNoneMatch;
if (Guid.TryParse(ifNoneMatchHeader ?? string.Empty, out ifNoneMatch))
{
if (cacheKey.HasValue && cacheKey.Value == ifNoneMatch)
{
return true;
}
}
}
return false;
}
/// <summary>
/// Determines whether [is not modified] [the specified if modified since].
/// </summary>
/// <param name="ifModifiedSince">If modified since.</param>
/// <param name="cacheDuration">Duration of the cache.</param>
/// <param name="dateModified">The date modified.</param>
/// <returns><c>true</c> if [is not modified] [the specified if modified since]; otherwise, <c>false</c>.</returns>
private bool IsNotModified(DateTime ifModifiedSince, TimeSpan? cacheDuration, DateTime? dateModified)
{
if (dateModified.HasValue)
{
var lastModified = NormalizeDateForComparison(dateModified.Value);
ifModifiedSince = NormalizeDateForComparison(ifModifiedSince);
return lastModified <= ifModifiedSince;
}
if (cacheDuration.HasValue)
{
var cacheExpirationDate = ifModifiedSince.Add(cacheDuration.Value);
if (DateTime.UtcNow < cacheExpirationDate)
{
return true;
}
}
return false;
}
/// <summary>
/// When the browser sends the IfModifiedDate, it's precision is limited to seconds, so this will account for that
/// </summary>
/// <param name="date">The date.</param>
/// <returns>DateTime.</returns>
private DateTime NormalizeDateForComparison(DateTime date)
{
return new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second, date.Kind);
}
/// <summary>
/// Adds the response headers.
/// </summary>
/// <param name="hasOptions">The has options.</param>
/// <param name="responseHeaders">The response headers.</param>
private void AddResponseHeaders(IHasOptions hasOptions, IEnumerable<KeyValuePair<string, string>> responseHeaders)
{
foreach (var item in responseHeaders)
{
hasOptions.Options[item.Key] = item.Value;
}
}
/// <summary>
/// Gets the error result.
/// </summary>
/// <param name="statusCode">The status code.</param>
/// <param name="errorMessage">The error message.</param>
/// <param name="responseHeaders">The response headers.</param>
/// <returns>System.Object.</returns>
public void ThrowError(int statusCode, string errorMessage, IDictionary<string, string> responseHeaders = null)
{
var error = new HttpError
{
Status = statusCode,
ErrorCode = errorMessage
};
if (responseHeaders != null)
{
AddResponseHeaders(error, responseHeaders);
}
throw error;
2013-03-08 17:25:25 +00:00
}
}
2014-01-12 03:29:47 +00:00
}