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 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();
}
public async Task Invoke(HttpContext context)
{
_logger.TraceMiddlewareEntry();
SetOcelotRequestId(context);
_logger.TraceInvokeNext();
await _next.Invoke(context);
_logger.TraceInvokeNextCompleted();
_logger.TraceMiddlewareCompleted();
}
public async Task Invoke(HttpContext context)
{
_logger.TraceMiddlewareEntry();
_logger.TraceInvokeNext();
await _next.Invoke(context);
_logger.TraceInvokeNextCompleted();
if (PipelineError)
{
var errors = PipelineErrors;
_logger.LogError($"{errors.Count} pipeline errors found in {MiddlwareName}. Setting error response status code");
SetErrorResponse(context, errors);
}
else
{
_logger.LogDebug("no pipeline errors, setting and returning completed response");
await _responder.SetResponseOnHttpContext(context, HttpResponseMessage);
}
_logger.TraceMiddlewareCompleted();
}
public async Task Invoke(HttpContext context)
{
_logger.TraceMiddlewareEntry();
var options = DownstreamRoute.ReRoute.RateLimitOptions;
// check if rate limiting is enabled
if (!DownstreamRoute.ReRoute.EnableEndpointEndpointRateLimiting)
{
_logger.LogDebug($"EndpointRateLimiting is not enabled for {DownstreamRoute.ReRoute.DownstreamPathTemplate}");
_logger.TraceInvokeNext();
await _next.Invoke(context);
_logger.TraceInvokeNextCompleted();
_logger.TraceMiddlewareCompleted();
return;
}
// compute identity from request
var identity = SetIdentity(context, options);
// check white list
if (IsWhitelisted(identity, options))
{
_logger.LogDebug($"{DownstreamRoute.ReRoute.DownstreamPathTemplate} is white listed from rate limiting");
_logger.TraceInvokeNext();
await _next.Invoke(context);
_logger.TraceInvokeNextCompleted();
_logger.TraceMiddlewareCompleted();
return;
}
var rule = options.RateLimitRule;
if (rule.Limit > 0)
{
// increment counter
var counter = _processor.ProcessRequest(identity, options);
// check if limit is reached
if (counter.TotalRequests > rule.Limit)
{
//compute retry after value
var retryAfter = _processor.RetryAfterFrom(counter.Timestamp, rule);
// log blocked request
LogBlockedRequest(context, identity, counter, rule);
var retrystring = retryAfter.ToString(System.Globalization.CultureInfo.InvariantCulture);
// break execution
await ReturnQuotaExceededResponse(context, options, retrystring);
_logger.TraceMiddlewareCompleted();
return;
}
}
//set X-Rate-Limit headers for the longest period
if (!options.DisableRateLimitHeaders)
{
var headers = _processor.GetRateLimitHeaders(context, identity, options);
context.Response.OnStarting(SetRateLimitHeaders, state: headers);
}
_logger.TraceInvokeNext();
await _next.Invoke(context);
_logger.TraceInvokeNextCompleted();
_logger.TraceMiddlewareCompleted();
}
