BridgeController.cs

Go to the documentation of this file.

using System;
using System.Net;
using System.Net.Mime;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
 
using Newtonsoft.Json;
 
using Serilog.Context;
 
using Tgstation.Server.Api;
using Tgstation.Server.Host.Components.Interop;
using Tgstation.Server.Host.Components.Interop.Bridge;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    [Route("/" + RouteExtension)] // obsolete route, but BYOND can't handle a simple fucking 301
    [Route(Routes.ApiRoot + RouteExtension)]
    [ApiExplorerSettings(IgnoreApi = true)]
    public sealed class BridgeController : ApiControllerBase
    {
        const string RouteExtension = "Bridge";
 
        static bool LogContent => logContentDisableCounter == 0;
 
        static uint logContentDisableCounter;
 
        static long requestsProcessed;
 
        readonly IBridgeDispatcher bridgeDispatcher;
 
        readonly ILogger<BridgeController> logger;
 
        internal static void TemporarilyDisableContentLogging() => Interlocked.Increment(ref logContentDisableCounter);
 
        internal static void ReenableContentLogging() => Interlocked.Decrement(ref logContentDisableCounter);
 
        public BridgeController(IBridgeDispatcher bridgeDispatcher, IHostApplicationLifetime applicationLifetime, ILogger<BridgeController> logger)
        {
            this.bridgeDispatcher = bridgeDispatcher ?? throw new ArgumentNullException(nameof(bridgeDispatcher));
            ArgumentNullException.ThrowIfNull(applicationLifetime);
 
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
            applicationLifetime.ApplicationStopped.Register(() => requestsProcessed = 0);
        }
 
        [HttpGet]
        [AllowAnonymous]
        public async ValueTask<IActionResult> Process([FromQuery] string data, CancellationToken cancellationToken)
        {
            using (LogContext.PushProperty(SerilogContextHelper.BridgeRequestIterationContextProperty, Interlocked.Increment(ref requestsProcessed)))
            {
                // Nothing to see here
                var remoteIP = Request.HttpContext.Connection.RemoteIpAddress;
                if (remoteIP == null || !IPAddress.IsLoopback(remoteIP))
                {
                    logger.LogTrace("Rejecting remote bridge request from {remoteIP}", remoteIP);
                    return Forbid();
                }
 
                BridgeParameters? request;
                try
                {
                    request = JsonConvert.DeserializeObject<BridgeParameters>(data, DMApiConstants.SerializerSettings);
                }
                catch (Exception ex)
                {
                    if (LogContent)
                        logger.LogWarning(ex, "Error deserializing bridge request: {badJson}", data);
                    else
                        logger.LogWarning(ex, "Error deserializing bridge request!");
 
                    return BadRequest();
                }
 
                if (request == null)
                {
                    if (LogContent)
                        logger.LogWarning("Error deserializing bridge request: {badJson}", data);
                    else
                        logger.LogWarning("Error deserializing bridge request!");
 
                    return BadRequest();
                }
 
                if (LogContent)
                    logger.LogTrace("Bridge Request: {json}", data);
                else
                    logger.LogTrace("Bridge Request");
 
                var response = await bridgeDispatcher.ProcessBridgeRequest(request, cancellationToken);
                if (response == null)
                    Forbid();
 
                var responseJson = JsonConvert.SerializeObject(response, DMApiConstants.SerializerSettings);
 
                if (LogContent)
                    logger.LogTrace("Bridge Response: {json}", responseJson);
                return Content(responseJson, MediaTypeNames.Application.Json);
            }
        }
    }
}