CommContext.cs

Go to the documentation of this file.

using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tgstation.Server.Host.IO;

namespace Tgstation.Server.Host.Components.Interop
{
    sealed class CommContext : ICommContext
    {
        readonly IIOManager ioManager;

        readonly ILogger<CommContext> logger;

        readonly FileSystemWatcher fileSystemWatcher;

        readonly CancellationTokenSource cancellationTokenSource;

        readonly CancellationToken cancellationToken;

        ICommHandler handler;

        bool disposed;

        public CommContext(IIOManager ioManager, ILogger<CommContext> logger, string directory, string filter)
        {
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));

            directory = ioManager.ResolvePath(directory) ?? throw new ArgumentNullException(nameof(directory));
            if (filter == null)
                throw new ArgumentNullException(nameof(filter));

            fileSystemWatcher = new FileSystemWatcher(directory, filter)
            {
                EnableRaisingEvents = true,
                IncludeSubdirectories = false,
                NotifyFilter = NotifyFilters.LastWrite
            };

            fileSystemWatcher.Created += HandleWrite;
            fileSystemWatcher.Changed += HandleWrite;

            cancellationTokenSource = new CancellationTokenSource();
            cancellationToken = cancellationTokenSource.Token;
            disposed = false;
        }

        public void Dispose()
        {
            if (disposed)
                return;
            disposed = true;
            fileSystemWatcher.Dispose();
            cancellationTokenSource.Cancel();
            cancellationTokenSource.Dispose();
        }

        async void HandleWrite(object sender, FileSystemEventArgs e)    //this is what async void was made for
        {
            try
            {
                var fileBytes = await ioManager.ReadAllBytes(e.FullPath, cancellationToken).ConfigureAwait(false);
                var file = Encoding.UTF8.GetString(fileBytes);

                logger.LogTrace("Read interop command json: {0}", file);

                CommCommand command;
                try
                {
                    command = new CommCommand
                    {
                        Parameters = JsonConvert.DeserializeObject<IReadOnlyDictionary<string, object>>(file),
                        RawJson = file
                    };
                }
                catch (JsonException ex)
                {
                    //file not fully written yet
                    logger.LogDebug("Suppressing json convert exception for command file write: {0}", ex);
                    return;
                }

                await (handler?.HandleInterop(command, cancellationToken) ?? Task.CompletedTask).ConfigureAwait(false);
            }
            catch (OperationCanceledException) { }
            catch (Exception ex)
            {
                logger.LogDebug("Exception while trying to handle command json write: {0}", ex);
            }
        }

        public void RegisterHandler(ICommHandler handler)
        {
            if (this.handler != null)
                throw new InvalidOperationException("RegisterHandler already called!");
            this.handler = handler ?? throw new ArgumentNullException(nameof(handler));
        }
    }
}