SwarmUpdateOperation.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
 
using Tgstation.Server.Api.Models.Internal;
 
namespace Tgstation.Server.Host.Swarm
{
    public class SwarmUpdateOperation
    {
        public IReadOnlyList<SwarmServerInformation> InvolvedServers => initialInvolvedServers ?? throw new InvalidOperationException("This property can only be checked on controller SwarmUpdateOperations!");
 
        public Version TargetVersion { get; }
 
        public Task<bool> CommitGate => commitTcs.Task;
 
        readonly IReadOnlyList<SwarmServerInformation>? initialInvolvedServers;
 
        readonly TaskCompletionSource<bool> commitTcs;
 
        readonly HashSet<string>? nodesThatNeedToBeReadyToCommit;
 
        public SwarmUpdateOperation(Version targetVersion)
        {
            TargetVersion = targetVersion ?? throw new ArgumentNullException(nameof(targetVersion));
            commitTcs = new TaskCompletionSource<bool>();
        }
 
        public SwarmUpdateOperation(Version targetVersion, IEnumerable<SwarmServerInformation> currentNodes)
            : this(targetVersion)
        {
            initialInvolvedServers = currentNodes?.ToList() ?? throw new ArgumentNullException(nameof(currentNodes));
            nodesThatNeedToBeReadyToCommit = initialInvolvedServers
                .Where(node => !node.Controller)
                .Select(node => node.Identifier!)
                .ToHashSet();
        }
 
        public SwarmUpdateAbortResult Abort()
        {
            if (commitTcs.TrySetResult(false))
                return SwarmUpdateAbortResult.Aborted;
 
            return commitTcs.Task.Result
                ? SwarmUpdateAbortResult.CantAbortCommitted
                : SwarmUpdateAbortResult.AlreadyAborted;
        }
 
        public bool Commit()
        {
            if (nodesThatNeedToBeReadyToCommit != null && nodesThatNeedToBeReadyToCommit.Count != 0)
                throw new InvalidOperationException($"Cannot commit! There are still {nodesThatNeedToBeReadyToCommit.Count} nodes that need to be ready!");
 
            if (commitTcs.Task.IsCompleted && !commitTcs.Task.Result)
                return false;
 
            commitTcs.SetResult(true); // let the InvalidOperationException throw
            return true;
        }
 
        public bool MarkNodeReady(string nodeIdentifier)
        {
            ArgumentNullException.ThrowIfNull(nodeIdentifier);
 
            if (nodesThatNeedToBeReadyToCommit == null)
                throw new InvalidOperationException("A non-controller node tried to mark a node as ready!");
 
            lock (nodesThatNeedToBeReadyToCommit)
            {
                if (!nodesThatNeedToBeReadyToCommit.Remove(nodeIdentifier))
                    return Abort() != SwarmUpdateAbortResult.Aborted;
 
                if (nodesThatNeedToBeReadyToCommit.Count == 0)
                    commitTcs.TrySetResult(true);
 
                return true;
            }
        }
    }
}