public ErrorHandlingMiddleware(RequestDelegate next, IWebHostEnvironment host, IActionResultExecutor <ObjectResult> executor, ILogger <ErrorHandlingMiddleware> logger)
{
this.next = next;
this.host = host;
this.executor = executor;
this.logger = logger;
}
public WrapperBase(RequestDelegate next, AutoWrapperOptions options, ILogger <AutoWrapperMiddleware> logger, IActionResultExecutor <ObjectResult> executor)
{
_next = next;
_options = options;
_logger = logger;
_executor = executor;
}
public ErrorHandlingMiddleware(RequestDelegate next, IActionResultExecutor <ObjectResult> executor,
ILoggerFactory loggerFactory)
{
_next = next;
_executor = executor;
_loggerFactory = loggerFactory;
}
public async Task InvokeAsync(HttpContext context, IActionResultExecutor <ObjectResult> writer, ISemanticLog log)
{
if (TryGetErrorCode(context, out var statusCode) && IsErrorStatusCode(statusCode))
{
var(error, _) = ApiExceptionConverter.ToErrorDto(statusCode, context);
await WriteErrorAsync(context, error, writer);
return;
}
try
{
await next(context);
}
catch (Exception ex)
{
log.LogError(ex, w => w.WriteProperty("message", "An unexpected exception has occurred."));
if (!context.Response.HasStarted)
{
var(error, _) = ex.ToErrorDto(context);
await WriteErrorAsync(context, error, writer);
}
}
if (IsErrorStatusCode(context.Response.StatusCode) && !context.Response.HasStarted)
{
var(error, _) = ApiExceptionConverter.ToErrorDto(context.Response.StatusCode, context);
await WriteErrorAsync(context, error, writer);
}
}
public ExceptionHandlerMiddleware(RequestDelegate next, IActionResultExecutor <ObjectResult> executor, ILoggerFactory loggerFactory)
{
this.next = next;
this.executor = executor;
logger = loggerFactory.CreateLogger <ExceptionHandlerMiddleware>();
clearCacheHeadersDelegate = ClearCacheHeaders;
}
public Task WriteProblemDetails(HttpContext context, IActionResultExecutor <ObjectResult> executor, object body, Exception exception, bool isDebug = false)
{
var statusCode = context.Response.StatusCode;
object details = exception == null?DelegateResponse(body, statusCode) : GetProblemDetails(exception, isDebug);
if (details is ProblemDetails)
{
(details as ProblemDetails).Instance = context.Request.Path;
}
var routeData = context.GetRouteData() ?? _emptyRouteData;
var actionContext = new ActionContext(context, routeData, _emptyActionDescriptor);
var result = new ObjectResult(details)
{
StatusCode = (details is ProblemDetails problem) ? problem.Status : statusCode,
DeclaredType = details.GetType()
};
result.ContentTypes.Add(TypeIdentifier.ProblemJSONHttpContentMediaType);
result.ContentTypes.Add(TypeIdentifier.ProblemXMLHttpContentMediaType);
return(executor.ExecuteAsync(actionContext, result));
}
public ExceptionHandlerMiddleware(
RequestDelegate next,
IActionResultExecutor <ObjectResult> executor,
ILogger <ExceptionHandlerMiddleware> logger)
{
_next = next;
_executor = executor;
_logger = logger;
}
public ExceptionHandler(
RequestDelegate next,
IHostingEnvironment env,
IActionResultExecutor <ObjectResult> resultExecutor)
{
_next = next;
_env = env;
_resultExecutor = resultExecutor;
}
public static Task ExecuteResultAsync <TResult>([NotNull] this HttpContext context, [NotNull] TResult result)
where TResult : IActionResult
{
IActionResultExecutor <TResult> executor = context.RequestServices.GetRequiredService <IActionResultExecutor <TResult> >();
RouteData routeData = context.GetRouteData();
ActionContext actionContext = new ActionContext(context, routeData, new ActionDescriptor());
return(executor.ExecuteAsync(actionContext, result));
}
public RequestExceptionMiddleware(IActionResultExecutor <ObjectResult> resultWriter, ISemanticLog log)
{
Guard.NotNull(resultWriter, nameof(resultWriter));
Guard.NotNull(log, nameof(log));
this.resultWriter = resultWriter;
this.log = log;
}
public ErrorWrappingMiddleware(
RequestDelegate next,
IActionResultExecutor <ObjectResult> executor,
ILogger <ErrorWrappingMiddleware> logger)
{
_next = next;
_executor = executor;
_logger = logger;
}
public async Task HandleProblemDetailsExceptionAsync(HttpContext context, IActionResultExecutor <ObjectResult> executor, object body, Exception exception = null)
{
await new ApiProblemDetailsMember().WriteProblemDetails(context, executor, body, exception, _options.IsDebug);
if (_options.EnableExceptionLogging && exception != null)
{
_logger.Log(LogLevel.Error, exception, $"[{context.Response.StatusCode}]: { exception.GetBaseException().Message }");
}
}
public WebhookMiddleware(
RequestDelegate next,
IActionResultExecutor <ObjectResult> objectResultExecutor,
ITelegramBotClient botClient,
IOptions <BotOptions> options)
{
_next = next;
_botClient = botClient;
_options = options.Value;
_objectResultExecutor = objectResultExecutor;
}
public ExceptionMiddleware(RequestDelegate next, IActionResultExecutor <ObjectResult> executor, ILoggerFactory loggerFactory)
{
this.next = next;
this.executor = executor;
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.WriteTo.File("logs\\myapp.txt", rollingInterval: RollingInterval.Day)
.CreateLogger();
}
public WrapperBase(RequestDelegate next, DiagnosticContext diagnosticContext,
AutoWrapperOptions options,
IActionResultExecutor <ObjectResult> executor)
{
_next = next;
_diagnosticContext = diagnosticContext;
_options = options;
_messageTemplate = new MessageTemplateParser().Parse(DefaultRequestCompletionMessageTemplate);
_logger = options.Logger ?? Log.ForContext <WrapperBase>();
_executor = executor;
}
public ProblemDetailsMiddleware(
RequestDelegate next,
IOptions <ProblemDetailsOptions> options,
IActionResultExecutor <ObjectResult> executor,
ILogger <ProblemDetailsMiddleware> logger)
{
Next = next;
Options = options.Value;
Executor = executor;
Logger = logger;
}
public ThrottlingMiddlewareTests()
{
_throttlingConfiguration = new ThrottlingConfiguration
{
ConcurrentRequestLimit = 5,
Enabled = true,
};
_cts = new CancellationTokenSource();
_httpContext.RequestAborted = _cts.Token;
_httpContext.User = new ClaimsPrincipal(new ClaimsIdentity("authenticationType", "nametype", "roletype"));
_throttlingConfiguration.ExcludedEndpoints.Add(new ExcludedEndpoint {
Method = "get", Path = "/health/check"
});
_middleware = new Lazy <ThrottlingMiddleware>(
() => new ThrottlingMiddleware(
async x =>
{
x.Response.StatusCode = 200;
try
{
if (!int.TryParse(Regex.Match(x.Request.Path, "/duration/(\\d+)").Groups[1].Value, out var duration))
{
duration = 5000;
}
var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_cts.Token, x.RequestAborted);
await Task.Delay(duration, linkedTokenSource.Token);
}
catch (TaskCanceledException) when(_cts.Token.IsCancellationRequested)
{
}
catch (TaskCanceledException) when(x.RequestAborted.IsCancellationRequested)
{
x.Response.StatusCode = StatusCodes.Status408RequestTimeout;
}
},
Options.Create(_throttlingConfiguration),
Options.Create(new SecurityConfiguration {
Enabled = _securityEnabled
}),
NullLogger <ThrottlingMiddleware> .Instance));
IActionResultExecutor <ObjectResult> executor = Substitute.For <IActionResultExecutor <ObjectResult> >();
executor.ExecuteAsync(Arg.Any <ActionContext>(), Arg.Any <ObjectResult>()).ReturnsForAnyArgs(Task.CompletedTask);
_collection.AddSingleton <IActionResultExecutor <ObjectResult> >(executor);
_provider = _collection.BuildServiceProvider();
_httpContext.RequestServices = _provider;
}
/// <summary>
///
/// </summary>
/// <param name="mvcOptions"></param>
/// <param name="contentResultExecutor"></param>
/// <param name="controllerActionInvokerCache"></param>
/// <param name="actionInvokerFactory"></param>
/// <param name="actionInvokeInfoCache"></param>
public RouteTesterActionInvokerFactory(
IOptions <MvcOptions> mvcOptions,
IActionResultExecutor <ContentResult> contentResultExecutor,
ControllerActionInvokerCache controllerActionInvokerCache,
ActionInvokerFactory actionInvokerFactory,
ActualActionInvokeInfoCache actionInvokeInfoCache)
{
_mvcOptions = mvcOptions;
_contentResultExecutor = contentResultExecutor;
_controllerActionInvokerCache = controllerActionInvokerCache;
_actionInvokerFactory = actionInvokerFactory;
_actionInvokeInfoCache = actionInvokeInfoCache;
}
/// <summary>
///
/// </summary>
/// <param name="actionContext"></param>
/// <param name="valueProviderFactories"></param>
/// <param name="contentResultExecutor"></param>
/// <param name="controllerActionInvokerCache"></param>
/// <param name="actionInvokerFactory"></param>
/// <param name="actionInvokeInfoCache"></param>
public RouteTesterActionInvoker(
ActionContext actionContext,
IList <IValueProviderFactory> valueProviderFactories,
IActionResultExecutor <ContentResult> contentResultExecutor,
ControllerActionInvokerCache controllerActionInvokerCache,
ActionInvokerFactory actionInvokerFactory,
ActualActionInvokeInfoCache actionInvokeInfoCache)
{
_actionContext = actionContext;
_valueProviderFactories = valueProviderFactories;
_contentResultExecutor = contentResultExecutor;
_controllerActionInvokerCache = controllerActionInvokerCache;
_actionInvokerFactory = actionInvokerFactory;
_actionInvokeInfoCache = actionInvokeInfoCache;
}
public ProblemDetailsMiddleware(
RequestDelegate next,
IOptions <ProblemDetailsOptions> options,
IActionResultExecutor <ObjectResult> executor,
IHostingEnvironment environment,
ILogger <ProblemDetailsMiddleware> logger)
{
Next = next;
Options = options.Value;
Executor = executor;
Logger = logger;
var fileProvider = Options.FileProvider ?? environment.ContentRootFileProvider;
DetailsProvider = new ExceptionDetailsProvider(fileProvider, Options.SourceCodeLineCount);
}
/// <inheritdoc />
public override Task ExecuteResultAsync(ActionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
IJqGridJsonService jqGridJsonService = context.HttpContext.RequestServices.GetRequiredService <IJqGridJsonService>();
IActionResultExecutor <JsonResult> jsonResultExecutor = context.HttpContext.RequestServices.GetRequiredService <IActionResultExecutor <JsonResult> >();
return(jsonResultExecutor.ExecuteAsync(context, new JsonResult(Value, jqGridJsonService.GetJqGridJsonResultSerializerSettings(SerializerSettings))
{
ContentType = ContentType,
StatusCode = StatusCode
}));
}
public HalObjectResultExecutor(
IActionResultExecutor <ObjectResult> executor,
IHttpResponseStreamWriterFactory writerFactory,
OutputFormatterSelector formatterSelector,
ILogger <HalObjectResultExecutor> logger)
{
this.executor = executor
?? throw new ArgumentNullException(nameof(executor));
this.formatterSelector = formatterSelector
?? throw new ArgumentNullException(nameof(formatterSelector));
if (writerFactory == null)
{
throw new ArgumentNullException(nameof(writerFactory));
}
this.writerFactory = writerFactory.CreateWriter;
this.logger = logger
?? throw new ArgumentNullException(nameof(logger));
}
private void Init(bool securityEnabled)
{
_cts = new CancellationTokenSource();
_httpContext.RequestAborted = _cts.Token;
_httpContext.User = new ClaimsPrincipal(new ClaimsIdentity("authenticationType", "nametype", "roletype"));
var throttlingConfiguration = new ThrottlingConfiguration
{
ConcurrentRequestLimit = 5,
};
throttlingConfiguration.ExcludedEndpoints.Add(new ExcludedEndpoint {
Method = "get", Path = "/health/check"
});
_middleware = new ThrottlingMiddleware(
async x =>
{
x.Response.StatusCode = 200;
try
{
await Task.Delay(5000, _cts.Token);
}
catch (TaskCanceledException) when(_cts.Token.IsCancellationRequested)
{
}
},
Options.Create(throttlingConfiguration),
Options.Create(new Microsoft.Health.Fhir.Core.Configs.SecurityConfiguration {
Enabled = securityEnabled
}),
NullLogger <ThrottlingMiddleware> .Instance);
_executor = Substitute.For <IActionResultExecutor <ObjectResult> >();
_executor.ExecuteAsync(Arg.Any <ActionContext>(), Arg.Any <ObjectResult>()).ReturnsForAnyArgs(Task.CompletedTask);
_collection.AddSingleton <IActionResultExecutor <ObjectResult> >(_executor);
_provider = _collection.BuildServiceProvider();
_httpContext.RequestServices = _provider;
}
/// <inheritdoc />
public override Task ExecuteResultAsync(ActionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
HttpResponse response = context.HttpContext.Response;
response.StatusCode = StatusCode.Value;
response.Headers.Add("X-Page-Current", Value.PageCurrent.ToString());
response.Headers.Add("X-Page-Size", Value.PageSize.ToString());
if (Value.TotalCount.HasValue)
{
response.Headers.Add("X-Page-Total", Value.TotalCount.ToString());
}
IActionResultExecutor <JsonResult> executor = context.HttpContext.RequestServices.GetRequiredService <IActionResultExecutor <JsonResult> >();
return(executor.ExecuteAsync(context, new JsonResult(Value)));
}
public async Task InvokeAsync(HttpContext context, IActionResultExecutor <ObjectResult> writer,
ILogger <RequestExceptionMiddleware> log)
{
if (context.Request.Query.TryGetValue("error", out var header) && int.TryParse(header, NumberStyles.Integer, CultureInfo.InvariantCulture, out var statusCode) && IsErrorStatusCode(statusCode))
{
var(error, _) = ApiExceptionConverter.ToErrorDto(statusCode, context);
await WriteErrorAsync(context, error, writer);
return;
}
try
{
await next(context);
}
catch (Exception ex)
{
log.LogError(ex, "An unexpected exception has occurred.");
if (!context.Response.HasStarted)
{
var localizer = context.RequestServices.GetRequiredService <IStringLocalizer <AppResources> >();
var(error, _) = ex.ToErrorDto(localizer, context);
await WriteErrorAsync(context, error, writer);
}
}
if (IsErrorStatusCode(context.Response.StatusCode) && !context.Response.HasStarted)
{
var(error, _) = ApiExceptionConverter.ToErrorDto(context.Response.StatusCode, context);
await WriteErrorAsync(context, error, writer);
}
}
public AutoWrapperMiddleware(RequestDelegate next, AutoWrapperOptions options, ILogger <AutoWrapperMiddleware> logger, IActionResultExecutor <ObjectResult> executor) : base(next, options, logger, executor)
{
var jsonSettings = Helpers.JSONHelper.GetJSONSettings(options.IgnoreNullValue, options.ReferenceLoopHandling, options.UseCamelCaseNamingStrategy);
_awm = new AutoWrapperMembers(options, logger, jsonSettings);
}
public ExceptionMiddleware(RequestDelegate next, IActionResultExecutor <ObjectResult> executor, ILogger <ExceptionMiddleware> logger)
{
this.next = next;
this.executor = executor;
_logger = logger;
}
public HalFormattingContext(ActionContext context, ObjectResult result, IActionResultExecutor <ObjectResult> executor)
{
this.Context = context ?? throw new ArgumentNullException(nameof(context));
this.Result = result ?? throw new ArgumentNullException(nameof(result));
this.Executor = executor ?? throw new ArgumentNullException(nameof(executor));
}
public ApiExceptionMiddleware(RequestDelegate next, IActionResultExecutor <ObjectResult> executor, ILoggerFactory loggerFactory)
{
_next = next;
_executor = executor;
_logger = loggerFactory.CreateLogger <ApiExceptionMiddleware>();
}
public ExceptionHandlerMiddleware(IActionResultExecutor <ObjectResult> executor, ILoggerFactory loggerFactory)
{
this.executor = executor;
logger = loggerFactory.CreateLogger <ExceptionHandlerMiddleware>();
}
