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();
}
