ApplicationBuilderExtensions.cs

Go to the documentation of this file.

using System;
using System.Globalization;
using System.Net;
 
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
 
using Serilog.Context;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Response;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Properties;
using Tgstation.Server.Host.System;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Extensions
{
    static class ApplicationBuilderExtensions
    {
        internal static bool LogSwarmIdentifier { get; set; }
 
        public static void UseDbConflictHandling(this IApplicationBuilder applicationBuilder)
        {
            ArgumentNullException.ThrowIfNull(applicationBuilder);
 
            applicationBuilder.Use(async (context, next) =>
            {
                var logger = GetLogger(context);
                try
                {
                    await next();
                }
                catch (DbUpdateException e)
                {
                    if (e.InnerException is OperationCanceledException)
                    {
                        logger.LogTrace(e, "Rethrowing DbUpdateException as OperationCanceledException");
                        throw e.InnerException;
                    }
 
                    logger.LogDebug(e, "Database conflict!");
                    await new ConflictObjectResult(new ErrorMessageResponse(ErrorCode.DatabaseIntegrityConflict)
                    {
                        AdditionalData = String.Format(CultureInfo.InvariantCulture, (e.InnerException ?? e).Message),
                    }).ExecuteResultAsync(new ActionContext
                    {
                        HttpContext = context,
                    });
                }
            });
        }
 
        public static void UseCancelledRequestSuppression(this IApplicationBuilder applicationBuilder)
        {
            ArgumentNullException.ThrowIfNull(applicationBuilder);
            applicationBuilder.Use(async (context, next) =>
            {
                var logger = GetLogger(context);
                try
                {
                    await next();
                }
                catch (OperationCanceledException ex)
                {
                    logger.LogDebug(ex, "Request cancelled!");
                }
            });
        }
 
        public static void UseServerErrorHandling(this IApplicationBuilder applicationBuilder)
        {
            ArgumentNullException.ThrowIfNull(applicationBuilder);
 
            applicationBuilder.Use(async (context, next) =>
            {
                var logger = GetLogger(context);
                try
                {
                    await next();
                }
                catch (Exception e)
                {
                    logger.LogError(e, "Failed request!");
                    await new JsonResult(
                        new ErrorMessageResponse(ErrorCode.InternalServerError)
                        {
                            AdditionalData = e.ToString(),
                        })
                    {
                        StatusCode = (int)HttpStatusCode.InternalServerError,
                    }
                    .ExecuteResultAsync(new ActionContext
                    {
                        HttpContext = context,
                    });
                }
            });
        }
 
        public static void UseApiCompatibility(this IApplicationBuilder applicationBuilder)
        {
            ArgumentNullException.ThrowIfNull(applicationBuilder);
 
            applicationBuilder.Use(async (context, next) =>
            {
                var apiHeadersProvider = context.RequestServices.GetRequiredService<IApiHeadersProvider>();
                if (apiHeadersProvider.ApiHeaders?.Compatible(
                    Version.Parse(
                        MasterVersionsAttribute.Instance.RawGraphQLVersion)) == false)
                {
                    await new BadRequestObjectResult(
                        new ErrorMessageResponse(ErrorCode.ApiMismatch))
                    .ExecuteResultAsync(new ActionContext
                    {
                        HttpContext = context,
                    });
                    return;
                }
 
                await next();
            });
        }
 
        public static void UseServerBranding(this IApplicationBuilder applicationBuilder, IAssemblyInformationProvider assemblyInformationProvider)
        {
            ArgumentNullException.ThrowIfNull(applicationBuilder);
            ArgumentNullException.ThrowIfNull(assemblyInformationProvider);
 
            applicationBuilder.Use((context, next) =>
            {
                context.Response.Headers.Add("X-Powered-By", assemblyInformationProvider.VersionPrefix);
                return next();
            });
        }
 
        public static void UseDisabledNginxProxyBuffering(this IApplicationBuilder applicationBuilder)
        {
            ArgumentNullException.ThrowIfNull(applicationBuilder);
 
            // https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/#x-accel-buffering
            applicationBuilder.Use((context, next) =>
            {
                context.Response.Headers.Add("X-Accel-Buffering", "no");
                return next();
            });
        }
 
        public static void UseAdditionalRequestLoggingContext(this IApplicationBuilder applicationBuilder, SwarmConfiguration swarmConfiguration)
        {
            ArgumentNullException.ThrowIfNull(applicationBuilder);
            ArgumentNullException.ThrowIfNull(swarmConfiguration);
 
            if (LogSwarmIdentifier && swarmConfiguration.Identifier != null)
                applicationBuilder.Use(async (context, next) =>
                {
                    using (LogContext.PushProperty(SerilogContextHelper.SwarmIdentifierContextProperty, swarmConfiguration.Identifier))
                        await next();
                });
        }
 
        static ILogger GetLogger(HttpContext httpContext) => httpContext.RequestServices.GetRequiredService<ILoggerFactory>().CreateLogger(typeof(ApplicationBuilderExtensions));
    }
}