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

removed some code we dont need as not expecting any errors so should just throw an exception to the global handler

Browse Source
This commit is contained in:
Tom Gardham-Pallister 2017-02-06 21:47:08 +00:00
parent a4495b8fa9
commit 0a66051b92
14 changed files with 37 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Ocelot/Errors/Middleware/ExceptionHandlerMiddleware.cs
View File

@ -41,13 +41,13 @@ namespace Ocelot.Errors.Middleware
var message = CreateMessage(context, e);
_logger.LogError(message, e);
await SetInternalServerErrorOnResponse(context);
SetInternalServerErrorOnResponse(context);
}
_logger.LogDebug("ocelot pipeline finished");
}
private async Task SetInternalServerErrorOnResponse(HttpContext context)
private void SetInternalServerErrorOnResponse(HttpContext context)
{
context.Response.OnStarting(x =>
{

2
src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancer.cs
View File

@ -8,6 +8,6 @@ namespace Ocelot.LoadBalancer.LoadBalancers
public interface ILoadBalancer
{
Task<Response<HostAndPort>> Lease();
Response Release(HostAndPort hostAndPort);
void Release(HostAndPort hostAndPort);
}
}

4
src/Ocelot/LoadBalancer/LoadBalancers/LeastConnectionLoadBalancer.cs
View File

@ -53,7 +53,7 @@ namespace Ocelot.LoadBalancer.LoadBalancers
}
}
public Response Release(HostAndPort hostAndPort)
public void Release(HostAndPort hostAndPort)
{
lock(_syncLock)
{
@ -69,8 +69,6 @@ namespace Ocelot.LoadBalancer.LoadBalancers
_leases.Add(replacementLease);
}
}
return new OkResponse();
}
private Lease AddConnection(Lease lease)

5
src/Ocelot/LoadBalancer/LoadBalancers/NoLoadBalancer.cs
View File

@ -17,13 +17,12 @@ namespace Ocelot.LoadBalancer.LoadBalancers
public async Task<Response<HostAndPort>> Lease()
{
var service = _services.FirstOrDefault();
var service = await Task.FromResult(_services.FirstOrDefault());
return new OkResponse<HostAndPort>(service.HostAndPort);
}
public Response Release(HostAndPort hostAndPort)
public void Release(HostAndPort hostAndPort)
{
return new OkResponse();
}
}
}

5
src/Ocelot/LoadBalancer/LoadBalancers/RoundRobinLoadBalancer.cs
View File

@ -22,14 +22,13 @@ namespace Ocelot.LoadBalancer.LoadBalancers
_last = 0;
}
var next = _services[_last];
var next = await Task.FromResult(_services[_last]);
_last++;
return new OkResponse<HostAndPort>(next.HostAndPort);
}
public Response Release(HostAndPort hostAndPort)
public void Release(HostAndPort hostAndPort)
{
return new OkResponse();
}
}
}

13
src/Ocelot/LoadBalancer/Middleware/LoadBalancingMiddleware.cs
View File

@ -31,14 +31,14 @@ namespace Ocelot.LoadBalancer.Middleware
{
_logger.LogDebug("started calling load balancing middleware");
var getLoadBalancer = _loadBalancerHouse.Get(DownstreamRoute.ReRoute.LoadBalancerKey);
if(getLoadBalancer.IsError)
var loadBalancer = _loadBalancerHouse.Get(DownstreamRoute.ReRoute.LoadBalancerKey);
if(loadBalancer.IsError)
{
SetPipelineError(getLoadBalancer.Errors);
SetPipelineError(loadBalancer.Errors);
return;
}
var hostAndPort = await getLoadBalancer.Data.Lease();
var hostAndPort = await loadBalancer.Data.Lease();
if(hostAndPort.IsError)
{
SetPipelineError(hostAndPort.Errors);
@ -53,11 +53,12 @@ namespace Ocelot.LoadBalancer.Middleware
{
await _next.Invoke(context);
getLoadBalancer.Data.Release(hostAndPort.Data);
loadBalancer.Data.Release(hostAndPort.Data);
}
catch (Exception)
{
getLoadBalancer.Data.Release(hostAndPort.Data);
loadBalancer.Data.Release(hostAndPort.Data);
_logger.LogDebug("error calling next middleware, exception will be thrown to global handler");
throw;
}

6
src/Ocelot/Responder/HttpContextResponder.cs
View File

@ -24,7 +24,7 @@ namespace Ocelot.Responder
_removeOutputHeaders = removeOutputHeaders;
}
public async Task<Response> SetResponseOnHttpContext(HttpContext context, HttpResponseMessage response)
public async Task SetResponseOnHttpContext(HttpContext context, HttpResponseMessage response)
{
_removeOutputHeaders.Remove(response.Headers);
@ -56,7 +56,6 @@ namespace Ocelot.Responder
{
await stream.CopyToAsync(context.Response.Body);
}
return new OkResponse();
}
private static void AddHeaderIfDoesntExist(HttpContext context, KeyValuePair<string, IEnumerable<string>> httpResponseHeader)
@ -67,14 +66,13 @@ namespace Ocelot.Responder
}
}
public async Task<Response> SetErrorResponseOnContext(HttpContext context, int statusCode)
public void SetErrorResponseOnContext(HttpContext context, int statusCode)
{
context.Response.OnStarting(x =>
{
context.Response.StatusCode = statusCode;
return Task.CompletedTask;
}, context);
return new OkResponse();
}
}
}

5
src/Ocelot/Responder/IHttpResponder.cs
View File

@ -1,13 +1,12 @@
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Ocelot.Responses;
namespace Ocelot.Responder
{
public interface IHttpResponder
{
Task<Response> SetResponseOnHttpContext(HttpContext context, HttpResponseMessage response);
Task<Response> SetErrorResponseOnContext(HttpContext context, int statusCode);
Task SetResponseOnHttpContext(HttpContext context, HttpResponseMessage response);
void SetErrorResponseOnContext(HttpContext context, int statusCode);
}
}

17
src/Ocelot/Responder/Middleware/ResponderMiddleware.cs
View File

@ -46,34 +46,27 @@ namespace Ocelot.Responder.Middleware
_logger.LogDebug("received errors setting error response");
await SetErrorResponse(context, errors);
SetErrorResponse(context, errors);
}
else
{
_logger.LogDebug("no pipeline error, setting response");
var setResponse = await _responder.SetResponseOnHttpContext(context, HttpResponseMessage);
if (setResponse.IsError)
{
_logger.LogDebug("error setting response, returning error to client");
await SetErrorResponse(context, setResponse.Errors);
}
await _responder.SetResponseOnHttpContext(context, HttpResponseMessage);
}
}
private async Task SetErrorResponse(HttpContext context, List<Error> errors)
private void SetErrorResponse(HttpContext context, List<Error> errors)
{
var statusCode = _codeMapper.Map(errors);
if (!statusCode.IsError)
{
await _responder.SetErrorResponseOnContext(context, statusCode.Data);
_responder.SetErrorResponseOnContext(context, statusCode.Data);
}
else
{
await _responder.SetErrorResponseOnContext(context, 500);
_responder.SetErrorResponseOnContext(context, 500);
}
}
}

2
src/Ocelot/ServiceDiscovery/ConfigurationServiceProvider.cs
View File

@ -15,7 +15,7 @@ namespace Ocelot.ServiceDiscovery
public async Task<List<Service>> Get()
{
return _services;
return await Task.FromResult(_services);
}
}
}

2
test/Ocelot.UnitTests/LoadBalancer/LeastConnectionTests.cs
View File

@ -51,7 +51,7 @@ namespace Ocelot.UnitTests.LoadBalancer
{
var hostAndPort = await _leastConnection.Lease();
await Task.Delay(_random.Next(1, 100));
var response = _leastConnection.Release(hostAndPort.Data);
_leastConnection.Release(hostAndPort.Data);
}
[Fact]

4
test/Ocelot.UnitTests/LoadBalancer/LoadBalancerHouseTests.cs
View File

@ -114,7 +114,7 @@ namespace Ocelot.UnitTests.LoadBalancer
throw new NotImplementedException();
}
public Response Release(HostAndPort hostAndPort)
public void Release(HostAndPort hostAndPort)
{
throw new NotImplementedException();
}
@ -127,7 +127,7 @@ namespace Ocelot.UnitTests.LoadBalancer
throw new NotImplementedException();
}
public Response Release(HostAndPort hostAndPort)
public void Release(HostAndPort hostAndPort)
{
throw new NotImplementedException();
}

9
test/Ocelot.UnitTests/LoadBalancer/LoadBalancerMiddlewareTests.cs
View File

@ -170,6 +170,15 @@ namespace Ocelot.UnitTests.LoadBalancer
.Verify(x => x.Add("OcelotMiddlewareErrors", _getLoadBalancerHouseError.Errors), Times.Once);
}
private void ThenAnErrorSayingReleaseFailedIsSetOnThePipeline()
{
_scopedRepository
.Verify(x => x.Add("OcelotMiddlewareError", true), Times.Once);
_scopedRepository
.Verify(x => x.Add("OcelotMiddlewareErrors", It.IsAny<List<Error>>()), Times.Once);
}
private void ThenAnErrorStatingHostAndPortCouldNotBeFoundIsSetOnPipeline()
{
_scopedRepository

8
test/Ocelot.UnitTests/Responder/ResponderMiddlewareTests.cs
View File

@ -62,19 +62,11 @@ namespace Ocelot.UnitTests.Responder
{
this.Given(x => x.GivenTheHttpResponseMessageIs(new HttpResponseMessage()))
.And(x => x.GivenThereAreNoPipelineErrors())
.And(x => x.GivenTheResponderReturns())
.When(x => x.WhenICallTheMiddleware())
.Then(x => x.ThenThereAreNoErrors())
.BDDfy();
}
private void GivenTheResponderReturns()
{
_responder
.Setup(x => x.SetResponseOnHttpContext(It.IsAny<HttpContext>(), It.IsAny<HttpResponseMessage>()))
.ReturnsAsync(new OkResponse());
}
private void GivenThereAreNoPipelineErrors()
{
_scopedRepository