private GrainRouteValues GetRequestRoute(DownstreamContext context)
{
GrainRouteValues routeValues = new GrainRouteValues();
string[] route = context.DownstreamRequest.AbsolutePath.Split('/')
.Where(s => !string.IsNullOrEmpty(s))
.ToArray();
if (route.Length < 2 || route.Length > 3)
{
return(null);
}
routeValues.SiloName = context.DownstreamReRoute.ServiceName;
routeValues.GrainName = route[0];
routeValues.GrainMethodName = route[1];
routeValues.RequestUri = context.DownstreamRequest.ToUri();
//Claims to Claims Tranformation Whether to inject GrainKey
var claim = context.HttpContext.User.FindFirst("GrainKey");
if (claim != null)
{
routeValues.GrainId = claim.Value;
}
else
{
routeValues.GrainId = (route.Length == 3) ? route[2] : null;
}
try
{
routeValues.Querys = this.GetQueryParameter(context.DownstreamRequest.Query);
routeValues.Body = this.GetBodyParameter(context.DownstreamRequest, context.HttpContext.Request);
}
catch (Exception ex)
{
throw new OrleansGrainReferenceException("Error parsing request parameters ...", ex);
}
return(routeValues);
}
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);
}
}
public async Task <Response <ServiceHostAndPort> > Lease(DownstreamContext context)
{
var key = context.HttpContext.Request.Cookies[_key];
lock (_lock)
{
if (!string.IsNullOrEmpty(key) && _stored.ContainsKey(key))
{
var cached = _stored[key];
var updated = new StickySession(cached.HostAndPort, DateTime.UtcNow.AddMilliseconds(_keyExpiryInMs), key);
_stored[key] = updated;
_bus.Publish(updated, _keyExpiryInMs);
return(new OkResponse <ServiceHostAndPort>(updated.HostAndPort));
}
}
var next = await _loadBalancer.Lease(context);
if (next.IsError)
{
return(new ErrorResponse <ServiceHostAndPort>(next.Errors));
}
lock (_lock)
{
if (!string.IsNullOrEmpty(key) && !_stored.ContainsKey(key))
{
var ss = new StickySession(next.Data, DateTime.UtcNow.AddMilliseconds(_keyExpiryInMs), key);
_stored[key] = ss;
_bus.Publish(ss, _keyExpiryInMs);
}
}
return(new OkResponse <ServiceHostAndPort>(next.Data));
}
public IHttpClient Create(DownstreamContext context)
{
_cacheKey = GetCacheKey(context);
var httpClient = _cacheHandlers.Get(_cacheKey);
if (httpClient != null)
{
return(httpClient);
}
var httpclientHandler = new HttpClientHandler
{
AllowAutoRedirect = context.DownstreamReRoute.HttpHandlerOptions.AllowAutoRedirect,
UseCookies = context.DownstreamReRoute.HttpHandlerOptions.UseCookieContainer,
CookieContainer = new CookieContainer()
};
if (context.DownstreamReRoute.DangerousAcceptAnyServerCertificateValidator)
{
httpclientHandler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
_logger
.LogWarning($"You have ignored all SSL warnings by using DangerousAcceptAnyServerCertificateValidator for this DownstreamReRoute, UpstreamPathTemplate: {context.DownstreamReRoute.UpstreamPathTemplate}, DownstreamPathTemplate: {context.DownstreamReRoute.DownstreamPathTemplate}");
}
var timeout = context.DownstreamReRoute.QosOptionsOptions.TimeoutValue == 0
? _defaultTimeout
: TimeSpan.FromMilliseconds(context.DownstreamReRoute.QosOptionsOptions.TimeoutValue);
_httpClient = new HttpClient(CreateHttpMessageHandler(httpclientHandler, context.DownstreamReRoute))
{
Timeout = timeout
};
_client = new HttpClientWrapper(_httpClient);
return(_client);
}
private bool Authorize(DownstreamContext ctx)
{
if (ctx.DownstreamReRoute.AuthenticationOptions.AuthenticationProviderKey == null)
{
return(true);
}
else
{
//flag for authorization
bool auth = false;
//where are stored the claims of the jwt token
Claim[] claims = ctx.HttpContext.User.Claims.ToArray <Claim>();
//where are stored the required claims for the route
Dictionary <string, string> required = ctx.DownstreamReRoute.RouteClaimsRequirement;
auth = claims.Any(claim => required.ContainsKey(claim.Type) && required[claim.Type].Split(',', StringSplitOptions.RemoveEmptyEntries).Contains(claim.Value));
return(auth);
}
}
public void should_map_all_downstream_to_upstream_when_not_aggregate()
{
var billDownstreamReRoute = new DownstreamReRouteBuilder().WithKey("Bill").Build();
var downstreamReRoutes = new List <DownstreamReRoute>
{
billDownstreamReRoute,
};
var reRoute = new ReRouteBuilder()
.WithDownstreamReRoutes(downstreamReRoutes)
.Build();
var billDownstreamContext = new DownstreamContext(new DefaultHttpContext())
{
DownstreamResponse =
new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("Bill says hi")
},
DownstreamReRoute = billDownstreamReRoute,
Errors = new List <Error> {
new AnyError()
},
DownstreamRequest = new HttpRequestMessage(HttpMethod.Get, new Uri("http://www.bbc.co.uk")),
};
var downstreamContexts = new List <DownstreamContext> {
billDownstreamContext
};
this.Given(x => GivenTheUpstreamContext(new DownstreamContext(new DefaultHttpContext())))
.And(x => GivenTheReRoute(reRoute))
.And(x => GivenTheDownstreamContext(downstreamContexts))
.When(x => WhenIAggregate())
.Then(x => ThenTheContentIs("Bill says hi"))
.And(x => ThenTheUpstreamContextIsMappedForNonAggregate())
.BDDfy();
}
public async Task Invoke(DownstreamContext context)
{
if (!context.IsError && context.HttpContext.Request.Method.ToUpper() != "OPTIONS" &&
IsAuthenticatedRoute(context.DownstreamReRoute))
{
if (!_options.ClientAuthorization)
{
Logger.LogInformation($"未启用客户端授权管道");
await _next.Invoke(context);
}
else
{
Logger.LogInformation($"{context.HttpContext.Request.Path} 是认证路由. {MiddlewareName} 开始校验授权信息");
#region 提取客户端ID
var clientId = "client_cjy";
var path = context.DownstreamReRoute.UpstreamPathTemplate.OriginalValue; //路由地址
var clientClaim = context.HttpContext.User.Claims.FirstOrDefault(p => p.Type == _options.ClientKey);
if (!string.IsNullOrEmpty(clientClaim?.Value))
{//从Claims中提取客户端id
clientId = clientClaim?.Value;
}
#endregion
if (await _ahphAuthenticationProcessor.CheckClientAuthenticationAsync(clientId, path))
{
await _next.Invoke(context);
}
else
{//未授权直接返回错误
var error = new UnauthenticatedError($"请求认证路由 {context.HttpContext.Request.Path}客户端未授权");
Logger.LogWarning($"路由地址 {context.HttpContext.Request.Path} 自定义认证管道校验失败. {error}");
SetPipelineError(context, error);
}
}
}
else
{
await _next.Invoke(context);
}
}
private UriBuilder CreateServiceFabricUri(DownstreamContext context, Response <DownstreamPath> dsPath)
{
var query = context.DownstreamRequest.RequestUri.Query;
var scheme = context.DownstreamReRoute.DownstreamScheme;
var host = context.DownstreamRequest.RequestUri.Host;
var port = context.DownstreamRequest.RequestUri.Port;
var serviceFabricPath = $"/{context.DownstreamReRoute.ServiceName + dsPath.Data.Value}";
Uri uri;
if (RequestForStatefullService(query))
{
uri = new Uri($"{scheme}://{host}:{port}{serviceFabricPath}{query}");
}
else
{
var split = string.IsNullOrEmpty(query) ? "?" : "&";
uri = new Uri($"{scheme}://{host}:{port}{serviceFabricPath}{query}{split}cmd=instance");
}
return(new UriBuilder(uri));
}
private static void RemoveQueryStringParametersThatHaveBeenUsedInTemplate(DownstreamContext context)
{
foreach (var nAndV in context.TemplatePlaceholderNameAndValues)
{
var name = nAndV.Name.Replace("{", "").Replace("}", "");
if (context.DownstreamRequest.Query.Contains(name) &&
context.DownstreamRequest.Query.Contains(nAndV.Value))
{
var questionMarkOrAmpersand = context.DownstreamRequest.Query.IndexOf(name, StringComparison.Ordinal);
context.DownstreamRequest.Query = context.DownstreamRequest.Query.Remove(questionMarkOrAmpersand - 1, 1);
var rgx = new Regex($@"\b{name}={nAndV.Value}\b");
context.DownstreamRequest.Query = rgx.Replace(context.DownstreamRequest.Query, "");
if (!string.IsNullOrEmpty(context.DownstreamRequest.Query))
{
context.DownstreamRequest.Query = '?' + context.DownstreamRequest.Query.Substring(1);
}
}
}
}
public Response Build(GrainRouteValues routeValues, DownstreamContext context)
{
try
{
string clientKey = this.GetClientKey(routeValues.GrainType);
if (clusterClientCache.Keys.Where(f => f == clientKey).Count() > 0)
{
return(new OkResponse());
}
clusterClientCache.GetOrAdd(clientKey, (key) =>
{
return(this.BuildClusterClient(routeValues, context));
});
return(new OkResponse());
}
catch (Exception ex)
{
this._logger.LogError(ex.Message, ex);
return(new ErrorResponse <GrainRouteValues>(new UnknownError(ex.Message)));
}
}
public async Task Invoke(DownstreamContext context)
{
var httpStatusCode = HttpStatusCode.OK;
var buildRequest = await _dotNettyRequestBuilder.BuildRequest(context);
string resultMessage;
if (buildRequest.IsError)
{
resultMessage = "bad request";
httpStatusCode = HttpStatusCode.BadRequest;
Logger.LogDebug(resultMessage);
}
else
{
try
{
var endpoint = new IPEndPoint(IPAddress.Parse(context.DownstreamRequest.Host), context.DownstreamRequest.Port);
resultMessage = await _serviceProxyProvider.InvokeAsync <string>(buildRequest.Data, context.DownstreamRequest.AbsolutePath, endpoint);
}
catch (RpcException ex)
{
httpStatusCode = HttpStatusCode.InternalServerError;
resultMessage = $"rpc exception.";
Logger.LogError("apigateway dotnetty client error", ex);
}
catch (Exception ex)
{
httpStatusCode = HttpStatusCode.ServiceUnavailable;
resultMessage = $"error in request dotnetty service.";
Logger.LogError($"{resultMessage}--{context.DownstreamRequest.ToUri()}", ex);
}
}
OkResponse <DotNettyHttpContent> httpResponse = new OkResponse <DotNettyHttpContent>(new DotNettyHttpContent(resultMessage));
context.HttpContext.Response.ContentType = "application/json";
context.DownstreamResponse = new DownstreamResponse(httpResponse.Data, httpStatusCode, httpResponse.Data.Headers, "");
}
public async Task Invoke(DownstreamContext context)
{
var preFAndRs = context.DownstreamReRoute.UpstreamHeadersFindAndReplace;
//todo - this should be on httprequestmessage not httpcontext?
_preReplacer.Replace(context.HttpContext, preFAndRs);
_addHeadersToRequest.SetHeadersOnDownstreamRequest(context.DownstreamReRoute.AddHeadersToUpstream, context.HttpContext);
await _next.Invoke(context);
if (context.IsError)
{
return;
}
var postFAndRs = context.DownstreamReRoute.DownstreamHeadersFindAndReplace;
_postReplacer.Replace(context.DownstreamResponse, postFAndRs, context.DownstreamRequest);
_addHeadersToResponse.Add(context.DownstreamReRoute.AddHeadersToDownstream, context.DownstreamResponse);
}
public static Task HandleExceptionAsync(DownstreamContext context, BaseException ex)
{
if (ex.code == 0)
{
ex.code = HttpStatusCode.InternalServerError; // 500 if unexpected
}
// actual response
var result = JsonConvert.SerializeObject(new {
messsage = ex.Message,
status = ex.code,
requested_uri = context.HttpContext.Request.Path,
origin = ex.origin,
timestamp = DateTime.Now
});
context.HttpContext.Response.ContentType = "application/json";
context.HttpContext.Response.StatusCode = (int)ex.code;
return(context.HttpContext.Response.WriteAsync(result));
}
public static async Task <IApplicationBuilder> UseOcelot(this IApplicationBuilder app, Action <IOcelotPipelineBuilder, OcelotPipelineConfiguration> builderAction, OcelotPipelineConfiguration configuration)
{
await CreateConfiguration(app); // initConfiguration
ConfigureDiagnosticListener(app);
var ocelotPipelineBuilder = new OcelotPipelineBuilder(app.ApplicationServices);
builderAction?.Invoke(ocelotPipelineBuilder, configuration ?? new OcelotPipelineConfiguration());
var ocelotDelegate = ocelotPipelineBuilder.Build();
app.Properties["analysis.NextMiddlewareName"] = "TransitionToOcelotMiddleware";
app.Use(async(context, task) =>
{
var downstreamContext = new DownstreamContext(context);
await ocelotDelegate.Invoke(downstreamContext);
});
return(app);
}
public async Task <Response <ServiceHostAndPort> > Lease(DownstreamContext downstreamContext)
{
var services = await _services();
if (services == null || services.Count == 0)
{
return(new ErrorResponse <ServiceHostAndPort>(new ServicesAreEmptyError("There were no services in NoLoadBalancer")));
}
var service = await Task.FromResult(services.FirstOrDefault());
var my_service = new Service("", new ServiceHostAndPort(downstreamContext.DownstreamReRoute.DownstreamAddresses.FirstOrDefault().Host, downstreamContext.DownstreamReRoute.DownstreamAddresses.FirstOrDefault().Port), "", "", Enumerable.Empty <string>());
if (service.HostAndPort.DownstreamHost == my_service.HostAndPort.DownstreamHost && service.HostAndPort.DownstreamPort == my_service.HostAndPort.DownstreamPort)
{
return(new OkResponse <ServiceHostAndPort>(service.HostAndPort));
}
else
{
return(new OkResponse <ServiceHostAndPort>(my_service.HostAndPort));
}
}
public Response Replace(DownstreamContext context, List <HeaderFindAndReplace> fAndRs)
{
var response = context.DownstreamResponse;
var request = context.DownstreamRequest;
foreach (var f in fAndRs)
{
var dict = response.Headers.ToDictionary(x => x.Key);
//if the response headers contain a matching find and replace
if (dict.TryGetValue(f.Key, out var values))
{
//check to see if it is a placeholder in the find...
var placeholderValue = _placeholders.Get(f.Find, request);
if (!placeholderValue.IsError)
{
//if it is we need to get the value of the placeholder
var replaced = values.Values.ToList()[f.Index].Replace(placeholderValue.Data, f.Replace.LastCharAsForwardSlash());
response.Headers.Remove(response.Headers.First(item => item.Key == f.Key));
response.Headers.Add(new Header(f.Key, new List <string> {
replaced
}));
}
else
{
var replaced = values.Values.ToList()[f.Index].Replace(f.Find, f.Replace);
response.Headers.Remove(response.Headers.First(item => item.Key == f.Key));
response.Headers.Add(new Header(f.Key, new List <string> {
replaced
}));
}
}
}
return(new OkResponse());
}
public async Task <Response <HttpResponseMessage> > GetResponse(DownstreamContext context)
{
var builder = new HttpClientBuilder(_factory, _cacheHandlers, _logger);
var httpClient = builder.Create(context);
try
{
var response = await httpClient.SendAsync(context.DownstreamRequest.ToHttpRequestMessage(), context.HttpContext.RequestAborted);
return(new OkResponse <HttpResponseMessage>(response));
}
catch (Exception exception)
{
var error = _mapper.Map(exception);
return(new ErrorResponse <HttpResponseMessage>(error));
}
finally
{
builder.Save();
}
}
public async Task Invoke(DownstreamContext context)
{
//如果不需要校验权限
if (!context.DownstreamRoute.Authentication)
{
await _next.Invoke(context);
}
else
{
//获取token
string token = GetToken(context.HttpContext);
if (string.IsNullOrWhiteSpace(token) || !ValidateToken(token))
{
SetPipelineError(context, new AuthorizationError());
}
else
{
await _next.Invoke(context);
}
}
}
public Response<GrpcRequest> BuildRequest(DownstreamContext context)
{
var route = context.DownstreamRequest.AbsolutePath.Trim('/').Split('/');
if (route.Length != 2)
{
return SetError($"error request:{route},must do like this:http://domain:port/grpc/ServiceName/MethordName/");
}
string svcName = route[0].ToUpper();
string methodName = route[1].ToUpper();
//判断是否存在对应grpc服务、方法
var grpcDescript = descriptor.Descriptor;
if (!grpcDescript.ContainsKey(svcName))
{
return SetError($"service name is not defined.{svcName}");
}
if (!grpcDescript[svcName].ContainsKey(methodName))
{
return SetError($"method name is not defined.{methodName}");
}
GrpcRequest grpcRequest = new GrpcRequest
{
GrpcMethod = grpcDescript[svcName][methodName],
Headers = GetRequestHeaders(context)
};
try
{
//需要替换Scheme
context.DownstreamRequest.Scheme = "http";
var requestJson = GetRequestJson(context);
grpcRequest.RequestMessage = JsonConvert.DeserializeObject(requestJson, grpcRequest.GrpcMethod.InputType.ClrType);
}
catch (Exception)
{
return SetError("request parameter error");
}
context.DownstreamRequest.Scheme = "grpc";
return new OkResponse<GrpcRequest>(grpcRequest);
}
public void should_call_request_unable_to_complete_request()
{
var reRoute = new DownstreamReRouteBuilder()
.WithIsQos(false)
.WithHttpHandlerOptions(new HttpHandlerOptions(false, false, false))
.WithReRouteKey("")
.WithQosOptions(new QoSOptionsBuilder().Build())
.Build();
var context = new DownstreamContext(new DefaultHttpContext())
{
DownstreamReRoute = reRoute,
DownstreamRequest = new DownstreamRequest(new HttpRequestMessage()
{
RequestUri = new Uri("http://localhost:60080")
}),
};
this.Given(x => x.GivenTheRequestIs(context))
.When(x => x.WhenIGetResponse())
.Then(x => x.ThenTheResponseIsCalledError())
.BDDfy();
}
public async Task Invoke(DownstreamContext context)
{
try
{
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");
}
public async Task Invoke(DownstreamContext context)
{
await _next.Invoke(context);
if (context.IsError)
{
//保存请求的信息
BaseLogModel logModel = new BaseLogModel()
{
Type = 1,
Content = $"{context.ToErrorString()} errors found in {MiddlewareName}. Setting error response for request path:{context.HttpContext.Request.Path}, request method: {context.HttpContext.Request.Method}"
};
_log.Error(logModel);
SetErrorResponse(context.HttpContext, context.Errors);
}
else
{
//Logger.LogDebug("no pipeline errors, setting and returning completed response");
await _responder.SetResponseOnHttpContext(context.HttpContext, context.DownstreamResponse);
}
}
private async Task WhenIMakeRequestsToKeepRefreshingTheSession()
{
var context = new DefaultHttpContext();
var cookies = new FakeCookies();
cookies.AddCookie("sessionid", "321");
context.Request.Cookies = cookies;
_downstreamContext = new DownstreamContext(context);
var firstHostAndPort = await _stickySessions.Lease(_downstreamContext);
firstHostAndPort.Data.DownstreamHost.ShouldBe("one");
firstHostAndPort.Data.DownstreamPort.ShouldBe(80);
Thread.Sleep(80);
var secondHostAndPort = await _stickySessions.Lease(_downstreamContext);
secondHostAndPort.Data.DownstreamHost.ShouldBe("one");
secondHostAndPort.Data.DownstreamPort.ShouldBe(80);
Thread.Sleep(80);
}
public async Task Invoke(DownstreamContext context)
{
var upstreamUrlPath = context.HttpContext.Request.Path.ToString();
var upstreamHost = context.HttpContext.Request.Headers["Host"];
var configuration = _repo.Get();
if (configuration.IsError)
{
Logger.LogWarning($"{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}");
var downstreamRoute = _downstreamRouteFinder.FindDownstreamRoute(upstreamUrlPath, context.HttpContext.Request.Method, configuration.Data, upstreamHost);
if (downstreamRoute.IsError)
{
Logger.LogWarning($"{MiddlewareName} setting pipeline errors. IDownstreamRouteFinder returned {downstreamRoute.Errors.ToErrorString()}");
SetPipelineError(context, downstreamRoute.Errors);
return;
}
var downstreamPathTemplates = string.Join(", ", downstreamRoute.Data.ReRoute.DownstreamReRoute.Select(r => r.DownstreamPathTemplate.Value));
Logger.LogDebug($"downstream templates are {downstreamPathTemplates}");
context.TemplatePlaceholderNameAndValues = downstreamRoute.Data.TemplatePlaceholderNameAndValues;
await _multiplexer.Multiplex(context, downstreamRoute.Data.ReRoute, _next);
}
public static async Task Invoke(DownstreamContext context, Func <Task> next)
{
await next.Invoke();
//开始记录日志
var serviceProvider = context.HttpContext.RequestServices;
var logger = serviceProvider.GetRequiredService <ILogger <ASFRequestLoggerMiddleware> >();
try
{
if (context.HttpContext.Items.ContainsKey("asf_parmission"))
{
if (context.HttpContext.Items["asf_parmission"] is Permission per)
{
//判断是否需要记录日志
if (per.IsLogger)
{
await ASFRequestLogger.Record(context.HttpContext, per);
}
}
else
{
logger.LogError($"HttpContext.Items[\"asf_parmission\"] is not equal to {typeof(Permission)}");
return;
}
}
return;
}
catch (Exception ex)
{
logger.LogError(ex, "ASF Logging");
await next.Invoke();
return;
}
}
private static IApplicationBuilder CreateOcelotPipeline(IApplicationBuilder builder, OcelotPipelineConfiguration pipelineConfiguration)
{
var pipelineBuilder = new OcelotPipelineBuilder(builder.ApplicationServices);
pipelineBuilder.BuildExtOcelotPipeline(pipelineConfiguration);
var firstDelegate = pipelineBuilder.Build();
/*
* inject first delegate into first piece of asp.net middleware..maybe not like this
* then because we are updating the http context in ocelot it comes out correct for
* rest of asp.net..
*/
builder.Properties["analysis.NextMiddlewareName"] = "TransitionToOcelotMiddleware";
builder.Use(async(context, task) =>
{
var downstreamContext = new DownstreamContext(context);
await firstDelegate.Invoke(downstreamContext);
});
return(builder);
}
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 void should_call_request_correctly()
{
var reRoute = new DownstreamReRouteBuilder()
.WithIsQos(false)
.WithHttpHandlerOptions(new HttpHandlerOptions(false, false, false))
.WithReRouteKey("")
.WithQosOptions(new QoSOptionsBuilder().Build())
.Build();
var context = new DownstreamContext(new DefaultHttpContext())
{
DownstreamReRoute = reRoute,
DownstreamRequest = new DownstreamRequest(new HttpRequestMessage()
{
RequestUri = new Uri("http://www.bbc.co.uk")
}),
};
this.Given(x => x.GivenTheRequestIs(context))
.And(x => GivenTheHouseReturnsOkHandler())
.When(x => x.WhenIGetResponse())
.Then(x => x.ThenTheResponseIsCalledCorrectly())
.BDDfy();
}
public IHttpClient Create(DownstreamContext request)
{
_cacheKey = GetCacheKey(request);
var httpClient = _cacheHandlers.Get(_cacheKey);
if (httpClient != null)
{
return(httpClient);
}
_httpclientHandler = new HttpClientHandler
{
AllowAutoRedirect = request.DownstreamReRoute.HttpHandlerOptions.AllowAutoRedirect,
UseCookies = request.DownstreamReRoute.HttpHandlerOptions.UseCookieContainer,
CookieContainer = new CookieContainer()
};
_httpClient = new HttpClient(CreateHttpMessageHandler(_httpclientHandler, request.DownstreamReRoute));
_client = new HttpClientWrapper(_httpClient);
return(_client);
}
public async Task <Response> Security(DownstreamContext context)
{
if (!context.HttpContext.Request.Headers.TryGetValue("Authorization", out StringValues value))
{
return(new OkResponse());
}
string tokne = value.ToString().Replace("Bearer ", "");
this.LoadBlacklistToken();
if (_cache.TryGetValue(tokne, out string warnInfo))
{
context.HttpContext.Response.StatusCode = 401;
var bytes = Encoding.UTF8.GetBytes(warnInfo);
await context.HttpContext.Response.Body.WriteAsync(bytes, 0, bytes.Length);
var error = new UnauthenticatedError($"{tokne} Token enters the blacklist");
return(new ErrorResponse(error));
}
else
{
return(await Task.FromResult(new OkResponse()));
}
}
