BaseRemoteDeploymentManager.cs

Go to the documentation of this file.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
 
using Tgstation.Server.Common.Extensions;
using Tgstation.Server.Host.Components.Repository;
using Tgstation.Server.Host.Models;
 
namespace Tgstation.Server.Host.Components.Deployment.Remote
{
    abstract class BaseRemoteDeploymentManager : IRemoteDeploymentManager
    {
        protected Api.Models.Instance Metadata { get; }
 
        protected ILogger<BaseRemoteDeploymentManager> Logger { get; }
 
        readonly ConcurrentDictionary<long, Action<bool>> activationCallbacks;
 
        protected BaseRemoteDeploymentManager(
            ILogger<BaseRemoteDeploymentManager> logger,
            Api.Models.Instance metadata,
            ConcurrentDictionary<long, Action<bool>> activationCallbacks)
        {
            Logger = logger ?? throw new ArgumentNullException(nameof(logger));
            Metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
            this.activationCallbacks = activationCallbacks ?? throw new ArgumentNullException(nameof(activationCallbacks));
        }
 
        public async ValueTask PostDeploymentComments(
            CompileJob compileJob,
            RevisionInformation? previousRevisionInformation,
            RepositorySettings repositorySettings,
            string? repoOwner,
            string? repoName,
            CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(compileJob);
            ArgumentNullException.ThrowIfNull(repositorySettings);
            ArgumentNullException.ThrowIfNull(repoOwner);
            ArgumentNullException.ThrowIfNull(repoName);
 
            if (repositorySettings.AccessToken == null)
                return;
 
            var deployedRevisionInformation = compileJob.RevisionInformation;
            if ((previousRevisionInformation != null && previousRevisionInformation.CommitSha == deployedRevisionInformation.CommitSha)
                || !repositorySettings.PostTestMergeComment!.Value)
                return;
 
            previousRevisionInformation ??= new RevisionInformation();
            previousRevisionInformation.ActiveTestMerges ??= new List<RevInfoTestMerge>();
 
            deployedRevisionInformation.ActiveTestMerges ??= new List<RevInfoTestMerge>();
 
            // added prs
            var addedTestMerges = deployedRevisionInformation
                .ActiveTestMerges
                .Select(x => x.TestMerge)
                .Where(x => !previousRevisionInformation
                    .ActiveTestMerges
                    .Any(y => y.TestMerge.Number == x.Number))
                .ToList();
            var removedTestMerges = previousRevisionInformation
                .ActiveTestMerges
                .Select(x => x.TestMerge)
                .Where(x => !deployedRevisionInformation
                    .ActiveTestMerges
                    .Any(y => y.TestMerge.Number == x.Number))
                .ToList();
            var updatedTestMerges = deployedRevisionInformation
                .ActiveTestMerges
                .Select(x => x.TestMerge)
                .Where(x => previousRevisionInformation
                    .ActiveTestMerges
                    .Any(y => y.TestMerge.Number == x.Number))
                .ToList();
 
            if (addedTestMerges.Count == 0 && removedTestMerges.Count == 0 && updatedTestMerges.Count == 0)
                return;
 
            Logger.LogTrace(
                "Commenting on {addedCount} added, {removedCount} removed, and {updatedCount} updated test merge sources...",
                addedTestMerges.Count,
                removedTestMerges.Count,
                updatedTestMerges.Count);
 
            var tasks = new List<ValueTask>(addedTestMerges.Count + updatedTestMerges.Count + removedTestMerges.Count);
            foreach (var addedTestMerge in addedTestMerges)
            {
                var addCommentTask = CommentOnTestMergeSource(
                    repositorySettings,
                    repoOwner,
                    repoName,
                    FormatTestMerge(
                        repositorySettings,
                        compileJob,
                        addedTestMerge,
                        repoOwner,
                        repoName,
                        false),
                    addedTestMerge.Number,
                    cancellationToken);
                tasks.Add(addCommentTask);
            }
 
            foreach (var removedTestMerge in removedTestMerges)
            {
                var removeCommentTask = CommentOnTestMergeSource(
                    repositorySettings,
                    repoOwner,
                    repoName,
                    "#### Test Merge Removed",
                    removedTestMerge.Number,
                    cancellationToken);
                tasks.Add(removeCommentTask);
            }
 
            foreach (var updatedTestMerge in updatedTestMerges)
            {
                var updateCommentTask = CommentOnTestMergeSource(
                    repositorySettings,
                    repoOwner,
                    repoName,
                    FormatTestMerge(
                        repositorySettings,
                        compileJob,
                        updatedTestMerge,
                        repoOwner,
                        repoName,
                        true),
                    updatedTestMerge.Number,
                    cancellationToken);
                tasks.Add(updateCommentTask);
            }
 
            if (tasks.Count > 0)
                await ValueTaskExtensions.WhenAll(tasks);
        }
 
        public ValueTask ApplyDeployment(CompileJob compileJob, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(compileJob);
 
            if (activationCallbacks.TryGetValue(compileJob.Require(x => x.Id), out var activationCallback))
                activationCallback(true);
 
            return ApplyDeploymentImpl(compileJob, cancellationToken);
        }
 
        public abstract ValueTask FailDeployment(CompileJob compileJob, string errorMessage, CancellationToken cancellationToken);
 
        public ValueTask MarkInactive(CompileJob compileJob, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(compileJob);
 
            if (activationCallbacks.TryRemove(compileJob.Require(x => x.Id), out var activationCallback))
                activationCallback(false);
 
            return MarkInactiveImpl(compileJob, cancellationToken);
        }
 
        public abstract ValueTask<IReadOnlyCollection<TestMerge>> RemoveMergedTestMerges(
            IRepository repository,
            RepositorySettings repositorySettings,
            RevisionInformation revisionInformation,
            CancellationToken cancellationToken);
 
        public ValueTask StageDeployment(CompileJob compileJob, Action<bool>? activationCallback, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(compileJob);
 
            var compileJobId = compileJob.Require(x => x.Id);
            if (activationCallback != null && !activationCallbacks.TryAdd(compileJobId, activationCallback))
                Logger.LogError("activationCallbacks conflicted on CompileJob #{id}!", compileJobId);
 
            return StageDeploymentImpl(compileJob, cancellationToken);
        }
 
        public abstract ValueTask StartDeployment(
            Api.Models.Internal.IGitRemoteInformation remoteInformation,
            CompileJob compileJob,
            CancellationToken cancellationToken);
 
        protected abstract ValueTask StageDeploymentImpl(CompileJob compileJob, CancellationToken cancellationToken);
 
        protected abstract ValueTask ApplyDeploymentImpl(CompileJob compileJob, CancellationToken cancellationToken);
 
        protected abstract ValueTask MarkInactiveImpl(CompileJob compileJob, CancellationToken cancellationToken);
 
        protected abstract string FormatTestMerge(
            RepositorySettings repositorySettings,
            CompileJob compileJob,
            TestMerge testMerge,
            string remoteRepositoryOwner,
            string remoteRepositoryName,
            bool updated);
 
        protected abstract ValueTask CommentOnTestMergeSource(
            RepositorySettings repositorySettings,
            string remoteRepositoryOwner,
            string remoteRepositoryName,
            string comment,
            int testMergeNumber,
            CancellationToken cancellationToken);
    }
}