GraphQLServerClient.cs

Go to the documentation of this file.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
 
using StrawberryShake;
 
using Tgstation.Server.Api;
 
namespace Tgstation.Server.Client.GraphQL
{
    class GraphQLServerClient : IGraphQLServerClient
    {
        [MemberNotNullWhen(true, nameof(setAuthenticationHeader))]
        [MemberNotNullWhen(true, nameof(bearerCredentialsTask))]
        bool Authenticated => basicCredentialsHeader != null;
 
        [MemberNotNullWhen(true, nameof(bearerCredentialsHeaderTaskLock))]
        [MemberNotNullWhen(true, nameof(basicCredentialsHeader))]
        bool CanReauthenticate => basicCredentialsHeader != null;
 
        readonly IGraphQLClient graphQLClient;
 
        readonly IAsyncDisposable serviceProvider;
 
        readonly ILogger<GraphQLServerClient> logger;
 
        readonly Action<AuthenticationHeaderValue>? setAuthenticationHeader;
 
        readonly AuthenticationHeaderValue? basicCredentialsHeader;
 
        readonly object? bearerCredentialsHeaderTaskLock;
 
        Task<(AuthenticationHeaderValue Header, DateTime Exp)?>? bearerCredentialsTask;
 
        [DoesNotReturn]
        static void ThrowOtherCallerFailedAuthException()
            => throw new AuthenticationException("Another caller failed to authenticate!");
 
        public GraphQLServerClient(
            IGraphQLClient graphQLClient,
            IAsyncDisposable serviceProvider,
            ILogger<GraphQLServerClient> logger)
        {
            this.graphQLClient = graphQLClient ?? throw new ArgumentNullException(nameof(graphQLClient));
            this.serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }
 
        protected GraphQLServerClient(
            IGraphQLClient graphQLClient,
            IAsyncDisposable serviceProvider,
            ILogger<GraphQLServerClient> logger,
            Action<AuthenticationHeaderValue> setAuthenticationHeader,
            AuthenticationHeaderValue? basicCredentialsHeader,
            IOperationResult<ILoginResult> loginResult)
            : this(graphQLClient, serviceProvider, logger)
        {
            this.setAuthenticationHeader = setAuthenticationHeader ?? throw new ArgumentNullException(nameof(setAuthenticationHeader));
            ArgumentNullException.ThrowIfNull(loginResult);
            this.basicCredentialsHeader = basicCredentialsHeader;
 
            var task = CreateCredentialsTuple(loginResult);
            if (!task.IsCompleted)
                throw new InvalidOperationException($"Expected {nameof(CreateCredentialsTuple)} to not await in constructor!");
 
            bearerCredentialsTask = Task.FromResult<(AuthenticationHeaderValue Header, DateTime Exp)?>(task.Result);
 
            if (Authenticated)
                bearerCredentialsHeaderTaskLock = new object();
        }
 
        public virtual ValueTask DisposeAsync() => serviceProvider.DisposeAsync();
 
        public ValueTask<IOperationResult<TResultData>> RunOperationAsync<TResultData>(Func<IGraphQLClient, ValueTask<IOperationResult<TResultData>>> operationExecutor, CancellationToken cancellationToken)
            where TResultData : class
        {
            ArgumentNullException.ThrowIfNull(operationExecutor);
            return WrapAuthentication(operationExecutor, cancellationToken);
        }
 
        public ValueTask<IOperationResult<TResultData>> RunOperation<TResultData>(Func<IGraphQLClient, Task<IOperationResult<TResultData>>> operationExecutor, CancellationToken cancellationToken)
            where TResultData : class
        {
            ArgumentNullException.ThrowIfNull(operationExecutor);
            return WrapAuthentication(async localClient => await operationExecutor(localClient), cancellationToken);
        }
 
        public async ValueTask<IDisposable> Subscribe<TResultData>(Func<IGraphQLClient, IObservable<IOperationResult<TResultData>>> operationExecutor, IObserver<IOperationResult<TResultData>> observer, CancellationToken cancellationToken)
            where TResultData : class
        {
            ArgumentNullException.ThrowIfNull(operationExecutor);
            ArgumentNullException.ThrowIfNull(observer);
 
            var observable = operationExecutor(graphQLClient);
 
            if (Authenticated)
            {
                var tuple = await bearerCredentialsTask.ConfigureAwait(false);
                if (!tuple.HasValue)
                    ThrowOtherCallerFailedAuthException();
 
                var (currentAuthHeader, expires) = tuple.Value;
                if (expires <= DateTimeOffset.UtcNow)
                    currentAuthHeader = await Reauthenticate(currentAuthHeader, cancellationToken).ConfigureAwait(false);
 
                setAuthenticationHeader(currentAuthHeader);
            }
 
            // maybe make this handle reauthentication one day
            // but would need to check if lost auth results in complete events being sent
            // if so, it can't be done
            return observable.Subscribe(observer);
        }
 
        protected virtual ValueTask<AuthenticationHeaderValue> CreateUpdatedAuthenticationHeader(string bearer)
            => ValueTask.FromResult(
                new AuthenticationHeaderValue(
                    ApiHeaders.BearerAuthenticationScheme,
                    bearer));
 
        async ValueTask<IOperationResult<TResultData>> WrapAuthentication<TResultData>(Func<IGraphQLClient, ValueTask<IOperationResult<TResultData>>> operationExecutor, CancellationToken cancellationToken)
            where TResultData : class
        {
            if (!Authenticated)
                return await operationExecutor(graphQLClient).ConfigureAwait(false);
 
            var tuple = await bearerCredentialsTask.ConfigureAwait(false);
            if (!tuple.HasValue)
                ThrowOtherCallerFailedAuthException();
 
            var (currentAuthHeader, expires) = tuple.Value;
            if (expires <= DateTimeOffset.UtcNow)
                currentAuthHeader = await Reauthenticate(currentAuthHeader, cancellationToken).ConfigureAwait(false);
 
            setAuthenticationHeader(currentAuthHeader);
 
            var operationResult = await operationExecutor(graphQLClient);
 
            if (operationResult.IsAuthenticationError())
            {
                currentAuthHeader = await Reauthenticate(currentAuthHeader, cancellationToken).ConfigureAwait(false);
                setAuthenticationHeader(currentAuthHeader);
                return await operationExecutor(graphQLClient);
            }
 
            return operationResult;
        }
 
        async ValueTask<AuthenticationHeaderValue> Reauthenticate(AuthenticationHeaderValue currentToken, CancellationToken cancellationToken)
        {
            if (!CanReauthenticate)
                throw new AuthenticationException("Authentication expired or invalid and cannot re-authenticate.");
 
            TaskCompletionSource<(AuthenticationHeaderValue Header, DateTime Exp)?>? tcs = null;
            do
            {
                var bearerCredentialsTaskLocal = bearerCredentialsTask;
                if (!bearerCredentialsTaskLocal!.IsCompleted)
                {
                    var currentTuple = await bearerCredentialsTaskLocal.ConfigureAwait(false);
                    if (!currentTuple.HasValue)
                        ThrowOtherCallerFailedAuthException();
 
                    return currentTuple.Value.Header;
                }
 
                lock (bearerCredentialsHeaderTaskLock!)
                {
                    if (bearerCredentialsTask == bearerCredentialsTaskLocal)
                    {
                        var result = bearerCredentialsTaskLocal.Result;
                        if (result?.Header != currentToken)
                        {
                            if (!result.HasValue)
                                ThrowOtherCallerFailedAuthException();
 
                            return result.Value.Header;
                        }
 
                        tcs = new TaskCompletionSource<(AuthenticationHeaderValue, DateTime)?>();
                        bearerCredentialsTask = tcs.Task;
                    }
                }
            }
            while (tcs == null);
 
            setAuthenticationHeader!(basicCredentialsHeader!);
            var loginResult = await graphQLClient.Login.ExecuteAsync(cancellationToken).ConfigureAwait(false);
            try
            {
                var tuple = await CreateCredentialsTuple(loginResult).ConfigureAwait(false);
                tcs.SetResult(tuple);
                return tuple.Header;
            }
            catch (AuthenticationException)
            {
                tcs.SetResult(null);
                throw;
            }
        }
 
        async ValueTask<(AuthenticationHeaderValue Header, DateTime Exp)> CreateCredentialsTuple(IOperationResult<ILoginResult> loginResult)
        {
            var bearer = loginResult.EnsureSuccess(logger);
 
            var header = await CreateUpdatedAuthenticationHeader(bearer.EncodedToken);
 
            return (Header: header, Exp: bearer.ValidTo);
        }
    }
}