GitHubClientFactory.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
 
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Octokit;
 
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.System;
 
namespace Tgstation.Server.Host.Utils.GitHub
{
    sealed class GitHubClientFactory : IGitHubClientFactory
    {
        const uint ClientCacheDays = 7;
 
        const string DefaultCacheKey = "~!@TGS_DEFAULT_GITHUB_CLIENT_CACHE_KEY@!~";
 
        readonly IAssemblyInformationProvider assemblyInformationProvider;
 
        readonly ILogger<GitHubClientFactory> logger;
 
        readonly GeneralConfiguration generalConfiguration;
 
        readonly Dictionary<string, (GitHubClient Client, DateTimeOffset LastUsed)> clientCache;
 
        public GitHubClientFactory(
            IAssemblyInformationProvider assemblyInformationProvider,
            ILogger<GitHubClientFactory> logger,
            IOptions<GeneralConfiguration> generalConfigurationOptions)
        {
            this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
            generalConfiguration = generalConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
 
            clientCache = new Dictionary<string, (GitHubClient, DateTimeOffset)>();
        }
 
        public IGitHubClient CreateClient() => GetOrCreateClient(generalConfiguration.GitHubAccessToken);
 
        public IGitHubClient CreateClient(string accessToken)
            => GetOrCreateClient(
                accessToken ?? throw new ArgumentNullException(nameof(accessToken)));
 
        GitHubClient GetOrCreateClient(string? accessToken)
        {
            GitHubClient client;
            bool cacheHit;
            DateTimeOffset? lastUsed;
            lock (clientCache)
            {
                string cacheKey;
                if (String.IsNullOrWhiteSpace(accessToken))
                {
                    accessToken = null;
                    cacheKey = DefaultCacheKey;
                }
                else
                    cacheKey = accessToken;
 
                cacheHit = clientCache.TryGetValue(cacheKey, out var tuple);
 
                var now = DateTimeOffset.UtcNow;
                if (!cacheHit)
                {
                    var product = assemblyInformationProvider.ProductInfoHeaderValue.Product!;
                    client = new GitHubClient(
                        new ProductHeaderValue(
                            product.Name,
                            product.Version));
 
                    if (accessToken != null)
                        client.Credentials = new Credentials(accessToken);
 
                    clientCache.Add(cacheKey, (Client: client, LastUsed: now));
                    lastUsed = null;
                }
                else
                {
                    logger.LogTrace("Cache hit for GitHubClient");
                    client = tuple.Client;
                    lastUsed = tuple.LastUsed;
                    tuple.LastUsed = now;
                }
 
                // Prune the cache
                var purgeCount = 0U;
                var purgeAfter = now.AddDays(-ClientCacheDays);
                foreach (var key in clientCache.Keys.ToList())
                {
                    if (key == cacheKey)
                        continue; // save the hash lookup
 
                    tuple = clientCache[key];
                    if (tuple.LastUsed <= purgeAfter)
                    {
                        clientCache.Remove(key);
                        ++purgeCount;
                    }
                }
 
                if (purgeCount > 0)
                    logger.LogDebug(
                        "Pruned {count} expired GitHub client(s) from cache that haven't been used in {purgeAfterHours} days.",
                        purgeCount,
                        ClientCacheDays);
            }
 
            var rateLimitInfo = client.GetLastApiInfo()?.RateLimit;
            if (rateLimitInfo != null)
                if (rateLimitInfo.Remaining == 0)
                    logger.LogWarning(
                        "Requested GitHub client has no requests remaining! Limit resets at {resetTime}",
                        rateLimitInfo.Reset.ToString("o"));
                else if (rateLimitInfo.Remaining < 25) // good luck hitting these lines on codecov
                    logger.LogWarning(
                        "Requested GitHub client has only {remainingRequests} requests remaining after the usage at {lastUse}! Limit resets at {resetTime}",
                        rateLimitInfo.Remaining,
                        lastUsed,
                        rateLimitInfo.Reset.ToString("o"));
                else
                    logger.LogDebug(
                        "Requested GitHub client has {remainingRequests} requests remaining after the usage at {lastUse}. Limit resets at {resetTime}",
                        rateLimitInfo.Remaining,
                        lastUsed,
                        rateLimitInfo.Reset.ToString("o"));
 
            return client;
        }
    }
}