public Response <IQoSProvider> Get(DownstreamReRoute reRoute)
{
try
{
if (_qoSProviders.TryGetValue(reRoute.QosKey, out var qosProvider))
{
if (reRoute.IsQos && qosProvider.CircuitBreaker == null)
{
qosProvider = _qoSProviderFactory.Get(reRoute);
Add(reRoute.QosKey, qosProvider);
}
return(new OkResponse <IQoSProvider>(_qoSProviders[reRoute.QosKey]));
}
qosProvider = _qoSProviderFactory.Get(reRoute);
Add(reRoute.QosKey, qosProvider);
return(new OkResponse <IQoSProvider>(qosProvider));
}
catch (Exception ex)
{
return(new ErrorResponse <IQoSProvider>(new List <Ocelot.Errors.Error>()
{
new UnableToFindQoSProviderError($"unabe to find qos provider for {reRoute.QosKey}, exception was {ex}")
}));
}
}
private void GivenThereIsALoadBalancer(DownstreamReRoute reRoute, ILoadBalancer loadBalancer)
{
_reRoute = reRoute;
_loadBalancer = loadBalancer;
_factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).ReturnsAsync(new OkResponse <ILoadBalancer>(loadBalancer));
_getResult = _loadBalancerHouse.Get(reRoute, _serviceProviderConfig).Result;
}
public async Task <Response <HttpRequestMessage> > Map(HttpRequest request, DownstreamReRoute downstreamReRoute)
{
try
{
if (!Version.TryParse(downstreamReRoute.DownstreamHttpVersion, out Version version))
{
version = new Version(1, 1);
}
var requestMessage = new HttpRequestMessage()
{
Content = await MapContent(request),
Method = MapMethod(request, downstreamReRoute),
RequestUri = MapUri(request),
Version = version,
};
MapHeaders(request, requestMessage);
return(new OkResponse <HttpRequestMessage>(requestMessage));
}
catch (Exception ex)
{
return(new ErrorResponse <HttpRequestMessage>(new UnmappableRequestError(ex)));
}
}
public Response <IDelegatingHandlerHandlerProvider> Get(DownstreamReRoute request)
{
try
{
if (_housed.TryGetValue(request.ReRouteKey, out var provider))
{
//todo once day we might need a check here to see if we need to create a new provider
provider = _housed[request.ReRouteKey];
return(new OkResponse <IDelegatingHandlerHandlerProvider>(provider));
}
//todo - unit test for this
var providerResponse = _factory.Get(request);
if (providerResponse.IsError)
{
return(new ErrorResponse <IDelegatingHandlerHandlerProvider>(providerResponse.Errors));
}
provider = providerResponse.Data;
AddHoused(request.ReRouteKey, provider);
return(new OkResponse <IDelegatingHandlerHandlerProvider>(provider));
}
catch (Exception ex)
{
return(new ErrorResponse <IDelegatingHandlerHandlerProvider>(new List <Error>()
{
new UnableToFindDelegatingHandlerProviderError($"unabe to find delegating handler provider for {request.ReRouteKey} exception is {ex}")
}));
}
}
public Response <IDelegatingHandlerHandlerProvider> Get(DownstreamReRoute request)
{
var handlersAppliedToAll = _allRoutesProvider.Get();
var provider = new DelegatingHandlerHandlerProvider();
foreach (var handler in handlersAppliedToAll)
{
provider.Add(handler);
}
if (request.HttpHandlerOptions.UseTracing)
{
provider.Add(() => (DelegatingHandler)_factory.Get());
}
if (request.IsQos)
{
var qosProvider = _qosProviderHouse.Get(request);
if (qosProvider.IsError)
{
return(new ErrorResponse <IDelegatingHandlerHandlerProvider>(qosProvider.Errors));
}
provider.Add(() => new PollyCircuitBreakingDelegatingHandler(qosProvider.Data, _loggerFactory));
}
return(new OkResponse <IDelegatingHandlerHandlerProvider>(provider));
}
public async Task <Response <ILoadBalancer> > Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
{
var response = _serviceProviderFactory.Get(config, reRoute);
if (response.IsError)
{
return(new ErrorResponse <ILoadBalancer>(response.Errors));
}
var serviceProvider = response.Data;
switch (reRoute.LoadBalancerOptions?.Type)
{
case nameof(RoundRobin):
return(new OkResponse <ILoadBalancer>(new RoundRobin(async() => await serviceProvider.Get())));
case nameof(LeastConnection):
return(new OkResponse <ILoadBalancer>(new LeastConnection(async() => await serviceProvider.Get(), reRoute.ServiceName)));
case nameof(CookieStickySessions):
var loadBalancer = new RoundRobin(async() => await serviceProvider.Get());
var bus = new InMemoryBus <StickySession>();
return(new OkResponse <ILoadBalancer>(new CookieStickySessions(loadBalancer, reRoute.LoadBalancerOptions.Key, reRoute.LoadBalancerOptions.ExpiryInMs, bus)));
default:
return(new OkResponse <ILoadBalancer>(new NoLoadBalancer(async() => await serviceProvider.Get())));
}
}
private void GivenARequest()
{
var reRoute = new DownstreamReRouteBuilder().WithIsQos(false)
.WithHttpHandlerOptions(new HttpHandlerOptions(false, false, false)).WithReRouteKey("").Build();
_request = reRoute;
}
public IHttpClient Create(DownstreamContext context)
{
_cacheKey = context.DownstreamReRoute;
var httpClient = _cacheHandlers.Get(_cacheKey);
if (httpClient != null)
{
_client = httpClient;
return(httpClient);
}
var handler = CreateHandler(context);
if (context.DownstreamReRoute.DangerousAcceptAnyServerCertificateValidator)
{
handler.ServerCertificateCustomValidationCallback = (request, certificate, chain, errors) => true;
_logger
.LogWarning($"You have ignored all SSL warnings by using DangerousAcceptAnyServerCertificateValidator for this DownstreamReRoute, UpstreamPathTemplate: {context.DownstreamReRoute.UpstreamPathTemplate}, DownstreamPathTemplate: {context.DownstreamReRoute.DownstreamPathTemplate}");
}
var timeout = context.DownstreamReRoute.QosOptions.TimeoutValue == 0
? _defaultTimeout
: TimeSpan.FromMilliseconds(context.DownstreamReRoute.QosOptions.TimeoutValue);
_httpClient = new HttpClient(CreateHttpMessageHandler(handler, context.DownstreamReRoute))
{
Timeout = timeout
};
_client = new HttpClientWrapper(_httpClient);
return(_client);
}
public Response<ILoadBalancer> Create(DownstreamReRoute reRoute, IServiceDiscoveryProvider serviceProvider)
{
var loadBalancer = new RoundRobin(async () => await serviceProvider.Get());
var bus = new InMemoryBus<StickySession>();
return new OkResponse<ILoadBalancer>(new CookieStickySessions(loadBalancer, reRoute.LoadBalancerOptions.Key,
reRoute.LoadBalancerOptions.ExpiryInMs, bus));
}
public void SetUp()
{
_downstreamReRouteKey = new DownstreamReRouteBuilder().Build();
_stringKey = "test";
_client = new HttpClientWrapper(new HttpClient());
_downstreamReRouteDictionary = new ConcurrentDictionary <DownstreamReRoute, IHttpClient>();
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_downstreamReRouteDictionary.TryAdd(new DownstreamReRouteBuilder().Build(), new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary = new ConcurrentDictionary <string, IHttpClient>();
_stringReRouteDictionary.TryAdd("1", new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary.TryAdd("2", new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary.TryAdd("3", new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary.TryAdd("4", new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary.TryAdd("5", new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary.TryAdd("6", new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary.TryAdd("7", new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary.TryAdd("8", new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary.TryAdd("9", new HttpClientWrapper(new HttpClient()));
_stringReRouteDictionary.TryAdd("10", new HttpClientWrapper(new HttpClient()));
}
public PollyQoSProvider(DownstreamReRoute reRoute, IOcelotLoggerFactory loggerFactory)
{
_logger = loggerFactory.CreateLogger <PollyQoSProvider>();
_timeoutPolicy = Policy.TimeoutAsync(TimeSpan.FromMilliseconds(reRoute.QosOptionsOptions.TimeoutValue), reRoute.QosOptionsOptions.TimeoutStrategy);
_circuitBreakerPolicy = Policy
.Handle <HttpRequestException>()
.Or <TimeoutRejectedException>()
.Or <TimeoutException>()
.CircuitBreakerAsync(
exceptionsAllowedBeforeBreaking: reRoute.QosOptionsOptions.ExceptionsAllowedBeforeBreaking,
durationOfBreak: TimeSpan.FromMilliseconds(reRoute.QosOptionsOptions.DurationOfBreak),
onBreak: (ex, breakDelay) =>
{
_logger.LogError(
".Breaker logging: Breaking the circuit for " + breakDelay.TotalMilliseconds + "ms!", ex);
},
onReset: () =>
{
_logger.LogDebug(".Breaker logging: Call ok! Closed the circuit again.");
},
onHalfOpen: () =>
{
_logger.LogDebug(".Breaker logging: Half-open; next call is a trial.");
}
);
_circuitBreaker = new CircuitBreaker(_circuitBreakerPolicy, _timeoutPolicy);
}
public async Task <Response <ILoadBalancer> > Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
{
try
{
if (_loadBalancers.TryGetValue(reRoute.ReRouteKey, out var loadBalancer))
{
loadBalancer = _loadBalancers[reRoute.ReRouteKey];
if (reRoute.LoadBalancer != loadBalancer.GetType().Name)
{
loadBalancer = await _factory.Get(reRoute, config);
AddLoadBalancer(reRoute.ReRouteKey, loadBalancer);
}
return(new OkResponse <ILoadBalancer>(loadBalancer));
}
loadBalancer = await _factory.Get(reRoute, config);
AddLoadBalancer(reRoute.ReRouteKey, loadBalancer);
return(new OkResponse <ILoadBalancer>(loadBalancer));
}
catch (Exception ex)
{
return(new ErrorResponse <ILoadBalancer>(new List <Ocelot.Errors.Error>()
{
new UnableToFindLoadBalancerError($"unabe to find load balancer for {reRoute.ReRouteKey} exception is {ex}")
}));
}
}
private void GivenThereIsAQoSProvider(DownstreamReRoute reRoute, IQoSProvider qoSProvider)
{
_reRoute = reRoute;
_qoSProvider = qoSProvider;
_factory.Setup(x => x.Get(_reRoute)).Returns(_qoSProvider);
_getResult = _qosProviderHouse.Get(reRoute);
}
public Response <ILoadBalancer> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
{
var serviceProviderFactoryResponse = _serviceProviderFactory.Get(config, reRoute);
if (serviceProviderFactoryResponse.IsError)
{
return(new ErrorResponse <ILoadBalancer>(serviceProviderFactoryResponse.Errors));
}
var serviceProvider = serviceProviderFactoryResponse.Data;
var requestedType = reRoute.LoadBalancerOptions?.Type ?? nameof(NoLoadBalancer);
var applicableCreator = _loadBalancerCreators.SingleOrDefault(c => c.Type == requestedType);
if (applicableCreator == null)
{
return(new ErrorResponse <ILoadBalancer>(new CouldNotFindLoadBalancerCreator($"Could not find load balancer creator for Type: {requestedType}, please check your config specified the correct load balancer and that you have registered a class with the same name.")));
}
var createdLoadBalancerResponse = applicableCreator.Create(reRoute, serviceProvider);
if (createdLoadBalancerResponse.IsError)
{
return(new ErrorResponse <ILoadBalancer>(createdLoadBalancerResponse.Errors));
}
return(new OkResponse <ILoadBalancer>(createdLoadBalancerResponse.Data));
}
public IQoSProvider Get(DownstreamReRoute reRoute)
{
if (reRoute.QosOptions.UseQos)
{
return(new PollyQoSProvider(reRoute, _loggerFactory));
}
return(new NoQoSProvider());
}
private HttpMethod MapMethod(HttpRequest request, DownstreamReRoute downstreamReRoute)
{
if (!string.IsNullOrEmpty(downstreamReRoute?.DownstreamHttpMethod))
{
return(new HttpMethod(downstreamReRoute.DownstreamHttpMethod));
}
return(new HttpMethod(request.Method));
}
public Response <List <Func <DelegatingHandler> > > Get(DownstreamReRoute downstreamReRoute)
{
var globalDelegatingHandlers = _serviceProvider
.GetServices <GlobalDelegatingHandler>()
.ToList();
var reRouteSpecificHandlers = _serviceProvider
.GetServices <DelegatingHandler>()
.ToList();
var handlers = new List <Func <DelegatingHandler> >();
foreach (var handler in globalDelegatingHandlers)
{
if (GlobalIsInHandlersConfig(downstreamReRoute, handler))
{
reRouteSpecificHandlers.Add(handler.DelegatingHandler);
}
else
{
handlers.Add(() => handler.DelegatingHandler);
}
}
if (downstreamReRoute.DelegatingHandlers.Any())
{
var sorted = SortByConfigOrder(downstreamReRoute, reRouteSpecificHandlers);
foreach (var handler in sorted)
{
handlers.Add(() => handler);
}
}
if (downstreamReRoute.HttpHandlerOptions.UseTracing)
{
handlers.Add(() => (DelegatingHandler)_tracingFactory.Get());
}
if (downstreamReRoute.QosOptions.UseQos)
{
var handler = _qoSFactory.Get(downstreamReRoute);
if (handler != null && !handler.IsError)
{
handlers.Add(() => handler.Data);
}
else
{
_logger.LogWarning($"ReRoute {downstreamReRoute.UpstreamPathTemplate} specifies use QoS but no QosHandler found in DI container. Will use not use a QosHandler, please check your setup!");
handlers.Add(() => new NoQosDelegatingHandler());
}
}
return(new OkResponse <List <Func <DelegatingHandler> > >(handlers));
}
public IHttpClient Create(DownstreamReRoute request)
{
var httpclientHandler = new HttpClientHandler {
AllowAutoRedirect = request.HttpHandlerOptions.AllowAutoRedirect, UseCookies = request.HttpHandlerOptions.UseCookieContainer
};
var client = new HttpClient(CreateHttpMessageHandler(httpclientHandler, request));
return(new HttpClientWrapper(client));
}
public Response <List <Func <DelegatingHandler> > > Get(DownstreamReRoute request)
{
var globalDelegatingHandlers = _serviceProvider
.GetServices <GlobalDelegatingHandler>()
.ToList();
var reRouteSpecificHandlers = _serviceProvider
.GetServices <DelegatingHandler>()
.ToList();
var handlers = new List <Func <DelegatingHandler> >();
foreach (var handler in globalDelegatingHandlers)
{
if (GlobalIsInHandlersConfig(request, handler))
{
reRouteSpecificHandlers.Add(handler.DelegatingHandler);
}
else
{
handlers.Add(() => handler.DelegatingHandler);
}
}
if (request.DelegatingHandlers.Any())
{
var sorted = SortByConfigOrder(request, reRouteSpecificHandlers);
foreach (var handler in sorted)
{
handlers.Add(() => handler);
}
}
if (request.HttpHandlerOptions.UseTracing)
{
handlers.Add(() => (DelegatingHandler)_tracingFactory.Get());
}
if (request.QosOptions.UseQos)
{
var handler = _qoSFactory.Get(request);
if (handler != null && !handler.IsError)
{
handlers.Add(() => handler.Data);
}
else
{
return(new ErrorResponse <List <Func <DelegatingHandler> > >(handler?.Errors));
}
}
return(new OkResponse <List <Func <DelegatingHandler> > >(handlers));
}
public Response <DelegatingHandler> Get(DownstreamReRoute request)
{
var handler = _serviceProvider.GetService <QosDelegatingHandlerDelegate>();
if (handler != null)
{
return(new OkResponse <DelegatingHandler>(handler(request, _ocelotLoggerFactory)));
}
return(new ErrorResponse <DelegatingHandler>(new UnableToFindQoSProviderError($"could not find qosProvider for {request.DownstreamScheme}{request.DownstreamAddresses}{request.DownstreamDownstreamPathTemplate}")));
}
private List <DelegatingHandler> SortByConfigOrder(DownstreamReRoute request, List <DelegatingHandler> reRouteSpecificHandlers)
{
return(reRouteSpecificHandlers
.Where(x => request.DelegatingHandlers.Contains(x.GetType().Name))
.OrderBy(d =>
{
var type = d.GetType().Name;
var pos = request.DelegatingHandlers.IndexOf(type);
return pos;
}).ToList());
}
public Response <ILoadBalancer> Create(DownstreamReRoute reRoute, IServiceDiscoveryProvider serviceProvider)
{
try
{
return(new OkResponse <ILoadBalancer>(_creatorFunc(reRoute, serviceProvider)));
}
catch (Exception e)
{
return(new ErrorResponse <ILoadBalancer>(new ErrorInvokingLoadBalancerCreator(e)));
}
}
public Response <List <Func <DelegatingHandler> > > Get(DownstreamReRoute request)
{
var globalDelegatingHandlers = _serviceProvider
.GetServices <GlobalDelegatingHandler>()
.ToList();
var reRouteSpecificHandlers = _serviceProvider
.GetServices <DelegatingHandler>()
.ToList();
var handlers = new List <Func <DelegatingHandler> >();
foreach (var handler in globalDelegatingHandlers)
{
if (GlobalIsInHandlersConfig(request, handler))
{
reRouteSpecificHandlers.Add(handler.DelegatingHandler);
}
else
{
handlers.Add(() => handler.DelegatingHandler);
}
}
if (request.DelegatingHandlers.Any())
{
var sorted = SortByConfigOrder(request, reRouteSpecificHandlers);
foreach (var handler in sorted)
{
handlers.Add(() => handler);
}
}
if (request.HttpHandlerOptions.UseTracing)
{
handlers.Add(() => (DelegatingHandler)_factory.Get());
}
if (request.IsQos)
{
var qosProvider = _qosProviderHouse.Get(request);
if (qosProvider.IsError)
{
return(new ErrorResponse <List <Func <DelegatingHandler> > >(qosProvider.Errors));
}
handlers.Add(() => new PollyCircuitBreakingDelegatingHandler(qosProvider.Data, _loggerFactory));
}
return(new OkResponse <List <Func <DelegatingHandler> > >(handlers));
}
private ReRoute SetUpReRoute(FileReRoute fileReRoute, DownstreamReRoute downstreamReRoutes)
{
var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(fileReRoute);
var reRoute = new ReRouteBuilder()
.WithUpstreamHttpMethod(fileReRoute.UpstreamHttpMethod)
.WithUpstreamPathTemplate(upstreamTemplatePattern)
.WithDownstreamReRoute(downstreamReRoutes)
.WithUpstreamHost(fileReRoute.UpstreamHost)
.Build();
return(reRoute);
}
private void GivenARequest(DownstreamReRoute downstream)
{
var context = new DownstreamContext(new DefaultHttpContext())
{
DownstreamReRoute = downstream,
DownstreamRequest = new DownstreamRequest(new HttpRequestMessage()
{
RequestUri = new Uri("http://localhost:5003")
}),
};
_context = context;
}
private void GivenARequestWithAUrlAndMethod(DownstreamReRoute downstream, string url, HttpMethod method)
{
var context = new DownstreamContext(new DefaultHttpContext())
{
DownstreamReRoute = downstream,
DownstreamRequest = new DownstreamRequest(new HttpRequestMessage()
{
RequestUri = new Uri(url), Method = method
}),
};
_context = context;
}
public async Task <ILoadBalancer> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
{
var serviceProvider = _serviceProviderFactory.Get(config, reRoute);
switch (reRoute.LoadBalancer)
{
case "RoundRobin":
return(new RoundRobin(async() => await serviceProvider.Get()));
case "LeastConnection":
return(new LeastConnection(async() => await serviceProvider.Get(), reRoute.ServiceName));
default:
return(new NoLoadBalancer(await serviceProvider.Get()));
}
}
public Response <ILoadBalancer> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
{
try
{
Response <ILoadBalancer> result;
if (_loadBalancers.TryGetValue(reRoute.LoadBalancerKey, out var loadBalancer))
{
loadBalancer = _loadBalancers[reRoute.LoadBalancerKey];
if (reRoute.LoadBalancerOptions.Type != loadBalancer.GetType().Name)
{
result = _factory.Get(reRoute, config);
if (result.IsError)
{
return(new ErrorResponse <ILoadBalancer>(result.Errors));
}
loadBalancer = result.Data;
AddLoadBalancer(reRoute.LoadBalancerKey, loadBalancer);
}
return(new OkResponse <ILoadBalancer>(loadBalancer));
}
result = _factory.Get(reRoute, config);
if (result.IsError)
{
return(new ErrorResponse <ILoadBalancer>(result.Errors));
}
loadBalancer = result.Data;
AddLoadBalancer(reRoute.LoadBalancerKey, loadBalancer);
return(new OkResponse <ILoadBalancer>(loadBalancer));
}
catch (Exception ex)
{
return(new ErrorResponse <ILoadBalancer>(new List <Ocelot.Errors.Error>()
{
new UnableToFindLoadBalancerError($"unabe to find load balancer for {reRoute.LoadBalancerKey} exception is {ex}"),
}));
}
}
public async Task <ILoadBalancer> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
{
var serviceProvider = _serviceProviderFactory.Get(config, reRoute);
switch (reRoute.LoadBalancerOptions?.Type)
{
case nameof(RoundRobin):
return(new RoundRobin(async() => await serviceProvider.Get()));
case nameof(LeastConnection):
return(new LeastConnection(async() => await serviceProvider.Get(), reRoute.ServiceName));
case nameof(CookieStickySessions):
var loadBalancer = new RoundRobin(async() => await serviceProvider.Get());
return(new CookieStickySessions(loadBalancer, reRoute.LoadBalancerOptions.Key, reRoute.LoadBalancerOptions.ExpiryInMs));
default:
return(new NoLoadBalancer(await serviceProvider.Get()));
}
}
public async Task <Response <HttpRequestMessage> > Map(HttpRequest request, DownstreamReRoute downstreamReRoute)
{
try
{
var requestMessage = new HttpRequestMessage()
{
Content = await MapContent(request),
Method = MapMethod(request, downstreamReRoute),
RequestUri = MapUri(request)
};
MapHeaders(request, requestMessage);
return(new OkResponse <HttpRequestMessage>(requestMessage));
}
catch (Exception ex)
{
return(new ErrorResponse <HttpRequestMessage>(new UnmappableRequestError(ex)));
}
}
