public TracingHandlerFactory(
IServiceTracer tracer,
IRequestScopedDataRepository repo)
{
_repo = repo;
_tracer = tracer;
}
public TracingHandlerFactory(
IServiceProvider services,
IRequestScopedDataRepository repo)
{
_repo = repo;
_tracer = services.GetService <ITracer>();
}
public Placeholders(IBaseUrlFinder finder, IRequestScopedDataRepository repo)
{
_repo = repo;
_finder = finder;
_placeholders = new Dictionary<string, Func<Response<string>>>();
_placeholders.Add("{BaseUrl}", () => new OkResponse<string>(_finder.Find()));
_placeholders.Add("{TraceId}", () => {
var traceId = _repo.Get<string>("TraceId");
if(traceId.IsError)
{
return new ErrorResponse<string>(traceId.Errors);
}
return new OkResponse<string>(traceId.Data);
});
_requestPlaceholders = new Dictionary<string, Func<HttpRequestMessage, string>>();
_requestPlaceholders.Add("{DownstreamBaseUrl}", x => {
var downstreamUrl = $"{x.RequestUri.Scheme}://{x.RequestUri.Host}";
if(x.RequestUri.Port != 80 && x.RequestUri.Port != 443)
{
downstreamUrl = $"{downstreamUrl}:{x.RequestUri.Port}";
}
return $"{downstreamUrl}/";
});
}
public ReRouteRequestIdMiddleware(OcelotRequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository)
: base(loggerFactory.CreateLogger <ReRouteRequestIdMiddleware>())
{
_next = next;
_requestScopedDataRepository = requestScopedDataRepository;
}
public ExceptionHandlerMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository repo)
: base(loggerFactory.CreateLogger <ExceptionHandlerMiddleware>())
{
_next = next;
_repo = repo;
}
public TracerMiddleware(RequestDelegate next, IRequestScopedDataRepository requestScopedDataRepository, ITracerHandler tracer, TracerOptions tracerOptions)
{
_next = next;
_requestScopedDataRepository = requestScopedDataRepository;
_tracer = tracer;
TracerKeys.Environment = tracerOptions.Environment;
TracerKeys.SystemName = tracerOptions.SystemName;
}
public OcelotHttpTracingHandler(
IServiceTracer tracer,
IRequestScopedDataRepository repo,
HttpMessageHandler httpMessageHandler = null)
{
_repo = repo;
_tracer = tracer ?? throw new ArgumentNullException(nameof(tracer));
InnerHandler = httpMessageHandler ?? new HttpClientHandler();
}
public TracerHandler(IRequestScopedDataRepository requestScopedDataRepository,
IJsonHelper jsonHelper,
ITracerStore tracerStore,
IOptions <TracerOptions> tracerOptions)
{
_requestScopedDataRepository = requestScopedDataRepository;
_tracerStore = tracerStore;
_jsonHelper = jsonHelper;
_tracerOptions = tracerOptions.Value;
}
public HttpRequesterMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IHttpRequester requester,
IRequestScopedDataRepository requestScopedDataRepository)
: base(requestScopedDataRepository)
{
_next = next;
_requester = requester;
_logger = loggerFactory.CreateLogger <HttpRequesterMiddleware>();
}
public QueryStringBuilderMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository,
IAddQueriesToRequest addQueriesToRequest)
: base(requestScopedDataRepository)
{
_next = next;
_addQueriesToRequest = addQueriesToRequest;
_logger = loggerFactory.CreateLogger <QueryStringBuilderMiddleware>();
}
public AuthenticationMiddleware(RequestDelegate next,
IApplicationBuilder app,
IRequestScopedDataRepository requestScopedDataRepository,
IOcelotLoggerFactory loggerFactory)
: base(requestScopedDataRepository)
{
_next = next;
_app = app;
_logger = loggerFactory.CreateLogger <AuthenticationMiddleware>();
}
public AuthorisationMiddleware(RequestDelegate next,
IRequestScopedDataRepository requestScopedDataRepository,
IAuthoriser authoriser,
IOcelotLoggerFactory loggerFactory)
: base(requestScopedDataRepository)
{
_next = next;
_authoriser = authoriser;
_logger = loggerFactory.CreateLogger <AuthorisationMiddleware>();
}
public DownstreamRequestInitialiserMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository,
Mapper.IRequestMapper requestMapper)
: base(requestScopedDataRepository)
{
_next = next;
_logger = loggerFactory.CreateLogger <DownstreamRequestInitialiserMiddleware>();
_requestMapper = requestMapper;
}
public ExceptionHandlerMiddleware(OcelotRequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IOcelotConfigurationProvider provider,
IRequestScopedDataRepository repo)
{
_provider = provider;
_repo = repo;
_next = next;
_logger = loggerFactory.CreateLogger <ExceptionHandlerMiddleware>();
}
public ExceptionHandlerMiddleware(OcelotRequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IInternalConfigurationRepository configRepo,
IRequestScopedDataRepository repo)
: base(loggerFactory.CreateLogger <ExceptionHandlerMiddleware>())
{
_configRepo = configRepo;
_repo = repo;
_next = next;
}
public HttpRequestHeadersBuilderMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository,
IAddHeadersToRequest addHeadersToRequest)
: base(requestScopedDataRepository)
{
_next = next;
_addHeadersToRequest = addHeadersToRequest;
_logger = loggerFactory.CreateLogger <HttpRequestHeadersBuilderMiddleware>();
}
public DownstreamRouteFinderMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IDownstreamRouteFinder downstreamRouteFinder,
IRequestScopedDataRepository requestScopedDataRepository)
: base(requestScopedDataRepository)
{
_next = next;
_downstreamRouteFinder = downstreamRouteFinder;
_logger = loggerFactory.CreateLogger <DownstreamRouteFinderMiddleware>();
}
public OutputCacheMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository scopedDataRepository,
IOcelotCache <HttpResponseMessage> outputCache)
: base(scopedDataRepository)
{
_next = next;
_outputCache = outputCache;
_logger = loggerFactory.CreateLogger <OutputCacheMiddleware>();
}
public LoadBalancingMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository,
ILoadBalancerHouse loadBalancerHouse)
: base(requestScopedDataRepository)
{
_next = next;
_logger = loggerFactory.CreateLogger <QueryStringBuilderMiddleware>();
_loadBalancerHouse = loadBalancerHouse;
}
public ClientRateLimitMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository,
IRateLimitCounterHandler counterHandler)
: base(requestScopedDataRepository)
{
_next = next;
_logger = loggerFactory.CreateLogger <ClientRateLimitMiddleware>();
_counterHandler = counterHandler;
_processor = new ClientRateLimitProcessor(counterHandler);
}
public ExceptionHandlerMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository,
IOcelotConfigurationProvider configProvider)
: base(requestScopedDataRepository)
{
_configProvider = configProvider;
_next = next;
_requestScopedDataRepository = requestScopedDataRepository;
_logger = loggerFactory.CreateLogger <ExceptionHandlerMiddleware>();
}
public ResponderMiddleware(RequestDelegate next,
IHttpResponder responder,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository,
IErrorsToHttpStatusCodeMapper codeMapper)
: base(requestScopedDataRepository)
{
_next = next;
_responder = responder;
_codeMapper = codeMapper;
_logger = loggerFactory.CreateLogger <ResponderMiddleware>();
}
public HttpRequestBuilderMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository,
IRequestCreator requestCreator,
IQosProviderHouse qosProviderHouse)
: base(requestScopedDataRepository)
{
_next = next;
_requestCreator = requestCreator;
_qosProviderHouse = qosProviderHouse;
_logger = loggerFactory.CreateLogger <HttpRequestBuilderMiddleware>();
}
public OutputCacheMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository scopedDataRepository,
IOcelotCache <CachedResponse> outputCache,
IRegionCreator regionCreator)
: base(scopedDataRepository)
{
_next = next;
_outputCache = outputCache;
_logger = loggerFactory.CreateLogger <OutputCacheMiddleware>();
_regionCreator = regionCreator;
}
public DownstreamUrlCreatorMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IDownstreamPathPlaceholderReplacer replacer,
IRequestScopedDataRepository requestScopedDataRepository,
IUrlBuilder urlBuilder)
: base(requestScopedDataRepository)
{
_next = next;
_replacer = replacer;
_urlBuilder = urlBuilder;
_logger = loggerFactory.CreateLogger <DownstreamUrlCreatorMiddleware>();
}
public ErrorLogMiddleware(RequestDelegate next,
ILoggerFactory loggerFactory,
IErrorCodeStore errorCodeStore,
IRequestScopedDataRepository requestScopedDataRepository,
IJsonHelper jsonHelper)
{
_next = next;
_logger = loggerFactory.CreateLogger <ErrorLogMiddleware>();
_errorCodeStore = errorCodeStore;
_requestScopedDataRepository = requestScopedDataRepository;
_jsonHelper = jsonHelper;
}
public HttpHeadersTransformationMiddleware(RequestDelegate next,
IOcelotLoggerFactory loggerFactory,
IRequestScopedDataRepository requestScopedDataRepository,
IHttpContextRequestHeaderReplacer preReplacer,
IHttpResponseHeaderReplacer postReplacer)
: base(requestScopedDataRepository)
{
_next = next;
_postReplacer = postReplacer;
_preReplacer = preReplacer;
_logger = loggerFactory.CreateLogger <HttpHeadersTransformationMiddleware>();
}
public AspDotNetLogger(ILogger logger, IRequestScopedDataRepository scopedDataRepository)
{
_logger = logger;
_scopedDataRepository = scopedDataRepository;
_func = (state, exception) =>
{
if (exception == null)
{
return(state);
}
else
{
return($"{state}, exception: {exception}");
}
};
}
public Placeholders(IBaseUrlFinder finder, IRequestScopedDataRepository repo, IHttpContextAccessor httpContextAccessor)
{
_repo = repo;
_httpContextAccessor = httpContextAccessor;
_finder = finder;
_placeholders = new Dictionary <string, Func <Response <string> > >
{
{ "{BaseUrl}", GetBaseUrl() },
{ "{TraceId}", GetTraceId() },
{ "{RemoteIpAddress}", GetRemoteIpAddress() }
};
_requestPlaceholders = new Dictionary <string, Func <DownstreamRequest, string> >
{
{ "{DownstreamBaseUrl}", GetDownstreamBaseUrl() }
};
}
public WebApiTraceFilterAttribute(IRequestScopedDataRepository requestScopedDataRepository, IJsonHelper jsonHelper)
{
this.requestScopedDataRepository = requestScopedDataRepository;
this.jsonHelper = jsonHelper;
}
