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 Microsoft.Extensions.Primitives;
using Microsoft.Net.Http.Headers;
 
using Serilog.Context;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Response;
using Tgstation.Server.Host.Configuration;
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)
        {
            if (applicationBuilder == null)
                throw new ArgumentNullException(nameof(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 UseDisabledClientCache(this IApplicationBuilder applicationBuilder)
        {
            if (applicationBuilder == null)
                throw new ArgumentNullException(nameof(applicationBuilder));
            applicationBuilder.Use(async (context, next) =>
            {
                context.Response.Headers.Add(HeaderNames.CacheControl, new StringValues("no-cache"));
                await next();
            });
        }
 
        public static void UseCancelledRequestSuppression(this IApplicationBuilder applicationBuilder)
        {
            if (applicationBuilder == null)
                throw new ArgumentNullException(nameof(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)
        {
            if (applicationBuilder == null)
                throw new ArgumentNullException(nameof(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 UseServerBranding(this IApplicationBuilder applicationBuilder, IAssemblyInformationProvider assemblyInformationProvider)
        {
            if (applicationBuilder == null)
                throw new ArgumentNullException(nameof(applicationBuilder));
            if (assemblyInformationProvider == null)
                throw new ArgumentNullException(nameof(assemblyInformationProvider));
 
            applicationBuilder.Use(async (context, next) =>
            {
                context.Response.Headers.Add("X-Powered-By", assemblyInformationProvider.VersionPrefix);
                await next();
            });
        }
 
        public static void UseAdditionalRequestLoggingContext(this IApplicationBuilder applicationBuilder, SwarmConfiguration swarmConfiguration)
        {
            if (applicationBuilder == null)
                throw new ArgumentNullException(nameof(applicationBuilder));
            if (swarmConfiguration == null)
                throw new ArgumentNullException(nameof(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));
    }
}