lgladsden/jellyfin-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixes issues with HttpClientManager

Browse Source
This commit is contained in:
Bond_009 2019-06-14 16:32:37 +02:00
parent 54c6f02ebb
commit d405a400aa
10 changed files with 119 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Emby.Dlna/PlayTo/SsdpHttpClient.cs
View File

@ -34,16 +34,13 @@ namespace Emby.Dlna.PlayTo
{ {
var cancellationToken = CancellationToken.None; var cancellationToken = CancellationToken.None;
using (var response = await PostSoapDataAsync(NormalizeServiceUrl(baseUrl, service.ControlUrl), "\"" + service.ServiceType + "#" + command + "\"", postData, header, logRequest, cancellationToken) var url = NormalizeServiceUrl(baseUrl, service.ControlUrl);
using (var response = await PostSoapDataAsync(url, '\"' + service.ServiceType + '#' + command + '\"', postData, header, logRequest, cancellationToken)
.ConfigureAwait(false)) .ConfigureAwait(false))
using (var stream = response.Content)
using (var reader = new StreamReader(stream, Encoding.UTF8))
{ {
using (var stream = response.Content) return XDocument.Parse(reader.ReadToEnd(), LoadOptions.PreserveWhitespace);
{
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
return XDocument.Parse(reader.ReadToEnd(), LoadOptions.PreserveWhitespace);
}
}
} }
} }
@ -121,15 +118,18 @@ namespace Emby.Dlna.PlayTo
} }
} }
private Task<HttpResponseInfo> PostSoapDataAsync(string url, private Task<HttpResponseInfo> PostSoapDataAsync(
string url,
string soapAction, string soapAction,
string postData, string postData,
string header, string header,
bool logRequest, bool logRequest,
CancellationToken cancellationToken) CancellationToken cancellationToken)
{ {
if (!soapAction.StartsWith("\"")) if (soapAction[0] != '\"')
soapAction = "\"" + soapAction + "\""; {
soapAction = '\"' + soapAction + '\"';
}
var options = new HttpRequestOptions var options = new HttpRequestOptions
{ {

13
Emby.Server.Implementations/ApplicationHost.cs
View File

@ -430,7 +430,7 @@ namespace Emby.Server.Implementations
/// Gets the current application user agent /// Gets the current application user agent
/// </summary> /// </summary>
/// <value>The application user agent.</value> /// <value>The application user agent.</value>
public string ApplicationUserAgent => Name.Replace(' ','-') + "/" + ApplicationVersion; public string ApplicationUserAgent => Name.Replace(' ','-') + '/' + ApplicationVersion;
/// <summary> /// <summary>
/// Gets the email address for use within a comment section of a user agent field. /// Gets the email address for use within a comment section of a user agent field.
@ -690,11 +690,6 @@ namespace Emby.Server.Implementations
await HttpServer.RequestHandler(req, request.GetDisplayUrl(), request.Host.ToString(), localPath, CancellationToken.None).ConfigureAwait(false); await HttpServer.RequestHandler(req, request.GetDisplayUrl(), request.Host.ToString(), localPath, CancellationToken.None).ConfigureAwait(false);
} }
protected virtual IHttpClient CreateHttpClient()
{
return new HttpClientManager.HttpClientManager(ApplicationPaths, LoggerFactory, FileSystemManager, () => ApplicationUserAgent);
}
public static IStreamHelper StreamHelper { get; set; } public static IStreamHelper StreamHelper { get; set; }
/// <summary> /// <summary>
@ -720,7 +715,11 @@ namespace Emby.Server.Implementations
serviceCollection.AddSingleton(FileSystemManager); serviceCollection.AddSingleton(FileSystemManager);
serviceCollection.AddSingleton<TvDbClientManager>(); serviceCollection.AddSingleton<TvDbClientManager>();
HttpClient = CreateHttpClient(); HttpClient = new HttpClientManager.HttpClientManager(
ApplicationPaths,
LoggerFactory.CreateLogger<HttpClientManager.HttpClientManager>(),
FileSystemManager,
() => ApplicationUserAgent);
serviceCollection.AddSingleton(HttpClient); serviceCollection.AddSingleton(HttpClient);
serviceCollection.AddSingleton(NetworkManager); serviceCollection.AddSingleton(NetworkManager);

143
Emby.Server.Implementations/HttpClientManager/HttpClientManager.cs
View File

@ -23,11 +23,6 @@ namespace Emby.Server.Implementations.HttpClientManager
/// </summary> /// </summary>
public class HttpClientManager : IHttpClient public class HttpClientManager : IHttpClient
{ {
/// <summary>
/// When one request to a host times out, we'll ban all other requests for this period of time, to prevent scans from stalling
/// </summary>
private const int TimeoutSeconds = 30;
/// <summary> /// <summary>
/// The _logger /// The _logger
/// </summary> /// </summary>
@ -46,7 +41,7 @@ namespace Emby.Server.Implementations.HttpClientManager
/// </summary> /// </summary>
public HttpClientManager( public HttpClientManager(
IApplicationPaths appPaths, IApplicationPaths appPaths,
ILoggerFactory loggerFactory, ILogger<HttpClientManager> logger,
IFileSystem fileSystem, IFileSystem fileSystem,
Func<string> defaultUserAgentFn) Func<string> defaultUserAgentFn)
{ {
@ -55,18 +50,15 @@ namespace Emby.Server.Implementations.HttpClientManager
throw new ArgumentNullException(nameof(appPaths)); throw new ArgumentNullException(nameof(appPaths));
} }
if (loggerFactory == null) if (logger == null)
{ {
throw new ArgumentNullException(nameof(loggerFactory)); throw new ArgumentNullException(nameof(logger));
} }
_logger = loggerFactory.CreateLogger(nameof(HttpClientManager)); _logger = logger;
_fileSystem = fileSystem; _fileSystem = fileSystem;
_appPaths = appPaths; _appPaths = appPaths;
_defaultUserAgentFn = defaultUserAgentFn; _defaultUserAgentFn = defaultUserAgentFn;
// http://stackoverflow.com/questions/566437/http-post-returns-the-error-417-expectation-failed-c
ServicePointManager.Expect100Continue = false;
} }
/// <summary> /// <summary>
@ -83,13 +75,12 @@ namespace Emby.Server.Implementations.HttpClientManager
/// <param name="enableHttpCompression">if set to <c>true</c> [enable HTTP compression].</param> /// <param name="enableHttpCompression">if set to <c>true</c> [enable HTTP compression].</param>
/// <returns>HttpClient.</returns> /// <returns>HttpClient.</returns>
/// <exception cref="ArgumentNullException">host</exception> /// <exception cref="ArgumentNullException">host</exception>
private HttpClient GetHttpClient(string url, bool enableHttpCompression) private HttpClient GetHttpClient(string url)
{ {
var key = GetHostFromUrl(url) + enableHttpCompression; var key = GetHostFromUrl(url);
if (!_httpClients.TryGetValue(key, out var client)) if (!_httpClients.TryGetValue(key, out var client))
{ {
client = new HttpClient() client = new HttpClient()
{ {
BaseAddress = new Uri(url) BaseAddress = new Uri(url)
@ -109,24 +100,27 @@ namespace Emby.Server.Implementations.HttpClientManager
if (!string.IsNullOrWhiteSpace(userInfo)) if (!string.IsNullOrWhiteSpace(userInfo))
{ {
_logger.LogWarning("Found userInfo in url: {0} ... url: {1}", userInfo, url); _logger.LogWarning("Found userInfo in url: {0} ... url: {1}", userInfo, url);
url = url.Replace(userInfo + "@", string.Empty); url = url.Replace(userInfo + '@', string.Empty);
} }
var request = new HttpRequestMessage(method, url); var request = new HttpRequestMessage(method, url);
AddRequestHeaders(request, options); AddRequestHeaders(request, options);
if (options.EnableHttpCompression) switch (options.DecompressionMethod)
{ {
if (options.DecompressionMethod.HasValue case CompressionMethod.Deflate | CompressionMethod.Gzip:
&& options.DecompressionMethod.Value == CompressionMethod.Gzip)
{
request.Headers.Add(HeaderNames.AcceptEncoding, new[] { "gzip", "deflate" }); request.Headers.Add(HeaderNames.AcceptEncoding, new[] { "gzip", "deflate" });
} break;
else case CompressionMethod.Deflate:
{
request.Headers.Add(HeaderNames.AcceptEncoding, "deflate"); request.Headers.Add(HeaderNames.AcceptEncoding, "deflate");
} break;
case CompressionMethod.Gzip:
request.Headers.Add(HeaderNames.AcceptEncoding, "gzip");
break;
case 0:
default:
break;
} }
if (options.EnableKeepAlive) if (options.EnableKeepAlive)
@ -134,20 +128,8 @@ namespace Emby.Server.Implementations.HttpClientManager
request.Headers.Add(HeaderNames.Connection, "Keep-Alive"); request.Headers.Add(HeaderNames.Connection, "Keep-Alive");
} }
if (!string.IsNullOrEmpty(options.Host))
{
request.Headers.Add(HeaderNames.Host, options.Host);
}
if (!string.IsNullOrEmpty(options.Referer))
{
request.Headers.Add(HeaderNames.Referer, options.Referer);
}
//request.Headers.Add(HeaderNames.CacheControl, "no-cache"); //request.Headers.Add(HeaderNames.CacheControl, "no-cache");
//request.Headers.Add(HeaderNames., options.TimeoutMs;
/* /*
if (!string.IsNullOrWhiteSpace(userInfo)) if (!string.IsNullOrWhiteSpace(userInfo))
{ {
@ -188,9 +170,7 @@ namespace Emby.Server.Implementations.HttpClientManager
/// <param name="options">The options.</param> /// <param name="options">The options.</param>
/// <returns>Task{HttpResponseInfo}.</returns> /// <returns>Task{HttpResponseInfo}.</returns>
public Task<HttpResponseInfo> GetResponse(HttpRequestOptions options) public Task<HttpResponseInfo> GetResponse(HttpRequestOptions options)
{ => SendAsync(options, HttpMethod.Get);
return SendAsync(options, HttpMethod.Get);
}
/// <summary> /// <summary>
/// Performs a GET request and returns the resulting stream /// Performs a GET request and returns the resulting stream
@ -324,18 +304,29 @@ namespace Emby.Server.Implementations.HttpClientManager
options.CancellationToken.ThrowIfCancellationRequested(); options.CancellationToken.ThrowIfCancellationRequested();
var client = GetHttpClient(options.Url, options.EnableHttpCompression); var client = GetHttpClient(options.Url);
var httpWebRequest = GetRequestMessage(options, httpMethod); var httpWebRequest = GetRequestMessage(options, httpMethod);
if (options.RequestContentBytes != null || if (options.RequestContentBytes != null
!string.IsNullOrEmpty(options.RequestContent) || || !string.IsNullOrEmpty(options.RequestContent)
httpMethod == HttpMethod.Post) || httpMethod == HttpMethod.Post)
{ {
try try
{ {
httpWebRequest.Content = new StringContent(Encoding.UTF8.GetString(options.RequestContentBytes) ?? options.RequestContent ?? string.Empty); if (options.RequestContentBytes != null)
{
httpWebRequest.Content = new ByteArrayContent(options.RequestContentBytes);
}
else if (options.RequestContent != null)
{
httpWebRequest.Content = new StringContent(options.RequestContent);
}
else
{
httpWebRequest.Content = new ByteArrayContent(Array.Empty<byte>());
}
/*
var contentType = options.RequestContentType ?? "application/x-www-form-urlencoded"; var contentType = options.RequestContentType ?? "application/x-www-form-urlencoded";
if (options.AppendCharsetToMimeType) if (options.AppendCharsetToMimeType)
@ -343,8 +334,11 @@ namespace Emby.Server.Implementations.HttpClientManager
contentType = contentType.TrimEnd(';') + "; charset=\"utf-8\""; contentType = contentType.TrimEnd(';') + "; charset=\"utf-8\"";
} }
httpWebRequest.Headers.Add(HeaderNames.ContentType, contentType); httpWebRequest.Headers.Add(HeaderNames.ContentType, contentType);*/
await client.SendAsync(httpWebRequest).ConfigureAwait(false); using (var response = await client.SendAsync(httpWebRequest).ConfigureAwait(false))
{
return await HandleResponseAsync(response, options).ConfigureAwait(false);
}
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -374,18 +368,7 @@ namespace Emby.Server.Implementations.HttpClientManager
using (var response = await client.SendAsync(httpWebRequest).ConfigureAwait(false)) using (var response = await client.SendAsync(httpWebRequest).ConfigureAwait(false))
{ {
await EnsureSuccessStatusCode(response, options).ConfigureAwait(false); return await HandleResponseAsync(response, options).ConfigureAwait(false);
options.CancellationToken.ThrowIfCancellationRequested();
using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
var memoryStream = new MemoryStream();
await stream.CopyToAsync(memoryStream).ConfigureAwait(false);
memoryStream.Position = 0;
return GetResponseInfo(response, memoryStream, memoryStream.Length, null);
}
} }
} }
catch (OperationCanceledException ex) catch (OperationCanceledException ex)
@ -394,9 +377,25 @@ namespace Emby.Server.Implementations.HttpClientManager
} }
} }
private HttpResponseInfo GetResponseInfo(HttpResponseMessage httpResponse, Stream content, long? contentLength, IDisposable disposable) private async Task<HttpResponseInfo> HandleResponseAsync(HttpResponseMessage response, HttpRequestOptions options)
{ {
var responseInfo = new HttpResponseInfo(disposable) await EnsureSuccessStatusCode(response, options).ConfigureAwait(false);
options.CancellationToken.ThrowIfCancellationRequested();
using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
var memoryStream = new MemoryStream();
await stream.CopyToAsync(memoryStream, 81920, options.CancellationToken).ConfigureAwait(false);
memoryStream.Position = 0;
return GetResponseInfo(response, memoryStream, memoryStream.Length);
}
}
private HttpResponseInfo GetResponseInfo(HttpResponseMessage httpResponse, Stream content, long? contentLength)
{
var responseInfo = new HttpResponseInfo()
{ {
Content = content, Content = content,
StatusCode = httpResponse.StatusCode, StatusCode = httpResponse.StatusCode,
@ -433,16 +432,14 @@ namespace Emby.Server.Implementations.HttpClientManager
private static void SetHeaders(HttpContentHeaders headers, HttpResponseInfo responseInfo) private static void SetHeaders(HttpContentHeaders headers, HttpResponseInfo responseInfo)
{ {
foreach (var key in headers) foreach (var header in headers)
{ {
responseInfo.Headers[key.Key] = string.Join(", ", key.Value); responseInfo.Headers[header.Key] = string.Join(", ", header.Value);
} }
} }
public Task<HttpResponseInfo> Post(HttpRequestOptions options) public Task<HttpResponseInfo> Post(HttpRequestOptions options)
{ => SendAsync(options, HttpMethod.Post);
return SendAsync(options, HttpMethod.Post);
}
/// <summary> /// <summary>
/// Downloads the contents of a given url into a temporary location /// Downloads the contents of a given url into a temporary location
@ -451,10 +448,8 @@ namespace Emby.Server.Implementations.HttpClientManager
/// <returns>Task{System.String}.</returns> /// <returns>Task{System.String}.</returns>
public async Task<string> GetTempFile(HttpRequestOptions options) public async Task<string> GetTempFile(HttpRequestOptions options)
{ {
using (var response = await GetTempFileResponse(options).ConfigureAwait(false)) var response = await GetTempFileResponse(options).ConfigureAwait(false);
{ return response.TempFilePath;
return response.TempFilePath;
}
} }
public async Task<HttpResponseInfo> GetTempFileResponse(HttpRequestOptions options) public async Task<HttpResponseInfo> GetTempFileResponse(HttpRequestOptions options)
@ -481,13 +476,13 @@ namespace Emby.Server.Implementations.HttpClientManager
_logger.LogDebug("HttpClientManager.GetTempFileResponse url: {0}", options.Url); _logger.LogDebug("HttpClientManager.GetTempFileResponse url: {0}", options.Url);
} }
var client = GetHttpClient(options.Url, options.EnableHttpCompression); var client = GetHttpClient(options.Url);
try try
{ {
options.CancellationToken.ThrowIfCancellationRequested(); options.CancellationToken.ThrowIfCancellationRequested();
using (var response = (await client.SendAsync(httpWebRequest).ConfigureAwait(false))) using (var response = (await client.SendAsync(httpWebRequest, options.CancellationToken).ConfigureAwait(false)))
{ {
await EnsureSuccessStatusCode(response, options).ConfigureAwait(false); await EnsureSuccessStatusCode(response, options).ConfigureAwait(false);
@ -530,7 +525,7 @@ namespace Emby.Server.Implementations.HttpClientManager
{ {
if (options.LogErrors) if (options.LogErrors)
{ {
_logger.LogError(webException, "Error {status} getting response from {url}", webException.Status, options.Url); _logger.LogError(webException, "Error {Status} getting response from {Url}", webException.Status, options.Url);
} }
var exception = new HttpException(webException.Message, webException); var exception = new HttpException(webException.Message, webException);
@ -565,7 +560,7 @@ namespace Emby.Server.Implementations.HttpClientManager
if (options.LogErrors) if (options.LogErrors)
{ {
_logger.LogError(ex, "Error getting response from {url}", options.Url); _logger.LogError(ex, "Error getting response from {Url}", options.Url);
} }
return ex; return ex;

2
Emby.Server.Implementations/LiveTv/EmbyTV/DirectRecorder.cs
View File

@ -71,7 +71,7 @@ namespace Emby.Server.Implementations.LiveTv.EmbyTV
UserAgent = "Emby/3.0", UserAgent = "Emby/3.0",
// Shouldn't matter but may cause issues // Shouldn't matter but may cause issues
EnableHttpCompression = false DecompressionMethod = CompressionMethod.None
}; };
using (var response = await _httpClient.SendAsync(httpRequestOptions, "GET").ConfigureAwait(false)) using (var response = await _httpClient.SendAsync(httpRequestOptions, "GET").ConfigureAwait(false))

20
Emby.Server.Implementations/LiveTv/Listings/SchedulesDirect.cs
View File

@ -627,15 +627,7 @@ namespace Emby.Server.Implementations.LiveTv.Listings
ListingsProviderInfo providerInfo) ListingsProviderInfo providerInfo)
{ {
// Schedules direct requires that the client support compression and will return a 400 response without it // Schedules direct requires that the client support compression and will return a 400 response without it
options.EnableHttpCompression = true; options.DecompressionMethod = CompressionMethod.Deflate;
// On windows 7 under .net core, this header is not getting added
#if NETSTANDARD2_0
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
options.RequestHeaders[HeaderNames.AcceptEncoding] = "deflate";
}
#endif
try try
{ {
@ -665,15 +657,7 @@ namespace Emby.Server.Implementations.LiveTv.Listings
ListingsProviderInfo providerInfo) ListingsProviderInfo providerInfo)
{ {
// Schedules direct requires that the client support compression and will return a 400 response without it // Schedules direct requires that the client support compression and will return a 400 response without it
options.EnableHttpCompression = true; options.DecompressionMethod = CompressionMethod.Deflate;
// On windows 7 under .net core, this header is not getting added
#if NETSTANDARD2_0
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
options.RequestHeaders[HeaderNames.AcceptEncoding] = "deflate";
}
#endif
try try
{ {

4
Emby.Server.Implementations/LiveTv/Listings/XmlTvListingsProvider.cs
View File

@ -73,11 +73,9 @@ namespace Emby.Server.Implementations.LiveTv.Listings
CancellationToken = cancellationToken, CancellationToken = cancellationToken,
Url = path, Url = path,
Progress = new SimpleProgress<double>(), Progress = new SimpleProgress<double>(),
DecompressionMethod = CompressionMethod.Gzip,
// It's going to come back gzipped regardless of this value // It's going to come back gzipped regardless of this value
// So we need to make sure the decompression method is set to gzip // So we need to make sure the decompression method is set to gzip
EnableHttpCompression = true, DecompressionMethod = CompressionMethod.Gzip,
UserAgent = "Emby/3.0" UserAgent = "Emby/3.0"

2
Emby.Server.Implementations/LiveTv/TunerHosts/SharedHttpStream.cs
View File

@ -47,7 +47,7 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts
CancellationToken = CancellationToken.None, CancellationToken = CancellationToken.None,
BufferContent = false, BufferContent = false,
EnableHttpCompression = false, DecompressionMethod = CompressionMethod.None,
}; };
foreach (var header in mediaSource.RequiredHttpHeaders) foreach (var header in mediaSource.RequiredHttpHeaders)

12
Jellyfin.Server/Program.cs
View File

@ -118,8 +118,20 @@ namespace Jellyfin.Server
SQLitePCL.Batteries_V2.Init(); SQLitePCL.Batteries_V2.Init();
// Increase the max http request limit
// The default connection limit is 10 for ASP.NET hosted applications and 2 for all others.
ServicePointManager.DefaultConnectionLimit = Math.Max(96, ServicePointManager.DefaultConnectionLimit);
// Disable the "Expect: 100-Continue" header by default
// http://stackoverflow.com/questions/566437/http-post-returns-the-error-417-expectation-failed-c
ServicePointManager.Expect100Continue = false;
// CA5359: Do Not Disable Certificate Validation
#pragma warning disable CA5359
// Allow all https requests // Allow all https requests
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(delegate { return true; }); ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(delegate { return true; });
#pragma warning restore CA5359
var fileSystem = new ManagedFileSystem(_loggerFactory, appPaths); var fileSystem = new ManagedFileSystem(_loggerFactory, appPaths);

29
MediaBrowser.Common/Net/HttpRequestOptions.cs
View File

@ -1,6 +1,5 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq;
using System.Threading; using System.Threading;
using Microsoft.Net.Http.Headers; using Microsoft.Net.Http.Headers;
@ -17,7 +16,7 @@ namespace MediaBrowser.Common.Net
/// <value>The URL.</value> /// <value>The URL.</value>
public string Url { get; set; } public string Url { get; set; }
public CompressionMethod? DecompressionMethod { get; set; } public CompressionMethod DecompressionMethod { get; set; }
/// <summary> /// <summary>
/// Gets or sets the accept header. /// Gets or sets the accept header.
@ -49,13 +48,21 @@ namespace MediaBrowser.Common.Net
/// Gets or sets the referrer. /// Gets or sets the referrer.
/// </summary> /// </summary>
/// <value>The referrer.</value> /// <value>The referrer.</value>
public string Referer { get; set; } public string Referer
{
get => GetHeaderValue(HeaderNames.Referer);
set => RequestHeaders[HeaderNames.Referer] = value;
}
/// <summary> /// <summary>
/// Gets or sets the host. /// Gets or sets the host.
/// </summary> /// </summary>
/// <value>The host.</value> /// <value>The host.</value>
public string Host { get; set; } public string Host
{
get => GetHeaderValue(HeaderNames.Host);
set => RequestHeaders[HeaderNames.Host] = value;
}
/// <summary> /// <summary>
/// Gets or sets the progress. /// Gets or sets the progress.
@ -63,12 +70,6 @@ namespace MediaBrowser.Common.Net
/// <value>The progress.</value> /// <value>The progress.</value>
public IProgress<double> Progress { get; set; } public IProgress<double> Progress { get; set; }
/// <summary>
/// Gets or sets a value indicating whether [enable HTTP compression].
/// </summary>
/// <value><c>true</c> if [enable HTTP compression]; otherwise, <c>false</c>.</value>
public bool EnableHttpCompression { get; set; }
public Dictionary<string, string> RequestHeaders { get; private set; } public Dictionary<string, string> RequestHeaders { get; private set; }
public string RequestContentType { get; set; } public string RequestContentType { get; set; }
@ -104,13 +105,12 @@ namespace MediaBrowser.Common.Net
/// </summary> /// </summary>
public HttpRequestOptions() public HttpRequestOptions()
{ {
EnableHttpCompression = true;
RequestHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); RequestHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
LogRequest = true; LogRequest = true;
LogErrors = true; LogErrors = true;
CacheMode = CacheMode.None; CacheMode = CacheMode.None;
DecompressionMethod = CompressionMethod.Deflate;
} }
} }
@ -122,7 +122,8 @@ namespace MediaBrowser.Common.Net
public enum CompressionMethod public enum CompressionMethod
{ {
Deflate, None = 0b00000001,
Gzip Deflate = 0b00000010,
Gzip = 0b00000100
} }
} }

12
MediaBrowser.Common/Net/HttpResponseInfo.cs
View File

@ -52,13 +52,6 @@ namespace MediaBrowser.Common.Net
/// <value>The headers.</value> /// <value>The headers.</value>
public Dictionary<string, string> Headers { get; set; } public Dictionary<string, string> Headers { get; set; }
private readonly IDisposable _disposable;
public HttpResponseInfo(IDisposable disposable)
{
_disposable = disposable;
Headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
}
public HttpResponseInfo() public HttpResponseInfo()
{ {
Headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase); Headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
@ -66,10 +59,7 @@ namespace MediaBrowser.Common.Net
public void Dispose() public void Dispose()
{ {
if (_disposable != null) // Only IDisposable for backwards compatibility
{
_disposable.Dispose();
}
} }
} }
} }