GitHubService.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
 
using Octokit;
 
using Tgstation.Server.Host.Configuration;
 
namespace Tgstation.Server.Host.Utils.GitHub
{
    sealed class GitHubService : IAuthenticatedGitHubService
    {
        readonly IGitHubClient gitHubClient;
 
        readonly ILogger<GitHubService> logger;
 
        readonly UpdatesConfiguration updatesConfiguration;
 
        public GitHubService(IGitHubClient gitHubClient, ILogger<GitHubService> logger, UpdatesConfiguration updatesConfiguration)
        {
            this.gitHubClient = gitHubClient ?? throw new ArgumentNullException(nameof(gitHubClient));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
            this.updatesConfiguration = updatesConfiguration ?? throw new ArgumentNullException(nameof(updatesConfiguration));
        }
 
        public async ValueTask<string> CreateOAuthAccessToken(OAuthConfiguration oAuthConfiguration, string code, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(oAuthConfiguration);
 
            ArgumentNullException.ThrowIfNull(code);
 
            logger.LogTrace("CreateOAuthAccessToken");
 
            var response = await gitHubClient
                .Oauth
                .CreateAccessToken(
                    new OauthTokenRequest(
                        oAuthConfiguration.ClientId,
                        oAuthConfiguration.ClientSecret,
                        code)
                    {
                        RedirectUri = oAuthConfiguration.RedirectUrl,
                    })
                .WaitAsync(cancellationToken);
 
            var token = response.AccessToken;
            return token;
        }
 
        public async ValueTask<Dictionary<Version, Release>> GetTgsReleases(CancellationToken cancellationToken)
        {
            logger.LogTrace("GetTgsReleases");
            var allReleases = await gitHubClient
                .Repository
                .Release
                    .GetAll(updatesConfiguration.GitHubRepositoryId)
                    .WaitAsync(cancellationToken);
 
            var gitPrefix = updatesConfiguration.GitTagPrefix ?? String.Empty;
 
            logger.LogTrace("{totalReleases} total releases", allReleases.Count);
            var releases = allReleases!
                .Where(release =>
                {
                    if (!release.PublishedAt.HasValue)
                    {
                        logger.LogDebug("Release tag without PublishedAt: {releaseTag}", release.TagName);
                        return false;
                    }
 
                    if (!release.TagName.StartsWith(gitPrefix, StringComparison.InvariantCulture))
                        return false;
 
                    return true;
                })
                .GroupBy(release =>
                {
                    if (!Version.TryParse(release.TagName.Replace(gitPrefix, String.Empty, StringComparison.Ordinal), out var version))
                    {
                        logger.LogDebug("Unparsable release tag: {releaseTag}", release.TagName);
                        return null;
                    }
 
                    return version;
                })
                .Where(grouping => grouping.Key != null)
 
                // GitHub can return the same result twice or some other nonsense
                .Select(grouping => Tuple.Create(grouping.Key!, grouping.OrderBy(x => x.PublishedAt ?? DateTimeOffset.MinValue).First()))
                .ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2);
 
            logger.LogTrace("{parsedReleases} parsed releases", releases.Count);
            return releases;
        }
 
        public async ValueTask<Uri> GetUpdatesRepositoryUrl(CancellationToken cancellationToken)
        {
            logger.LogTrace("GetUpdatesRepositoryUrl");
            var repository = await gitHubClient
                .Repository
                    .Get(updatesConfiguration.GitHubRepositoryId)
                    .WaitAsync(cancellationToken);
 
            var repoUrl = new Uri(repository.HtmlUrl);
            logger.LogTrace("Maps to {repostioryUrl}", repoUrl);
 
            return repoUrl;
        }
 
        public async ValueTask<long> GetCurrentUserId(CancellationToken cancellationToken)
        {
            logger.LogTrace("CreateOAuthAccessToken");
 
            var userDetails = await gitHubClient.User.Current().WaitAsync(cancellationToken);
            return userDetails.Id;
        }
 
        public Task CommentOnIssue(string repoOwner, string repoName, string comment, int issueNumber, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(repoOwner);
 
            ArgumentNullException.ThrowIfNull(repoName);
 
            ArgumentNullException.ThrowIfNull(comment);
 
            logger.LogTrace("CommentOnIssue");
 
            return gitHubClient
                .Issue
                .Comment
                .Create(
                    repoOwner,
                    repoName,
                    issueNumber,
                    comment)
                .WaitAsync(cancellationToken);
        }
 
        public Task AppendCommentOnIssue(string repoOwner, string repoName, string comment, IssueComment issueComment, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(repoOwner);
 
            ArgumentNullException.ThrowIfNull(repoName);
 
            ArgumentNullException.ThrowIfNull(comment);
 
            ArgumentNullException.ThrowIfNull(issueComment);
 
            logger.LogTrace("AppendCommentOnIssue");
 
            return gitHubClient
                .Issue
                .Comment
                .Update(
                    repoOwner,
                    repoName,
                    issueComment.Id,
                    issueComment.Body + comment)
                .WaitAsync(cancellationToken);
        }
 
        public async ValueTask<IssueComment?> GetExistingCommentOnIssue(string repoOwner, string repoName, string header, int issueNumber, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(repoOwner);
 
            ArgumentNullException.ThrowIfNull(repoName);
 
            ArgumentNullException.ThrowIfNull(header);
 
            logger.LogTrace("GetExistingCommentOnIssue");
 
            var comments = await gitHubClient
                .Issue
                .Comment
                .GetAllForIssue(
                    repoOwner,
                    repoName,
                    issueNumber)
                .WaitAsync(cancellationToken);
            if (comments == null)
            {
                return null;
            }
 
            long userId = await GetCurrentUserId(cancellationToken);
 
            for (int i = comments.Count - 1; i > -1; i--)
            {
                var currentComment = comments[i];
                if (currentComment.User?.Id == userId && (currentComment.Body?.StartsWith(header) ?? false))
                {
                    if (currentComment.Body.Length > 250000)
                    { // Limit should be 262,143 so we'll leave a 12,143 buffer
                        return null;
                    }
 
                    return currentComment;
                }
            }
 
            return null;
        }
 
        public async ValueTask<long> GetRepositoryId(string repoOwner, string repoName, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(repoOwner);
 
            ArgumentNullException.ThrowIfNull(repoName);
 
            logger.LogTrace("GetRepositoryId");
 
            var repo = await gitHubClient
                .Repository
                .Get(
                    repoOwner,
                    repoName)
                .WaitAsync(cancellationToken);
 
            return repo.Id;
        }
 
        public async ValueTask<long> CreateDeployment(NewDeployment newDeployment, string repoOwner, string repoName, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(newDeployment);
 
            ArgumentNullException.ThrowIfNull(repoOwner);
 
            ArgumentNullException.ThrowIfNull(repoName);
 
            logger.LogTrace("CreateDeployment");
 
            var deployment = await gitHubClient
                .Repository
                .Deployment
                .Create(
                    repoOwner,
                    repoName,
                    newDeployment)
                .WaitAsync(cancellationToken);
 
            return deployment.Id;
        }
 
        public Task CreateDeploymentStatus(NewDeploymentStatus newDeploymentStatus, string repoOwner, string repoName, long deploymentId, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(newDeploymentStatus);
 
            ArgumentNullException.ThrowIfNull(repoOwner);
 
            ArgumentNullException.ThrowIfNull(repoName);
 
            logger.LogTrace("CreateDeploymentStatus");
            return gitHubClient
                .Repository
                .Deployment
                .Status
                .Create(
                    repoOwner,
                    repoName,
                    deploymentId,
                    newDeploymentStatus)
                .WaitAsync(cancellationToken);
        }
 
        public Task CreateDeploymentStatus(NewDeploymentStatus newDeploymentStatus, long repoId, long deploymentId, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(newDeploymentStatus);
 
            logger.LogTrace("CreateDeploymentStatus");
            return gitHubClient
                .Repository
                .Deployment
                .Status
                .Create(
                    repoId,
                    deploymentId,
                    newDeploymentStatus)
                .WaitAsync(cancellationToken);
        }
 
        public Task<PullRequest> GetPullRequest(string repoOwner, string repoName, int pullRequestNumber, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(repoOwner);
 
            ArgumentNullException.ThrowIfNull(repoName);
 
            logger.LogTrace("GetPullRequest");
            return gitHubClient
                .Repository
                .PullRequest
                .Get(
                    repoOwner,
                    repoName,
                    pullRequestNumber)
                .WaitAsync(cancellationToken);
        }
 
        public Task<GitHubCommit> GetCommit(string repoOwner, string repoName, string committish, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(repoOwner);
 
            ArgumentNullException.ThrowIfNull(repoName);
 
            logger.LogTrace("GetPulGetCommitlRequest");
            return gitHubClient
                .Repository
                .Commit
                .Get(
                    repoOwner,
                    repoName,
                    committish)
                .WaitAsync(cancellationToken);
        }
    }
}