Provider.cs

Go to the documentation of this file.

using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Tgstation.Server.Host.Models;

namespace Tgstation.Server.Host.Components.Chat.Providers
{
    abstract class Provider : IProvider
    {
        protected ILogger Logger { get; }

        readonly Queue<Message> messageQueue;

        readonly object reconnectTaskLock;

        TaskCompletionSource<object> nextMessage;

        Task reconnectTask;

        CancellationTokenSource reconnectCts;

        protected Provider(ILogger logger, uint reconnectInterval)
        {
            Logger = logger ?? throw new ArgumentNullException(nameof(logger));

            messageQueue = new Queue<Message>();
            nextMessage = new TaskCompletionSource<object>();

            reconnectTaskLock = new object();

            SetReconnectInterval(reconnectInterval).GetAwaiter().GetResult();
            logger.LogTrace("Created.");
        }

        public abstract bool Connected { get; }

        public abstract string BotMention { get; }

        protected void EnqueueMessage(Message message)
        {
            lock (messageQueue)
            {
                messageQueue.Enqueue(message);
                nextMessage.TrySetResult(null);
            }
        }

        public virtual void Dispose()
        {
            StopReconnectionTimer().GetAwaiter().GetResult();
            Logger.LogTrace("Disposed");
        }

        public abstract Task<bool> Connect(CancellationToken cancellationToken);

        protected abstract Task DisconnectImpl(CancellationToken cancellationToken);

        public async Task Disconnect(CancellationToken cancellationToken)
        {
            await StopReconnectionTimer().ConfigureAwait(false);
            await DisconnectImpl(cancellationToken).ConfigureAwait(false);
        }

        public abstract Task<IReadOnlyCollection<ChannelRepresentation>> MapChannels(IEnumerable<Api.Models.ChatChannel> channels, CancellationToken cancellationToken);

        public async Task<Message> NextMessage(CancellationToken cancellationToken)
        {
            var cancelTcs = new TaskCompletionSource<object>();
            using (cancellationToken.Register(() => cancelTcs.SetCanceled()))
                await Task.WhenAny(nextMessage.Task, cancelTcs.Task).ConfigureAwait(false);
            cancellationToken.ThrowIfCancellationRequested();
            lock (messageQueue)
            {
                var result = messageQueue.Dequeue();
                if (messageQueue.Count == 0)
                    nextMessage = new TaskCompletionSource<object>();
                return result;
            }
        }

        Task StopReconnectionTimer()
        {
            lock (reconnectTaskLock)
                if (reconnectCts != null)
                {
                    reconnectCts.Cancel();
                    reconnectCts.Dispose();
                    reconnectCts = null;
                    Task reconnectTask = this.reconnectTask;
                    this.reconnectTask = null;
                    return reconnectTask;
                }

            return Task.CompletedTask;
        }

        public Task SetReconnectInterval(uint reconnectInterval)
        {
            if (reconnectInterval == 0)
                throw new ArgumentOutOfRangeException(nameof(reconnectInterval), reconnectInterval, "Reconnect interval cannot be zero!");

            Task stopOldTimerTask;
            lock (reconnectTaskLock)
            {
                stopOldTimerTask = StopReconnectionTimer();
                reconnectCts = new CancellationTokenSource();
                reconnectTask = ReconnectionLoop(reconnectInterval, reconnectCts.Token);
            }

            return stopOldTimerTask;
        }

        async Task ReconnectionLoop(uint reconnectInterval, CancellationToken cancellationToken)
        {
            do
            {
                try
                {
                    await Task.Delay(TimeSpan.FromMinutes(reconnectInterval), cancellationToken).ConfigureAwait(false);
                    if (!Connected)
                    {
                        Logger.LogInformation("Attempting to reconnect provider...");
                        await Disconnect(cancellationToken).ConfigureAwait(false);
                        if (await Connect(cancellationToken).ConfigureAwait(false))
                            EnqueueMessage(null);
                    }
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch(Exception e)
                {
                    Logger.LogError(e, "Error reconnecting!");
                }
            }
            while (true);
        }

        public abstract Task SendMessage(ulong channelId, string message, CancellationToken cancellationToken);

        public abstract Task<Func<string, string, Task>> SendUpdateMessage(
            RevisionInformation revisionInformation,
            Version byondVersion,
            DateTimeOffset? estimatedCompletionTime,
            string gitHubOwner,
            string gitHubRepo,
            ulong channelId,
            bool localCommitPushed,
            CancellationToken cancellationToken);
    }
}