public async Task Invoke(ITrafficContext trafficContext, BrolicTrafficDelegate next)
{
var endPoint = trafficContext.HttpContext.GetEndpoint();
endPoint.RequestDelegate(trafficContext.HttpContext);
await next(trafficContext);
}
public Task HandleTraffic(ITrafficContext trafficContext)
{
var response = trafficContext.HttpContext.Response;
_nullResponseWriter.WriteResponse(response);
return(Task.CompletedTask);
}
public async Task HandleTraffic(ITrafficContext trafficContext)
{
var rabbitMqRequest = await _rabbitMqRequestBuilder.BuildRabbitMqRequest(trafficContext);
await _rabbitMqRequestExecutor.ExecuteRequest(rabbitMqRequest);
trafficContext.HttpContext.Response.StatusCode = StatusCodes.Status202Accepted;
}
public async Task HandleTraffic(ITrafficContext trafficContext)
{
var httpRequestMessage = await _httpRequestBuilder.BuildHttpRequest(trafficContext);
var httpResponseMessage = await _httpRequestExecutor.ExecuteRequest(httpRequestMessage);
var httpResponse = trafficContext.HttpContext.Response;
await _httpResponseBuilder.BuildHttpResponse(httpResponse, httpResponseMessage);
}
public async Task Invoke(ITrafficContext trafficContext, BrolicTrafficDelegate next)
{
var routeContext = new RouteContext(trafficContext.HttpContext);
routeContext.RouteData.Routers.Add(_router);
await _router.RouteAsync(routeContext);
await routeContext.Handler(routeContext.HttpContext);
await next(trafficContext);
}
public async Task <RabbitMqRequest> BuildRabbitMqRequest(ITrafficContext trafficContext)
{
var requestBody = trafficContext.HttpContext.Request.Body;
requestBody.Seek(0, SeekOrigin.Begin);
using var streamReader = new StreamReader(requestBody);
var requestBodyText = await streamReader.ReadToEndAsync();
var rabbitMqRequest = JsonConvert.DeserializeObject <RabbitMqRequest>(requestBodyText);
var rabbitMqDownstreamOptions = trafficContext.Downstream.GetRabbitMqDownstreamOptions();
rabbitMqRequest.ConnectionKey = rabbitMqDownstreamOptions.ConnectionKey;
return(rabbitMqRequest);
}
public async Task Invoke(ITrafficContext trafficContext, BrolicTrafficDelegate next)
{
var trafficInitiatorId = await _trafficInitiatorIdentifier.IdentifyTrafficInitiator(trafficContext);
var httpContext = trafficContext.HttpContext;
var httpMethod = httpContext.Request.Method;
var rateLimitingRouteOptions = trafficContext.Route.GetRateLimitingRouteOptions();
var applicableRateLimitingRules = rateLimitingRouteOptions.Rules
.Where(r => !r.Methods.Any() || r.Methods.Contains(httpMethod));
var rateLimitingValidationResponses = new List <RateLimitingValidationResponse>();
foreach (var applicableRateLimitingRule in applicableRateLimitingRules)
{
var path = httpContext.Request.Path;
var parsedMethod = !applicableRateLimitingRule.Methods.Any()
? "Any"
: applicableRateLimitingRule.Methods.Aggregate(string.Empty, (current, method) =>
{
current += method;
return(current);
});
var rateLimitingValidationContext = new RateLimitingValidationContext
{
TrafficInitiatorId = trafficInitiatorId,
Path = path,
Method = parsedMethod,
Limit = applicableRateLimitingRule.Limit,
Period = applicableRateLimitingRule.Period
};
var rateLimitingValidationResponse = await _rateLimitingValidationStrategy.ValidateContext(rateLimitingValidationContext);
rateLimitingValidationResponses.Add(rateLimitingValidationResponse);
}
if (rateLimitingValidationResponses.Any(r => !r.IsValid))
{
httpContext.Response.StatusCode = StatusCodes.Status429TooManyRequests;
return;
}
await next(trafficContext);
}
public Task <Uri> BuildHttpRequestUri(ITrafficContext trafficContext)
{
var httpDownstreamOptions = trafficContext.Downstream.GetHttpDownstreamOptions();
var downstreamPath = httpDownstreamOptions.BasePath;
if (downstreamPath.Last() != '/')
{
downstreamPath += "/";
}
var httpRequest = trafficContext.HttpContext.Request;
var route = trafficContext.Route;
if (route.CatchAll)
{
var catchAllPathSegment = httpRequest
.RouteValues
.First(rv => rv.Key == "catchAllPathSegment")
.Value;
downstreamPath += catchAllPathSegment;
}
else if (route.PathSegments.Any())
{
downstreamPath = route.PathSegments.Aggregate(downstreamPath, (current, pathSegment) =>
{
if (current.Last() != '/')
{
current += "/";
}
var pathSegmentValue = httpRequest
.RouteValues
.First(rv => rv.Key == pathSegment)
.Value;
current += pathSegmentValue;
return(current);
});
}
var queryString = httpRequest.QueryString.Value;
downstreamPath += queryString;
return(Task.FromResult(new Uri(downstreamPath)));
}
public Task <string> IdentifyTrafficInitiator(ITrafficContext trafficContext)
{
var ipAddress = trafficContext.HttpContext.Connection.RemoteIpAddress.ToString();
return(Task.FromResult(ipAddress));
}
public async Task Invoke(ITrafficContext trafficContext, BrolicTrafficDelegate next)
{
var downstream = trafficContext.Downstream;
var trafficHandler = _trafficHandlerProvider.GetTrafficHandler(downstream.Handler);
await trafficHandler.HandleTraffic(trafficContext);
}
public async Task <HttpRequestMessage> BuildHttpRequest(ITrafficContext trafficContext)
{
var httpContext = trafficContext.HttpContext;
var httpRequestMessage = new HttpRequestMessage
{
RequestUri = await _httpRequestUriBuilder.BuildHttpRequestUri(trafficContext)
};
var requestMethod = httpContext.Request.Method.ToLower();
var buildHttpRequestContent = false;
switch (requestMethod)
{
case "get":
httpRequestMessage.Method = HttpMethod.Get;
break;
case "post":
httpRequestMessage.Method = HttpMethod.Post;
buildHttpRequestContent = true;
break;
case "put":
httpRequestMessage.Method = HttpMethod.Put;
buildHttpRequestContent = true;
break;
case "patch":
httpRequestMessage.Method = HttpMethod.Patch;
buildHttpRequestContent = true;
break;
case "delete":
httpRequestMessage.Method = HttpMethod.Delete;
break;
case "head":
httpRequestMessage.Method = HttpMethod.Head;
break;
case "options":
httpRequestMessage.Method = HttpMethod.Options;
break;
case "trace":
httpRequestMessage.Method = HttpMethod.Trace;
break;
default:
throw new ArgumentOutOfRangeException();
}
foreach (var(key, value) in httpContext.Request.Headers)
{
httpRequestMessage.Headers.TryAddWithoutValidation(key, value.ToArray());
}
if (!buildHttpRequestContent)
{
return(httpRequestMessage);
}
using var httpRequestContent = await _httpRequestContentBuilder.BuildHttpRequestContent(httpContext.Request);
httpRequestMessage.Content = httpRequestContent;
return(httpRequestMessage);
}