2013-03-24 03:45:00 +01:00
|
|
|
using System;
|
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.Globalization;
|
2013-03-08 18:25:25 +01:00
|
|
|
using System.IO;
|
2018-09-12 19:26:21 +02:00
|
|
|
using System.IO.Compression;
|
2013-03-24 03:45:00 +01:00
|
|
|
using System.Net;
|
2016-11-10 15:41:24 +01:00
|
|
|
using System.Runtime.Serialization;
|
2013-03-25 13:46:38 +01:00
|
|
|
using System.Text;
|
2013-03-24 03:45:00 +01:00
|
|
|
using System.Threading.Tasks;
|
2016-11-10 15:41:24 +01:00
|
|
|
using System.Xml;
|
2017-02-13 02:07:48 +01:00
|
|
|
using Emby.Server.Implementations.Services;
|
2019-01-13 20:20:41 +01:00
|
|
|
using MediaBrowser.Common.Extensions;
|
|
|
|
using MediaBrowser.Controller.Net;
|
2016-10-25 21:02:04 +02:00
|
|
|
using MediaBrowser.Model.IO;
|
2019-01-13 20:20:41 +01:00
|
|
|
using MediaBrowser.Model.Serialization;
|
2016-10-25 21:02:04 +02:00
|
|
|
using MediaBrowser.Model.Services;
|
2019-01-13 20:20:41 +01:00
|
|
|
using Microsoft.Extensions.Logging;
|
2016-10-25 21:02:04 +02:00
|
|
|
using IRequest = MediaBrowser.Model.Services.IRequest;
|
2014-12-26 18:45:06 +01:00
|
|
|
using MimeTypes = MediaBrowser.Model.Net.MimeTypes;
|
2013-03-08 18:25:25 +01:00
|
|
|
|
2016-11-11 02:37:20 +01:00
|
|
|
namespace Emby.Server.Implementations.HttpServer
|
2013-03-08 18:25:25 +01:00
|
|
|
{
|
2013-03-24 03:45:00 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Class HttpResultFactory
|
|
|
|
/// </summary>
|
2013-03-08 18:25:25 +01:00
|
|
|
public class HttpResultFactory : IHttpResultFactory
|
|
|
|
{
|
2013-03-24 03:45:00 +01:00
|
|
|
/// <summary>
|
|
|
|
/// The _logger
|
|
|
|
/// </summary>
|
|
|
|
private readonly ILogger _logger;
|
2013-10-31 15:03:23 +01:00
|
|
|
private readonly IFileSystem _fileSystem;
|
2014-02-04 05:04:19 +01:00
|
|
|
private readonly IJsonSerializer _jsonSerializer;
|
2018-09-12 19:26:21 +02:00
|
|
|
|
|
|
|
private IBrotliCompressor _brotliCompressor;
|
2013-03-24 03:45:00 +01:00
|
|
|
|
|
|
|
/// <summary>
|
2014-02-04 05:04:19 +01:00
|
|
|
/// Initializes a new instance of the <see cref="HttpResultFactory" /> class.
|
2013-03-24 03:45:00 +01:00
|
|
|
/// </summary>
|
2018-12-13 14:18:25 +01:00
|
|
|
public HttpResultFactory(ILoggerFactory loggerfactory, IFileSystem fileSystem, IJsonSerializer jsonSerializer, IBrotliCompressor brotliCompressor)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2013-10-31 15:03:23 +01:00
|
|
|
_fileSystem = fileSystem;
|
2014-02-04 05:04:19 +01:00
|
|
|
_jsonSerializer = jsonSerializer;
|
2018-09-12 19:26:21 +02:00
|
|
|
_brotliCompressor = brotliCompressor;
|
2018-12-13 14:18:25 +01:00
|
|
|
_logger = loggerfactory.CreateLogger("HttpResultFactory");
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <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>
|
2018-09-12 19:26:21 +02:00
|
|
|
public object GetResult(IRequest requestContext, byte[] content, string contentType, IDictionary<string, string> responseHeaders = null)
|
|
|
|
{
|
|
|
|
return GetHttpResult(requestContext, content, contentType, true, responseHeaders);
|
|
|
|
}
|
|
|
|
|
|
|
|
public object GetResult(string content, string contentType, IDictionary<string, string> responseHeaders = null)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
return GetHttpResult(null, content, contentType, true, responseHeaders);
|
|
|
|
}
|
|
|
|
|
|
|
|
public object GetResult(IRequest requestContext, Stream content, string contentType, IDictionary<string, string> responseHeaders = null)
|
|
|
|
{
|
|
|
|
return GetHttpResult(requestContext, content, contentType, true, responseHeaders);
|
|
|
|
}
|
|
|
|
|
|
|
|
public object GetResult(IRequest requestContext, string content, string contentType, IDictionary<string, string> responseHeaders = null)
|
|
|
|
{
|
|
|
|
return GetHttpResult(requestContext, content, contentType, true, responseHeaders);
|
2013-03-25 03:41:27 +01:00
|
|
|
}
|
|
|
|
|
2017-05-31 21:21:32 +02:00
|
|
|
public object GetRedirectResult(string url)
|
|
|
|
{
|
|
|
|
var responseHeaders = new Dictionary<string, string>();
|
|
|
|
responseHeaders["Location"] = url;
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var result = new HttpResult(Array.Empty<byte>(), "text/plain", HttpStatusCode.Redirect);
|
2017-05-31 21:21:32 +02:00
|
|
|
|
|
|
|
AddResponseHeaders(result, responseHeaders);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2013-03-25 03:41:27 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Gets the HTTP result.
|
|
|
|
/// </summary>
|
2018-09-12 19:26:21 +02:00
|
|
|
private IHasHeaders GetHttpResult(IRequest requestContext, Stream content, string contentType, bool addCachePrevention, IDictionary<string, string> responseHeaders = null)
|
2013-03-25 03:41:27 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var result = new StreamWriter(content, contentType, _logger);
|
2013-03-25 03:41:27 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (responseHeaders == null)
|
|
|
|
{
|
|
|
|
responseHeaders = new Dictionary<string, string>();
|
|
|
|
}
|
2013-03-25 03:41:27 +01:00
|
|
|
|
2019-01-17 18:47:41 +01:00
|
|
|
if (addCachePrevention && !responseHeaders.TryGetValue("Expires", out string expires))
|
2013-03-25 03:41:27 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
responseHeaders["Expires"] = "-1";
|
2013-03-25 03:41:27 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
AddResponseHeaders(result, responseHeaders);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the HTTP result.
|
|
|
|
/// </summary>
|
|
|
|
private IHasHeaders GetHttpResult(IRequest requestContext, byte[] content, string contentType, bool addCachePrevention, IDictionary<string, string> responseHeaders = null)
|
|
|
|
{
|
2018-12-29 17:26:36 +01:00
|
|
|
string compressionType = null;
|
|
|
|
bool isHeadRequest = false;
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2019-01-13 20:20:41 +01:00
|
|
|
if (requestContext != null)
|
|
|
|
{
|
2018-12-29 17:26:36 +01:00
|
|
|
compressionType = GetCompressionType(requestContext, content, contentType);
|
|
|
|
isHeadRequest = string.Equals(requestContext.Verb, "head", StringComparison.OrdinalIgnoreCase);
|
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
|
2018-12-29 17:26:36 +01:00
|
|
|
IHasHeaders result;
|
2018-09-12 19:26:21 +02:00
|
|
|
if (string.IsNullOrEmpty(compressionType))
|
2013-03-25 03:41:27 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var contentLength = content.Length;
|
2013-03-25 03:41:27 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (isHeadRequest)
|
2013-03-25 03:41:27 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
content = Array.Empty<byte>();
|
2013-03-25 03:41:27 +01:00
|
|
|
}
|
2013-03-25 13:46:38 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
result = new StreamWriter(content, contentType, contentLength, _logger);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
result = GetCompressedResult(content, compressionType, responseHeaders, isHeadRequest, contentType);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (responseHeaders == null)
|
|
|
|
{
|
|
|
|
responseHeaders = new Dictionary<string, string>();
|
|
|
|
}
|
|
|
|
|
2019-01-17 18:47:41 +01:00
|
|
|
if (addCachePrevention && !responseHeaders.TryGetValue("Expires", out string expires))
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
responseHeaders["Expires"] = "-1";
|
|
|
|
}
|
|
|
|
|
|
|
|
AddResponseHeaders(result, responseHeaders);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the HTTP result.
|
|
|
|
/// </summary>
|
|
|
|
private IHasHeaders GetHttpResult(IRequest requestContext, string content, string contentType, bool addCachePrevention, IDictionary<string, string> responseHeaders = null)
|
|
|
|
{
|
|
|
|
IHasHeaders result;
|
|
|
|
|
|
|
|
var bytes = Encoding.UTF8.GetBytes(content);
|
|
|
|
|
|
|
|
var compressionType = requestContext == null ? null : GetCompressionType(requestContext, bytes, contentType);
|
|
|
|
|
|
|
|
var isHeadRequest = requestContext == null ? false : string.Equals(requestContext.Verb, "head", StringComparison.OrdinalIgnoreCase);
|
|
|
|
|
|
|
|
if (string.IsNullOrEmpty(compressionType))
|
|
|
|
{
|
|
|
|
var contentLength = bytes.Length;
|
|
|
|
|
|
|
|
if (isHeadRequest)
|
|
|
|
{
|
|
|
|
bytes = Array.Empty<byte>();
|
2013-03-25 03:41:27 +01:00
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
|
|
|
|
result = new StreamWriter(bytes, contentType, contentLength, _logger);
|
2013-03-25 03:41:27 +01:00
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
result = GetCompressedResult(bytes, compressionType, responseHeaders, isHeadRequest, contentType);
|
|
|
|
}
|
|
|
|
|
2016-10-02 04:09:33 +02:00
|
|
|
if (responseHeaders == null)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2016-10-02 04:09:33 +02:00
|
|
|
responseHeaders = new Dictionary<string, string>();
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
2013-09-15 19:34:37 +02:00
|
|
|
|
2019-01-17 18:47:41 +01:00
|
|
|
if (addCachePrevention && !responseHeaders.TryGetValue("Expires", out string expires))
|
2016-11-12 07:58:50 +01:00
|
|
|
{
|
|
|
|
responseHeaders["Expires"] = "-1";
|
|
|
|
}
|
|
|
|
|
2016-10-02 04:09:33 +02:00
|
|
|
AddResponseHeaders(result, responseHeaders);
|
|
|
|
|
2013-03-24 03:45:00 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the optimized result.
|
|
|
|
/// </summary>
|
|
|
|
/// <typeparam name="T"></typeparam>
|
2018-09-12 19:26:21 +02:00
|
|
|
public object GetResult<T>(IRequest requestContext, T result, IDictionary<string, string> responseHeaders = null)
|
2013-03-24 03:45:00 +01:00
|
|
|
where T : class
|
|
|
|
{
|
|
|
|
if (result == null)
|
|
|
|
{
|
2019-01-06 21:50:43 +01:00
|
|
|
throw new ArgumentNullException(nameof(result));
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
2015-12-01 06:22:52 +01:00
|
|
|
if (responseHeaders == null)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2015-12-01 06:22:52 +01:00
|
|
|
responseHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
responseHeaders["Expires"] = "-1";
|
|
|
|
|
|
|
|
return ToOptimizedResultInternal(requestContext, result, responseHeaders);
|
|
|
|
}
|
|
|
|
|
|
|
|
private string GetCompressionType(IRequest request, byte[] content, string responseContentType)
|
|
|
|
{
|
|
|
|
if (responseContentType == null)
|
2015-12-01 06:22:52 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
return null;
|
2015-12-01 06:22:52 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
// Per apple docs, hls manifests must be compressed
|
|
|
|
if (!responseContentType.StartsWith("text/", StringComparison.OrdinalIgnoreCase) &&
|
|
|
|
responseContentType.IndexOf("json", StringComparison.OrdinalIgnoreCase) == -1 &&
|
|
|
|
responseContentType.IndexOf("javascript", StringComparison.OrdinalIgnoreCase) == -1 &&
|
|
|
|
responseContentType.IndexOf("xml", StringComparison.OrdinalIgnoreCase) == -1 &&
|
|
|
|
responseContentType.IndexOf("application/x-mpegURL", StringComparison.OrdinalIgnoreCase) == -1)
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (content.Length < 1024)
|
|
|
|
{
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
return GetCompressionType(request);
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
2016-11-10 15:41:24 +01:00
|
|
|
|
2019-01-06 21:50:43 +01:00
|
|
|
private static string GetCompressionType(IRequest request)
|
2016-11-10 15:41:24 +01:00
|
|
|
{
|
2016-11-11 02:37:20 +01:00
|
|
|
var acceptEncoding = request.Headers["Accept-Encoding"];
|
2016-11-10 15:41:24 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (acceptEncoding != null)
|
2016-11-11 02:37:20 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
//if (_brotliCompressor != null && acceptEncoding.IndexOf("br", StringComparison.OrdinalIgnoreCase) != -1)
|
|
|
|
// return "br";
|
|
|
|
|
|
|
|
if (acceptEncoding.IndexOf("deflate", StringComparison.OrdinalIgnoreCase) != -1)
|
2016-11-11 02:37:20 +01:00
|
|
|
return "deflate";
|
2016-11-10 15:41:24 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (acceptEncoding.IndexOf("gzip", StringComparison.OrdinalIgnoreCase) != -1)
|
2016-11-11 02:37:20 +01:00
|
|
|
return "gzip";
|
|
|
|
}
|
2016-11-10 15:41:24 +01:00
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
2019-01-08 00:27:46 +01:00
|
|
|
/// Returns the optimized result for the IRequestContext.
|
2016-11-10 15:41:24 +01:00
|
|
|
/// Does not use or store results in any cache.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="request"></param>
|
|
|
|
/// <param name="dto"></param>
|
|
|
|
/// <returns></returns>
|
|
|
|
public object ToOptimizedResult<T>(IRequest request, T dto)
|
2017-09-28 19:05:10 +02:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
return ToOptimizedResultInternal(request, dto);
|
2017-09-28 19:05:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private object ToOptimizedResultInternal<T>(IRequest request, T dto, IDictionary<string, string> responseHeaders = null)
|
2016-11-10 15:41:24 +01:00
|
|
|
{
|
2017-08-01 18:45:57 +02:00
|
|
|
var contentType = request.ResponseContentType;
|
2016-11-10 15:41:24 +01:00
|
|
|
|
2017-08-01 18:45:57 +02:00
|
|
|
switch (GetRealContentType(contentType))
|
2016-11-10 15:41:24 +01:00
|
|
|
{
|
2017-08-01 18:45:57 +02:00
|
|
|
case "application/xml":
|
|
|
|
case "text/xml":
|
|
|
|
case "text/xml; charset=utf-8": //"text/xml; charset=utf-8" also matches xml
|
2018-09-12 19:26:21 +02:00
|
|
|
return GetHttpResult(request, SerializeToXmlString(dto), contentType, false, responseHeaders);
|
2017-02-13 02:07:48 +01:00
|
|
|
|
2017-08-01 18:45:57 +02:00
|
|
|
case "application/json":
|
|
|
|
case "text/json":
|
2018-09-12 19:26:21 +02:00
|
|
|
return GetHttpResult(request, _jsonSerializer.SerializeToString(dto), contentType, false, responseHeaders);
|
2017-08-01 18:45:57 +02:00
|
|
|
default:
|
2018-09-12 19:26:21 +02:00
|
|
|
break;
|
|
|
|
}
|
2016-11-10 15:41:24 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var isHeadRequest = string.Equals(request.Verb, "head", StringComparison.OrdinalIgnoreCase);
|
2016-11-10 15:41:24 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var ms = new MemoryStream();
|
|
|
|
var writerFn = RequestHelper.GetResponseWriter(HttpListenerHost.Instance, contentType);
|
2017-09-28 19:05:10 +02:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
writerFn(dto, ms);
|
2016-11-10 15:41:24 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
ms.Position = 0;
|
2016-11-11 02:37:20 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (isHeadRequest)
|
2016-11-10 15:41:24 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
using (ms)
|
2016-11-10 15:41:24 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
return GetHttpResult(request, Array.Empty<byte>(), contentType, true, responseHeaders);
|
2016-11-10 15:41:24 +01:00
|
|
|
}
|
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
|
|
|
|
return GetHttpResult(request, ms, contentType, true, responseHeaders);
|
2016-11-10 15:41:24 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private IHasHeaders GetCompressedResult(byte[] content,
|
|
|
|
string requestedCompressionType,
|
|
|
|
IDictionary<string, string> responseHeaders,
|
|
|
|
bool isHeadRequest,
|
|
|
|
string contentType)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
|
|
|
if (responseHeaders == null)
|
|
|
|
{
|
2015-12-01 06:22:52 +01:00
|
|
|
responseHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
content = Compress(content, requestedCompressionType);
|
|
|
|
responseHeaders["Content-Encoding"] = requestedCompressionType;
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
responseHeaders["Vary"] = "Accept-Encoding";
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var contentLength = content.Length;
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (isHeadRequest)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var result = new StreamWriter(Array.Empty<byte>(), contentType, contentLength, _logger);
|
|
|
|
AddResponseHeaders(result, responseHeaders);
|
|
|
|
return result;
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
else
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var result = new StreamWriter(content, contentType, contentLength, _logger);
|
|
|
|
AddResponseHeaders(result, responseHeaders);
|
|
|
|
return result;
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
private byte[] Compress(byte[] bytes, string compressionType)
|
|
|
|
{
|
|
|
|
if (string.Equals(compressionType, "br", StringComparison.OrdinalIgnoreCase))
|
|
|
|
return CompressBrotli(bytes);
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (string.Equals(compressionType, "deflate", StringComparison.OrdinalIgnoreCase))
|
|
|
|
return Deflate(bytes);
|
|
|
|
|
|
|
|
if (string.Equals(compressionType, "gzip", StringComparison.OrdinalIgnoreCase))
|
|
|
|
return GZip(bytes);
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
throw new NotSupportedException(compressionType);
|
|
|
|
}
|
|
|
|
|
|
|
|
private byte[] CompressBrotli(byte[] bytes)
|
|
|
|
{
|
|
|
|
return _brotliCompressor.Compress(bytes);
|
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2019-01-06 21:50:43 +01:00
|
|
|
private static byte[] Deflate(byte[] bytes)
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
// In .NET FX incompat-ville, you can't access compressed bytes without closing DeflateStream
|
|
|
|
// Which means we must use MemoryStream since you have to use ToArray() on a closed Stream
|
|
|
|
using (var ms = new MemoryStream())
|
|
|
|
using (var zipStream = new DeflateStream(ms, CompressionMode.Compress))
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
zipStream.Write(bytes, 0, bytes.Length);
|
|
|
|
zipStream.Dispose();
|
|
|
|
|
|
|
|
return ms.ToArray();
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2019-01-06 21:50:43 +01:00
|
|
|
private static byte[] GZip(byte[] buffer)
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
using (var ms = new MemoryStream())
|
|
|
|
using (var zipStream = new GZipStream(ms, CompressionMode.Compress))
|
|
|
|
{
|
|
|
|
zipStream.Write(buffer, 0, buffer.Length);
|
|
|
|
zipStream.Dispose();
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
return ms.ToArray();
|
|
|
|
}
|
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
public static string GetRealContentType(string contentType)
|
|
|
|
{
|
|
|
|
return contentType == null
|
|
|
|
? null
|
|
|
|
: contentType.Split(';')[0].ToLower().Trim();
|
|
|
|
}
|
|
|
|
|
2019-01-06 21:50:43 +01:00
|
|
|
private static string SerializeToXmlString(object from)
|
2018-09-12 19:26:21 +02:00
|
|
|
{
|
|
|
|
using (var ms = new MemoryStream())
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var xwSettings = new XmlWriterSettings();
|
|
|
|
xwSettings.Encoding = new UTF8Encoding(false);
|
|
|
|
xwSettings.OmitXmlDeclaration = false;
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
using (var xw = XmlWriter.Create(ms, xwSettings))
|
|
|
|
{
|
|
|
|
var serializer = new DataContractSerializer(from.GetType());
|
|
|
|
serializer.WriteObject(xw, from);
|
|
|
|
xw.Flush();
|
|
|
|
ms.Seek(0, SeekOrigin.Begin);
|
|
|
|
var reader = new StreamReader(ms);
|
|
|
|
return reader.ReadToEnd();
|
|
|
|
}
|
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Pres the process optimized result.
|
|
|
|
/// </summary>
|
2013-12-07 16:52:38 +01:00
|
|
|
private object GetCachedResult(IRequest requestContext, IDictionary<string, string> responseHeaders, Guid cacheKey, string cacheKeyString, DateTime? lastDateModified, TimeSpan? cacheDuration, string contentType)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2016-08-13 06:57:21 +02:00
|
|
|
responseHeaders["ETag"] = string.Format("\"{0}\"", cacheKeyString);
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2017-05-09 20:51:26 +02:00
|
|
|
var noCache = (requestContext.Headers.Get("Cache-Control") ?? string.Empty).IndexOf("no-cache", StringComparison.OrdinalIgnoreCase) != -1;
|
|
|
|
|
|
|
|
if (!noCache)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2017-05-09 20:51:26 +02:00
|
|
|
if (IsNotModified(requestContext, cacheKey, lastDateModified, cacheDuration))
|
|
|
|
{
|
|
|
|
AddAgeHeader(responseHeaders, lastDateModified);
|
2017-09-22 22:33:01 +02:00
|
|
|
AddExpiresHeader(responseHeaders, cacheKeyString, cacheDuration);
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var result = new HttpResult(Array.Empty<byte>(), contentType ?? "text/html", HttpStatusCode.NotModified);
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2017-05-09 20:51:26 +02:00
|
|
|
AddResponseHeaders(result, responseHeaders);
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2017-05-09 20:51:26 +02:00
|
|
|
return result;
|
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
2017-09-22 22:33:01 +02:00
|
|
|
AddCachingHeaders(responseHeaders, cacheKeyString, lastDateModified, cacheDuration);
|
2013-03-24 03:45:00 +01:00
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2016-06-19 08:18:29 +02:00
|
|
|
public Task<object> GetStaticFileResult(IRequest requestContext,
|
2014-08-29 14:14:41 +02:00
|
|
|
string path,
|
2016-10-25 21:02:04 +02:00
|
|
|
FileShareMode fileShare = FileShareMode.Read)
|
2013-03-08 18:25:25 +01:00
|
|
|
{
|
2013-03-24 03:45:00 +01:00
|
|
|
if (string.IsNullOrEmpty(path))
|
|
|
|
{
|
2019-01-06 21:50:43 +01:00
|
|
|
throw new ArgumentNullException(nameof(path));
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
2014-08-30 16:26:29 +02:00
|
|
|
return GetStaticFileResult(requestContext, new StaticFileResultOptions
|
|
|
|
{
|
|
|
|
Path = path,
|
|
|
|
FileShare = fileShare
|
|
|
|
});
|
2014-03-12 20:56:12 +01:00
|
|
|
}
|
|
|
|
|
2016-06-19 08:18:29 +02:00
|
|
|
public Task<object> GetStaticFileResult(IRequest requestContext,
|
2014-08-30 16:26:29 +02:00
|
|
|
StaticFileResultOptions options)
|
2014-03-12 20:56:12 +01:00
|
|
|
{
|
2014-08-30 16:26:29 +02:00
|
|
|
var path = options.Path;
|
|
|
|
var fileShare = options.FileShare;
|
|
|
|
|
2014-03-12 20:56:12 +01:00
|
|
|
if (string.IsNullOrEmpty(path))
|
|
|
|
{
|
2019-01-06 21:50:43 +01:00
|
|
|
throw new ArgumentNullException(nameof(path));
|
2014-03-12 20:56:12 +01:00
|
|
|
}
|
|
|
|
|
2016-10-25 21:02:04 +02:00
|
|
|
if (fileShare != FileShareMode.Read && fileShare != FileShareMode.ReadWrite)
|
2013-09-15 19:34:37 +02:00
|
|
|
{
|
|
|
|
throw new ArgumentException("FileShare must be either Read or ReadWrite");
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (string.IsNullOrEmpty(options.ContentType))
|
2014-08-30 16:26:29 +02:00
|
|
|
{
|
|
|
|
options.ContentType = MimeTypes.GetMimeType(path);
|
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2016-07-17 18:59:40 +02:00
|
|
|
if (!options.DateLastModified.HasValue)
|
|
|
|
{
|
|
|
|
options.DateLastModified = _fileSystem.GetLastWriteTimeUtc(path);
|
|
|
|
}
|
|
|
|
|
2014-08-30 16:26:29 +02:00
|
|
|
var cacheKey = path + options.DateLastModified.Value.Ticks;
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2014-08-30 16:26:29 +02:00
|
|
|
options.CacheKey = cacheKey.GetMD5();
|
|
|
|
options.ContentFactory = () => Task.FromResult(GetFileStream(path, fileShare));
|
|
|
|
|
2017-07-18 19:34:56 +02:00
|
|
|
options.ResponseHeaders = options.ResponseHeaders ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
|
2014-08-30 16:26:29 +02:00
|
|
|
return GetStaticResult(requestContext, options);
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Gets the file stream.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="path">The path.</param>
|
2013-09-15 19:34:37 +02:00
|
|
|
/// <param name="fileShare">The file share.</param>
|
2013-03-24 03:45:00 +01:00
|
|
|
/// <returns>Stream.</returns>
|
2016-10-25 21:02:04 +02:00
|
|
|
private Stream GetFileStream(string path, FileShareMode fileShare)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2016-10-25 21:02:04 +02:00
|
|
|
return _fileSystem.GetFileStream(path, FileOpenMode.Open, FileAccessMode.Read, fileShare);
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
2016-06-19 08:18:29 +02:00
|
|
|
public Task<object> GetStaticResult(IRequest requestContext,
|
2014-08-29 14:14:41 +02:00
|
|
|
Guid cacheKey,
|
|
|
|
DateTime? lastDateModified,
|
|
|
|
TimeSpan? cacheDuration,
|
|
|
|
string contentType,
|
|
|
|
Func<Task<Stream>> factoryFn,
|
|
|
|
IDictionary<string, string> responseHeaders = null,
|
|
|
|
bool isHeadRequest = false)
|
|
|
|
{
|
2014-08-30 16:26:29 +02:00
|
|
|
return GetStaticResult(requestContext, new StaticResultOptions
|
|
|
|
{
|
|
|
|
CacheDuration = cacheDuration,
|
|
|
|
CacheKey = cacheKey,
|
|
|
|
ContentFactory = factoryFn,
|
|
|
|
ContentType = contentType,
|
|
|
|
DateLastModified = lastDateModified,
|
|
|
|
IsHeadRequest = isHeadRequest,
|
|
|
|
ResponseHeaders = responseHeaders
|
|
|
|
});
|
2014-08-29 14:14:41 +02:00
|
|
|
}
|
|
|
|
|
2016-06-19 08:18:29 +02:00
|
|
|
public async Task<object> GetStaticResult(IRequest requestContext, StaticResultOptions options)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2014-08-30 16:26:29 +02:00
|
|
|
var cacheKey = options.CacheKey;
|
2015-12-01 06:22:52 +01:00
|
|
|
options.ResponseHeaders = options.ResponseHeaders ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
2014-08-30 16:26:29 +02:00
|
|
|
var contentType = options.ContentType;
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!cacheKey.Equals(Guid.Empty))
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
var key = cacheKey.ToString("N");
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
// See if the result is already cached in the browser
|
|
|
|
var result = GetCachedResult(requestContext, options.ResponseHeaders, cacheKey, key, options.DateLastModified, options.CacheDuration, contentType);
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (result != null)
|
|
|
|
{
|
|
|
|
return result;
|
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
2017-09-24 22:24:12 +02:00
|
|
|
// TODO: We don't really need the option value
|
|
|
|
var isHeadRequest = options.IsHeadRequest || string.Equals(requestContext.Verb, "HEAD", StringComparison.OrdinalIgnoreCase);
|
2014-08-30 16:26:29 +02:00
|
|
|
var factoryFn = options.ContentFactory;
|
|
|
|
var responseHeaders = options.ResponseHeaders;
|
|
|
|
|
2017-08-01 18:45:57 +02:00
|
|
|
//var requestedCompressionType = GetCompressionType(requestContext);
|
2013-12-07 16:52:38 +01:00
|
|
|
|
2017-08-01 18:45:57 +02:00
|
|
|
var rangeHeader = requestContext.Headers.Get("Range");
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
if (!isHeadRequest && !string.IsNullOrEmpty(options.Path))
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2017-08-30 20:06:54 +02:00
|
|
|
var hasHeaders = new FileWriter(options.Path, contentType, rangeHeader, _logger, _fileSystem)
|
2017-08-01 18:45:57 +02:00
|
|
|
{
|
|
|
|
OnComplete = options.OnComplete,
|
|
|
|
OnError = options.OnError,
|
|
|
|
FileShare = options.FileShare
|
|
|
|
};
|
2017-08-30 20:06:54 +02:00
|
|
|
|
|
|
|
AddResponseHeaders(hasHeaders, options.ResponseHeaders);
|
|
|
|
return hasHeaders;
|
2016-12-22 17:47:43 +01:00
|
|
|
}
|
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var stream = await factoryFn().ConfigureAwait(false);
|
|
|
|
|
|
|
|
var totalContentLength = options.ContentLength;
|
|
|
|
if (!totalContentLength.HasValue)
|
2016-12-22 17:47:43 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
try
|
|
|
|
{
|
|
|
|
totalContentLength = stream.Length;
|
|
|
|
}
|
|
|
|
catch (NotSupportedException)
|
|
|
|
{
|
2016-12-22 17:47:43 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!string.IsNullOrWhiteSpace(rangeHeader) && totalContentLength.HasValue)
|
|
|
|
{
|
|
|
|
var hasHeaders = new RangeRequestWriter(rangeHeader, totalContentLength.Value, stream, contentType, isHeadRequest, _logger)
|
2014-02-19 06:21:03 +01:00
|
|
|
{
|
2017-08-01 18:45:57 +02:00
|
|
|
OnComplete = options.OnComplete
|
|
|
|
};
|
2017-08-30 20:06:54 +02:00
|
|
|
|
|
|
|
AddResponseHeaders(hasHeaders, options.ResponseHeaders);
|
|
|
|
return hasHeaders;
|
2017-08-01 18:45:57 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
if (totalContentLength.HasValue)
|
|
|
|
{
|
|
|
|
responseHeaders["Content-Length"] = totalContentLength.Value.ToString(UsCulture);
|
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2016-12-22 17:47:43 +01:00
|
|
|
if (isHeadRequest)
|
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
using (stream)
|
|
|
|
{
|
|
|
|
return GetHttpResult(requestContext, Array.Empty<byte>(), contentType, true, responseHeaders);
|
|
|
|
}
|
2016-12-22 17:47:43 +01:00
|
|
|
}
|
2014-02-19 06:21:03 +01:00
|
|
|
|
2017-08-30 20:06:54 +02:00
|
|
|
var hasHeaders = new StreamWriter(stream, contentType, _logger)
|
2017-08-01 18:45:57 +02:00
|
|
|
{
|
|
|
|
OnComplete = options.OnComplete,
|
|
|
|
OnError = options.OnError
|
|
|
|
};
|
2017-08-30 20:06:54 +02:00
|
|
|
|
|
|
|
AddResponseHeaders(hasHeaders, options.ResponseHeaders);
|
|
|
|
return hasHeaders;
|
2016-11-10 15:41:24 +01:00
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
2017-08-30 20:06:54 +02:00
|
|
|
/// <summary>
|
|
|
|
/// The us culture
|
|
|
|
/// </summary>
|
|
|
|
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
|
|
|
|
|
2013-03-24 03:45:00 +01:00
|
|
|
/// <summary>
|
|
|
|
/// Adds the caching responseHeaders.
|
|
|
|
/// </summary>
|
2017-09-22 22:33:01 +02:00
|
|
|
private void AddCachingHeaders(IDictionary<string, string> responseHeaders, string cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
|
|
|
// 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);
|
2016-08-14 02:52:32 +02:00
|
|
|
responseHeaders["Last-Modified"] = lastDateModified.Value.ToString("r");
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
2017-09-22 22:33:01 +02:00
|
|
|
if (cacheDuration.HasValue)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
|
|
|
responseHeaders["Cache-Control"] = "public, max-age=" + Convert.ToInt32(cacheDuration.Value.TotalSeconds);
|
|
|
|
}
|
2017-09-22 22:33:01 +02:00
|
|
|
else if (!string.IsNullOrEmpty(cacheKey))
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
|
|
|
responseHeaders["Cache-Control"] = "public";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
responseHeaders["Cache-Control"] = "no-cache, no-store, must-revalidate";
|
|
|
|
responseHeaders["pragma"] = "no-cache, no-store, must-revalidate";
|
|
|
|
}
|
|
|
|
|
2017-09-22 22:33:01 +02:00
|
|
|
AddExpiresHeader(responseHeaders, cacheKey, cacheDuration);
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Adds the expires header.
|
|
|
|
/// </summary>
|
2019-01-06 21:50:43 +01:00
|
|
|
private static void AddExpiresHeader(IDictionary<string, string> responseHeaders, string cacheKey, TimeSpan? cacheDuration)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2017-09-22 22:33:01 +02:00
|
|
|
if (cacheDuration.HasValue)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
|
|
|
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>
|
2019-01-06 21:50:43 +01:00
|
|
|
private static void AddAgeHeader(IDictionary<string, string> responseHeaders, DateTime? lastDateModified)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
|
|
|
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>
|
2018-09-12 19:26:21 +02:00
|
|
|
private bool IsNotModified(IRequest requestContext, Guid cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2016-11-27 20:36:56 +01:00
|
|
|
//var isNotModified = true;
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2016-11-11 02:37:20 +01:00
|
|
|
var ifModifiedSinceHeader = requestContext.Headers.Get("If-Modified-Since");
|
2013-03-24 03:45:00 +01:00
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(ifModifiedSinceHeader))
|
|
|
|
{
|
2019-01-13 21:46:33 +01:00
|
|
|
if (DateTime.TryParse(ifModifiedSinceHeader, out var ifModifiedSince))
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2016-11-27 20:36:56 +01:00
|
|
|
if (IsNotModified(ifModifiedSince.ToUniversalTime(), cacheDuration, lastDateModified))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-11 02:37:20 +01:00
|
|
|
var ifNoneMatchHeader = requestContext.Headers.Get("If-None-Match");
|
2013-03-24 03:45:00 +01:00
|
|
|
|
2018-09-12 19:26:21 +02:00
|
|
|
var hasCacheKey = !cacheKey.Equals(Guid.Empty);
|
|
|
|
|
2013-03-24 03:45:00 +01:00
|
|
|
// Validate If-None-Match
|
2018-09-12 19:26:21 +02:00
|
|
|
if ((hasCacheKey || !string.IsNullOrEmpty(ifNoneMatchHeader)))
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2016-11-27 20:36:56 +01:00
|
|
|
ifNoneMatchHeader = (ifNoneMatchHeader ?? string.Empty).Trim('\"');
|
|
|
|
|
2019-01-13 21:46:33 +01:00
|
|
|
if (Guid.TryParse(ifNoneMatchHeader, out var ifNoneMatch))
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
2018-09-12 19:26:21 +02:00
|
|
|
if (hasCacheKey && cacheKey.Equals(ifNoneMatch))
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
|
|
|
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>
|
2019-01-06 21:50:43 +01:00
|
|
|
private static DateTime NormalizeDateForComparison(DateTime date)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
|
|
|
return new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second, date.Kind);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Adds the response headers.
|
|
|
|
/// </summary>
|
2016-10-25 21:02:04 +02:00
|
|
|
/// <param name="hasHeaders">The has options.</param>
|
2013-03-24 03:45:00 +01:00
|
|
|
/// <param name="responseHeaders">The response headers.</param>
|
2019-01-06 21:50:43 +01:00
|
|
|
private static void AddResponseHeaders(IHasHeaders hasHeaders, IEnumerable<KeyValuePair<string, string>> responseHeaders)
|
2013-03-24 03:45:00 +01:00
|
|
|
{
|
|
|
|
foreach (var item in responseHeaders)
|
|
|
|
{
|
2016-10-25 21:02:04 +02:00
|
|
|
hasHeaders.Headers[item.Key] = item.Value;
|
2013-03-24 03:45:00 +01:00
|
|
|
}
|
|
|
|
}
|
2013-03-08 18:25:25 +01:00
|
|
|
}
|
2018-09-12 19:26:21 +02:00
|
|
|
|
|
|
|
public interface IBrotliCompressor
|
|
|
|
{
|
|
|
|
byte[] Compress(byte[] content);
|
|
|
|
}
|
2018-12-29 17:26:36 +01:00
|
|
|
}
|