tk/Ocelot
1
0
Fork 0
mirror of https://github.com/nsnail/Ocelot.git synced 2025-04-23 00:32:50 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: HttpClientCache and remove not used code current

Browse Source
This commit is contained in:
geffzhang 2017-03-07 08:29:03 +08:00
parent 10db534008
commit 23ad6ed264
7 changed files with 48 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
global.json
View File

@ -1,6 +1,6 @@
 {
"projects": [ "src", "test" ],
"sdk": {
"version": "1.0.0-preview2-003133"
"version": "1.0.0-preview2-003131"
}
}

2
src/Ocelot/DependencyInjection/ServiceCollectionExtensions.cs
View File

@ -135,7 +135,7 @@ namespace Ocelot.DependencyInjection
services.AddSingleton<IAuthenticationHandlerFactory, AuthenticationHandlerFactory>();
services.AddSingleton<IAuthenticationHandlerCreator, AuthenticationHandlerCreator>();
services.AddSingleton<IRateLimitCounterHandler, MemoryCacheRateLimitCounterHandler>();
services.AddSingleton<IHttpClientMessageCacheHandler, MemoryHttpClientMessageCacheHandler>();
services.AddSingleton<IHttpClientCache, MemoryHttpClientCache>();
// see this for why we register this as singleton http://stackoverflow.com/questions/37371264/invalidoperationexception-unable-to-resolve-service-for-type-microsoft-aspnetc
// could maybe use a scoped data repository

61
src/Ocelot/Requester/HttpClientBuilder.cs
View File

@ -11,61 +11,23 @@ namespace Ocelot.Requester
{
internal class HttpClientBuilder : IHttpClientBuilder
{
private TimeSpan? _timeout;
private readonly List<DelegatingHandler> _handlers = new List<DelegatingHandler>();
private readonly Dictionary<int, Func<DelegatingHandler>> _handlers = new Dictionary<int, Func<DelegatingHandler>>();
private Dictionary<string, string> _defaultHeaders;
private CookieContainer _cookieContainer;
private IQoSProvider _qoSProvider;
public IHttpClientBuilder WithCookieContainer(CookieContainer cookieContainer)
public IHttpClientBuilder WithQos(IQoSProvider qosProvider, IOcelotLogger logger)
{
_cookieContainer = cookieContainer;
_handlers.Add(5000, () => new PollyCircuitBreakingDelegatingHandler(qosProvider, logger));
return this;
}
public IHttpClientBuilder WithTimeout(TimeSpan timeout)
{
_timeout = timeout;
return this;
}
public IHttpClientBuilder WithHandler(DelegatingHandler handler)
{
_handlers.Add(handler);
return this;
}
public IHttpClientBuilder WithDefaultRequestHeaders(Dictionary<string, string> headers)
{
_defaultHeaders = headers;
return this;
}
public IHttpClient Create()
{
HttpClientHandler httpclientHandler = null;
if (_cookieContainer != null)
{
httpclientHandler = new HttpClientHandler() { CookieContainer = _cookieContainer };
}
else
{
httpclientHandler = new HttpClientHandler();
}
if (httpclientHandler.SupportsAutomaticDecompression)
{
httpclientHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
}
var httpclientHandler = new HttpClientHandler();
var client = new HttpClient(CreateHttpMessageHandler(httpclientHandler));
if (_timeout.HasValue)
{
client.Timeout = _timeout.Value;
}
if (_defaultHeaders == null)
{
return new HttpClientWrapper(client);
@ -81,11 +43,18 @@ namespace Ocelot.Requester
private HttpMessageHandler CreateHttpMessageHandler(HttpMessageHandler httpMessageHandler)
{
foreach (var handler in _handlers)
_handlers
.OrderByDescending(handler => handler.Key)
.Select(handler => handler.Value)
.Reverse()
.ToList()
.ForEach(handler =>
{
handler.InnerHandler = httpMessageHandler;
httpMessageHandler = handler;
}
var delegatingHandler = handler();
delegatingHandler.InnerHandler = httpMessageHandler;
httpMessageHandler = delegatingHandler;
});
return httpMessageHandler;
}
}

31
src/Ocelot/Requester/HttpClientHttpRequester.cs
View File

@ -11,10 +11,10 @@ namespace Ocelot.Requester
{
public class HttpClientHttpRequester : IHttpRequester
{
private IHttpClientMessageCacheHandler _cacheHandlers;
private readonly IHttpClientCache _cacheHandlers;
private readonly IOcelotLogger _logger;
public HttpClientHttpRequester(IOcelotLoggerFactory loggerFactory, IHttpClientMessageCacheHandler cacheHandlers)
public HttpClientHttpRequester(IOcelotLoggerFactory loggerFactory, IHttpClientCache cacheHandlers)
{
_logger = loggerFactory.CreateLogger<HttpClientHttpRequester>();
_cacheHandlers = cacheHandlers;
@ -24,21 +24,13 @@ namespace Ocelot.Requester
{
var builder = new HttpClientBuilder();
builder.WithCookieContainer(request.CookieContainer);
var cacheKey = GetCacheKey(request, builder);
string baseUrl = $"{request.HttpRequestMessage.RequestUri.Scheme}://{request.HttpRequestMessage.RequestUri.Authority}";
if (request.IsQos)
{
builder.WithHandler(new PollyCircuitBreakingDelegatingHandler(request.QosProvider, _logger));
baseUrl = $"{baseUrl}{request.QosProvider.CircuitBreaker.CircuitBreakerPolicy.PolicyKey}";
}
IHttpClient httpClient = _cacheHandlers.Get(baseUrl);
var httpClient = _cacheHandlers.Get(cacheKey);
if (httpClient == null)
{
httpClient = builder.Create();
_cacheHandlers.Set(baseUrl, httpClient, TimeSpan.FromMinutes(30));
_cacheHandlers.Set(cacheKey, httpClient, TimeSpan.FromHours(6));
}
try
@ -62,5 +54,18 @@ namespace Ocelot.Requester
}
}
private string GetCacheKey(Request.Request request, HttpClientBuilder builder)
{
string baseUrl = $"{request.HttpRequestMessage.RequestUri.Scheme}://{request.HttpRequestMessage.RequestUri.Authority}";
if (request.IsQos)
{
builder.WithQos(request.QosProvider, _logger);
baseUrl = $"{baseUrl}{request.QosProvider.CircuitBreaker.CircuitBreakerPolicy.PolicyKey}";
}
return baseUrl;
}
}
}

21
src/Ocelot/Requester/IHttpClientBuilder.cs
View File

@ -11,28 +11,11 @@ namespace Ocelot.Requester
{
public interface IHttpClientBuilder
{
/// <summary>
/// Sets the cookie container used to store server cookies by the handler
/// </summary>
/// <param name="cookieContainer"></param>
/// <returns></returns>
IHttpClientBuilder WithCookieContainer(CookieContainer cookieContainer);
/// <summary>
/// Sets the number of milliseconds to wait before the request times out.
/// Sets a PollyCircuitBreakingDelegatingHandler .
/// </summary>
IHttpClientBuilder WithTimeout(TimeSpan timeout);
/// <summary>
/// Sets a DelegatingHandler.
/// Can be reused to set several different Handlers in a pipeline.
/// </summary>
IHttpClientBuilder WithHandler(DelegatingHandler handler);
/// <summary>
/// Sets Default HttpRequestHeaders
/// </summary>
IHttpClientBuilder WithDefaultRequestHeaders(Dictionary<string, string> headers);
IHttpClientBuilder WithQos(IQoSProvider qosProvider, IOcelotLogger logger);
/// <summary>
/// Creates the <see cref="HttpClient"/>

2
src/Ocelot/Requester/IHttpClientMessageCacheHandler.cs → src/Ocelot/Requester/IHttpClientCache.cs
View File

@ -6,7 +6,7 @@ using System.Threading.Tasks;
namespace Ocelot.Requester
{
public interface IHttpClientMessageCacheHandler
public interface IHttpClientCache
{
bool Exists(string id);
IHttpClient Get(string id);

8
src/Ocelot/Requester/MemoryHttpClientMessageCacheHandler.cs → src/Ocelot/Requester/MemoryHttpClientCache.cs
View File

@ -7,18 +7,18 @@ using System.Threading.Tasks;
namespace Ocelot.Requester
{
public class MemoryHttpClientMessageCacheHandler : IHttpClientMessageCacheHandler
public class MemoryHttpClientCache : IHttpClientCache
{
private readonly IMemoryCache _memoryCache;
public MemoryHttpClientMessageCacheHandler(IMemoryCache memoryCache)
public MemoryHttpClientCache(IMemoryCache memoryCache)
{
_memoryCache = memoryCache;
}
public void Set(string id, IHttpClient counter, TimeSpan expirationTime)
public void Set(string id, IHttpClient client, TimeSpan expirationTime)
{
_memoryCache.Set(id, counter, new MemoryCacheEntryOptions().SetAbsoluteExpiration(expirationTime));
_memoryCache.Set(id, client, new MemoryCacheEntryOptions().SetAbsoluteExpiration(expirationTime));
}
public bool Exists(string id)