jellyfin/Emby.Server.Implementations/HttpServer/FileWriter.cs

253 lines
8.0 KiB
C#
Raw Normal View History

2019-11-01 17:38:54 +00:00
#pragma warning disable CS1591
using System;
2017-03-12 19:27:26 +00:00
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
2017-03-12 19:27:26 +00:00
using System.Net;
using System.Runtime.InteropServices;
2017-03-12 19:27:26 +00:00
using System.Threading;
using System.Threading.Tasks;
using MediaBrowser.Model.IO;
using MediaBrowser.Model.Services;
using Microsoft.AspNetCore.Http;
2020-03-24 15:12:06 +00:00
using Microsoft.Extensions.Logging;
using Microsoft.Net.Http.Headers;
2017-03-12 19:27:26 +00:00
namespace Emby.Server.Implementations.HttpServer
{
public class FileWriter : IHttpResult
{
private static readonly CultureInfo UsCulture = CultureInfo.ReadOnly(new CultureInfo("en-US"));
2017-03-12 19:27:26 +00:00
private static readonly string[] _skipLogExtensions = {
".js",
".html",
".css"
};
2017-03-12 19:27:26 +00:00
private readonly IStreamHelper _streamHelper;
private readonly ILogger _logger;
private readonly IFileSystem _fileSystem;
2017-03-13 04:08:23 +00:00
2017-03-12 19:27:26 +00:00
/// <summary>
/// The _options
/// </summary>
private readonly IDictionary<string, string> _options = new Dictionary<string, string>();
2017-03-12 19:27:26 +00:00
/// <summary>
/// The _requested ranges
2017-03-12 19:27:26 +00:00
/// </summary>
private List<KeyValuePair<long, long?>> _requestedRanges;
2017-03-12 19:27:26 +00:00
2019-03-05 18:32:22 +00:00
public FileWriter(string path, string contentType, string rangeHeader, ILogger logger, IFileSystem fileSystem, IStreamHelper streamHelper)
2017-03-12 19:27:26 +00:00
{
if (string.IsNullOrEmpty(contentType))
{
throw new ArgumentNullException(nameof(contentType));
2017-03-12 19:27:26 +00:00
}
2019-03-05 18:32:22 +00:00
_streamHelper = streamHelper;
2019-03-06 18:29:25 +00:00
_fileSystem = fileSystem;
2019-03-05 18:32:22 +00:00
2017-03-12 19:27:26 +00:00
Path = path;
_logger = logger;
2017-03-12 19:27:26 +00:00
RangeHeader = rangeHeader;
Headers[HeaderNames.ContentType] = contentType;
2017-03-12 19:27:26 +00:00
TotalContentLength = fileSystem.GetFileInfo(path).Length;
Headers[HeaderNames.AcceptRanges] = "bytes";
2017-03-12 19:27:26 +00:00
if (string.IsNullOrWhiteSpace(rangeHeader))
{
Headers[HeaderNames.ContentLength] = TotalContentLength.ToString(CultureInfo.InvariantCulture);
2017-03-12 19:27:26 +00:00
StatusCode = HttpStatusCode.OK;
}
else
{
StatusCode = HttpStatusCode.PartialContent;
SetRangeValues();
}
2020-01-08 16:52:50 +00:00
FileShare = FileShare.Read;
2017-03-12 19:27:26 +00:00
Cookies = new List<Cookie>();
}
private string RangeHeader { get; set; }
2017-03-12 19:27:26 +00:00
private bool IsHeadRequest { get; set; }
2017-03-12 19:27:26 +00:00
private long RangeStart { get; set; }
2017-03-12 19:27:26 +00:00
private long RangeEnd { get; set; }
2017-05-05 17:55:38 +00:00
private long RangeLength { get; set; }
public long TotalContentLength { get; set; }
public Action OnComplete { get; set; }
public Action OnError { get; set; }
public List<Cookie> Cookies { get; private set; }
2020-01-08 16:52:50 +00:00
public FileShare FileShare { get; set; }
2017-03-12 19:27:26 +00:00
/// <summary>
/// Gets the options.
2017-03-12 19:27:26 +00:00
/// </summary>
/// <value>The options.</value>
public IDictionary<string, string> Headers => _options;
public string Path { get; set; }
2017-03-12 19:27:26 +00:00
/// <summary>
/// Gets the requested ranges.
/// </summary>
/// <value>The requested ranges.</value>
protected List<KeyValuePair<long, long?>> RequestedRanges
{
get
{
if (_requestedRanges == null)
{
_requestedRanges = new List<KeyValuePair<long, long?>>();
// Example: bytes=0-,32-63
var ranges = RangeHeader.Split('=')[1].Split(',');
foreach (var range in ranges)
{
var vals = range.Split('-');
long start = 0;
long? end = null;
if (!string.IsNullOrEmpty(vals[0]))
{
start = long.Parse(vals[0], UsCulture);
}
2017-03-12 19:27:26 +00:00
if (!string.IsNullOrEmpty(vals[1]))
{
end = long.Parse(vals[1], UsCulture);
}
_requestedRanges.Add(new KeyValuePair<long, long?>(start, end));
}
}
return _requestedRanges;
}
}
public string ContentType { get; set; }
public IRequest RequestContext { get; set; }
public object Response { get; set; }
public int Status { get; set; }
public HttpStatusCode StatusCode
{
get => (HttpStatusCode)Status;
set => Status = (int)value;
}
/// <summary>
/// Sets the range values.
/// </summary>
private void SetRangeValues()
{
var requestedRange = RequestedRanges[0];
// If the requested range is "0-", we can optimize by just doing a stream copy
if (!requestedRange.Value.HasValue)
{
RangeEnd = TotalContentLength - 1;
}
else
{
RangeEnd = requestedRange.Value.Value;
}
RangeStart = requestedRange.Key;
RangeLength = 1 + RangeEnd - RangeStart;
// Content-Length is the length of what we're serving, not the original content
var lengthString = RangeLength.ToString(CultureInfo.InvariantCulture);
Headers[HeaderNames.ContentLength] = lengthString;
var rangeString = $"bytes {RangeStart}-{RangeEnd}/{TotalContentLength}";
Headers[HeaderNames.ContentRange] = rangeString;
2018-09-12 17:26:21 +00:00
_logger.LogDebug("Setting range response values for {0}. RangeRequest: {1} Content-Length: {2}, Content-Range: {3}", Path, RangeHeader, lengthString, rangeString);
}
public async Task WriteToAsync(HttpResponse response, CancellationToken cancellationToken)
2017-03-12 19:27:26 +00:00
{
try
{
// Headers only
if (IsHeadRequest)
{
return;
}
2018-09-12 17:26:21 +00:00
var path = Path;
2019-03-05 18:32:22 +00:00
var offset = RangeStart;
var count = RangeLength;
2018-09-12 17:26:21 +00:00
2019-03-05 18:32:22 +00:00
if (string.IsNullOrWhiteSpace(RangeHeader) || RangeStart <= 0 && RangeEnd >= TotalContentLength - 1)
2017-03-12 19:27:26 +00:00
{
2018-09-12 17:26:21 +00:00
var extension = System.IO.Path.GetExtension(path);
if (extension == null || !_skipLogExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase))
2018-09-12 17:26:21 +00:00
{
_logger.LogDebug("Transmit file {0}", path);
2018-09-12 17:26:21 +00:00
}
2017-09-04 19:28:22 +00:00
2019-03-05 18:32:22 +00:00
offset = 0;
count = 0;
2017-03-12 19:27:26 +00:00
}
2019-03-05 18:32:22 +00:00
await TransmitFile(response.Body, path, offset, count, FileShare, cancellationToken).ConfigureAwait(false);
2017-03-12 19:27:26 +00:00
}
finally
{
2019-03-05 18:32:22 +00:00
OnComplete?.Invoke();
2017-03-12 19:27:26 +00:00
}
}
2020-01-08 16:52:50 +00:00
public async Task TransmitFile(Stream stream, string path, long offset, long count, FileShare fileShare, CancellationToken cancellationToken)
{
2020-01-08 16:52:50 +00:00
var fileOptions = FileOptions.SequentialScan;
2017-03-12 19:27:26 +00:00
// use non-async filestream along with read due to https://github.com/dotnet/corefx/issues/6039
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
2020-01-08 16:52:50 +00:00
fileOptions |= FileOptions.Asynchronous;
}
2017-03-12 19:27:26 +00:00
2020-01-08 16:52:50 +00:00
using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, fileShare, IODefaults.FileStreamBufferSize, fileOptions))
{
if (offset > 0)
{
fs.Position = offset;
}
2017-03-12 19:27:26 +00:00
if (count > 0)
{
await _streamHelper.CopyToAsync(fs, stream, count, cancellationToken).ConfigureAwait(false);
}
else
{
2020-01-08 16:52:50 +00:00
await fs.CopyToAsync(stream, IODefaults.CopyToBufferSize, cancellationToken).ConfigureAwait(false);
}
}
2017-03-12 19:27:26 +00:00
}
}
}