public void Init() { _ctx = new PipelineContext(); _ctx.Add(1); _ctx.Add(2); _ctx.Add(3); _ctx.Add("4"); }
public async Task Invoke(HttpContext httpContext) { if (httpContext.Request.Path.StartsWithSegments(_middlewareConfiguration.StartsWithSegment)) { var pipelineContext = new PipelineContext(); pipelineContext .Add(httpContext); await _pipelineRequest.InvokeAsync(pipelineContext); if (pipelineContext.GetFirst(out PipelineMiddlewareEnum pipelineMiddlewareEnum)) { if (pipelineMiddlewareEnum == PipelineMiddlewareEnum.Exit) { return; } } else if (_middlewareConfiguration.AfterPipelineInvoke == PipelineMiddlewareEnum.Exit) { return; } } await _next(httpContext); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (!context.GetFirst(out HttpRequestMessage httpRequestMessage)) { throw new PipelineDependencyException <HttpRequestMessage>(this); } HttpClientRequest request = new HttpClientRequest(httpRequestMessage); CancellationTokenSource cts = new CancellationTokenSource(RequestTimeout); var cancellationTokens = context.Get <CancellationToken>(); var token = cancellationTokens.Any() ? CancellationTokenSource.CreateLinkedTokenSource( cancellationTokens.Concat(new[] { cts.Token }).ToArray() ).Token : cts.Token; try { var result = await request.InvokeAsync(token); context.Add(result); await next.Invoke(); } catch (HttpRequestException ex) { throw new PipelineException(this, ex.Message, ex); } catch (Exception ex) { throw new PipelineException(this, ex.Message, ex); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { context.Remove(CircuitBreakerEnum.OpenState); CircuitState.State currentState = CircuitState.State.Closed; _circuitState.Invoke(x => currentState = x.GetState()); var activeStates = new[] { CircuitState.State.Closed, CircuitState.State.Half_Open }; if (activeStates.Any(x => x == currentState)) { await next.Invoke(); if (!context.GetFirst(out HttpResponseMessage httpResponseMessage)) { throw new PipelineDependencyException <HttpResponseMessage>(this); } _circuitState.Invoke(x => x.Update(!httpResponseMessage.IsTransientFailure())); } else { context.Add(CircuitBreakerEnum.OpenState); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { await next.Invoke(); if (context.GetFirst(out HttpResponseMessage httpResponseMessage)) { var code = (int)httpResponseMessage.StatusCode; if ((Sanitize500s && Between(code, 500, 599)) || (Sanitize400s && Between(code, 400, 499)) || (Sanitize300s && Between(code, 300, 399)) || SanitizeResponseCodes.Contains(code)) { if (SaveOriginalContent) { var originalResponse = new ResponseSanitizerContent(); originalResponse.Copy(httpResponseMessage); context.Add(originalResponse); } HttpResponseBuilder.HttpResponseMessage(httpResponseMessage) .WithNoContent() .WithReasonPhrase(string.Empty) .If(ReturnErrorReference, resp => resp.WithStringContent($"{{\"errorReference\":\"{context.Id}\"}}")) .If(ReplacementResponseCode.HasValue, resp => resp.WithStatusCode(ReplacementResponseCode.Value)); } } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { var concurrentPipelineCount = ConcurrentPipelineCount < 1 ? 1 : ConcurrentPipelineCount; foreach (var requestAndPipeline in _requestAndPipeline) { context.Add(requestAndPipeline.Context); } var remainingItems = _requestAndPipeline .Skip(concurrentPipelineCount) .Select(x => x); var runningTasks = _requestAndPipeline .Take(concurrentPipelineCount) .Select(x => x.InvokeAsync()) .ToList(); while (runningTasks.Any()) { var task = await Task.WhenAny(runningTasks.ToArray()); runningTasks.Remove(task); var nextTask = remainingItems.FirstOrDefault(); if (nextTask != null) { runningTasks.Add(nextTask.InvokeAsync()); remainingItems = remainingItems.Skip(1); } } await next.Invoke(); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpRequestMessage httpRequestMessage)) { var redirectUri = FindMatchingRedirect(httpRequestMessage.RequestUri); if (redirectUri != null) { var redirected = new Redirected( httpRequestMessage, redirectUri); context.Add(redirected); httpRequestMessage.RequestUri = redirectUri; } else { if (Return404IfNotFound) { var response = HttpResponseBuilder .HttpResponseMessage() .WithStatusCode(404) .WithContent(new StringContent( "{\"RouteRedirect\": \"No matching route\"}", Encoding.ASCII, "appliation/json")) .Build(); context.Add(response); return; } } await next.Invoke(); } else { throw new PipelineDependencyException <HttpRequestMessage>(this); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (!context.GetFirst(out HttpContext httpContext)) { throw new PipelineDependencyException <HttpContext>(this); } PipelineConverters.Convert(httpContext.Request, out HttpRequestMessage httpRequestMessage, HeadersToRemove); context .Add(httpRequestMessage) .Add(httpContext.RequestAborted); await next.Invoke(); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { var stopWatch = new System.Diagnostics.Stopwatch(); try { stopWatch.Start(); await next.Invoke(); } finally { context.Add(stopWatch.Elapsed); stopWatch.Stop(); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (!context.GetFirst(out HttpContext httpContext)) { throw new PipelineDependencyException <HttpContext>(this); } var(result, versionNo) = GetVersionHeader(httpContext.Request.Headers); if (result) { context.Add(versionNo); } await next.Invoke(); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (!context.GetFirst(out HttpRequestMessage httpRequestMessage)) { throw new PipelineDependencyException <HttpRequestMessage>(this); } var parameters = HttpUtility.ParseQueryString(httpRequestMessage.RequestUri.Query); var paramNameAndValue = parameters.Cast <string>() .Where(key => string.Compare(key, ParamName, true) == 0) .Select(key => new { key, value = parameters[key] }) .FirstOrDefault(); var matched = false; switch (ParamEvaluation) { case ParamEvaluationEnum.ParamExists: matched = paramNameAndValue != null; break; case ParamEvaluationEnum.ParamDoesNotExist: matched = paramNameAndValue == null; break; case ParamEvaluationEnum.ParamValueMatches: matched = string.Compare(paramNameAndValue?.value, ParamValue, true) == 0; break; case ParamEvaluationEnum.ParamValueDoesNotMatch: matched = (paramNameAndValue != null) && string.Compare(paramNameAndValue?.value, ParamValue, true) != 0; break; } if (matched) { UriBuilder builder = new UriBuilder(RedirectUrl) { Query = httpRequestMessage.RequestUri.Query }; var redirectedUri = builder.Uri; context.Add(new Redirected(httpRequestMessage, redirectedUri)); httpRequestMessage.RequestUri = redirectedUri; } await next.Invoke(); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { PipelineContext parallelContext = new PipelineContext(); Task parallelTask = new Task(async() => await ParallelPipelineRequest.InvokeAsync(parallelContext)); parallelTask.Start(); context.Add(new ParallelPipelineInfo() { Context = parallelContext, ParallelTask = parallelTask }); await Task.WhenAll(new Task[] { next.Invoke(), parallelTask }); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpResponseMessage responseMessage)) { if (responseMessage.IsSuccessStatusCode) { var response = await responseMessage.Content.ReadAsStringAsync(); context.Add("response", response); } } else { throw new PipelineDependencyException <HttpResponseMessage>(this); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpResponseMessage responseMessage)) { if (responseMessage.IsSuccessStatusCode) { //var response = await responseMessage.Content.ReadAsStringAsync(); XmlSerializer serializer = new XmlSerializer(typeof(LuasLines)); var response = serializer.Deserialize(await responseMessage.Content.ReadAsStreamAsync()); context.Add("response", (LuasLines)response); } } else { throw new PipelineDependencyException <HttpResponseMessage>(this); } }
public void Context_Add() { //given _ctx.Add(5); //then Assert.AreEqual(5, _ctx.Count); Assert.AreEqual(4, _ctx.Get <int>().Count()); Assert.AreEqual(1, _ctx.Get <string>().Count()); CollectionAssert.AreEquivalent( new[] { 1, 2, 3, 5 }, _ctx.Get <int>().ToArray()); CollectionAssert.AreEquivalent( new[] { "4" }, _ctx.Get <string>().ToArray()); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpRequestMessage httpRequestMessage)) { UriBuilder builder = new UriBuilder(httpRequestMessage.RequestUri) { Host = RedirectHost, Port = RedirectPort }; var redirectUri = builder.Uri; context.Add(new Redirected(httpRequestMessage, builder.Uri)); httpRequestMessage.RequestUri = redirectUri; await next.Invoke(); } else throw new PipelineDependencyException<HttpRequestMessage>(this); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.Get("endpoint", out string endPoint)) { if (BaseUrl == null) { context.AddNotification(this, "Missing BaseUrl value"); return; } var uri = BaseUrl.Append(endPoint); context.Add(uri); await next.Invoke(); } else { context.AddNotification(this, "Missing endpoint information"); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpResponseMessage responseMessage)) { if (responseMessage.IsSuccessStatusCode) { var result = await responseMessage.Content.ReadAsStringAsync(); var response = JsonConvert.DeserializeObject <DublinBikeStation>(result); context.Add("response", response); } await next.Invoke(); } else { throw new PipelineDependencyException <HttpResponseMessage>(this); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { var count = Interlocked.Increment(ref _activeClients); try { if (count <= MaxClients) { context.Remove(RateLimiterEnum.RateLimited); await next.Invoke(); return; } context.Add(RateLimiterEnum.RateLimited); } finally { Interlocked.Decrement(ref _activeClients); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { try { await next.Invoke(); } finally { IActionResult objectResult = null; if (context.Get("response", out T response)) { objectResult = new ObjectResult(response) { StatusCode = 200 } } ; else { objectResult = new ObjectResult( new { context.Id, notifications = context .Get <Notification>() .Select((x, i) => new { id = i + 1, Handler = x.Handler.ToString(), x.ErrorMessage }) }) { StatusCode = 500 }; } context.Add <IActionResult>(objectResult); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out Uri uri)) { var response = await HttpClientRequest .Get() .Uri(uri) .InvokeAsync(); if (response.IsSuccessStatusCode) { context.Add(response); await next.Invoke(); } ; } else { context.AddNotification(this, "No URI specified"); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { context.Remove(FixedIntervalRetryEnum.RetryCountExceeded); int index = 0; await next.Invoke(); while (IsTransientFailure(context)) { var delay = Configuration.GetInterval(index); if (!delay.HasValue) { context.Add(FixedIntervalRetryEnum.RetryCountExceeded); break; } await Task.Delay(delay.Value); await next.Invoke(); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpResponseMessage responseMessage)) { if (responseMessage.IsSuccessStatusCode) { var result = await responseMessage.Content.ReadAsStringAsync(); var response = JsonConvert.DeserializeObject <ApiResponse <T> > (result, new IsoDateTimeConverter { DateTimeFormat = "dd/MM/yyyy HH:mm:ss" }); context.Add("response", response); await next.Invoke(); } } else { throw new PipelineDependencyException <HttpResponseMessage>(this); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpRequestMessage httpRequestMessage)) { if (httpRequestMessage.Content?.Headers.ContentLength > MaxRequestSize) { var response = HttpResponseBuilder .HttpResponseMessage() .WithReasonPhrase("Content too large") .WithStatusCode(500); context.Add(response); } else { await next.Invoke(); } } else { throw new PipelineDependencyException <HttpRequestMessage>(this); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpRequestMessage httpRequestMessage)) { if (RefusedMethods.Any(x => x == httpRequestMessage.Method)) { var response = HttpResponseBuilder .HttpResponseMessage() .WithReasonPhrase("Method refused") .WithStatusCode(403); context.Add(response); } else { await next.Invoke(); } } else { throw new PipelineDependencyException <HttpRequestMessage>(this); } }
public static PipelineContext AddNotification(this PipelineContext context, IPipelineHandler handler, string errorMessage) => context.Add(new Notification(handler, errorMessage));
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { context.Add(BaseUrl); await next.Invoke(); }