tk/Ocelot
1
0
Fork 0
mirror of https://github.com/nsnail/Ocelot.git synced 2025-04-22 06:22: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); var message = CreateMessage(context, e);
_logger.LogError(message, e); _logger.LogError(message, e);
await SetInternalServerErrorOnResponse(context); SetInternalServerErrorOnResponse(context);
} }
_logger.LogDebug("ocelot pipeline finished"); _logger.LogDebug("ocelot pipeline finished");
} }
private async Task SetInternalServerErrorOnResponse(HttpContext context) private void SetInternalServerErrorOnResponse(HttpContext context)
{ {
context.Response.OnStarting(x => context.Response.OnStarting(x =>
{ {

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

@ -8,6 +8,6 @@ namespace Ocelot.LoadBalancer.LoadBalancers
public interface ILoadBalancer public interface ILoadBalancer
{ {
Task<Response<HostAndPort>> Lease(); 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) lock(_syncLock)
{ {
@ -69,8 +69,6 @@ namespace Ocelot.LoadBalancer.LoadBalancers
_leases.Add(replacementLease); _leases.Add(replacementLease);
} }
} }
return new OkResponse();
} }
private Lease AddConnection(Lease lease) 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() public async Task<Response<HostAndPort>> Lease()
{ {
var service = _services.FirstOrDefault(); var service = await Task.FromResult(_services.FirstOrDefault());
return new OkResponse<HostAndPort>(service.HostAndPort); 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; _last = 0;
} }
var next = _services[_last]; var next = await Task.FromResult(_services[_last]);
_last++; _last++;
return new OkResponse<HostAndPort>(next.HostAndPort); 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"); _logger.LogDebug("started calling load balancing middleware");
var getLoadBalancer = _loadBalancerHouse.Get(DownstreamRoute.ReRoute.LoadBalancerKey); var loadBalancer = _loadBalancerHouse.Get(DownstreamRoute.ReRoute.LoadBalancerKey);
if(getLoadBalancer.IsError) if(loadBalancer.IsError)
{ {
SetPipelineError(getLoadBalancer.Errors); SetPipelineError(loadBalancer.Errors);
return; return;
} }
var hostAndPort = await getLoadBalancer.Data.Lease(); var hostAndPort = await loadBalancer.Data.Lease();
if(hostAndPort.IsError) if(hostAndPort.IsError)
{ {
SetPipelineError(hostAndPort.Errors); SetPipelineError(hostAndPort.Errors);
@ -53,11 +53,12 @@ namespace Ocelot.LoadBalancer.Middleware
{ {
await _next.Invoke(context); await _next.Invoke(context);
getLoadBalancer.Data.Release(hostAndPort.Data); loadBalancer.Data.Release(hostAndPort.Data);
} }
catch (Exception) 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"); _logger.LogDebug("error calling next middleware, exception will be thrown to global handler");
throw; throw;
} }

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

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

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

@ -1,13 +1,12 @@
using System.Net.Http; using System.Net.Http;
using System.Threading.Tasks; using System.Threading.Tasks;
using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http;
using Ocelot.Responses;
namespace Ocelot.Responder namespace Ocelot.Responder
{ {
public interface IHttpResponder public interface IHttpResponder
{ {
Task<Response> SetResponseOnHttpContext(HttpContext context, HttpResponseMessage response); Task SetResponseOnHttpContext(HttpContext context, HttpResponseMessage response);
Task<Response> SetErrorResponseOnContext(HttpContext context, int statusCode); 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"); _logger.LogDebug("received errors setting error response");
await SetErrorResponse(context, errors); SetErrorResponse(context, errors);
} }
else else
{ {
_logger.LogDebug("no pipeline error, setting response"); _logger.LogDebug("no pipeline error, setting response");
var setResponse = await _responder.SetResponseOnHttpContext(context, HttpResponseMessage); await _responder.SetResponseOnHttpContext(context, HttpResponseMessage);
if (setResponse.IsError)
{
_logger.LogDebug("error setting response, returning error to client");
await SetErrorResponse(context, setResponse.Errors);
}
} }
} }
private async Task SetErrorResponse(HttpContext context, List<Error> errors) private void SetErrorResponse(HttpContext context, List<Error> errors)
{ {
var statusCode = _codeMapper.Map(errors); var statusCode = _codeMapper.Map(errors);
if (!statusCode.IsError) if (!statusCode.IsError)
{ {
await _responder.SetErrorResponseOnContext(context, statusCode.Data); _responder.SetErrorResponseOnContext(context, statusCode.Data);
} }
else 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() 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(); var hostAndPort = await _leastConnection.Lease();
await Task.Delay(_random.Next(1, 100)); await Task.Delay(_random.Next(1, 100));
var response = _leastConnection.Release(hostAndPort.Data); _leastConnection.Release(hostAndPort.Data);
} }
[Fact] [Fact]

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

@ -114,7 +114,7 @@ namespace Ocelot.UnitTests.LoadBalancer
throw new NotImplementedException(); throw new NotImplementedException();
} }
public Response Release(HostAndPort hostAndPort) public void Release(HostAndPort hostAndPort)
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
@ -127,7 +127,7 @@ namespace Ocelot.UnitTests.LoadBalancer
throw new NotImplementedException(); throw new NotImplementedException();
} }
public Response Release(HostAndPort hostAndPort) public void Release(HostAndPort hostAndPort)
{ {
throw new NotImplementedException(); 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); .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() private void ThenAnErrorStatingHostAndPortCouldNotBeFoundIsSetOnPipeline()
{ {
_scopedRepository _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())) this.Given(x => x.GivenTheHttpResponseMessageIs(new HttpResponseMessage()))
.And(x => x.GivenThereAreNoPipelineErrors()) .And(x => x.GivenThereAreNoPipelineErrors())
.And(x => x.GivenTheResponderReturns())
.When(x => x.WhenICallTheMiddleware()) .When(x => x.WhenICallTheMiddleware())
.Then(x => x.ThenThereAreNoErrors()) .Then(x => x.ThenThereAreNoErrors())
.BDDfy(); .BDDfy();
} }
private void GivenTheResponderReturns()
{
_responder
.Setup(x => x.SetResponseOnHttpContext(It.IsAny<HttpContext>(), It.IsAny<HttpResponseMessage>()))
.ReturnsAsync(new OkResponse());
}
private void GivenThereAreNoPipelineErrors() private void GivenThereAreNoPipelineErrors()
{ {
_scopedRepository _scopedRepository