protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
try
{
IAsyncPolicy policy;
if (_qoSProvider.CircuitBreaker.Policies.Length == 1)
{
policy = _qoSProvider.CircuitBreaker.Policies[0];
}
else
{
policy = Policy.WrapAsync(_qoSProvider.CircuitBreaker.Policies);
}
return(await policy.ExecuteAsync(() => base.SendAsync(request, cancellationToken)));
}
catch (BrokenCircuitException ex)
{
_logger.LogError($"Reached to allowed number of exceptions. Circuit is open", ex);
throw;
}
catch (HttpRequestException ex)
{
_logger.LogError($"Error in CircuitBreakingDelegatingHandler.SendAync", ex);
throw;
}
}
public async Task Invoke(HttpContext context)
{
var upstreamUrlPath = context.Request.Path.ToString();
//todo make this getting config its own middleware one day?
var configuration = await _configProvider.Get();
if (configuration.IsError)
{
_logger.LogError($"{MiddlewareName} setting pipeline errors. IOcelotConfigurationProvider returned {configuration.Errors.ToErrorString()}");
SetPipelineError(configuration.Errors);
}
SetServiceProviderConfigurationForThisRequest(configuration.Data.ServiceProviderConfiguration);
_logger.LogDebug("upstream url path is {upstreamUrlPath}", upstreamUrlPath);
var downstreamRoute = _downstreamRouteFinder.FindDownstreamRoute(upstreamUrlPath, context.Request.Method, configuration.Data);
if (downstreamRoute.IsError)
{
_logger.LogError($"{MiddlewareName} setting pipeline errors. IDownstreamRouteFinder returned {downstreamRoute.Errors.ToErrorString()}");
SetPipelineError(downstreamRoute.Errors);
return;
}
_logger.LogDebug("downstream template is {downstreamRoute.Data.ReRoute.DownstreamPath}", downstreamRoute.Data.ReRoute.DownstreamPathTemplate);
SetDownstreamRouteForThisRequest(downstreamRoute.Data);
await _next.Invoke(context);
}
public async Task Invoke(HttpContext context)
{
_logger.TraceMiddlewareEntry();
if (IsAuthenticatedRoute(DownstreamRoute.ReRoute))
{
_logger.LogDebug($"{context.Request.Path} is an authenticated route. {MiddlwareName} checking if client is authenticated");
var authenticationHandler = _authHandlerFactory.Get(_app, DownstreamRoute.ReRoute.AuthenticationOptions);
if (authenticationHandler.IsError)
{
_logger.LogError($"Error getting authentication handler for {context.Request.Path}. {authenticationHandler.Errors.ToErrorString()}");
SetPipelineError(authenticationHandler.Errors);
_logger.TraceMiddlewareCompleted();
return;
}
await authenticationHandler.Data.Handler.Handle(context);
if (context.User.Identity.IsAuthenticated)
{
_logger.LogDebug($"Client has been authenticated for {context.Request.Path}");
_logger.TraceInvokeNext();
await _next.Invoke(context);
_logger.TraceInvokeNextCompleted();
_logger.TraceMiddlewareCompleted();
}
else
{
var error = new List <Error>
{
new UnauthenticatedError(
$"Request for authenticated route {context.Request.Path} by {context.User.Identity.Name} was unauthenticated")
};
_logger.LogError($"Client has NOT been authenticated for {context.Request.Path} and pipeline error set. {error.ToErrorString()}");
SetPipelineError(error);
_logger.TraceMiddlewareCompleted();
return;
}
}
else
{
_logger.LogTrace($"No authentication needed for {context.Request.Path}");
_logger.TraceInvokeNext();
await _next.Invoke(context);
_logger.TraceInvokeNextCompleted();
_logger.TraceMiddlewareCompleted();
}
}
public async Task <List <Service> > Get()
{
// 如果Consul有问题会导致网关异常
//var queryResult = await _consul.Health.Service(_config.KeyOfServiceInConsul, string.Empty, true);
if (_config.KeyOfServiceInConsul == string.Empty)
{
return(new List <Service>());
}
QueryResult <ServiceEntry[]> queryResult = new QueryResult <ServiceEntry[]>();
try
{
queryResult = await _consul.Health.Service(_config.KeyOfServiceInConsul, string.Empty, true);
}
catch (Exception ex)
{
_logger.LogError($"_consul.Health.Service异常{_config.KeyOfServiceInConsul}", ex);
return(await GetServiceFromCache(_config.KeyOfServiceInConsul));
}
var services = new List <Service>();
foreach (var serviceEntry in queryResult.Response)
{
if (IsValid(serviceEntry))
{
try
{
var nodes = await _consul.Catalog.Nodes();
if (nodes.Response == null)
{
services.Add(BuildService(serviceEntry, null));
}
else
{
var serviceNode = nodes.Response.FirstOrDefault(n => n.Address == serviceEntry.Service.Address);
services.Add(BuildService(serviceEntry, serviceNode));
}
}
catch (Exception ex)
{
_logger.LogError($"_consul.Catalog.Nodes异常{serviceEntry.Service}", ex);
return(await GetServiceFromCache(_config.KeyOfServiceInConsul));
}
}
else
{
_logger.LogWarning($"Unable to use service Address: {serviceEntry.Service.Address} and Port: {serviceEntry.Service.Port} as it is invalid. Address must contain host only e.g. localhost and port must be greater than 0");
}
}
await ServiceToCache(_config.KeyOfServiceInConsul, services);
return(services.ToList());
}
public PollyQoSProvider(ReRoute 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 Invoke(DownstreamContext context)
{
if (IsAuthenticatedRoute(context.DownstreamReRoute))
{
_logger.LogDebug($"{context.HttpContext.Request.Path} is an authenticated route. {MiddlewareName} checking if client is authenticated");
var result = await context.HttpContext.AuthenticateAsync(context.DownstreamReRoute.AuthenticationOptions.AuthenticationProviderKey);
context.HttpContext.User = result.Principal;
if (context.HttpContext.User.Identity.IsAuthenticated)
{
_logger.LogDebug($"Client has been authenticated for {context.HttpContext.Request.Path}");
await _next.Invoke(context);
}
else
{
var error = new List <Error>
{
new UnauthenticatedError(
$"Request for authenticated route {context.HttpContext.Request.Path} by {context.HttpContext.User.Identity.Name} was unauthenticated")
};
_logger.LogError($"Client has NOT been authenticated for {context.HttpContext.Request.Path} and pipeline error set. {error.ToErrorString()}");
SetPipelineError(context, error);
}
}
else
{
_logger.LogTrace($"No authentication needed for {context.HttpContext.Request.Path}");
await _next.Invoke(context);
}
}
public async Task <IActionResult> Command()
{
try
{
using (var reader = new StreamReader(HttpContext.Request.Body))
{
var json = await reader.ReadToEndAsync();
var command = JsonConvert.DeserializeObject <ICommand>(json, _jsonSerialiserSettings);
_logger.LogDebug($"{_baseSchemeUrlAndPort}/command called, my state is {_node.State.GetType().FullName}");
var commandResponse = await _node.Accept(command);
json = JsonConvert.SerializeObject(commandResponse, _jsonSerialiserSettings);
return(StatusCode(200, json));
}
}
catch (Exception e)
{
_logger.LogError($"THERE WAS A PROBLEM ON NODE {_node.State.CurrentState.Id}", e);
throw;
}
}
public async Task Invoke(HttpContext context)
{
_logger.TraceMiddlewareEntry();
var upstreamUrlPath = context.Request.Path.ToString().SetLastCharacterAs('/');
_logger.LogDebug("upstream url path is {upstreamUrlPath}", upstreamUrlPath);
var downstreamRoute = await _downstreamRouteFinder.FindDownstreamRoute(upstreamUrlPath, context.Request.Method);
if (downstreamRoute.IsError)
{
_logger.LogError($"{MiddlwareName} setting pipeline errors. IDownstreamRouteFinder returned {downstreamRoute.Errors.ToErrorString()}");
SetPipelineError(downstreamRoute.Errors);
_logger.TraceMiddlewareCompleted();
return;
}
_logger.LogDebug("downstream template is {downstreamRoute.Data.ReRoute.DownstreamPath}", downstreamRoute.Data.ReRoute.DownstreamPathTemplate);
SetDownstreamRouteForThisRequest(downstreamRoute.Data);
_logger.TraceInvokeNext();
await _next.Invoke(context);
_logger.TraceInvokeNextCompleted();
_logger.TraceMiddlewareCompleted();
}
private IClusterClient ConnectClient(string serviceName, IClusterClient client)
{
int attempt = 0;
while (true)
{
try
{
client.Connect().Wait();
_logger.LogDebug($"Connection {serviceName} Sucess...");
return(client);
}
catch (Exception ex)
{
_logger.LogError($"Connection {serviceName} Faile...", ex);
attempt++;
if (attempt <= this._options.InitializeAttemptsBeforeFailing)
{
_logger.LogDebug($"Attempt {attempt} of " + this._options.InitializeAttemptsBeforeFailing + " failed to initialize the Orleans client.");
Task.Delay(TimeSpan.FromSeconds(4)).Wait();
continue;
}
throw new OrleansConnectionFailedException($"Connection {serviceName} Faile...");
}
}
}
/// <summary>
/// Used: https://stackoverflow.com/a/40256772
/// </summary>
/// <returns></returns>
public async Task Discover(IEnumerable <string> serviceNames)
{
if (!_options.ResolveClientsOnStartup)
{
return;
}
try
{
foreach (var serviceName in serviceNames?.Distinct())
{
_logger.LogInformation($"Resolving service: '{serviceName}'.");
var serviceNameUri = ServiceFabricUriBuilder.Build(serviceName);
var partitions = await _fabricClient.QueryManager.GetPartitionListAsync(serviceNameUri);
foreach (var partition in partitions)
{
_logger.LogInformation($"Discovered service partition: '{partition.PartitionInformation.Kind}':'{partition.PartitionInformation.Id}'");
var key = partition.PartitionInformation.Kind switch
{
ServicePartitionKind.Singleton => ServicePartitionKey.Singleton,
_ => throw new ArgumentOutOfRangeException($"Partitionkind: '{partition.PartitionInformation.Kind}' unknown."),
};
try
{
var resolved = await _servicePartitionResolver.ResolveAsync(serviceNameUri, key, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), CancellationToken.None);
foreach (var endpoint in resolved.Endpoints)
{
_logger.LogInformation($"Discovered service endpoint: '{endpoint.Address}'");
}
}
catch (Exception ex)
{
_logger.LogError($"Could not resolve service: '{serviceNameUri}'.", ex);
}
}
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
try
{
return(await Policy
.WrapAsync(_qoSProvider.CircuitBreaker.CircuitBreakerPolicy, _qoSProvider.CircuitBreaker.TimeoutPolicy)
.ExecuteAsync(() => base.SendAsync(request, cancellationToken)));
}
catch (BrokenCircuitException ex)
{
_logger.LogError($"Reached to allowed number of exceptions. Circuit is open", ex);
throw;
}
catch (HttpRequestException ex)
{
_logger.LogError($"Error in CircuitBreakingDelegatingHandler.SendAync", ex);
throw;
}
}
public HeaderTransformations Create(FileReRoute fileReRoute)
{
var upstream = new List <HeaderFindAndReplace>();
foreach (var input in fileReRoute.UpstreamHeaderTransform)
{
var hAndr = Map(input);
if (!hAndr.IsError)
{
upstream.Add(hAndr.Data);
}
else
{
_logger.LogError($"Unable to add UpstreamHeaderTransform {input.Key}: {input.Value}");
}
}
var downstream = new List <HeaderFindAndReplace>();
var addHeadersToDownstream = new List <AddHeader>();
foreach (var input in fileReRoute.DownstreamHeaderTransform)
{
if (input.Value.Contains(","))
{
var hAndr = Map(input);
if (!hAndr.IsError)
{
downstream.Add(hAndr.Data);
}
else
{
_logger.LogError($"Unable to add DownstreamHeaderTransform {input.Key}: {input.Value}");
}
}
else
{
addHeadersToDownstream.Add(new AddHeader(input.Key, input.Value));
}
}
return(new HeaderTransformations(upstream, downstream, addHeadersToDownstream));
}
public async Task Invoke(DownstreamContext context)
{
await _next.Invoke(context);
if (context.IsError)
{
var errors = context.Errors;
_logger.LogError($"{errors.Count} pipeline errors found in {MiddlewareName}. Setting error response status code");
foreach (var error in errors)
{
_logger.LogError(error.Message);
}
SetErrorResponse(context.HttpContext, errors);
}
else
{
_logger.LogDebug("no pipeline errors, setting and returning completed response");
await _responder.SetResponseOnHttpContext(context.HttpContext, context.DownstreamResponse);
}
}
private IClusterClient ConnectClient(string serviceName, IClusterClient client)
{
try
{
client.Connect(RetryFilter).Wait();
_logger.LogDebug($"Connection {serviceName} Sucess...");
return(client);
}
catch (Exception ex)
{
_logger.LogError($"Connection {serviceName} Faile...", ex);
throw new OrleansConnectionFailedException($"Connection {serviceName} Faile...");
}
}
public async Task Invoke(DownstreamContext context)
{
var upstreamUrlPath = context.HttpContext.Request.Path.ToString();
var upstreamHost = context.HttpContext.Request.Headers["Host"];
var configuration = await _configProvider.Get();
if (configuration.IsError)
{
_logger.LogError($"{MiddlewareName} setting pipeline errors. IOcelotConfigurationProvider returned {configuration.Errors.ToErrorString()}");
SetPipelineError(context, configuration.Errors);
return;
}
context.ServiceProviderConfiguration = configuration.Data.ServiceProviderConfiguration;
_logger.LogDebug("upstream url path is {upstreamUrlPath}", upstreamUrlPath);
var downstreamRoute = _downstreamRouteFinder.FindDownstreamRoute(upstreamUrlPath, context.HttpContext.Request.Method, configuration.Data, upstreamHost);
if (downstreamRoute.IsError)
{
_logger.LogError($"{MiddlewareName} setting pipeline errors. IDownstreamRouteFinder returned {downstreamRoute.Errors.ToErrorString()}");
SetPipelineError(context, downstreamRoute.Errors);
return;
}
//todo - put this back in
// _logger.LogDebug("downstream template is {downstreamRoute.Data.ReRoute.DownstreamPath}", downstreamRoute.Data.ReRoute.DownstreamReRoute.DownstreamPathTemplate);
context.TemplatePlaceholderNameAndValues = downstreamRoute.Data.TemplatePlaceholderNameAndValues;
await _multiplexer.Multiplex(context, downstreamRoute.Data.ReRoute, _next);
}
public async Task <Response <OrleansResponseMessage> > Invoke(GrainReference grain, GrainRouteValues route)
{
ObjectMethodExecutor executor;
object[] parameters;
try
{
string key = $"{route.SiloName}.{route.GrainName}.{route.GrainMethodName}";
executor = _cachedExecutors.GetOrAdd(key, (_key) =>
{
ObjectMethodExecutor _executor = ObjectMethodExecutor.Create(route.GrainMethod, grain.GrainType.GetTypeInfo());
return(_executor);
});
parameters = GetParameters(executor, route);
}
catch (Exception ex)
{
_logger.LogError($"Binding parameter failed", ex);
return(new ErrorResponse <OrleansResponseMessage>(new UnknownError(ex.Message)));
}
try
{
return(await this.Invoke(executor, grain, parameters));
}
catch (Exception ex)
{
_logger.LogError($"Request {grain.GrainType.Name} Orleans failed,", ex);
if (ex.InnerException != null && ex.InnerException is Orleans.Runtime.OrleansMessageRejectionException)
{
await Task.Delay(1);
return(await this.Invoke(executor, grain, parameters));
}
throw ex;
}
}
public async Task Invoke(HttpContext context)
{
await _next.Invoke(context);
if (PipelineError)
{
var errors = PipelineErrors;
_logger.LogError($"{PipelineErrors.Count} pipeline errors found in {MiddlewareName}. Setting error response status code");
SetErrorResponse(context, errors);
}
else
{
_logger.LogDebug("no pipeline errors, setting and returning completed response");
await _responder.SetResponseOnHttpContext(context, HttpResponseMessage);
}
}
public async Task <List <Service> > Get()
{
var serviceNameUri = ServiceFabricUriBuilder.Build(_servicename);
var services = new List <Service>();
try
{
var service = await _servicePartitionResolver.ResolveAsync(serviceNameUri, ServicePartitionKey.Singleton, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), CancellationToken.None);
services.Add(BuildService(service));
}
catch (Exception ex)
{
_logger.LogError($"Could not resolve service: '{serviceNameUri}'.", ex);
}
return(services);
}
public async Task <List <Service> > Get()
{
var queryResult = await _consul.Health.Service(_consulConfig.KeyOfServiceInConsul, string.Empty, true);
var services = new List <Service>();
foreach (var serviceEntry in queryResult.Response)
{
if (IsValid(serviceEntry))
{
services.Add(BuildService(serviceEntry));
}
else
{
_logger.LogError($"Unable to use service Address: {serviceEntry.Service.Address} and Port: {serviceEntry.Service.Port} as it is invalid. Address must contain host only e.g. localhost and port must be greater than 0");
}
}
return(services.ToList());
}
public void Add(List <AddHeader> addHeaders, HttpResponseMessage response)
{
foreach (var add in addHeaders)
{
if (add.Value.StartsWith('{') && add.Value.EndsWith('}'))
{
var value = _placeholders.Get(add.Value);
if (value.IsError)
{
_logger.LogError($"Unable to add header to response {add.Key}: {add.Value}");
continue;
}
response.Headers.TryAddWithoutValidation(add.Key, value.Data);
}
else
{
response.Headers.TryAddWithoutValidation(add.Key, add.Value);
}
}
}
public async Task <Response <OrleansResponseMessage> > Invoke(GrainReference grain, GrainRouteValues route)
{
try
{
string key = $"{route.SiloName}.{route.GrainName}.{route.GrainMethodName}";
var executor = _cachedExecutors.GetOrAdd(key, (_key) =>
{
ObjectMethodExecutor _executor = ObjectMethodExecutor.Create(route.GrainMethod, grain.GrainType.GetTypeInfo());
return(_executor);
});
var parameters = GetParameters(executor, route);
var result = await this.ExecuteAsync(executor, grain, parameters);
var message = new OrleansResponseMessage(new OrleansContent(result, this._jsonSerializer), HttpStatusCode.OK);
return(new OkResponse <OrleansResponseMessage>(message));
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
return(new ErrorResponse <OrleansResponseMessage>(new UnknownError(ex.Message)));
}
}
public async Task Invoke(HttpContext context)
{
try
{
await TrySetGlobalRequestId(context);
_logger.LogDebug("ocelot pipeline started");
await _next.Invoke(context);
}
catch (Exception e)
{
_logger.LogDebug("error calling middleware");
var message = CreateMessage(context, e);
_logger.LogError(message, e);
SetInternalServerErrorOnResponse(context);
}
_logger.LogDebug("ocelot pipeline finished");
}
