public override async Task Invoke(HttpContext context)
{
var request = context.Request;
if (request.Headers.TryGetValue(AuthHeader.Authorization.ToString(), out var value))
{
var firstAuthHeader = value.FirstOrDefault();
if (firstAuthHeader != null)
{
if (firstAuthHeader.StartsWith(AuthHeader.Basic.ToString(), StringComparison.OrdinalIgnoreCase))
{
var userNamePassword = Encoding.UTF8.GetString(Convert.FromBase64String(firstAuthHeader.Replace(AuthHeader.Basic.ToString(), "",
StringComparison.OrdinalIgnoreCase))).Split(':');
var userName = userNamePassword.ElementAt(0);
var password = userNamePassword.ElementAt(1);
if (string.Equals(userName, "test", StringComparison.CurrentCultureIgnoreCase) &&
password == "password")
{
context.Items.Add("username", userName);
await NextMiddleware.Invoke(context);
return;
}
}
}
}
context.Response.StatusCode = 401;
context.Response.Headers.Add("WWW-Authenticate", AuthHeader.Basic.ToString());
}
public async Task InvokeAsync(TestCtx parameter, NextMiddleware next, CancellationToken cancellationToken)
{
parameter.ExecutedMiddlewaresCount++;
parameter.Msg += "Before_" + nameof(Middleware1);
await next();
parameter.Msg += "After_" + nameof(Middleware1);
}
public async Task InvokeAsync(SomeContext parameter, NextMiddleware next, CancellationToken cancellationToken)
{
_logger.LogInformation("before SubdomainDetectMiddleware next");
// imagine complex logic for detecting which subdomain should process this
parameter.Response.Type = SubDomainType.Subdomain1;
await next();
_logger.LogInformation("after SubdomainDetectMiddleware next");
}
protected middleware_context()
{
Env = new InMemoryCommunicationContext
{
PipelineData =
{
PipelineStage = new PipelineStage()
{
CurrentState = PipelineContinuation.Continue
}
}
};
Next = new NextMiddleware(() => NextCalled = true);
}
/// <summary>
/// Invokes middleware.
/// </summary>
/// <param name="parameter">Pipeline parameter.</param>
/// <param name="next">Next middleware.</param>
/// <param name="cancellationToken">Cancellation token.</param>
public Task InvokeAsync(SomeContext parameter, NextMiddleware next, CancellationToken cancellationToken)
{
foreach (var doc in parameter.Request.Documents)
{
parameter.Response.Documents.Add(new Subdomain1Document
{
FileName = doc.FileName,
FileId = doc.FileId,
AdditionalInfo = "some additional data"
});
}
return(next());
}
public async Task InvokeAsync(SomeContext parameter, NextMiddleware next, CancellationToken cancellationToken)
{
_logger.LogInformation("before PreconditionCheckMiddleware next");
if (parameter.Request is null)
{
// also can supply additional error message ...
parameter.Response.IsValid = false;
return;
}
await next();
_logger.LogInformation("after PreconditionCheckMiddleware next");
}
/// <summary>
/// Invokes middleware.
/// </summary>
/// <param name="parameter">Pipeline parameter.</param>
/// <param name="next">Next middleware.</param>
/// <param name="cancellationToken">Cancellation token.</param>
public async Task InvokeAsync(SomeContext parameter, NextMiddleware next, CancellationToken cancellationToken)
{
var sw = new Stopwatch();
sw.Start();
try
{
await next();
}
catch (Exception e)
{
_logger.LogError(e, "Exception!");
}
finally
{
sw.Stop();
_logger.LogInformation("Pipeline time {Time}", sw.ElapsedMilliseconds);
}
}
/// <summary>
/// Execute configured pipeline.
/// </summary>
/// <param name="parameter">Pipeline parameter.</param>
/// <param name="cancellationToken">Cancellation token.</param>
public Task ExecuteAsync(TParameter parameter, CancellationToken cancellationToken = default)
{
if (_pipelineComponents.Count == 0)
{
return(Task.CompletedTask);
}
var index = 0;
NextMiddleware next = _completedMiddleware;
next = () =>
{
var type = _pipelineComponents[index];
index++;
if (index == _pipelineComponents.Count)
{
next = _completedMiddleware; // final action
}
if (type.NextMiddlewareType is not null)
{
var typedMiddleware = (IMiddleware <TParameter>)ActivatorUtilities.CreateInstance(_serviceProvider, type.NextMiddlewareType);
return(typedMiddleware.InvokeAsync(parameter, next, cancellationToken));
}
if (type.NextFunc is not null)
{
return(type.NextFunc(_serviceProvider, (_, _) => next())(parameter, cancellationToken));
}
throw new InvalidOperationException("Invalid pipeline component. No middleware or delegate supplied.");
};
return(next());
}
