public ForwarderMiddleware(RequestDelegate next, ILogger <ForwarderMiddleware> logger, IHttpForwarder forwarder, IRandomFactory randomFactory) { _next = next ?? throw new ArgumentNullException(nameof(next)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _forwarder = forwarder ?? throw new ArgumentNullException(nameof(forwarder)); _randomFactory = randomFactory ?? throw new ArgumentNullException(nameof(randomFactory)); }
private void ConfigureReverseProxy(IApplicationBuilder app, IHttpForwarder forwarder) { var mappings = _options.GetReverseProxyMappings(); if (mappings?.Any() == true) { var httpClient = new HttpMessageInvoker(new SocketsHttpHandler() { UseProxy = false, AllowAutoRedirect = false, AutomaticDecompression = DecompressionMethods.None, UseCookies = false }); var requestOptions = new ForwarderRequestConfig { ActivityTimeout = TimeSpan.FromSeconds(100) }; app.UseRouting(); app.UseEndpoints(endpoints => { foreach (var mapping in mappings) { endpoints.Map(mapping.Key, async httpContext => { await forwarder.SendAsync(httpContext, mapping.Value, httpClient, requestOptions); }); } }); } }
public void Configure(IApplicationBuilder app, IHttpForwarder forwarder) { app.UseHsts(); app.UseHttpsRedirection(); app.UseHosting(forwarder); }
public PersistentSubscriptionController(IHttpForwarder httpForwarder, IPublisher publisher, IPublisher networkSendQueue) : base(publisher) { _httpForwarder = httpForwarder; _networkSendQueue = networkSendQueue; }
public void Configure(IApplicationBuilder app, IHttpForwarder forwarder) { if (_options.EnableCors == true) { app.UseCors(corsPolicy => { corsPolicy.AllowAnyOrigin() .AllowAnyMethod() .AllowAnyHeader(); }); } app.UseStatusCodePages("text/html", "<html><head><title>Error {0}</title></head><body><h1>HTTP {0}</h1></body></html>"); app.UseDeveloperExceptionPage(); ConfigureReverseProxy(app, forwarder); var pathBase = _options.GetPathBase(); if (!string.IsNullOrEmpty(pathBase)) { app.Map(pathBase, ConfigureFileServer); } else { ConfigureFileServer(app); } }
public void Register( TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendService) { _projections = new EventStore.Projections.Core.Projections( db, mainQueue, mainBus, timerService, timeProvider, httpForwarder, httpServices, networkSendService, projectionWorkerThreadCount: _projectionWorkerThreadCount, runProjections: _runProjections); }
public ProjectionsController(IHttpForwarder httpForwarder, IPublisher publisher, IPublisher networkSendQueue) : base(publisher) { _httpForwarder = httpForwarder; _clusterNodeJs = new MiniWeb("/web/es/js/projections", Locations.ProjectionsDirectory); _networkSendQueue = networkSendQueue; _miniWebPrelude = new MiniWeb("/web/es/js/projections/v8/Prelude", Locations.PreludeDirectory); }
public static IApplicationBuilder UseHosting(this IApplicationBuilder app, IHttpForwarder forwarder) { var hosting = app.ApplicationServices.GetService <Hosting>(); app.UseRouting(); hosting.UseHostingOnApplicationBuilder(app, forwarder); return(app); }
public Projections( TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue, int projectionWorkerThreadCount, RunProjections runProjections) { _projectionWorkerThreadCount = projectionWorkerThreadCount; SetupMessaging( db, mainQueue, mainBus, timerService, timeProvider, httpForwarder, httpServices, networkSendQueue, runProjections); }
/// <summary> /// Forwards the incoming request to the destination server, and the response back to the client. /// </summary> /// <param name="context">The HttpContext to forward.</param> /// <param name="destinationPrefix">The url prefix for where to forward the request to.</param> /// <param name="httpClient">The HTTP client used to forward the request.</param> /// <param name="requestConfig">Config for the outgoing request.</param> /// <returns>The status of a forwarding operation.</returns> public static ValueTask <ForwarderError> SendAsync(this IHttpForwarder forwarder, HttpContext context, string destinationPrefix, HttpMessageInvoker httpClient, ForwarderRequestConfig requestConfig) { if (forwarder is null) { throw new ArgumentNullException(nameof(forwarder)); } return(forwarder.SendAsync(context, destinationPrefix, httpClient, requestConfig, HttpTransformer.Default)); }
public AtomController(IHttpForwarder httpForwarder, IPublisher publisher, IPublisher networkSendQueue, bool disableHTTPCaching = false) : base(publisher) { _httpForwarder = httpForwarder; _networkSendQueue = networkSendQueue; if (disableHTTPCaching) { // ReSharper disable once RedundantNameQualifier Transport.Http.Configure.DisableHTTPCaching = true; } }
public static ProjectionManagerNode Create( TFChunkDb db, QueuedHandler inputQueue, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue, IPublisher[] queues, RunProjections runProjections) { var projectionManagerNode = new ProjectionManagerNode(inputQueue, queues, runProjections); var projectionsController = new ProjectionsController(httpForwarder, inputQueue, networkSendQueue); foreach (var httpService in httpServices) { httpService.SetupController(projectionsController); } return projectionManagerNode; }
public static ProjectionManagerNode Create( TFChunkDb db, QueuedHandler inputQueue, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue, IPublisher[] queues, RunProjections runProjections) { var projectionManagerNode = new ProjectionManagerNode(inputQueue, queues, runProjections); var projectionsController = new ProjectionsController(httpForwarder, inputQueue, networkSendQueue); foreach (var httpService in httpServices) { httpService.SetupController(projectionsController); } return(projectionManagerNode); }
public ProjectionsController(IHttpForwarder httpForwarder, IPublisher publisher, IPublisher networkSendQueue) : base(publisher) { _httpForwarder = httpForwarder; var singleNodeFSRoot = MiniWeb.GetWebRootFileSystemDirectory("EventStore.SingleNode.Web"); _singleNodeJs = new MiniWeb("/web/es/js/projections", Path.Combine(singleNodeFSRoot, Path.Combine("singlenode-web", "js", "projections"))); var fileSystemWebRoot = MiniWeb.GetWebRootFileSystemDirectory("EventStore.Projections.Core"); _networkSendQueue = networkSendQueue; _miniWebPrelude = new MiniWeb("/web/es/js/projections/v8/Prelude", Path.Combine(fileSystemWebRoot, @"Prelude")); _miniWebResources = new MiniWeb("/web/es/js/projections/resources", Path.Combine(fileSystemWebRoot, Path.Combine("web-resources", "js"))); }
public ProjectionsController(IHttpForwarder httpForwarder, IPublisher publisher, IPublisher networkSendQueue) : base(publisher) { _httpForwarder = httpForwarder; var clusterNodeFSRoot = MiniWeb.GetWebRootFileSystemDirectory(); _clusterNodeJs = new MiniWeb("/web/es/js/projections", Path.Combine(clusterNodeFSRoot, Path.Combine("projections"))); var fileSystemWebRoot = MiniWeb.GetWebRootFileSystemDirectory(); _networkSendQueue = networkSendQueue; _miniWebPrelude = new MiniWeb("/web/es/js/projections/v8/Prelude", Path.Combine(fileSystemWebRoot, @"Prelude")); _miniWebResources = new MiniWeb("/web/es/js/projections/resources", Path.Combine(fileSystemWebRoot, Path.Combine("web-resources", "js"))); }
public StandardComponents( TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendService) { _db = db; _mainQueue = mainQueue; _mainBus = mainBus; _timerService = timerService; _timeProvider = timeProvider; _httpForwarder = httpForwarder; _httpServices = httpServices; _networkSendService = networkSendService; }
/// <summary> /// Constructor. /// </summary> /// <param name="blazorProxyService">The <see cref="Service"/></param> /// <param name="config">The <see cref="ProxyConfig"/></param> /// <param name="httpClient">HttpClient for forwarding requests.</param> /// <param name="forwarder">The YARP forwarder.</param> /// <param name="cache">The cache used for storing session information.</param> /// <param name="aesCipher">The <see cref="AesCipher"/> used for cookie encryption.</param> /// <param name="dnsClient">The <see cref="LookupClient"/> for service discovery.</param> /// <param name="sessionTransformer">The <see cref="SessionTransformer"/>.</param> public BlazorController( Service blazorProxyService, ProxyConfig config, HttpMessageInvoker httpClient, IHttpForwarder forwarder, IDistributedCache cache, AesCipher aesCipher, LookupClient dnsClient, SessionTransformer sessionTransformer) { this.blazorProxyService = blazorProxyService; this.config = config; this.httpClient = httpClient; this.forwarder = forwarder; this.cache = cache; this.cipher = aesCipher; this.transformer = sessionTransformer; this.dnsClient = dnsClient; }
public StandardComponents( TFChunkDb db, IQueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendService) { _db = db; _mainQueue = mainQueue; _mainBus = mainBus; _timerService = timerService; _timeProvider = timeProvider; _httpForwarder = httpForwarder; _httpServices = httpServices; _networkSendService = networkSendService; }
/// <summary> /// Constructor. /// </summary> /// <param name="NeonSsoSessionProxyService"></param> /// <param name="httpClient"></param> /// <param name="forwarder"></param> /// <param name="cache"></param> /// <param name="aesCipher"></param> /// <param name="dexClient"></param> public AuthController( Service NeonSsoSessionProxyService, HttpMessageInvoker httpClient, IHttpForwarder forwarder, IDistributedCache cache, AesCipher aesCipher, DexClient dexClient, SessionTransformer sessionTransformer, DistributedCacheEntryOptions cacheOptions ) { this.NeonSsoSessionProxyService = NeonSsoSessionProxyService; this.httpClient = httpClient; this.forwarder = forwarder; this.cache = cache; this.cipher = aesCipher; this.transformer = sessionTransformer; this.dexClient = dexClient; this.cacheOptions = cacheOptions; }
/// <summary> /// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. /// </summary> public void Configure(IApplicationBuilder app, IHttpForwarder httpProxy) { var httpClient = new HttpMessageInvoker(new SocketsHttpHandler() { UseProxy = false, AllowAutoRedirect = false, AutomaticDecompression = DecompressionMethods.None, UseCookies = false }); var transformBuilder = app.ApplicationServices.GetRequiredService <ITransformBuilder>(); var transformer = transformBuilder.Create(context => { context.AddQueryRemoveKey("param1"); context.AddQueryValue("area", "xx2", false); context.AddOriginalHost(false); }); // or var transformer = new CustomTransformer(); // or var transformer = HttpTransformer.Default; var requestOptions = new ForwarderRequestConfig { Timeout = TimeSpan.FromSeconds(100) }; app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.Map("/{**catch-all}", async httpContext => { await httpProxy.SendAsync(httpContext, "https://example.com", httpClient, requestOptions, transformer); var errorFeature = httpContext.GetForwarderErrorFeature(); if (errorFeature != null) { var error = errorFeature.Error; var exception = errorFeature.Exception; } }); }); }
private void SetupMessaging( TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue, RunProjections runProjections) { _coreQueues = new List <QueuedHandler>(); _managerInputBus = new InMemoryBus("manager input bus"); _managerInputQueue = new QueuedHandler(_managerInputBus, "Projections Master"); while (_coreQueues.Count < _projectionWorkerThreadCount) { var coreInputBus = new InMemoryBus("bus"); var coreQueue = new QueuedHandler( coreInputBus, "Projection Core #" + _coreQueues.Count, groupName: "Projection Core"); var projectionNode = new ProjectionWorkerNode(db, coreQueue, timeProvider, runProjections); projectionNode.SetupMessaging(coreInputBus); var forwarder = new RequestResponseQueueForwarder( inputQueue: coreQueue, externalRequestQueue: mainQueue); // forwarded messages projectionNode.CoreOutput.Subscribe <ClientMessage.ReadEvent>(forwarder); projectionNode.CoreOutput.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder); projectionNode.CoreOutput.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder); projectionNode.CoreOutput.Subscribe <ClientMessage.ReadAllEventsForward>(forwarder); projectionNode.CoreOutput.Subscribe <ClientMessage.WriteEvents>(forwarder); if (runProjections >= RunProjections.System) { projectionNode.CoreOutput.Subscribe( Forwarder.Create <CoreProjectionManagementMessage.StateReport>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create <CoreProjectionManagementMessage.ResultReport>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create <CoreProjectionManagementMessage.StatisticsReport>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create <CoreProjectionManagementMessage.Started>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create <CoreProjectionManagementMessage.Stopped>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create <CoreProjectionManagementMessage.Faulted>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create <CoreProjectionManagementMessage.Prepared>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create <CoreProjectionManagementMessage.SlaveProjectionReaderAssigned>( _managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create <ProjectionManagementMessage.ControlMessage>(_managerInputQueue)); } projectionNode.CoreOutput.Subscribe <TimerMessage.Schedule>(timerService); projectionNode.CoreOutput.Subscribe(Forwarder.Create <Message>(coreQueue)); // forward all coreInputBus.Subscribe(new UnwrapEnvelopeHandler()); _coreQueues.Add(coreQueue); } _managerInputBus.Subscribe( Forwarder.CreateBalancing <FeedReaderMessage.ReadPage>(_coreQueues.Cast <IPublisher>().ToArray())); _projectionManagerNode = ProjectionManagerNode.Create( db, _managerInputQueue, httpForwarder, httpServices, networkSendQueue, _coreQueues.Cast <IPublisher>().ToArray(), runProjections); _projectionManagerNode.SetupMessaging(_managerInputBus); { var forwarder = new RequestResponseQueueForwarder( inputQueue: _managerInputQueue, externalRequestQueue: mainQueue); _projectionManagerNode.Output.Subscribe <ClientMessage.ReadEvent>(forwarder); _projectionManagerNode.Output.Subscribe <ClientMessage.ReadStreamEventsBackward>(forwarder); _projectionManagerNode.Output.Subscribe <ClientMessage.ReadStreamEventsForward>(forwarder); _projectionManagerNode.Output.Subscribe <ClientMessage.WriteEvents>(forwarder); _projectionManagerNode.Output.Subscribe( Forwarder.Create <ProjectionManagementMessage.RequestSystemProjections>(mainQueue)); _projectionManagerNode.Output.Subscribe(Forwarder.Create <Message>(_managerInputQueue)); _projectionManagerNode.Output.Subscribe <TimerMessage.Schedule>(timerService); // self forward all mainBus.Subscribe(Forwarder.Create <SystemMessage.StateChangeMessage>(_managerInputQueue)); _managerInputBus.Subscribe(new UnwrapEnvelopeHandler()); } }
private void SetupMessaging( TFChunkDb db, QueuedHandler mainQueue, ISubscriber mainBus, TimerService timerService, ITimeProvider timeProvider, IHttpForwarder httpForwarder, HttpService[] httpServices, IPublisher networkSendQueue, RunProjections runProjections) { _coreQueues = new List<QueuedHandler>(); _managerInputBus = new InMemoryBus("manager input bus"); _managerInputQueue = new QueuedHandler(_managerInputBus, "Projections Master"); while (_coreQueues.Count < _projectionWorkerThreadCount) { var coreInputBus = new InMemoryBus("bus"); var coreQueue = new QueuedHandler( coreInputBus, "Projection Core #" + _coreQueues.Count, groupName: "Projection Core"); var projectionNode = new ProjectionWorkerNode(db, coreQueue, timeProvider, runProjections); projectionNode.SetupMessaging(coreInputBus); var forwarder = new RequestResponseQueueForwarder( inputQueue: coreQueue, externalRequestQueue: mainQueue); // forwarded messages projectionNode.CoreOutput.Subscribe<ClientMessage.ReadEvent>(forwarder); projectionNode.CoreOutput.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder); projectionNode.CoreOutput.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder); projectionNode.CoreOutput.Subscribe<ClientMessage.ReadAllEventsForward>(forwarder); projectionNode.CoreOutput.Subscribe<ClientMessage.WriteEvents>(forwarder); if (runProjections >= RunProjections.System) { projectionNode.CoreOutput.Subscribe( Forwarder.Create<CoreProjectionManagementMessage.StateReport>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create<CoreProjectionManagementMessage.ResultReport>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create<CoreProjectionManagementMessage.StatisticsReport>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create<CoreProjectionManagementMessage.Started>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create<CoreProjectionManagementMessage.Stopped>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create<CoreProjectionManagementMessage.Faulted>(_managerInputQueue)); projectionNode.CoreOutput.Subscribe( Forwarder.Create<CoreProjectionManagementMessage.Prepared>(_managerInputQueue)); } projectionNode.CoreOutput.Subscribe(timerService); projectionNode.CoreOutput.Subscribe(Forwarder.Create<Message>(coreQueue)); // forward all coreInputBus.Subscribe(new UnwrapEnvelopeHandler()); _coreQueues.Add(coreQueue); } _managerInputBus.Subscribe( Forwarder.CreateBalancing<FeedReaderMessage.ReadPage>(_coreQueues.Cast<IPublisher>().ToArray())); _projectionManagerNode = ProjectionManagerNode.Create( db, _managerInputQueue, httpForwarder, httpServices, networkSendQueue, _coreQueues.Cast<IPublisher>().ToArray(), runProjections); _projectionManagerNode.SetupMessaging(_managerInputBus); { var forwarder = new RequestResponseQueueForwarder( inputQueue: _managerInputQueue, externalRequestQueue: mainQueue); _projectionManagerNode.Output.Subscribe<ClientMessage.ReadEvent>(forwarder); _projectionManagerNode.Output.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder); _projectionManagerNode.Output.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder); _projectionManagerNode.Output.Subscribe<ClientMessage.WriteEvents>(forwarder); _projectionManagerNode.Output.Subscribe( Forwarder.Create<ProjectionManagementMessage.RequestSystemProjections>(mainQueue)); _projectionManagerNode.Output.Subscribe(Forwarder.Create<Message>(_managerInputQueue)); _projectionManagerNode.Output.Subscribe(timerService); // self forward all mainBus.Subscribe(Forwarder.Create<SystemMessage.StateChangeMessage>(_managerInputQueue)); _managerInputBus.Subscribe(new UnwrapEnvelopeHandler()); } }
public UsersController(IHttpForwarder httpForwarder, IPublisher publisher, IPublisher networkSendQueue) : base(publisher) { _httpForwarder = httpForwarder; _networkSendQueue = networkSendQueue; }
/// <summary> /// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. /// </summary> public void Configure(IApplicationBuilder app, IHttpForwarder forwarder) { // Configure our own HttpMessageInvoker for outbound calls for proxy operations var httpClient = new HttpMessageInvoker(new SocketsHttpHandler() { UseProxy = false, AllowAutoRedirect = false, AutomaticDecompression = DecompressionMethods.None, UseCookies = false }); // Setup our own request transform class var transformer = new CustomTransformer(); // or HttpTransformer.Default; var requestOptions = new ForwarderRequestConfig { Timeout = TimeSpan.FromSeconds(100) }; app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.Map("/test/{**catch-all}", async httpContext => { var error = await forwarder.SendAsync(httpContext, "https://example.com", httpClient, requestOptions, (context, proxyRequest) => { // Customize the query string: var queryContext = new QueryTransformContext(context.Request); queryContext.Collection.Remove("param1"); queryContext.Collection["area"] = "xx2"; // Assign the custom uri. Be careful about extra slashes when concatenating here. proxyRequest.RequestUri = new Uri("https://example.com" + context.Request.Path + queryContext.QueryString); // Suppress the original request header, use the one from the destination Uri. proxyRequest.Headers.Host = null; return(default); }); // Check if the proxy operation was successful if (error != ForwarderError.None) { var errorFeature = httpContext.Features.Get <IForwarderErrorFeature>(); var exception = errorFeature.Exception; } }); // When using IHttpForwarder for direct forwarding you are responsible for routing, destination discovery, load balancing, affinity, etc.. // For an alternate example that includes those features see BasicYarpSample. endpoints.Map("/{**catch-all}", async httpContext => { var error = await forwarder.SendAsync(httpContext, "https://example.com", httpClient, requestOptions, transformer); // Check if the proxy operation was successful if (error != ForwarderError.None) { var errorFeature = httpContext.Features.Get <IForwarderErrorFeature>(); var exception = errorFeature.Exception; } }); });
/// <summary> /// Forwards the incoming request to the destination server, and the response back to the client. /// </summary> /// <param name="context">The HttpContext to forward.</param> /// <param name="destinationPrefix">The url prefix for where to forward the request to.</param> /// <param name="httpClient">The HTTP client used to forward the request.</param> /// <param name="requestConfig">Config for the outgoing request.</param> /// <param name="requestTransform">Transform function to apply to the forwarded request.</param> /// <returns>The status of a forwarding operation.</returns> public static ValueTask <ForwarderError> SendAsync(this IHttpForwarder forwarder, HttpContext context, string destinationPrefix, HttpMessageInvoker httpClient, ForwarderRequestConfig requestConfig, Func <HttpContext, HttpRequestMessage, ValueTask> requestTransform) { return(forwarder.SendAsync(context, destinationPrefix, httpClient, requestConfig, new RequestTransformer(requestTransform))); }